basic-motor-scaler-scan.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Minimal: Scan scaler *vs* motor\n",
    "\n",
    "*APS Training for Bluesky Data Acquisition*.\n",
    "\n",
    "**Objective**\n",
    "\n",
    "Connect an EPICS motor PV, an EPICS scaler PV, and scan using the bluesky *RunEngine* with the *BestEffortCallback* to visualize the acquired data.\n",
    "\n",
    "EPICS PV | Python object name | description\n",
    ":--- | :--- | :---\n",
    "`gp:m1` | `xpos` | motor PV (simulates a stepper motor)\n",
    "`gp:scaler1` | `vsc16` | scaler PV (simulates a Joerger VSC16 scaler)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Connect the motor\n",
    "\n",
    "First, import the [`ophyd.EpicsMotor`](https://blueskyproject.io/ophyd/generated/ophyd.epics_motor.EpicsMotor.html?highlight=epicsmotor#ophyd.epics_motor.EpicsMotor) (class) definition.  This Python class from `ophyd` is the best representation of the synApps [motor](https://github.com/epics-modules/motor) record."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "from ophyd import EpicsMotor"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Then, define the `xpos` object.  The EPICS PV is the first argument.  The `name=\"xpos\"` is\n",
    "required.  Make the value of this keyword argument match the name of the Python object being assigned.  The `labels=(\"motor\",)` keyword argument enables certain features for the user interface that will be described later."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "xpos = EpicsMotor(\"gp:m1\", name=\"xpos\", labels=(\"motor\",))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Wait for that to connect with EPICS"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "xpos.wait_for_connection()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Show the position of the `xpos` motor now."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "xpos.position"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "-0.3"
      ]
     },
     "metadata": {},
     "execution_count": 4
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Try to move `xpos` using the IPython magic command: `%mov`."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "# wrap in a try..except handler so notebook can run past this point\n",
    "try:\n",
    "    %mov xpos 1\n",
    "except Exception as exc:\n",
    "    print(f\"Exception: {exc}\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Exception: Line magic function `%mov` not found.\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Note this command fails since the IPython magic commands are not loaded automatically.  As an alternative, use the motor's `.move(SETPOINT)` method to move the motor to the new *SETPOINT* value.  Here, move `xpos` to `1`."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "xpos.move(1)"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "MoveStatus(done=True, pos=xpos, elapsed=1.5, success=True, settle_time=0.0)"
      ]
     },
     "metadata": {},
     "execution_count": 6
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "The `.move()` method returns a status object.  The status object may be used to report about the move or to wait for the motor to complete its move.\n",
    "\n",
    "Next, load the IPython *Magic* commands provided by `bluesky`.  These are helpers to make the command line use easier.  Use them at your choice."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "from bluesky.magics import BlueskyMagics\n",
    "get_ipython().register_magics(BlueskyMagics)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Repeat the move of `xpos` by sending it to `0` using the magic command."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "%mov xpos 0"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "xpos:   9%|██▌                         | 0.09/1.0 [00:00<00:01,  1.46s/degrees]\n",
      "xpos:  19%|█████▎                      | 0.19/1.0 [00:00<00:00,  1.22s/degrees]\n",
      "xpos:  29%|███████▊                   | 0.291/1.0 [00:00<00:00,  1.15s/degrees]\n",
      "xpos:  39%|██████████▌                | 0.391/1.0 [00:00<00:00,  1.11s/degrees]\n",
      "xpos:  49%|█████████████▎             | 0.491/1.0 [00:00<00:00,  1.09s/degrees]\n",
      "xpos:  59%|███████████████▉           | 0.592/1.0 [00:00<00:00,  1.07s/degrees]\n",
      "xpos:  69%|██████████████████▋        | 0.692/1.0 [00:00<00:00,  1.06s/degrees]\n",
      "xpos:  79%|█████████████████████▍     | 0.793/1.0 [00:00<00:00,  1.05s/degrees]\n",
      "xpos:  89%|████████████████████████▏  | 0.894/1.0 [00:00<00:00,  1.05s/degrees]\n",
      "xpos:  97%|███████████████████████████▏| 0.97/1.0 [00:01<00:00,  1.07s/degrees]\n",
      "xpos: 100%|██████████████████████████▉| 0.999/1.0 [00:01<00:00,  1.14s/degrees]\n",
      "xpos: 100%|█████████████████████████████| 1.0/1.0 [00:01<00:00,  1.24s/degrees]\n",
      "xpos [In progress. No progress bar available.]                                 \n",
      "                                                                               \n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Connect the scaler\n",
    "\n",
    "The `ophyd` package provides two representations of the synApps [scaler](https://github.com/epics-modules/scaler) record ([`EpicsScaler`](https://blueskyproject.io/ophyd/reference/builtin-devices.html#epicsscaler) and [`ScalerCH`](https://blueskyproject.io/ophyd/reference/builtin-devices.html#scalerch)).  My _opinion_ is that the `ScalerCH` class provides the representation most compatible with use at the APS.\n",
    "\n",
    "As before, import the ophyd class:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "from ophyd.scaler import ScalerCH"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Then, connect with the EPICS PV.  This is similar to how the motor was connected (above).  Make the `name=` keyword match with the Python object name being created.   The `labels=(\"scalers\", \"detectors\")` keyword argument enables certain features for the user interface that will be described later."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "vsc16 = ScalerCH(\"gp:scaler1\", name=\"vsc16\", labels=[\"scalers\", \"detectors\"])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Configure the Python object to ignore the channels with no name defined (in the `.NMnn` field of the scaler PV).\n",
    "\n",
    "In this example control screen for our scaler, only a few of the channels are named:\n",
    "\n",
    "![`scaler` GUI](resources/scaler.png \"`scaler1` GUI\")"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "vsc16.select_channels()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Show the value for each of the named channels in **our** scaler.  This will also include the most recent count time."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "vsc16.read()"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "OrderedDict([('timebase',\n",
       "              {'value': 6000000.0, 'timestamp': 1629391538.435033}),\n",
       "             ('I0', {'value': 1.0, 'timestamp': 1629391538.435033}),\n",
       "             ('scint', {'value': 2.0, 'timestamp': 1629391538.435033}),\n",
       "             ('diode', {'value': 3.0, 'timestamp': 1629391538.435033}),\n",
       "             ('I00', {'value': 3.0, 'timestamp': 1629391538.435033}),\n",
       "             ('roi1', {'value': 0.0, 'timestamp': 1629391538.435033}),\n",
       "             ('roi2', {'value': 0.0, 'timestamp': 1629391538.435033}),\n",
       "             ('vsc16_time', {'value': 0.6, 'timestamp': 1629391538.435033})])"
      ]
     },
     "metadata": {},
     "execution_count": 12
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "If *no* channels are shown, such as:\n",
    "\n",
    "```python\n",
    "OrderedDict([('vsc16_time', {'value': 0.0, 'timestamp': 631152000.0})])\n",
    "```\n",
    "\n",
    "then we want to name some channels here for our simulator.  We can do this directly from Python (although you would not usually want to do this at a real, operating instrument, since the channels are named as a result of hardware connections with real detectors).  We'll take channels 1-5 for `timebase`, `I0`, `scint`, `diode`, & `I00`, then skip a few channels to 11 & 12 and call them `roi1` & `roi2`, respectively.\n",
    "\n",
    "It's OK to have empty (that is, unnamed) channels.  It's not OK to have white space in these names since the names will be used as Python objects within bluesky.  That also means no other characters (such as math symbols and such) that cannot be used as a [Python object name](https://www.python.org/dev/peps/pep-0008/#naming-conventions).  Also, do not use the same name in two different scaler channels."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "vsc16.channels.chan01.chname.put(\"timebase\")\n",
    "vsc16.channels.chan02.chname.put(\"I0\")\n",
    "vsc16.channels.chan03.chname.put(\"scint\")\n",
    "vsc16.channels.chan04.chname.put(\"diode\")\n",
    "vsc16.channels.chan05.chname.put(\"I00\")\n",
    "vsc16.channels.chan11.chname.put(\"roi1\")\n",
    "vsc16.channels.chan12.chname.put(\"roi2\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Then select the named channels and read again:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "source": [
    "vsc16.select_channels()\n",
    "vsc16.read()"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "OrderedDict([('timebase',\n",
       "              {'value': 6000000.0, 'timestamp': 1629391538.435033}),\n",
       "             ('I0', {'value': 1.0, 'timestamp': 1629391538.435033}),\n",
       "             ('scint', {'value': 2.0, 'timestamp': 1629391538.435033}),\n",
       "             ('diode', {'value': 3.0, 'timestamp': 1629391538.435033}),\n",
       "             ('I00', {'value': 3.0, 'timestamp': 1629391538.435033}),\n",
       "             ('roi1', {'value': 0.0, 'timestamp': 1629391538.435033}),\n",
       "             ('roi2', {'value': 0.0, 'timestamp': 1629391538.435033}),\n",
       "             ('vsc16_time', {'value': 0.6, 'timestamp': 1629391538.435033})])"
      ]
     },
     "metadata": {},
     "execution_count": 14
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Set the scaler's counting time\n",
    "\n",
    "The `ScalerCH` class defines the count time as the `preset_time` attribute.  Show it's value:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "source": [
    "vsc16.preset_time.get()"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "metadata": {},
     "execution_count": 15
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Set the counting time to 0.5 s using the `%mov` magic command (same command that moves a motor)."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "source": [
    "%mov vsc16.preset_time 0.5"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Use the IPython `%ct` magic command to count each object with the `detectors` label keyword."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "source": [
    "vsc16.preset_time.get()"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "metadata": {},
     "execution_count": 17
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "source": [
    "ct"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[This data will not be saved. Use the RunEngine to collect data.]\n",
      "timebase                       6000000.0\n",
      "I0                             2.0\n",
      "scint                          3.0\n",
      "diode                          2.0\n",
      "I00                            2.0\n",
      "roi1                           0.0\n",
      "roi2                           0.0\n",
      "vsc16_time                     0.6\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "source": [
    "%ct"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[This data will not be saved. Use the RunEngine to collect data.]\n",
      "timebase                       6000000.0\n",
      "I0                             3.0\n",
      "scint                          2.0\n",
      "diode                          3.0\n",
      "I00                            2.0\n",
      "roi1                           0.0\n",
      "roi2                           0.0\n",
      "vsc16_time                     0.6\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### `labels` and the `%wa` magic command\n",
    "\n",
    "As noted above, the `labels=LIST` keyword argument used when the motor and scaler objects were create enable certain features.  For example, the `%ct` magic command will count all the `detectors`.\n",
    "\n",
    "Actually, `detectors` is the default argument for the `%ct` magic.  If an arument is supplied, it is the name of a label to be matched.  This is why the additional label of `scalers` was included.  Thus, we could count *only* `scalers` with the command `%ct scalers`.\n",
    "\n",
    "Use the `labels` keyword liberally to group similar objects.\n",
    "\n",
    "The `%wa` magic shows relevant information for all labeled objects (or, for the named label if supplied).  For example:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "source": [
    "%wa"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "motor\n",
      "  Positioner                     Value       Low Limit   High Limit  Offset     \n",
      "  xpos                           0.0         -32000.0    32000.0     0.0        \n",
      "\n",
      "  Local variable name                    Ophyd name (to be recorded as metadata)\n",
      "  xpos                                   xpos                                  \n",
      "\n",
      "scalers\n",
      "  Local variable name                    Ophyd name (to be recorded as metadata)\n",
      "  vsc16                                  vsc16                                 \n",
      "\n",
      "detectors\n",
      "  Local variable name                    Ophyd name (to be recorded as metadata)\n",
      "  vsc16                                  vsc16                                 \n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "source": [
    "%wa motor"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "motor\n",
      "  Positioner                     Value       Low Limit   High Limit  Offset     \n",
      "  xpos                           0.0         -32000.0    32000.0     0.0        \n",
      "\n",
      "  Local variable name                    Ophyd name (to be recorded as metadata)\n",
      "  xpos                                   xpos                                  \n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Prepare to scan\n",
    "\n",
    "Before we can run our first bluesky scan, we have to import various software tools.\n",
    "\n",
    "First is the bluesky `RunEngine()`, which will manage the various activities for the scan (move motor, wait, trigger scaler, wait, collect channel data, publish to data subscribers, ...).\n",
    "\n",
    "Create a `RunEngine()` object.  The argument here is a dictionary (empty in this training session).  (For routine operations at an instrument, the dictionary is filled with information saved from the previous session.)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "source": [
    "import bluesky\n",
    "RE = bluesky.RunEngine({})"
   ],
   "outputs": [],
   "metadata": {
    "tags": []
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "To save the acquired data, we connect with a MongoDB database using a preconfigured datafile that describes our *training* catalog.  Using the IPython `!` technique to issue a Linux command from an IPython session, we `cat` (concatenate) the contents of that file to the output here:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "source": [
    "!cat ~/.local/share/intake/training.yml"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "# file: training.yml\n",
      "# purpose: Configuration file to connect Bluesky databroker with MongoDB\n",
      "# For Bluesky Python Training at APS\n",
      "\n",
      "# Copy to: ~/.local/share/intake/training.yml\n",
      "# Create subdirectories as needed\n",
      "\n",
      "sources:\n",
      "  training:\n",
      "    args:\n",
      "      asset_registry_db: mongodb://localhost:27017/training-bluesky\n",
      "      metadatastore_db: mongodb://localhost:27017/training-bluesky\n",
      "    driver: bluesky-mongo-normalized-catalog\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "To connect, we need the *training* catalog.  This name is provided by the line indented after the `sources:` line in the above `.yml` file.  (The name of the `.yml` file does not matter.  The `databroker.catalog` software will look through all `.yml` files in this directory for the`training` configuration.)\n",
    "\n",
    "We'll use the reference to our databroker catalog frequently, so we give it a short name."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "source": [
    "import databroker\n",
    "db = databroker.catalog[\"training\"]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "How many (bluesky data collection) *runs* are recorded in this catalog?  Get its *length*:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "source": [
    "len(db)"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "68"
      ]
     },
     "metadata": {},
     "execution_count": 25
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Configure `RE` to publish the run data to our `db` object.  We must use the `.v1` software interface for legacy reasons."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "source": [
    "RE.subscribe(db.v1.insert)"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "metadata": {},
     "execution_count": 26
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "A progress bar can be helpful to show that long operations are actually progressing.  These steps load a progress bar and configure `RE`."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "source": [
    "from bluesky.utils import ProgressBarManager\n",
    "pbar_manager = ProgressBarManager()\n",
    "RE.waiting_hook = pbar_manager"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "The `BestEffortCallback` provides easy visualization of data (tables, plots, peaks statistics) as it is acquired by the `RE`.  Subscribe it to the `RE` so it receives data during a `RE()` run."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "source": [
    "from bluesky.callbacks.best_effort import BestEffortCallback\n",
    "bec = BestEffortCallback()\n",
    "RE.subscribe(bec)\n",
    "peaks = bec.peaks"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Supplemental *baseline* data is recorded before and after each run.  Additionally, EPICS Channel Access monitors can update PVs asynchronous to the primary data acquisition.  These *monitor*s can be saved as additional data streams in a run.  Prepare to use this feature."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "source": [
    "from bluesky import SupplementalData\n",
    "sd = SupplementalData()\n",
    "RE.preprocessors.append(sd)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Add the name of this notebook as metadata to every run.  This is done by adding to the RunEngine's metadata dictionary (`RE.md`), content that will be added to the *start* document of every run.  The metadata is useful documentation about a run and can be used for several purposes, such as to record a general condition (such as the name of this notebook) or to identify these runs from a database search."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "source": [
    "RE.md[\"notebook\"] = \"basic-motor-scaler-scan\""
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Summary of preparations for scanning\n",
    "\n",
    "- EPICS connections to motor and scaler\n",
    "- databroker\n",
    "- RunEngine\n",
    "- subscriptions\n",
    "    - databroker\n",
    "    - ProgressBarManager\n",
    "    - BestEffortCallback (tables and plots)\n",
    "    - supplemental data (monitors and baselines)\n",
    "- metadata"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## First scan\n",
    "\n",
    "The standard plans provided in [`bluesky.plans`](https://blueskyproject.io/bluesky/plans.html#pre-assembled-plans) are sufficient for many needs, so import them and, in the same command, give the package a short name (`bp`) since it is used frequently."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "source": [
    "from bluesky import plans as bp"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "The [`scan()`](https://blueskyproject.io/bluesky/generated/bluesky.plans.scan.html#bluesky.plans.scan) plan is flexible and will be used here to scan scaler *vs.* motor.  The first argument is the *list* of detectors to be recorded.  Here, we give the scaler object `vsc16`.  The next argument is the positioner object, then start and end positions, finally, the number of points to be collected.\n",
    "\n",
    "Observe that we do not run the scan directly, but rather give the scan to the `RE()` object.  The `RE()` object will run the scan, performing each of the actions defined by the scan, but also handle the additional tasks of managing the data acquisition process, publishing data to all subscribers (here: databroker and BestEffortCallback) and checking for updates from EPICS and checking if the run must be interrupted either by user request or some other observation.  (We have not configured any of those other observations in this simple example.)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "source": [
    "RE(bp.scan([vsc16], xpos, -1, 1, 7))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n",
      "\n",
      "Transient Scan ID: 1     Time: 2021-08-19 14:02:41\n",
      "Persistent Unique Scan ID: 'fb41419c-0aef-4ff4-8992-7aa2b62f9931'\n",
      "xpos:   9%|██▍                        | 0.091/1.0 [00:00<00:01,  1.97s/degrees]\n",
      "xpos:  19%|█████▎                      | 0.19/1.0 [00:00<00:01,  1.47s/degrees]\n",
      "xpos:  29%|████████                    | 0.29/1.0 [00:00<00:00,  1.31s/degrees]\n",
      "xpos:  39%|██████████▉                 | 0.39/1.0 [00:00<00:00,  1.23s/degrees]\n",
      "xpos:  49%|█████████████▎             | 0.491/1.0 [00:00<00:00,  1.18s/degrees]\n",
      "xpos:  59%|███████████████▉           | 0.591/1.0 [00:00<00:00,  1.15s/degrees]\n",
      "xpos:  69%|██████████████████▋        | 0.691/1.0 [00:00<00:00,  1.13s/degrees]\n",
      "xpos:  79%|█████████████████████▍     | 0.792/1.0 [00:00<00:00,  1.11s/degrees]\n",
      "xpos:  89%|████████████████████████   | 0.892/1.0 [00:00<00:00,  1.10s/degrees]\n",
      "xpos:  97%|██████████████████████████▏| 0.968/1.0 [00:01<00:00,  1.12s/degrees]\n",
      "xpos: 100%|██████████████████████████▉| 0.999/1.0 [00:01<00:00,  1.18s/degrees]\n",
      "xpos: 100%|█████████████████████████████| 1.0/1.0 [00:01<00:00,  1.28s/degrees]\n",
      "xpos [In progress. No progress bar available.]                                 \n",
      "                                                                               \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "                                                                               \n",
      "New stream: 'primary'\n",
      "+-----------+------------+------------+------------+------------+------------+------------+------------+------------+------------+\n",
      "|   seq_num |       time |       xpos |   timebase |         I0 |      scint |      diode |        I00 |       roi1 |       roi2 |\n",
      "+-----------+------------+------------+------------+------------+------------+------------+------------+------------+------------+\n",
      "|         1 | 14:02:43.7 |   -1.00000 |    6000000 |          3 |          2 |          1 |          3 |          0 |          0 |\n",
      "xpos:  27%|██████▎                | 0.091/0.33333 [00:00<00:00,  1.79s/degrees]\n",
      "xpos:  57%|█████████████▋          | 0.19/0.33333 [00:00<00:00,  1.38s/degrees]\n",
      "xpos:  84%|████████████████████▏   | 0.28/0.33333 [00:00<00:00,  1.29s/degrees]\n",
      "xpos:  98%|██████████████████████▌| 0.327/0.33333 [00:00<00:00,  1.42s/degrees]\n",
      "xpos: 100%|██████████████████████▉| 0.333/0.33333 [00:00<00:00,  1.69s/degrees]\n",
      "xpos [In progress. No progress bar available.]                                 \n",
      "                                                                               \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "                                                                               \n",
      "|         2 | 14:02:45.8 |   -0.66700 |    6000000 |          3 |          3 |          3 |          2 |          0 |          0 |\n",
      "xpos:  27%|██████▎                | 0.091/0.33367 [00:00<00:00,  2.07s/degrees]\n",
      "xpos:  57%|█████████████▏         | 0.191/0.33367 [00:00<00:00,  1.52s/degrees]\n",
      "xpos:  84%|███████████████████▎   | 0.281/0.33367 [00:00<00:00,  1.39s/degrees]\n",
      "xpos:  98%|██████████████████████▌| 0.327/0.33367 [00:00<00:00,  1.50s/degrees]\n",
      "xpos: 100%|█████████████████████| 0.33367/0.33367 [00:00<00:00,  1.77s/degrees]\n",
      "xpos [In progress. No progress bar available.]                                 \n",
      "                                                                               \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "                                                                               \n",
      "|         3 | 14:02:48.0 |   -0.33300 |    6000000 |          2 |          2 |          2 |          3 |          0 |          0 |\n",
      "xpos:  27%|██████▊                  | 0.091/0.333 [00:00<00:00,  1.42s/degrees]\n",
      "xpos:  57%|██████████████▎          | 0.191/0.333 [00:00<00:00,  1.20s/degrees]\n",
      "xpos:  84%|█████████████████████▊    | 0.28/0.333 [00:00<00:00,  1.18s/degrees]\n",
      "xpos:  98%|████████████████████████▌| 0.327/0.333 [00:00<00:00,  1.32s/degrees]\n",
      "xpos: 100%|█████████████████████████| 0.333/0.333 [00:00<00:00,  1.60s/degrees]\n",
      "xpos [In progress. No progress bar available.]                                 \n",
      "                                                                               \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "                                                                               \n",
      "|         4 | 14:02:50.1 |    0.00000 |    6000000 |          1 |          3 |          1 |          2 |          0 |          0 |\n",
      "xpos:  27%|██████▍                 | 0.09/0.33333 [00:00<00:00,  1.35s/degrees]\n",
      "xpos:  57%|█████████████▋          | 0.19/0.33333 [00:00<00:00,  1.16s/degrees]\n",
      "xpos:  84%|████████████████████▏   | 0.28/0.33333 [00:00<00:00,  1.15s/degrees]\n",
      "xpos:  98%|██████████████████████▌| 0.327/0.33333 [00:00<00:00,  1.29s/degrees]\n",
      "xpos: 100%|██████████████████████▉| 0.333/0.33333 [00:00<00:00,  1.57s/degrees]\n",
      "xpos [In progress. No progress bar available.]                                 \n",
      "                                                                               \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "                                                                               \n",
      "|         5 | 14:02:52.1 |    0.33300 |    6000000 |          3 |          2 |          3 |          3 |          0 |          0 |\n",
      "xpos:  27%|██████▎                | 0.091/0.33367 [00:00<00:00,  1.26s/degrees]\n",
      "xpos:  57%|█████████████▏         | 0.191/0.33367 [00:00<00:00,  1.13s/degrees]\n",
      "xpos:  84%|███████████████████▎   | 0.281/0.33367 [00:00<00:00,  1.13s/degrees]\n",
      "xpos:  98%|██████████████████████▌| 0.327/0.33367 [00:00<00:00,  1.27s/degrees]\n",
      "xpos: 100%|█████████████████████| 0.33367/0.33367 [00:00<00:00,  1.55s/degrees]\n",
      "xpos [In progress. No progress bar available.]                                 \n",
      "                                                                               \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "                                                                               \n",
      "|         6 | 14:02:54.2 |    0.66700 |    6000000 |          3 |          3 |          3 |          3 |          0 |          0 |\n",
      "xpos:  27%|███████                   | 0.09/0.333 [00:00<00:00,  1.90s/degrees]\n",
      "xpos:  57%|██████████████▊           | 0.19/0.333 [00:00<00:00,  1.43s/degrees]\n",
      "xpos:  84%|█████████████████████▊    | 0.28/0.333 [00:00<00:00,  1.33s/degrees]\n",
      "xpos:  98%|████████████████████████▌| 0.327/0.333 [00:00<00:00,  1.45s/degrees]\n",
      "xpos: 100%|█████████████████████████| 0.333/0.333 [00:00<00:00,  1.72s/degrees]\n",
      "xpos [In progress. No progress bar available.]                                 \n",
      "                                                                               \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "vsc16 [In progress. No progress bar available.]                                \n",
      "                                                                               \n",
      "|         7 | 14:02:56.3 |    1.00000 |    6000000 |          3 |          4 |          3 |          2 |          0 |          0 |\n",
      "+-----------+------------+------------+------------+------------+------------+------------+------------+------------+------------+\n",
      "generator scan ['fb41419c'] (scan num: 1)\n"
     ]
    },
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "/home/apsu/Apps/miniconda3/envs/bluesky_2021_1/lib/python3.8/site-packages/bluesky/callbacks/fitting.py:165: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  np.sum(input * grids[dir].astype(float), labels, index) / normalizer\n"
     ]
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "('fb41419c-0aef-4ff4-8992-7aa2b62f9931',)"
      ]
     },
     "metadata": {},
     "execution_count": 32
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x1080 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "The scan ran, data was collected and printed at each step of the scan.  Finally, plots were made of the scaler channel *vs* motor position for each active channel.\n",
    "\n",
    "## Fix a few _problems_\n",
    "\n",
    "There were some problems.  First is that an error was reported after the scan (`... callbacks/fitting.py:165: RuntimeWarning: invalid value encountered in double_scalars `).  This error is because the scalers showed no peak during the scan.  The scaler is a simulator with no real data.  We'll ignore that error here.\n",
    "\n",
    "Another problem is that all _named_ scaler channels are shown.  Let's reduce that list to `I0` and `scint` just to show how it is done.  (Set back to default: `vsc16.select_channels()`)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "source": [
    "vsc16.select_channels(['I0', 'scint'])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Another problem is that the scaler counts for 0.1s longer than we have configured.  This is a problem with the underlying EPICS support for a simulated (a.k.a. *soft channel*) scaler.  We'll ignore that error here.\n",
    "\n",
    "Next problem is that the progress bar is a nuisance in this notebook so we'll remove it."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "source": [
    "RE.waiting_hook = None"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Then, repeat the same scan."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "source": [
    "RE(bp.scan([vsc16], xpos, -1, 1, 7))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n",
      "\n",
      "Transient Scan ID: 2     Time: 2021-08-19 14:02:58\n",
      "Persistent Unique Scan ID: 'b5f76f7c-78f2-45a5-8264-e0af2ba540bf'\n",
      "New stream: 'primary'\n",
      "+-----------+------------+------------+------------+------------+\n",
      "|   seq_num |       time |       xpos |         I0 |      scint |\n",
      "+-----------+------------+------------+------------+------------+\n",
      "|         1 | 14:03:01.6 |   -1.00000 |          2 |          2 |\n",
      "|         2 | 14:03:03.0 |   -0.66700 |          3 |          3 |\n",
      "|         3 | 14:03:04.4 |   -0.33300 |          2 |          2 |\n",
      "|         4 | 14:03:05.8 |    0.00000 |          1 |          1 |\n",
      "|         5 | 14:03:07.2 |    0.33300 |          2 |          2 |\n",
      "|         6 | 14:03:08.5 |    0.66700 |          1 |          1 |\n",
      "|         7 | 14:03:09.9 |    1.00000 |          4 |          1 |\n",
      "+-----------+------------+------------+------------+------------+\n",
      "generator scan ['b5f76f7c'] (scan num: 2)\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "('b5f76f7c-78f2-45a5-8264-e0af2ba540bf',)"
      ]
     },
     "metadata": {},
     "execution_count": 35
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 360x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Scan with a *different* counting time : _staging_\n",
    "\n",
    "Suppose that we wish to use a different counting time, we could change the `vsc16.preset_time` value before running the scan.  Another way is to use the `ophyd` concept of [*stage* & *unstage*](https://blueskyproject.io/ophyd/device-overview.html?highlight=staging#stage-and-unstage).  \n",
    "\n",
    "*Staging* is the action of preparing an ophyd device for operation, then resetting it afterwards to its previous values.  For our scaler, we could *stage* a different counting time that would be used during the run, then removed after the run is complete.  The `stage()` and `unstage()` methods are controlled by an `OrderedDictionary` where the keys are the attributes of the Python object and the values are used during the run.  The `RE()` takes care of calling `stage()` and `unstage()` during the scan.\n",
    "\n",
    "Here we show staging of a 2.0s `preset_time` for the run.  Also shown are the `preset_time` value before and after the run."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "source": [
    "print(f\"{vsc16.preset_time.get() = }\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "vsc16.preset_time.get() = 0.5\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "source": [
    "vsc16.stage_sigs[\"preset_time\"] = 2.0"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Repeat the same scan."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "source": [
    "RE(bp.scan([vsc16], xpos, -1, 1, 7))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n",
      "\n",
      "Transient Scan ID: 3     Time: 2021-08-19 14:03:10\n",
      "Persistent Unique Scan ID: '04dd2069-cca5-4b55-9ff2-7d4d474cb2e6'\n",
      "New stream: 'primary'\n",
      "+-----------+------------+------------+------------+------------+\n",
      "|   seq_num |       time |       xpos |         I0 |      scint |\n",
      "+-----------+------------+------------+------------+------------+\n",
      "|         1 | 14:03:15.2 |   -1.00000 |         10 |         12 |\n",
      "|         2 | 14:03:18.2 |   -0.66700 |          9 |          8 |\n",
      "|         3 | 14:03:21.1 |   -0.33300 |         10 |          9 |\n",
      "|         4 | 14:03:24.0 |    0.00000 |         11 |         12 |\n",
      "|         5 | 14:03:26.9 |    0.33300 |         11 |          9 |\n",
      "|         6 | 14:03:29.8 |    0.66700 |          8 |         11 |\n",
      "|         7 | 14:03:32.7 |    1.00000 |         11 |         12 |\n",
      "+-----------+------------+------------+------------+------------+\n",
      "generator scan ['04dd2069'] (scan num: 3)\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "('04dd2069-cca5-4b55-9ff2-7d4d474cb2e6',)"
      ]
     },
     "metadata": {},
     "execution_count": 38
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 360x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Custom plan with configurable count time\n",
    "\n",
    "It is common to want to set the count time at the time the scan is started.  For this feature, a custom scan plan is needed, where we will repeat the steps just shown.  This plan will use similar arguments as the `bp.scan()` used above, but add an optional keyword argument `ct` for the count time with a default of 1.0 second.  For housekeeping, we'll remove the staging configuration from the scaler after the scan.\n",
    "\n",
    "A bluesky [*plan*](https://blueskyproject.io/bluesky/plans.html) is a [Python generator function](https://duckduckgo.com/?t=ffsb&q=Python+generator+function&ia=web).  The `bp.scan()` call is the part that makes this a generator function.  Briefly, a bluesky plan defers execution of the actual scan until the `RE()` calls for it.  This indirection allows the `RE()` to manage the plan's execution when the beam dumps or other interruptions occur.  (A function becomes a generator by the presence of one or more `yield` commands.)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "source": [
    "def tscan(scaler, pos, pStart, pEnd, nPts, ct=1):\n",
    "    scaler.stage_sigs[\"preset_time\"] = ct\n",
    "    print(f\"{scaler.preset_time.get() = }\")\n",
    "\n",
    "    yield from bp.scan([scaler], pos, pStart, pEnd, nPts)\n",
    "\n",
    "    print(f\"{scaler.preset_time.get() = }\")\n",
    "    del scaler.stage_sigs[\"preset_time\"]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Run the custom plan with 2 seconds count time per point (so we can see this in the `time` axis)."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "source": [
    "RE(tscan(vsc16, xpos, -1, 1, 7, 2))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "scaler.preset_time.get() = 0.5\n",
      "\n",
      "\n",
      "Transient Scan ID: 4     Time: 2021-08-19 14:03:33\n",
      "Persistent Unique Scan ID: '6a8d542f-46b4-4fa4-a322-a9a81f2d7de9'\n",
      "New stream: 'primary'\n",
      "+-----------+------------+------------+------------+------------+\n",
      "|   seq_num |       time |       xpos |         I0 |      scint |\n",
      "+-----------+------------+------------+------------+------------+\n",
      "|         1 | 14:03:37.9 |   -1.00000 |          9 |         10 |\n",
      "|         2 | 14:03:40.9 |   -0.66700 |         10 |         10 |\n",
      "|         3 | 14:03:43.8 |   -0.33300 |          9 |          8 |\n",
      "|         4 | 14:03:46.7 |    0.00000 |         12 |         12 |\n",
      "|         5 | 14:03:49.6 |    0.33300 |          9 |          8 |\n",
      "|         6 | 14:03:52.5 |    0.66700 |         12 |         11 |\n",
      "|         7 | 14:03:55.4 |    1.00000 |         11 |          9 |\n",
      "+-----------+------------+------------+------------+------------+\n",
      "generator scan ['6a8d542f'] (scan num: 4)\n",
      "\n",
      "\n",
      "\n",
      "scaler.preset_time.get() = 0.5\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "('6a8d542f-46b4-4fa4-a322-a9a81f2d7de9',)"
      ]
     },
     "metadata": {},
     "execution_count": 40
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 360x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Challenges\n",
    "\n",
    "Try these additional modifications or activities.\n",
    "\n",
    "1. Use `logger` to report at various places.\n",
    "\n",
    "   _Hint_: `logger.info(\"text: %s  value: %g\", s1, v2, ...)`\n",
    "\n",
    "   Consider examples as used in [`peak_finder_example.py`](instrument/plans/peak_finder_example.py).\n",
    "   See the [Python logging tutorial](https://docs.python.org/3/howto/logging.html) for more information.\n",
    "1. Write a custom plan that accepts user-provided metadata.\n",
    "\n",
    "   _Hint_: [`bp.scan()`](https://blueskyproject.io/bluesky/generated/bluesky.plans.scan.html#bluesky.plans.scan) has the `md` keyword argument (_kwarg_) that accepts a dictionary of _key: value_ pairs as the metadata when the plan is run.  Your custom plan should accept the same kwarg and pass this to `bp.scan(md=the_dictionary)`, possibly after adding some of its own keys to the metadata."
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.8.10 64-bit ('bluesky_2021_2': conda)"
  },
  "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.8.10"
  },
  "interpreter": {
   "hash": "fa399ef8ed4fbc3b7fe63ebf4307839a170374bf77134d519fcb3b724ac0582b"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}