{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# XAFS scan\n",
    "\n",
    "From *APS Python Training for Bluesky Data Acquisition*.\n",
    "\n",
    "**Objective**\n",
    "\n",
    "Example multi-segment XAFS scan.  A full scan might be divided into:\n",
    "\n",
    "region | steps | units | count time\n",
    "--- | --- | --- | ---\n",
    "pre-edge | constant energy | keV | constant\n",
    "near-edge | constant energy | eV | constant\n",
    "low _k_ | constant k | 1/angstrom | constant\n",
    "higher _k_ | constant k | 1/angstrom | scales with _k_\n",
    "\n",
    "For the higher _k_ region, the count time is computed as:\n",
    "\n",
    "    preset_time = requested_time * (1 + factor*k**exponent)\n",
    "\n",
    "where `exponent=0.5`, `factor=2.0`, and `requested_time` is the time specified by the caller.\n",
    "\n",
    "note: We are connected to _simulated_ hardware.  The simulated scalers generate random pulses. All detector data is random numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Start the `instrument` package\n",
    "\n",
    "Our instrument package is in the `bluesky` subdirectory here so we add that to the search path before importing it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/prjemian/bluesky/instrument/_iconfig.py\n",
      "Activating auto-logging. Current session state plus future input saved.\n",
      "Filename       : /home/prjemian/Documents/projects/BCDA-APS/bluesky_training/docs/source/howto/.logs/ipython_console.log\n",
      "Mode           : rotate\n",
      "Output logging : True\n",
      "Raw input log  : False\n",
      "Timestamping   : True\n",
      "State          : active\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I Thu-18:16:30 - ############################################################ startup\n",
      "I Thu-18:16:30 - logging started\n",
      "I Thu-18:16:30 - logging level = 10\n",
      "I Thu-18:16:30 - /home/prjemian/bluesky/instrument/session_logs.py\n",
      "I Thu-18:16:30 - /home/prjemian/bluesky/instrument/collection.py\n",
      "I Thu-18:16:30 - CONDA_PREFIX = /home/prjemian/.conda/envs/bluesky_2023_2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exception reporting mode: Minimal\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I Thu-18:16:30 - xmode exception level: 'Minimal'\n",
      "I Thu-18:16:30 - /home/prjemian/bluesky/instrument/mpl/notebook.py\n",
      "I Thu-18:16:30 - #### Bluesky Framework ####\n",
      "I Thu-18:16:30 - /home/prjemian/bluesky/instrument/framework/check_python.py\n",
      "I Thu-18:16:30 - /home/prjemian/bluesky/instrument/framework/check_bluesky.py\n",
      "I Thu-18:16:30 - /home/prjemian/bluesky/instrument/framework/initialize.py\n",
      "I Thu-18:16:30 - RunEngine metadata saved in directory: /home/prjemian/Bluesky_RunEngine_md\n",
      "I Thu-18:16:30 - using databroker catalog 'training'\n",
      "I Thu-18:16:30 - using ophyd control layer: pyepics\n",
      "I Thu-18:16:30 - /home/prjemian/bluesky/instrument/framework/metadata.py\n",
      "I Thu-18:16:30 - /home/prjemian/bluesky/instrument/epics_signal_config.py\n",
      "I Thu-18:16:30 - Using RunEngine metadata for scan_id\n",
      "I Thu-18:16:30 - #### Devices ####\n",
      "I Thu-18:16:30 - /home/prjemian/bluesky/instrument/devices/area_detector.py\n",
      "I Thu-18:16:30 - /home/prjemian/bluesky/instrument/devices/calculation_records.py\n",
      "I Thu-18:16:33 - /home/prjemian/bluesky/instrument/devices/fourc_diffractometer.py\n",
      "I Thu-18:16:33 - /home/prjemian/bluesky/instrument/devices/ioc_stats.py\n",
      "I Thu-18:16:33 - /home/prjemian/bluesky/instrument/devices/kohzu_monochromator.py\n",
      "I Thu-18:16:33 - /home/prjemian/bluesky/instrument/devices/motors.py\n",
      "I Thu-18:16:33 - /home/prjemian/bluesky/instrument/devices/noisy_detector.py\n",
      "I Thu-18:16:34 - /home/prjemian/bluesky/instrument/devices/scaler.py\n",
      "I Thu-18:16:34 - /home/prjemian/bluesky/instrument/devices/shutter_simulator.py\n",
      "I Thu-18:16:34 - /home/prjemian/bluesky/instrument/devices/simulated_fourc.py\n",
      "I Thu-18:16:34 - /home/prjemian/bluesky/instrument/devices/simulated_kappa.py\n",
      "I Thu-18:16:34 - /home/prjemian/bluesky/instrument/devices/slits.py\n",
      "I Thu-18:16:34 - /home/prjemian/bluesky/instrument/devices/sixc_diffractometer.py\n",
      "I Thu-18:16:35 - /home/prjemian/bluesky/instrument/devices/temperature_signal.py\n",
      "I Thu-18:16:35 - #### Callbacks ####\n",
      "I Thu-18:16:35 - /home/prjemian/bluesky/instrument/callbacks/spec_data_file_writer.py\n",
      "I Thu-18:16:35 - #### Plans ####\n",
      "I Thu-18:16:35 - /home/prjemian/bluesky/instrument/plans/lup_plan.py\n",
      "I Thu-18:16:35 - /home/prjemian/bluesky/instrument/plans/peak_finder_example.py\n",
      "I Thu-18:16:35 - /home/prjemian/bluesky/instrument/utils/image_analysis.py\n",
      "I Thu-18:16:35 - #### Utilities ####\n",
      "I Thu-18:16:35 - writing to SPEC file: /home/prjemian/Documents/projects/BCDA-APS/bluesky_training/docs/source/howto/20230413-181635.dat\n",
      "I Thu-18:16:35 -    >>>>   Using default SPEC file name   <<<<\n",
      "I Thu-18:16:35 -    file will be created when bluesky ends its next scan\n",
      "I Thu-18:16:35 -    to change SPEC file, use command:   newSpecFile('title')\n",
      "I Thu-18:16:35 - #### Startup is complete. ####\n"
     ]
    }
   ],
   "source": [
    "import pathlib, sys\n",
    "sys.path.append(str(pathlib.Path.home() / \"bluesky\"))\n",
    "from instrument.collection import *\n",
    "\n",
    "RE.waiting_hook = None  # disable the progress bar, looks awful in notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll use these later.  Import now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ophyd import EpicsSignalRO\n",
    "\n",
    "import math\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Energy & _k_\n",
    "\n",
    "The Kohzu monochromator support expects energy in *keV* and wavelength in\n",
    "*1/angstrom*.  XAFS is similar, _k_ in *1/angstrom*, but also uses *eV*\n",
    "sometimes for energy.  We need to be flexible.\n",
    "\n",
    "Fundamental physical constants are provided by the\n",
    "[scipy](https://www.scipy.org/) package.  The Python\n",
    "[pint](https://pint.readthedocs.io/) package is used to provide\n",
    "unit conversions that will help to convert between energy and _k_\n",
    "coordinates.\n",
    "With these two packages, our software provides flexibility for the units\n",
    "a caller must use.  And the code we use documents itself about our choice\n",
    "of units.\n",
    "\n",
    "Here we define routines to convert between energy and _k_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pint\n",
    "import scipy.constants\n",
    "\n",
    "ureg = pint.UnitRegistry()\n",
    "Qty = ureg.Quantity  # a shortcut\n",
    "\n",
    "hbar = Qty(scipy.constants.hbar, \"J Hz^-1\")\n",
    "electron_mass = Qty(scipy.constants.m_e, \"kg\")\n",
    "TWO_M_OVER_HBAR_SQR = 2 * electron_mass / (hbar**2)\n",
    "\n",
    "\n",
    "def energy_to_k(E, E0):\n",
    "    energy_difference = Qty(E - E0, \"keV\")\n",
    "    kSqr = (TWO_M_OVER_HBAR_SQR * energy_difference).to(\"1/angstrom^2\")\n",
    "    return math.sqrt(kSqr.magnitude)\n",
    "\n",
    "\n",
    "def k_to_energy(k, E0):\n",
    "    \"\"\"\n",
    "    k = sqrt( (2m(E-E0)) / hbar^2) = sqrt( const * (E-E0))\n",
    "    \"\"\"\n",
    "    k_with_units = Qty(k, \"1/angstrom\")\n",
    "    edge_keV = Qty(E0, \"keV\")\n",
    "    energy_difference = (k_with_units**2 / TWO_M_OVER_HBAR_SQR).to(\"keV\")\n",
    "    return (energy_difference + edge_keV).magnitude"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple segments\n",
    "\n",
    "XAFS scans measure signals from two or more detectors as the incident X-ray energy is varied.  One method is to step the energy where the step size is different depending on the region of the scan.  Steps could be in constant units of energy or _k_ (see above).\n",
    "\n",
    "We define here a default list of four regions (known here as `segments`), each showing a different feature of units or count time weighting.  This default list is used in the `xafs()` scan below if the caller chooses.  The `get_energies_and_times()` function parses the supplied list of segments and returns a list of `(energy_keV, count_time)` pairs for use in a [bluesky](https://blueskyproject.io/bluesky/).[plans](https://blueskyproject.io/bluesky/plans.html).[list_scan()](https://blueskyproject.io/bluesky/generated/bluesky.plans.list_scan.html#bluesky.plans.list_scan)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "XAFS_SCAN_SEGMENTS_VARIETY = (\n",
    "    # X could be keV, eV, k, or kwt (k-weighted count time)\n",
    "    # axis, start, end, step, count_time\n",
    "    (\"keV\", -.2, -.015, .02, 3),\n",
    "    (\"eV\", -15, 10, 2.5, 1),\n",
    "    (\"k\", .5, 2, .2, 0.5),\n",
    "    (\"kwt\", 2, 10, .5, 1),\n",
    ")\n",
    "\n",
    "DEFAULT_XAFS_SCAN_SEGMENTS = (\n",
    "    # here, only keV and kwt\n",
    "    # axis, start, end, step, count_time\n",
    "    (\"keV\", -0.2, -0.015, 0.02, 3),\n",
    "    (\"keV\", -0.015, 0.005, 0.0015, 2),\n",
    "    (\"kwt\", 1.5, 12, 0.5, 1),\n",
    ")\n",
    "\n",
    "def parse_segments(edge_keV, segments):\n",
    "    accepted = \"keV eV k kwt\"\n",
    "\n",
    "    results = []\n",
    "\n",
    "    for i, seg in enumerate(segments):\n",
    "        # error checking\n",
    "        if seg[0].lower() not in accepted.lower().split():\n",
    "            raise ValueError(\n",
    "                f\"Cannot scan in {seg[0]} now (segment {i+1}).\"\n",
    "                f\"  Only one of these: {accepted.split()}.\"\n",
    "            )\n",
    "        if len(seg) != 5:\n",
    "            raise ValueError(\n",
    "                \"Each segment must have 5 arguments:\"\n",
    "                \" X, start, end, step, time\"\n",
    "                f\"  Received: {seg} in segment {i+1}\"\n",
    "            )\n",
    "\n",
    "        axis_type = seg[0]\n",
    "        preset_time = seg[4]\n",
    "        position_array = np.arange(*seg[1:4])\n",
    "\n",
    "        if axis_type.lower() == \"kev\":\n",
    "            # count time is constant across this segment\n",
    "            time_array = np.full(shape=len(position_array), fill_value=seg[4])\n",
    "        elif axis_type.lower() == \"ev\":\n",
    "            position_array /= 1000.0  # convert to keV\n",
    "            # count time is constant across this segment\n",
    "            time_array = np.full(shape=len(position_array), fill_value=seg[4])\n",
    "        elif axis_type.lower() == \"k\":\n",
    "            position_array = np.array([\n",
    "                k_to_energy(k, edge_keV)\n",
    "                for k in position_array\n",
    "            ]) - edge_keV\n",
    "            # count time is constant across this segment\n",
    "            time_array = np.full(shape=len(position_array), fill_value=seg[4])\n",
    "        elif axis_type.lower() == \"kwt\":\n",
    "            # k-axis, k-weighted time\n",
    "            k_array = position_array.tolist()\n",
    "            position_array = np.array([\n",
    "                k_to_energy(k, edge_keV)\n",
    "                for k in position_array\n",
    "            ]) - edge_keV\n",
    "            # count time varies with k across this segment\n",
    "            # time = preset*(1 + factor * k**exponent)\n",
    "            factor = 2\n",
    "            exponent = .5\n",
    "            time_array = np.array([\n",
    "                preset_time * (1 + factor * k**exponent)\n",
    "                for k in k_array\n",
    "            ])\n",
    "\n",
    "        results += [\n",
    "            (edge_keV + v, t)\n",
    "            for v, t in zip(position_array, time_array)\n",
    "        ]\n",
    "\n",
    "    e_arr, t_arr = [], []\n",
    "    for e, t in sorted(results):\n",
    "        if e in e_arr:\n",
    "            continue  # no duplicates\n",
    "        e_arr.append(e)\n",
    "        t_arr.append(t)\n",
    "    return e_arr, t_arr\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a plot of count time _v_ energy using the `DEFAULT_XAFS_SCAN_SEGMENTS`.  See how the count time changes throughout the post-edge region due to use of `kwt` (_k_-weighted count time) axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='energy', ylabel='count_time'>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "e_arr, t_arr = parse_segments(7.1125, DEFAULT_XAFS_SCAN_SEGMENTS)\n",
    "df = pd.DataFrame(dict(energy=e_arr, count_time=t_arr))\n",
    "df.plot.scatter(\"energy\", \"count_time\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## real-time computation of absorption coefficient\n",
    "The absorption coefficient is computed from the ratio of two scaler channels.  We could compute that either in Python or EPICS.  Here, we choose an EPICS *userCalc* because its setup is more familiar to people experienced with EPICS.  The `instrument` package already provides support for 10 userCalcs.  We'll pick userCalc2 (since userCalc1 is already used by the simulated temperature controller).\n",
    "\n",
    "The computation will update when it gets new values for either scaler channel.  In our `xafs()` scan below, we'll connect (separately, so we don't get all the other data provided by the userCalc support) with the calculated value (_log(I00/I0)_) as an additional _detector_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_absorption_calc(absorption):\n",
    "    \"\"\"\n",
    "    Use a userCalc to compute ln(I00/I0) for real-time plots in collection.\n",
    "\n",
    "    PARAMETERS\n",
    "\n",
    "    absorption\n",
    "        obj: instance of apstools.synApps.SwaitRecord()\n",
    "    \"\"\"\n",
    "    absorption.reset()\n",
    "    s = scaler1.channels\n",
    "    yield from bps.mv(\n",
    "        absorption.channels.A.input_pv, s.chan02.s.pvname,  # I0\n",
    "        absorption.channels.B.input_pv, s.chan06.s.pvname,  # I00\n",
    "        absorption.calculation, \"ln(B/A)\",  # ln(I00/I0)\n",
    "        absorption.scanning_rate, \"I/O Intr\",\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `xafs()` plan\n",
    "\n",
    "With all the pieces defined, it is time to write a plan to measure the XAFS.  The caller must provide the absorption edge energy (in keV).  A list of segments is optional (will default to `DEFAULT_XAFS_SCAN_SEGMENTS` as defined above) so only the absorption edge energy is required.  Once the inputs are checked for correctness, the absorption calculation is setup in an EPICS userCalc ([SwaitRecord](https://apstools.readthedocs.io/en/latest/source/synApps/_swait.html#synapps-swait-record)).  Finally, the 1-D step scan is run by calling [bp.list_scan()](https://blueskyproject.io/bluesky/generated/bluesky.plans.list_scan.html#bluesky.plans.list_scan) with lists of energy and count time values for each step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def xafs(edge_keV, segments=None, detectors=None):\n",
    "    \"\"\"\n",
    "    Scan an edge: (keV\n",
    "\n",
    "    EXAMPLE::\n",
    "\n",
    "        RE(xafs(7.1125))  # scan iron K edge\n",
    "    \"\"\"\n",
    "    if detectors is None:\n",
    "        detectors = [scaler1]\n",
    "    if segments is None:\n",
    "        segments = DEFAULT_XAFS_SCAN_SEGMENTS\n",
    "    if len(segments) == 0:\n",
    "        return  # nothing to do\n",
    "\n",
    "    # use userCalc2 to calculate absorption\n",
    "    absorption = calcs.calc2\n",
    "    yield from prep_absorption_calc(absorption)\n",
    "\n",
    "    # override: just get the one signal\n",
    "    absorption = EpicsSignalRO(\n",
    "        calcs.calc2.calculated_value.pvname,\n",
    "        name=\"absorption\",\n",
    "        kind=\"hinted\"\n",
    "    )\n",
    "    detectors.append(absorption)\n",
    "\n",
    "    scaler1.select_channels((\"I0\", \"I00\"))\n",
    "\n",
    "    energy_list, count_time_list = parse_segments(edge_keV, segments)\n",
    "\n",
    "    comment = (\n",
    "        f\"xafs of {len(segments)} segments (combined) near {edge_keV} keV\"\n",
    "        f\": {len(energy_list)} points total\"\n",
    "    )\n",
    "    logger.info(comment)\n",
    "    yield from bp.list_scan(\n",
    "        detectors,\n",
    "        dcm.energy, energy_list,\n",
    "        scaler1.preset_time, count_time_list,\n",
    "        md=dict(\n",
    "            purpose=comment,\n",
    "            plan_name=\"xafs\"\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the IOC was just started, the motor positions may not allow the monochromator code to operate.  Let's check it and move the motors only if necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial dcm.energy.position=7.4563 keV\n"
     ]
    }
   ],
   "source": [
    "\n",
    "if (\n",
    "    dcm.wavelength.position == 0\n",
    "    and dcm.theta.position == 0\n",
    "    and dcm.y1.get() == 0\n",
    "    and dcm.z2.get() == 0\n",
    "):\n",
    "    from ophyd import EpicsMotor\n",
    "\n",
    "    print(f\"{dcm.name} is not initialized.  Moving motors to start position.\")\n",
    "    # The DCM controls do not allow operation of the underlying motors directly.\n",
    "    # Let's move them anyway, just from this code.\n",
    "    ioc = iconfig.get(\"GP_IOC_PREFIX\")\n",
    "    m_th = EpicsMotor(f\"{ioc}m45\", name=\"m_th\")\n",
    "    m_y1 = EpicsMotor(f\"{ioc}m46\", name=\"m_y1\")\n",
    "    m_z2 = EpicsMotor(f\"{ioc}m47\", name=\"m_z2\")\n",
    "    m_th.wait_for_connection()\n",
    "    m_y1.wait_for_connection()\n",
    "    m_z2.wait_for_connection()\n",
    "    \n",
    "    # we can't use Magicks so use RE to move them together\n",
    "    # These settings are ~3.7 keV, where th & z2 are comparable\n",
    "    # which means it takes roughly the same time to reach this position.\n",
    "    RE(bps.mv(m_th, 32.3, m_y1, -20.7, m_z2, 32.7))\n",
    "\n",
    "print(f\"Initial {dcm.energy.position=:.4f} keV\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## XAFS scan with bluesky"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I Thu-18:20:05 - xafs of 4 segments (combined) near 7.1125 keV: 44 points total\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Transient Scan ID: 965     Time: 2023-04-13 18:20:05\n",
      "Persistent Unique Scan ID: '13d5ecf4-55dd-41d8-9a96-4231230e6200'\n",
      "New stream: 'label_start_motor'\n",
      "New stream: 'primary'\n",
      "+-----------+------------+------------+------------+------------+------------+\n",
      "|   seq_num |       time | dcm_energy |         I0 |        I00 | absorption |\n",
      "+-----------+------------+------------+------------+------------+------------+\n",
      "|         1 | 18:20:07.9 |     6.9125 |          4 |          2 |   -0.69315 |\n",
      "|         2 | 18:20:09.6 |     6.9325 |          3 |          3 |    0.00000 |\n",
      "|         3 | 18:20:11.4 |     6.9525 |          4 |          3 |   -0.28768 |\n",
      "|         4 | 18:20:13.1 |     6.9725 |          3 |          3 |    0.00000 |\n",
      "|         5 | 18:20:14.9 |     6.9925 |          3 |          4 |    0.28768 |\n",
      "|         6 | 18:20:16.7 |     7.0125 |          4 |          2 |   -0.69315 |\n",
      "|         7 | 18:20:18.4 |     7.0325 |          2 |          3 |    0.40547 |\n",
      "|         8 | 18:20:20.1 |     7.0525 |          3 |          4 |    0.28768 |\n",
      "|         9 | 18:20:21.9 |     7.0725 |          2 |          3 |    0.40547 |\n",
      "|        10 | 18:20:23.7 |     7.0925 |          4 |          2 |   -0.69315 |\n",
      "|        11 | 18:20:25.2 |     7.0975 |          3 |          2 |   -0.40547 |\n",
      "|        12 | 18:20:26.6 |     7.1000 |          3 |          3 |    0.00000 |\n",
      "|        13 | 18:20:28.0 |     7.1025 |          3 |          3 |    0.00000 |\n",
      "|        14 | 18:20:29.3 |     7.1050 |          2 |          3 |    0.40547 |\n",
      "|        15 | 18:20:30.7 |     7.1075 |          4 |          2 |   -0.69315 |\n",
      "|        16 | 18:20:32.1 |     7.1092 |          2 |          3 |    0.40547 |\n",
      "|        17 | 18:20:33.5 |     7.1125 |          3 |          3 |    0.00000 |\n",
      "|        18 | 18:20:34.8 |     7.1135 |          3 |          1 |   -1.09861 |\n",
      "|        19 | 18:20:36.2 |     7.1144 |          2 |          3 |    0.40547 |\n",
      "|        20 | 18:20:37.5 |     7.1150 |          2 |          3 |    0.40547 |\n",
      "|        21 | 18:20:38.7 |     7.1156 |          4 |          2 |   -0.69315 |\n",
      "|        22 | 18:20:40.0 |     7.1171 |          2 |          1 |   -0.69315 |\n",
      "|        23 | 18:20:41.3 |     7.1175 |          2 |          4 |    0.69315 |\n",
      "|        24 | 18:20:42.7 |     7.1189 |          2 |          3 |    0.40547 |\n",
      "|        25 | 18:20:44.2 |     7.1200 |          2 |          2 |    0.00000 |\n",
      "|        26 | 18:20:45.6 |     7.1211 |          2 |          2 |    0.00000 |\n",
      "|        27 | 18:20:47.0 |     7.1235 |          2 |          2 |    0.00000 |\n",
      "|        28 | 18:20:48.4 |     7.1263 |          1 |          2 |    0.69315 |\n",
      "|        29 | 18:20:51.3 |     7.1277 |          9 |          7 |   -0.25131 |\n",
      "|        30 | 18:20:54.5 |     7.1363 |         12 |         10 |   -0.18232 |\n",
      "|        31 | 18:20:57.9 |     7.1468 |         10 |         12 |    0.18232 |\n",
      "|        32 | 18:21:01.4 |     7.1582 |         13 |         13 |    0.00000 |\n",
      "|        33 | 18:21:05.1 |     7.1734 |         13 |         14 |    0.07411 |\n",
      "|        34 | 18:21:09.0 |     7.1896 |         12 |         12 |    0.00000 |\n",
      "|        35 | 18:21:13.0 |     7.2078 |         11 |         13 |    0.16705 |\n",
      "|        36 | 18:21:17.1 |     7.2278 |         14 |         16 |    0.13353 |\n",
      "|        37 | 18:21:21.4 |     7.2497 |         15 |         16 |    0.06454 |\n",
      "|        38 | 18:21:25.8 |     7.2735 |         15 |         13 |   -0.14310 |\n",
      "|        39 | 18:21:30.2 |     7.2992 |         14 |         19 |    0.30538 |\n",
      "|        40 | 18:21:34.9 |     7.3268 |         14 |         20 |    0.35667 |\n",
      "|        41 | 18:21:39.7 |     7.3563 |         15 |         20 |    0.28768 |\n",
      "|        42 | 18:21:44.6 |     7.3878 |         16 |         19 |    0.17185 |\n",
      "|        43 | 18:21:49.5 |     7.4211 |         16 |         19 |    0.17185 |\n",
      "|        44 | 18:21:54.5 |     7.4563 |         19 |         18 |   -0.05407 |\n",
      "+-----------+------------+------------+------------+------------+------------+\n",
      "generator xafs ['13d5ecf4'] (scan num: 965)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('13d5ecf4-55dd-41d8-9a96-4231230e6200',)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x1500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# move near the starting point\n",
    "RE(bps.mv(dcm.energy, 7))\n",
    "\n",
    "my_segments = (  # faster than above, just for the demo\n",
    "    # X could be keV, eV, k, or kwt (k-weighted count time)\n",
    "    # axis, start, end, step, count_time\n",
    "    (\"keV\", -.2, -.015, .02, .6),\n",
    "    (\"eV\", -15, 10, 2.5, .5),\n",
    "    (\"k\", .5, 2, .2, 0.4),\n",
    "    (\"kwt\", 2, 10, .5, .5),\n",
    ")\n",
    "\n",
    "# start the scan\n",
    "RE(xafs(7.1125, segments=my_segments))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenges\n",
    "\n",
    "1. Scan XAFS with 3 segments (below-edge, near-edge, above-edge regions).\n",
    "2. Explain why we can't we scan in negative _k_-space.\n",
    "3. Modify the software to allow the user to control the _k_ weighting terms: `factor` and `exponent`.\n",
    "4. Modify the `xafs()` plan to accept user metadata.  (hint: provide for a `md` keyword argument that will be a dictionary.  See `bp.list_scan??` for an example.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "- https://docs.xrayabsorption.org/tutorials/XAFS_Fundamentals.pdf\n",
    "- https://docs.xrayabsorption.org/Workshops/IIT2013/Newville_Theory.pdf\n",
    "- https://en.wikipedia.org/wiki/X-ray_absorption_fine_structure\n",
    "- web tool: https://nbeaver.github.io/k-space-calculator/\n",
    "- https://github.com/nbeaver/k-space-calculator"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "1f009ff395435d424e52d204e98c6bc8bb56df49333235004ff33e4f2779d2a8"
  },
  "kernelspec": {
   "display_name": "Python 3.8.10 64-bit ('bluesky_2021_2': conda)",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}