{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Lesson 5, Part A: find a peak and lineup\n", "\n", "In this lesson, alignment to a narrow diffraction peak is \n", "using capabilities provided by \n", "the [ophyd](https://blueskyproject.io/ophyd/) package. The \n", "simulation consists of a simulated motor and simulated\n", "noisy detector.\n", "\n", "The noisy detector is configured to describe a narrow diffraction\n", "peak with Gaussian profile based on the value of the motor position.\n", "The peak is centered randomly somewhere between motor \n", "values -1 and +1. The width is less than 0.05 in the same units. The\n", "peak intensity is expected to be approximately 100,000 (counts/sec \n", "are typical units).\n", "\n", "**Preparation**\n", "\n", "Make sure the `instrument` package is in the same directory \n", "as this jupyter notebook. The `instrument` package included with \n", "this lesson is a brief version of the standard package used \n", "with any APS instrument. Since the notebook is for teaching,\n", "it does not connect with any mongodb database. The scans are \n", "not kept by the databroker. However, every scan is saved to a \n", "SPEC data file as described when the instrument package is loaded." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Objective\n", "\n", "Use *Bluesky* (the tools provided by the various packages \n", "of the [Bluesky framework](https://blueskyproject.io/)) \n", "to find the center and width of a simulated diffraction \n", "peak. Move the motor to the peak center.\n", "\n", "1. Use interactive ophyd commands to find the peak and assess the width.\n", "2. Use the RunEngine and bluesky plans to find the peak and assess the width.\n", "\n", "\n", "## Advanced\n", "\n", "3. Make a custom plan and run it to find the peak center.\n", "4. Add that new plan to the instrument package, then \n", " restart the notebook's kernel and try it.\n", "5. Add the simulated motor and noisy detector to the \n", " instrument package, then restart the notebook's \n", " kernel and find the peak again.\n", "\n", "\n", "----" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Initialize\n", "\n", "Load the instrument controls (which sets up the Bluesky framework for collection: `RE`, `bec`, `bp`, ...). This defines more than we need but works as a simple start, just like regular data acquisition at a beamline." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "I Thu-11:06:11 - ############################################################ startup\n", "I Thu-11:06:11 - logging started\n", "I Thu-11:06:11 - logging level = 10\n", "I Thu-11:06:11 - c:\\Users\\Pete\\Documents\\projects\\bluesky_training\\lessons\\instrument\\collection.py\n", "I Thu-11:06:11 - c:\\Users\\Pete\\Documents\\projects\\bluesky_training\\lessons\\instrument\\mpl\\notebook.py\n", "Activating auto-logging. Current session state plus future input saved.\n", "Filename : c:\\Users\\Pete\\Documents\\projects\\bluesky_training\\lessons\\.logs\\ipython_console.log\n", "Mode : rotate\n", "Output logging : True\n", "Raw input log : False\n", "Timestamping : True\n", "State : active\n", "I Thu-11:06:12 - bluesky framework\n", "I Thu-11:06:12 - c:\\Users\\Pete\\Documents\\projects\\bluesky_training\\lessons\\instrument\\framework\\check_python.py\n", "I Thu-11:06:12 - c:\\Users\\Pete\\Documents\\projects\\bluesky_training\\lessons\\instrument\\framework\\check_bluesky.py\n", "I Thu-11:06:14 - c:\\Users\\Pete\\Documents\\projects\\bluesky_training\\lessons\\instrument\\framework\\initialize.py\n", "I Thu-11:06:17 - c:\\Users\\Pete\\Documents\\projects\\bluesky_training\\lessons\\instrument\\framework\\metadata.py\n", "I Thu-11:06:17 - c:\\Users\\Pete\\Documents\\projects\\bluesky_training\\lessons\\instrument\\framework\\callbacks.py\n", "I Thu-11:06:17 - writing to SPEC file: c:\\Users\\Pete\\Documents\\projects\\bluesky_training\\lessons\\20200521-110617.dat\n", "I Thu-11:06:17 - >>>> Using default SPEC file name <<<<\n", "I Thu-11:06:17 - file will be created when bluesky ends its next scan\n", "I Thu-11:06:17 - to change SPEC file, use command: newSpecFile('title')\n" ] } ], "source": [ "from instrument.collection import *\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numpy provides the random number generator we'll use." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Load the ophyd simulators" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from ophyd.sim import motor, SynGauss" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Make a noisy detector\n", "\n", "Make a new ``noisy``, replacing the one from the simulator." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "noisy = SynGauss(\n", " 'noisy', \n", " motor, 'motor', \n", " # center somewhere between -1 and 1\n", " center=2 * (np.random.random()-0.5), \n", " # randomize these parameters\n", " Imax=100000 + 20000 * (np.random.random()-0.5),\n", " noise='poisson', \n", " sigma=0.016 + 0.015 * (np.random.random()-0.5), \n", " noise_multiplier=0.1 + 0.02 * (np.random.random()-0.5),\n", " labels={'detectors'})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "TODO: work this into the tutorial" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[This data will not be saved. Use the RunEngine to collect data.]\n", "noisy 0\n", "motor 0\n", "motor_setpoint 0\n" ] } ], "source": [ "%ct detectors motors" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Define the reported precision of the motor and detector." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "motor.precision = 5\n", "noisy.precision = 0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Print the values just configured" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "motor: 0\n", "center: -0.9922233044405593\n", "sigma: 0.02276535181863142\n", "Imax: 96204.44084875335\n", "noise: poisson\n", "noise_multiplier : 0.10293011351852485\n", "[This data will not be saved. Use the RunEngine to collect data.]\n", "noisy_det : 0\n" ] } ], "source": [ "print(f\"motor: {motor.position}\")\n", "print(f\"center: {noisy.center.get()}\")\n", "print(f\"sigma: {noisy.sigma.get()}\")\n", "print(f\"Imax: {noisy.Imax.get()}\")\n", "print(f\"noise: {noisy.noise.get()}\")\n", "print(f\"noise_multiplier : {noisy.noise_multiplier.get()}\")\n", "\n", "# tell the \"detector\" to \"count\" (get a new value based on the motor position)\n", "%ct noisy\n", "\n", "print(f\"noisy_det : {noisy.val.get()}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Use `ophyd` commands\n", "\n", "The first thing to learn is how to move the motor. As typical of many control systems, there are several ways to do this. We will focus on only two of these since we can apply them to both simulated motors *and* EPICS motors.\n", "\n", "Different from a real motor, our simulated motor moves immediately, so motor velocity and acceleration are not involved. Since the motor moves immediately, there is no discernable delay due to short or long motor motions.\n", "\n", "**tip**: There are several ways to do most things but this tutorial focuses on just a few with the hope that these ways are both simple and reuseable." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### motor, move and get position\n", "\n", "For a motor named `motor`, any of these commands can \n", "be used in an interactive session to move the motor from \n", "its current position to `1.0`:\n", " \n", " motor.set(1)\n", " motor.set(1).wait()\n", " %mov motor 1\n", "\n", "The `%mov` command is simplest so that is what we will use here.\n", "\n", "**tip**: The `%mov` command is absolute move, while `%movr` is a relative move.\n", "\n", "Move the motor from where it is now, to 1, and print its position." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] } ], "source": [ "%mov motor 1\n", "print(motor.position)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "motor.readback.get()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Move the motor to 0 (this time using a relative move)." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%movr motor -1\n", "motor.position" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### detector, count and get value\n", "\n", "Above, we created a detector named `noisy` that simulates a *scaler* (detector that records a single integer number of detection events, usually the number of X-ray photons received). Real scalers are told to measure for a fixed time interval. Our simulator does not have that feature.\n", "\n", "The simulated noisy detector computes its value for *counts* based on the position of the configured motor.\n", "\n", "Show the name of the motor configured into the `noisy` detector. Check that its name is `motor`." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SynAxis(prefix='', name='motor', read_attrs=['readback', 'setpoint'], configuration_attrs=['velocity', 'acceleration'])\n" ] } ], "source": [ "print(noisy._motor)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The value (number of counts) is kept in `noisy.val`. Show it's value now. \n", "\n", "**tip**: We can drop the `print()` wrapper if the command we use returns the value we'd print anyway. Use this convenient shortcut." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SynSignal(name='noisy', parent='noisy', value=0, timestamp=1590077189.4523768)" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "noisy.val" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We need to tell the detector to acquire data. To acquire data, our simulator will re-compute its value based on the motor position (as with a real detector, the value does not update without something that compels this computation), since that may have changed since the last computation.\n", "\n", "For interactive use with ophyd Devices, the command to call is [%ct](https://blueskyproject.io/bluesky/magics.html#taking-a-reading-using-ct-post-v1-3-0). We labeled the `noisy` object as `detectors` so it will be counted when `%ct` is called.\n", "\n", "TODO: improve the labels explanation here." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[This data will not be saved. Use the RunEngine to collect data.]\n", "noisy 0\n" ] } ], "source": [ "%ct" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Find the simulated peak\n", "\n", "With tools to move the motor and acquire data from the detector, we can try to find the simulated peak. It may take some retries since the peak is narrow. Take big steps first (such as `0.1`) to find non-zero counts, then smaller steps to find the peak.\n", "\n", "First, move to one end of the range, then start stepping until you find non-zero counts. Then use `%movr` and execute the same notebook cell repeatedly. Call the detector's `.get()` method to only print the number of counts and not the other information." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[This data will not be saved. Use the RunEngine to collect data.]\n", "noisy 90261\n", "motor=-1.00000 noisy=90261\n" ] } ], "source": [ "%mov motor -1\n", "%ct\n", "print(f\"motor={motor.position:.5f} noisy={noisy.val.get()}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The next cell will probably show a very small step size. Change it to `0.1` and execute the cell repeatedly with . Once you have reached a peak (or passed it), change the sign and make the step size smaller. Repeat until you are satisfied." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[This data will not be saved. Use the RunEngine to collect data.]\n", "noisy 31\n", "-0.90000, 31\n" ] } ], "source": [ "%movr motor .1\n", "%ct\n", "print(f\"{motor.position:.5f}, {noisy.val.get()}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Compare the peak center you found with the value printed after the `noisy` detector was configured (above). Probably, they will differ by a small amount since the simulator applies random noise to the signal." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Use RunEngine and bluesky plans\n", "\n", "Here we use the RunEngine (`RE`) and standard [bluesky plans](https://blueskyproject.io/bluesky/plans.html) to locate the simulated diffraction peak.\n", "\n", "Since we will do a series of scans, let's make a list to collect the results from each scan. We'll report that list later." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "results=[]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, some variables are defined which will make calling the scans more consistent.\n", "\n", "The first variable, *k*, is used to expand (only slightly) the range of the next scan to capture the full width of the peak. We'll also define *n* as the number of points in each scan." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "k = 1.5 # range expansion factor\n", "n = 29 # number of points per scan" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Locate the approximate peak position\n", "\n", "Scan from -2 to 2 to find the peak. Since it is a Gaussian (which decays rapidly away from the peak), we may need to increase *n*, the number of points in the scan. All we need is one point above the background to find it!\n", "\n", "Use the [*scan*](https://blueskyproject.io/bluesky/generated/bluesky.plans.scan.html?highlight=scan) plan from `bluesky.plans` (provided here as `bp`) to locate at least one point on the peak that is above the background of 0 counts." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "Transient Scan ID: 1 Time: 2020-05-21 11:10:04\n", "Persistent Unique Scan ID: '000f574f-cd64-4e2e-9375-3816ffef0146'\n", "New stream: 'primary'\n", "+-----------+------------+------------+------------+\n", "| seq_num | time | motor | noisy |\n", "+-----------+------------+------------+------------+\n", "| 1 | 11:10:04.7 | -2.00000 | 0 |\n", "| 2 | 11:10:04.8 | -1.85714 | 0 |\n", "| 3 | 11:10:04.9 | -1.71429 | 0 |\n", "| 4 | 11:10:05.0 | -1.57143 | 0 |\n", "| 5 | 11:10:05.1 | -1.42857 | 0 |\n", "| 6 | 11:10:05.1 | -1.28571 | 0 |\n", "| 7 | 11:10:05.2 | -1.14286 | 0 |\n", "| 8 | 11:10:05.3 | -1.00000 | 90943 |\n", "| 9 | 11:10:05.4 | -0.85714 | 0 |\n", "| 10 | 11:10:05.5 | -0.71429 | 0 |\n", "| 11 | 11:10:05.6 | -0.57143 | 0 |\n", "| 12 | 11:10:05.7 | -0.42857 | 0 |\n", "| 13 | 11:10:05.8 | -0.28571 | 0 |\n", "| 14 | 11:10:05.9 | -0.14286 | 0 |\n", "| 15 | 11:10:06.0 | 0.00000 | 0 |\n", "| 16 | 11:10:06.1 | 0.14286 | 0 |\n", "| 17 | 11:10:06.2 | 0.28571 | 0 |\n", "| 18 | 11:10:06.3 | 0.42857 | 0 |\n", "| 19 | 11:10:06.3 | 0.57143 | 0 |\n", "| 20 | 11:10:06.4 | 0.71429 | 0 |\n", "| 21 | 11:10:06.6 | 0.85714 | 0 |\n", "| 22 | 11:10:06.7 | 1.00000 | 0 |\n", "| 23 | 11:10:06.7 | 1.14286 | 0 |\n", "| 24 | 11:10:06.8 | 1.28571 | 0 |\n", "| 25 | 11:10:06.9 | 1.42857 | 0 |\n", "| 26 | 11:10:07.0 | 1.57143 | 0 |\n", "| 27 | 11:10:07.1 | 1.71429 | 0 |\n", "| 28 | 11:10:07.2 | 1.85714 | 0 |\n", "| 29 | 11:10:07.3 | 2.00000 | 0 |\n", "+-----------+------------+------------+------------+\n", "generator scan ['000f574f'] (scan num: 1)\n" ] }, { "data": { "text/plain": [ "('000f574f-cd64-4e2e-9375-3816ffef0146',)" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "image/svg+xml": [ "\r\n", "\r\n", "\r\n", "\r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", "\r\n" ], "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "RE(bp.scan([noisy], motor, -2, 2, n))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "One of the tools that works in the background of the Bluesky framework is the [*BestEffortCallback*](https://blueskyproject.io/bluesky/callbacks.html#best-effort-callback), known here as `bec`. When `bec` is configured (see `instrument/framework/initialize.py`) as part of scanning with the RunEngine, it will assess peak parameters from each scan, where applicable. The parameters are available in `bec.peaks` which we have, for convenience, defined as `peaks`. We access a couple of those parameters here for peak center and width." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{\n", "'com':\n", " {'noisy': -1.0}\n", ",\n", "'cen':\n", " {'noisy': -1.0}\n", ",\n", "'max':\n", " {'noisy': (-1.0,\n", " 90943)}\n", ",\n", "'min':\n", " {'noisy': (-2.0,\n", " 0)}\n", ",\n", "'fwhm':\n", " {'noisy': 0.1428571428571428}\n", ",\n", "}" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "peaks" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We'll grab the values we need from this dictionary. The term *sigma* is a measure of the peak width apparent from the data available. Since the step size of the scan is large with respect to the width of the peak shown above, this is a low precision finding. We should repeat this scan with finer step size near the peak to make a more precise assessment." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "center=-1.0000000, FWHM=0.1428571\n" ] } ], "source": [ "cen = peaks[\"cen\"][\"noisy\"]\n", "sigma = peaks[\"fwhm\"][\"noisy\"]\n", "results.append((RE.md[\"scan_id\"], cen, sigma))\n", "print(f\"center={cen:.7f}, FWHM={sigma:.7f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Refine the peak position\n", "\n", "Refine the scan to the range of (-sigma .. +sigma) near the center of the previous scan. Repeat as often as necessary (using ) to get the peak center and width. Use the [*relative scan*](https://blueskyproject.io/bluesky/generated/bluesky.plans.rel_scan.html?highlight=rel_scan) plan from `bluesky.plans` to find the peak.\n", "\n", "**tip**: Look for the plot in the cell above. Replots will be drawn in different colors. The legend indicates the `scan_id`." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "Transient Scan ID: 4 Time: 2020-05-21 11:12:24\n", "Persistent Unique Scan ID: '2631ce75-ce77-4da3-acba-4f109b29e29a'\n", "New stream: 'primary'\n", "+-----------+------------+------------+------------+\n", "| seq_num | time | motor | noisy |\n", "+-----------+------------+------------+------------+\n", "| 1 | 11:12:24.2 | -1.07724 | 94 |\n", "| 2 | 11:12:24.3 | -1.07116 | 250 |\n", "| 3 | 11:12:24.3 | -1.06509 | 555 |\n", "| 4 | 11:12:24.4 | -1.05902 | 1303 |\n", "| 5 | 11:12:24.5 | -1.05294 | 2729 |\n", "| 6 | 11:12:24.5 | -1.04687 | 5285 |\n", "| 7 | 11:12:24.6 | -1.04080 | 9916 |\n", "| 8 | 11:12:24.7 | -1.03472 | 16745 |\n", "| 9 | 11:12:24.7 | -1.02865 | 26837 |\n", "| 10 | 11:12:24.8 | -1.02258 | 39703 |\n", "| 11 | 11:12:24.8 | -1.01651 | 54063 |\n", "| 12 | 11:12:24.9 | -1.01043 | 69659 |\n", "| 13 | 11:12:25.0 | -1.00436 | 83210 |\n", "| 14 | 11:12:25.0 | -0.99829 | 92494 |\n", "| 15 | 11:12:25.1 | -0.99221 | 96544 |\n", "| 16 | 11:12:25.1 | -0.98614 | 92315 |\n", "| 17 | 11:12:25.2 | -0.98007 | 83636 |\n", "| 18 | 11:12:25.3 | -0.97399 | 70214 |\n", "| 19 | 11:12:25.3 | -0.96792 | 54588 |\n", "| 20 | 11:12:25.4 | -0.96185 | 39321 |\n", "| 21 | 11:12:25.4 | -0.95578 | 26623 |\n", "| 22 | 11:12:25.5 | -0.94970 | 16971 |\n", "| 23 | 11:12:25.5 | -0.94363 | 10057 |\n", "| 24 | 11:12:25.6 | -0.93756 | 5380 |\n", "| 25 | 11:12:25.7 | -0.93148 | 2675 |\n", "| 26 | 11:12:25.7 | -0.92541 | 1239 |\n", "| 27 | 11:12:25.8 | -0.91934 | 607 |\n", "| 28 | 11:12:25.8 | -0.91327 | 249 |\n", "| 29 | 11:12:25.9 | -0.90719 | 72 |\n", "+-----------+------------+------------+------------+\n", "generator rel_scan ['2631ce75'] (scan num: 4)\n", "center=-0.9921816, FWHM=0.0535156\n" ] }, { "data": { "image/png": "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", "image/svg+xml": [ "\r\n", "\r\n", "\r\n", "\r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", "\r\n" ], "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%mov motor cen\n", "RE(bp.rel_scan([noisy], motor, -k*sigma, k*sigma, n))\n", "# TODO: plt.gcf()\n", "\n", "cen = peaks[\"cen\"][\"noisy\"]\n", "sigma = peaks[\"fwhm\"][\"noisy\"]\n", "results.append((RE.md[\"scan_id\"], cen, sigma))\n", "print(f\"center={cen:.7f}, FWHM={sigma:.7f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Report the results\n", "\n", "Print a nice table with the results from each of our scans." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "======= =================== ====================\n", "scan ID center sigma \n", "======= =================== ====================\n", "1 -1.0 0.1428571428571428 \n", "3 -0.9922136823434071 0.05668097101727676 \n", "4 -0.9921815602844319 0.053515606485192824\n", "======= =================== ====================\n", "\n" ] } ], "source": [ "tbl = pyRestTable.Table()\n", "tbl.addLabel(\"scan ID\")\n", "tbl.addLabel(\"center\")\n", "tbl.addLabel(\"sigma\")\n", "for sid, cen, sigma in results:\n", " tbl.addRow((sid, cen, sigma))\n", "print(tbl)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3.7.7 64-bit ('bluesky_2020_5': conda)", "language": "python", "name": "python37764bitbluesky20205conda414c31c00fba48028d4852f6340d7af7" }, "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.7.7-final" } }, "nbformat": 4, "nbformat_minor": 4 }