{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Fly Scans with EPICS motor and scaler\n", "\n", "The `ScalerMotorFlyer()` device from [apstools](https://bcda-aps.github.io/apstools/latest/api/_devices.html#apstools.devices.flyer_motor_scaler.ScalerMotorFlyer) makes it possible to run fly scans with just the EPICS motor and scaler records.\n", "\n", "This combination of positioner and detector represent common EPICS support available to most APS beam lines. An external fly scan controller is not necessary, nor is any dedicated data collection hardware. Keep in mind that the capabilities of the motor and scaler will provide certain limits on how fast the scan completes and how many data points may be collected.\n", "\n", "**Contents**\n", "\n", "- [What is a bluesky/ophyd 'Flyer'?](#Overview)\n", "- [Step-by-step outline of 'ScalerMotorFlyer()'](#Outline)\n", "- [Prepare the session](#Setup)\n", "- [Run the fly scan](#Scan)\n", "- [Get the data and plot it](#Visualize)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Overview\n", "\n", "Q: *What is a bluesky/ophyd `Flyer`?*\n", "\n", "A bluesky/ophyd\n", "[Flyer](https://github.com/bluesky/ophyd/blob/0e8acb3df3d17e0ab7aa2cc924831f4a0c580449/ophyd/flyers.py#L17) is an ophyd [Device](https://github.com/bluesky/ophyd/blob/0e8acb3df3d17e0ab7aa2cc924831f4a0c580449/ophyd/device.py#L778) which describes a data collection process that is not managed by the bluesky RunEngine.\n", "Examples of such data collection processes include:\n", "\n", "- A system using dedicated hardware to control the measurement sequence and collect data.\n", "- Some software that can be called from Python.\n", "- A Python function that runs in a background thread.\n", "\n", "The `Flyer` interfaces with the RunEngine with these three distinct steps:\n", "\n", "1. `kickoff()` : Start the fly scan.\n", "2. `complete()` : Wait for the fly scan to complete.\n", "3. `collect()` : Get (and report) the fly scan data.\n", "\n", "Note: There is an additional step, `describe_collect()`, which informs bluesky\n", "about the type(s) of data reported by `collect()`.\n", "\n", "In `ScalerMotorFlyer()`, the *fly scan* protocol is managed by the\n", "`actions_thread()` method. This method is run in its own thread so it does not\n", "interfere with the bluesky `RunEngine`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Outline\n", "\n", "Here is a step-by-step outline of the fly scan protocol:\n", "\n", "1. Setup\n", " 1. Scaler update rate is set from the requested sampling `period`.\n", "2. Taxi\n", " 1. Motor is sent to the `start` position (using original velocity).\n", " 2. Wait for motor to reach `start` position.\n", "3. Fly\n", " 1. Motor velocity is set based on the requested `start` & `finish` positions and `fly_time` for the scan.\n", " 2. Scaler count time set to `fly_time` plus a smidgen (`scaler_time_pad`).\n", " 3. Start periodic data collection\n", " 1. Scaler provides (EPICS Channel Access) updates as new data is available.\n", " 2. Record motor position & scaler channel counts.\n", " 3. Record time stamps for motor and scaler (probably different).\n", " 4. Data accumulated to internal memory.\n", " 4. Scaler is started to count.\n", " 5. Motor is sent to `finish` (using fly scan velocity).\n", " 6. Wait for motor to stop moving.\n", " 7. Scaler is stopped.\n", " 8. Stop periodic data collection\n", "4. Finish\n", " 1. Reset to previous values\n", " 1. motor velocity\n", " 2. scaler update rate\n", " 2. Report any acquired data to Bluesky RunEngine.\n", " 1. Data for each counter is reported as the difference of successive readings.\n", "\n", "If any exceptions are raised by steps 1-3 (such as cannot set a value, timeout, wrong type of parameter given, ...), skip directly to step 4." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Setup\n", "\n", "Without [more explanation here](https://bcda-aps.github.io/apstools/latest/examples/de_0_adsim_hdf5_basic.html#bluesky), we set up our bluesky session for data acquisition, importing needed libraries and constructing the RunEngine and databroker for a temporary catalog. We will use an [EPICS IOC](https://hub.docker.com/r/prjemian/custom-synapps-6.2/tags) with the prefix `gp:`. This IOC provides a simulated motor and a simulated scaler, among other [features](https://github.com/prjemian/epics-docker/tree/main/v1.1/n5_custom_synApps#readmemd). The scaler is preconfigured with detector inputs. When the scaler is counting, its counters (detector channels) are updated by random integers." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%matplotlib inline\n", "from apstools.devices import make_dict_device\n", "from apstools.devices import ScalerMotorFlyer\n", "from bluesky import plan_stubs as bps\n", "from bluesky import plans as bp\n", "from bluesky import preprocessors as bpp\n", "from bluesky import RunEngine\n", "from bluesky.callbacks.best_effort import BestEffortCallback\n", "from matplotlib import pyplot as plt\n", "from ophyd import EpicsMotor\n", "from ophyd.scaler import ScalerCH\n", "import databroker\n", "\n", "IOC = \"gp:\"\n", "\n", "# ophyd-level\n", "m1 = EpicsMotor(f\"{IOC}m10\", name=\"motor\")\n", "scaler = ScalerCH(f\"{IOC}scaler1\", name=\"scaler\")\n", "m1.wait_for_connection()\n", "scaler.wait_for_connection()\n", "scaler.select_channels()\n", "\n", "# bluesky-level\n", "cat = databroker.temp().v2\n", "plt.ion() # enables matplotlib graphics\n", "RE = RunEngine({})\n", "RE.subscribe(cat.v1.insert)\n", "best_effort_callback = BestEffortCallback()\n", "RE.subscribe(best_effort_callback) # LivePlot & LiveTable" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Create the `flyer` object that will be used by the bluesky [fly()](https://blueskyproject.io/bluesky/generated/bluesky.plans.fly.html#bluesky.plans.fly) plan. The `ScalerMotorFlyer()` deivce supports the ophyd flyer interface, as described above.\n", "\n", "In this example, we describe a fly scan from motor position 1 to 5 that should take 4 seconds, collecting data at 0.1 second intervals. Other keyword parameters are accepted. See the documentation for full details." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "flyer = ScalerMotorFlyer(scaler, m1, 1, 5, fly_time=4, period=.1, name=\"flyer\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Augment the *standard* (a.k.a. bluesky pre-assembled) [`bp.fly()`](https://blueskyproject.io/bluesky/generated/bluesky.plans.fly.html#bluesky.plans.fly) plan to save the peak statistics to a separate stream in the run after the fly scan is complete." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def fly_with_stats(flyers, *, md=None):\n", " \"\"\"Replaces bp.fly(), adding stream for channel stats.\"\"\"\n", "\n", " @bpp.stage_decorator(flyers)\n", " @bpp.run_decorator(md=md)\n", " @bpp.stub_decorator()\n", " def _inner_fly():\n", " yield from bp.fly(flyers)\n", " for flyer in flyers:\n", " if hasattr(flyer, \"stats\") and isinstance(flyer.stats, dict):\n", " yield from _flyer_stats_stream(flyer, f\"{flyer.name}_stats\")\n", "\n", " def _flyer_stats_stream(flyer, stream=None):\n", " \"\"\"Output stats from this flyer into separate stream.\"\"\"\n", " yield from bps.create(name=stream or f\"{flyer.name}_stats\")\n", " for ch in list(flyer.stats.keys()):\n", " yield from bps.read(\n", " make_dict_device(\n", " {\n", " # fmt: off\n", " stat: v\n", " for stat, v in flyer.stats[ch].to_dict().items()\n", " if v is not None\n", " # fmt: on\n", " },\n", " name=ch\n", " )\n", " )\n", " yield from bps.save()\n", "\n", " yield from _inner_fly()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Scan\n", "\n", "Using our `flyer` device with the bluesky [fly()](https://blueskyproject.io/bluesky/generated/bluesky.plans.fly.html#bluesky.plans.fly) plan, run the fly scan. Supply additional metadata so we can label our plot. The call to `RE()` returns a list of the uids for each run that was executed. Collect this list (we expect only one uid in the list) for later use when accessing the run from the databroker." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "Transient Scan ID: 1 Time: 2022-12-14 12:42:21\n", "Persistent Unique Scan ID: '50b5225e-f698-46c2-9b54-c2038e635826'\n", "New stream: 'primary'\n", "+-----------+------------+\n", "| seq_num | time |\n", "+-----------+------------+\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/prjemian/micromamba/envs/bluesky_2022_3/lib/python3.9/site-packages/event_model/__init__.py:208: UserWarning: The document type 'bulk_events' has been deprecated in favor of 'event_page', whose structure is a transpose of 'bulk_events'.\n", " warnings.warn(\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "New stream: 'flyer_stats'\n", "+-----------+------------+\n", "generator fly_with_stats ['50b5225e'] (scan num: 1)\n", "\n", "\n", "\n" ] } ], "source": [ "uids = RE(fly_with_stats([flyer], md=dict(title=\"Demonstrate a scaler v. motor fly scan.\")))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the LiveTable and LivePlot from the BestEffortCallback do not yet know how to show this data, so they report minimal information about the fly scan." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Visualize\n", "\n", "To make a plot of the data, first get the run from the databroker, identified here by its uid." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "BlueskyRun\n", " uid='50b5225e-f698-46c2-9b54-c2038e635826'\n", " exit_status='success'\n", " 2022-12-14 12:42:21.253 -- 2022-12-14 12:42:29.889\n", " Streams:\n", " * flyer_stats\n", " * primary\n" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "run = cat.v2[uids[0]]\n", "run" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Show some of the run's metadata, verifying that we are looking at the run we just acquired." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "run.metadata['start']['scan_id']=1\n", "run.metadata['start']['title']='Demonstrate a scaler v. motor fly scan.'\n" ] } ], "source": [ "print(f\"{run.metadata['start']['scan_id']=}\")\n", "print(f\"{run.metadata['start']['title']=}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `run` has a single stream of data, named `primary`. Get the data from that stream:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset>\n",
       "Dimensions:              (time: 41)\n",
       "Coordinates:\n",
       "  * time                 (time) float64 1.671e+09 1.671e+09 ... 1.671e+09\n",
       "Data variables:\n",
       "    motor                (time) float64 1.09 1.19 1.19 1.29 ... 4.8 4.9 4.97 5.0\n",
       "    motor_user_setpoint  (time) float64 5.0 5.0 5.0 5.0 5.0 ... 5.0 5.0 5.0 5.0\n",
       "    clock                (time) float64 1e+06 1e+06 1e+06 ... 1e+06 1e+06 1e+06\n",
       "    I0                   (time) float64 0.0 1.0 0.0 0.0 1.0 ... 1.0 1.0 0.0 1.0\n",
       "    I00                  (time) float64 0.0 0.0 0.0 1.0 0.0 ... 0.0 1.0 0.0 1.0\n",
       "    scint                (time) float64 0.0 1.0 1.0 0.0 1.0 ... 1.0 0.0 1.0 0.0\n",
       "    diode                (time) float64 0.0 0.0 0.0 1.0 1.0 ... 1.0 1.0 0.0 0.0\n",
       "    scaler_time          (time) float64 0.1 0.1 0.1 0.1 0.1 ... 0.1 0.1 0.1 0.1
" ], "text/plain": [ "\n", "Dimensions: (time: 41)\n", "Coordinates:\n", " * time (time) float64 1.671e+09 1.671e+09 ... 1.671e+09\n", "Data variables:\n", " motor (time) float64 1.09 1.19 1.19 1.29 ... 4.8 4.9 4.97 5.0\n", " motor_user_setpoint (time) float64 5.0 5.0 5.0 5.0 5.0 ... 5.0 5.0 5.0 5.0\n", " clock (time) float64 1e+06 1e+06 1e+06 ... 1e+06 1e+06 1e+06\n", " I0 (time) float64 0.0 1.0 0.0 0.0 1.0 ... 1.0 1.0 0.0 1.0\n", " I00 (time) float64 0.0 0.0 0.0 1.0 0.0 ... 0.0 1.0 0.0 1.0\n", " scint (time) float64 0.0 1.0 1.0 0.0 1.0 ... 1.0 0.0 1.0 0.0\n", " diode (time) float64 0.0 0.0 0.0 1.0 1.0 ... 1.0 1.0 0.0 0.0\n", " scaler_time (time) float64 0.1 0.1 0.1 0.1 0.1 ... 0.1 0.1 0.1 0.1" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dataset = run.primary.read()\n", "dataset" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Choose data for the x and y axes from the `dataset` names:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "x = dataset[\"motor\"]\n", "y = dataset[\"diode\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Plot the data using matplotlib's [pyplot](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html) module. (The `pyplot as plt` library was imported above.)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'diode')" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "title = (\n", " f\"#{run.metadata['start']['scan_id']}\"\n", " f\": {run.metadata['start']['title']}\"\n", ")\n", "plt.plot(x.values, y.values)\n", "plt.title(title)\n", "plt.xlabel(x.name)\n", "plt.ylabel(y.name)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Show statistics collected for each scaler channel." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset>\n",
       "Dimensions:                 (time: 1)\n",
       "Coordinates:\n",
       "  * time                    (time) float64 1.671e+09\n",
       "Data variables: (12/81)\n",
       "    I0_mean_x               (time) float64 3.046\n",
       "    I0_mean_y               (time) float64 0.4878\n",
       "    I0_stddev_x             (time) float64 1.213\n",
       "    I0_stddev_y             (time) float64 0.5061\n",
       "    I0_slope                (time) float64 0.04756\n",
       "    I0_intercept            (time) float64 0.343\n",
       "    ...                      ...\n",
       "    diode_sigma             (time) float64 1.154\n",
       "    diode_min_x             (time) float64 1.09\n",
       "    diode_max_x             (time) float64 5.0\n",
       "    diode_min_y             (time) float64 0.0\n",
       "    diode_max_y             (time) float64 1.0\n",
       "    diode_x_at_max_y        (time) float64 4.9
" ], "text/plain": [ "\n", "Dimensions: (time: 1)\n", "Coordinates:\n", " * time (time) float64 1.671e+09\n", "Data variables: (12/81)\n", " I0_mean_x (time) float64 3.046\n", " I0_mean_y (time) float64 0.4878\n", " I0_stddev_x (time) float64 1.213\n", " I0_stddev_y (time) float64 0.5061\n", " I0_slope (time) float64 0.04756\n", " I0_intercept (time) float64 0.343\n", " ... ...\n", " diode_sigma (time) float64 1.154\n", " diode_min_x (time) float64 1.09\n", " diode_max_x (time) float64 5.0\n", " diode_min_y (time) float64 0.0\n", " diode_max_y (time) float64 1.0\n", " diode_x_at_max_y (time) float64 4.9" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "run.flyer_stats.read()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "There's a new utility function `apstools` since version 1.6.10: `plotxy()` does all these steps. Returns the exact, same results for just the named signals, plus a [computed](https://brainder.org/2011/08/20/gaussian-kernels-convert-fwhm-to-sigma/) ``fwhm = 2*sigma*sqrt(2ln(2))``. Lines are drawn at the centroid and fwhm." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{1: {'mean_x': 3.0456097560975612,\n", " 'mean_y': 0.4634146341463415,\n", " 'stddev_x': 1.2126995686906301,\n", " 'stddev_y': 0.5048544827774513,\n", " 'slope': 0.009237722080560458,\n", " 'intercept': 0.4352801376536687,\n", " 'correlation': 0.02218972390053605,\n", " 'centroid': 3.0742105263157895,\n", " 'sigma': 1.1539466182557723,\n", " 'min_x': 1.09,\n", " 'max_x': 5.0,\n", " 'min_y': 0.0,\n", " 'max_y': 1.0,\n", " 'x_at_max_y': 4.9,\n", " 'fwhm': 2.7173366275643693}}" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from apstools.utils import plotxy\n", "plotxy(run, \"motor\", \"diode\")" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3.9.13 ('base')", "language": "python", "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.9.13 | packaged by conda-forge | (main, May 27 2022, 16:56:21) \n[GCC 10.3.0]" }, "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "f38aef175fb08dfc130a7d9bb9234f0792dc9ad861f95b6c05aedd1b380356e2" } } }, "nbformat": 4, "nbformat_minor": 2 }