{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# **hkl_soleil** E6C psi axis\n", "\n", "Show how to set, compute, and scan $\\psi$ with the E6C diffractometer\n", "{ref}`geometry `. Use the `hkl_soleil` solver. Scan\n", "{math}`\\psi` at fixed {math}`Q` and {math}`hkl_2`.\n", "\n", "Virtual axes, such as $\\psi$, are features provided by the solver as *extras*.\n", "*Extras* are not necessarily available in every solver. Consult the solver\n", "documentation for details.\n", "\n", "---\n", "\n", "**NOTE**\n", "\n", "> **ⓘ** The demonstrations below rely on features provided by the\n", "> `hkl_soleil` solver.\n", "\n", "---\n", "\n", "## Concise Summary\n", "\n", "- Define an E6C diffractometer object using `hkl` computation engine (the default).\n", "- Add a sample.\n", "- Add two known reflections, and compute its $UB$ matrix\n", "- Set $\\psi$\n", " - Use the `\"psi_constant_vertical\"` mode.\n", " - Make a dictionary with $hkl_2$ and $\\psi$.\n", " - Finally, compute the real-space position at $hkl$.\n", "- Compute $\\psi$\n", " - Create a second E6C diffractometer object using the `\"psi\"` computation engine.\n", " - Copy the $UB$ matrix from the `e6c_hkl` diffractometer.\n", " - Set $hkl_2$.\n", " (Since these are simulators, copy the real-space motor positions.)\n", " - Show the position of $\\psi$.\n", "- Scan $\\psi$\n", " - Run the diffractometer's custom `scan_extra()` plan,\n", " specifying both $hkl$ (as `pseudos`) and $hkl_2$ (as `extras`).\n", "\n", "## Overview\n", "\n", "To work with $\\psi$ we'll use the `\"hkl\"` engine of the E6C [geometry](../diffractometers.rst). To compute\n", "$\\psi$ we'll use the `\"psi\"` engine. This table summarizes our use:\n", "\n", "engine | how it is used\n", "--- | ---\n", "`\"hkl\"` | work in reciprocal-space coordinates $h, k, l$\n", "`\"psi\"` | compute the $\\psi$ rotation angle (not for operations)\n", "\n", "\n", "\n", "$\\psi$ is the rotation of reference vector $hkl_2$ perpendicular to scattering\n", "vector $Q$:\n", "\n", "\n", "\n", "color | description\n", "--- | ---\n", "blue | incident and exit X-ray beams\n", "green | scattering vector ($Q$)\n", "red | reference vector ($hkl_2$)\n", "yellow | rotation ($\\psi$) from $hkl_2$ around $Q$\n", "black | principle cartesian axes\n", "gray | sample\n", "\n", "### Steps\n", "\n", "1. With the `\"hkl\"` engine:\n", " 1. Orient a crystalline sample with the `\"hkl\"` engine.\n", " 1. Define the azimuthal reflection $h_2, k_2, l_2$ and a $\\psi$ rotation.\n", " 1. Position the diffractometer for the $h, k, l$ reflection.\n", "1. With the `\"psi\"` engine:\n", " 1. Copy sample and orientation information from the `\"hkl\"` instance.\n", " 1. Copy position information:\n", " - This step is necessary since this notebook uses *simulated* motors.\n", " - Diffractometers using EPICS motors will do this automatically.\n", " 1. Compute `psi`.\n", " 1. Compare the computed `psi` value with the value set with the `\"hkl\"` instance.\n", "1. Scan $\\psi$ at fixed $Q$ and $hkl_2$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setup E6C Simulators\n", "\n", "Create instances of (simulated) E6C for the `\"hkl\"` and `\"psi\"` solver engines.\n", "The `hklpy2.creator()` function creates both." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import hklpy2\n", "\n", "e6c_hkl = hklpy2.creator(\n", " name=\"e6c_hkl\",\n", " geometry=\"E6C\",\n", " solver=\"hkl_soleil\",\n", " solver_kwargs={\"engine\": \"hkl\"},\n", ")\n", "e6c_psi = hklpy2.creator(\n", " name=\"e6c_psi\",\n", " geometry=\"E6C\",\n", " solver=\"hkl_soleil\",\n", " solver_kwargs={\"engine\": \"psi\"},\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Show the different calculation engines available for the E6C geometry." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e6c_hkl.core.solver.engines=['hkl', 'psi', 'q2', 'qper_qpar', 'tth2', 'incidence', 'emergence']\n" ] } ], "source": [ "print(f\"{e6c_hkl.core.solver.engines=}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "**NOTE**\n", "\n", "> **ⓘ** The `solver` works at a lower level than ophyd. All the code and\n", "> structures used by a solver are pure Python code (or calls from Python to\n", "> lower level libraries.)\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Show the different operation modes available with each engine for the E6C geometry.\n", "\n", "The `hkl` engine has a `\"psi_constant_vertical\"` mode that can be used to calculate reals given some fixed parameters (UB, wavelength, $(hkl)$, $(hkl)_2$, $\\psi$). The `psi` engine has only one mode." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e6c_hkl.core.modes=['bissector_vertical', 'constant_omega_vertical', 'constant_chi_vertical', 'constant_phi_vertical', 'lifting_detector_phi', 'lifting_detector_omega', 'lifting_detector_mu', 'double_diffraction_vertical', 'bissector_horizontal', 'double_diffraction_horizontal', 'psi_constant_vertical', 'psi_constant_horizontal', 'constant_mu_horizontal']\n", "e6c_psi.core.modes=['psi_vertical']\n" ] } ], "source": [ "print(f\"{e6c_hkl.core.modes=}\")\n", "print(f\"{e6c_psi.core.modes=}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Show the extra axes available with each mode used by this notebook. (The extras\n", "have default values at this time.)\n", "\n", "The `psi` engine has a pseudo axis `\"psi\"` that can be used to calculate $\\psi$ given some fixed parameters (reals, UB, wavelength, $(hkl)$, $(hkl)_2$)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e6c_hkl.core.mode='bissector_vertical'\n", "e6c_hkl.core.extras={}\n", "e6c_hkl.core.mode='psi_constant_vertical'\n", "e6c_hkl.core.extras={'h2': 0, 'k2': 0, 'l2': 0, 'psi': 0}\n", "e6c_psi.core.mode='psi_vertical'\n", "e6c_psi.core.extras={'h2': 0, 'k2': 0, 'l2': 0}\n" ] } ], "source": [ "e6c_hkl.core.mode = \"bissector_vertical\"\n", "print(f\"{e6c_hkl.core.mode=}\")\n", "print(f\"{e6c_hkl.core.extras=}\")\n", "\n", "e6c_hkl.core.mode = \"psi_constant_vertical\"\n", "print(f\"{e6c_hkl.core.mode=}\")\n", "print(f\"{e6c_hkl.core.extras=}\")\n", "\n", "# \"psi\" engine has only one mode, do not need to set it\n", "print(f\"{e6c_psi.core.mode=}\")\n", "print(f\"{e6c_psi.core.extras=}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Define and orient a sample" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The sample for this notebook is crystalline vibranium, with a cubic lattice of exactly $2\\pi$. With it mounted on oru diffractometer, we have identified two reflections which define its orientation." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Reflection(name='r400', h=4, k=0, l=0)\n", "Reflection(name='r040', h=0, k=4, l=0)\n", "e6c_hkl.sample.UB=[[0.034882054037, 0.999391435978, -0.0], [0.0, 0.0, 1.0], [0.999391435978, -0.034882054037, -0.0]]\n", "e6c_hkl.sample.U=[[0.034882054037, 0.999391435978, 0.0], [0.0, 0.0, 1.0], [0.999391435978, -0.034882054037, 0.0]]\n" ] } ], "source": [ "import math\n", "\n", "e6c_hkl.beam.wavelength.put(1.54) # angstrom (8.0509 keV)\n", "\n", "e6c_hkl.add_sample(\"vibranium\", 2 * math.pi, digits=5)\n", "\n", "e6c_hkl.add_reflection((4, 0, 0), (0, 29.354, 0, 2, 0, 58.71), name=\"r400\")\n", "e6c_hkl.add_reflection((0, 4, 0), (0, 29.354, 0, 92, 0, 58.71), name=\"r040\")\n", "for r in e6c_hkl.sample.reflections.order:\n", " print(f\"{e6c_hkl.sample.reflections[r]}\")\n", "e6c_hkl.core.calc_UB(*e6c_hkl.sample.reflections.order)\n", "\n", "print(f\"{e6c_hkl.sample.UB=!r}\")\n", "print(f\"{e6c_hkl.sample.U=!r}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Move to the $(111)$ orientation\n", "\n", "Before moving the diffractometer, ensure you have selected the desired operating\n", "*mode*." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(Hklpy2DiffractometerPseudoPos(h=1.00000000737, k=-8.2488e-08, l=0),\n", " Hklpy2DiffractometerRealPos(mu=0, omega=7.039252630487, chi=-2.512923e-06, phi=1.998994715295, gamma=0, delta=14.078505260974))" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "e6c_hkl.core.mode = \"bissector_vertical\"\n", "e6c_hkl.move(1, 0, 0)\n", "e6c_hkl.position, e6c_hkl.real_position" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Set ${hkl}_2$ and $\\psi$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Show the extra axes available with `psi_constant_vertical` mode." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e6c_hkl.core.solver_extra_axis_names=['h2', 'k2', 'l2', 'psi']\n" ] } ], "source": [ "e6c_hkl.core.mode = \"psi_constant_vertical\"\n", "print(f\"{e6c_hkl.core.solver_extra_axis_names=}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Set azimuthal reflection ${hkl}_2 = (110)$ and $\\psi=12$.\n", "\n", "The `extras` are described as a Python dictionary with values for each of the parameters." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e6c_hkl.core.extras={'h2': 1, 'k2': 1, 'l2': 0, 'psi': 12}\n" ] } ], "source": [ "e6c_hkl.core.extras = dict(h2=1, k2=1, l2=0, psi=12)\n", "print(f\"{e6c_hkl.core.extras=}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Compute the real-axis motor values with the $Q=(111)$ reflection oriented and $\\psi$ rotation." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "p_111=Hklpy2DiffractometerRealPos(mu=0, omega=113.608391926862, chi=80.226182466798, phi=130.002672432183, gamma=0, delta=-24.50984311379)\n" ] } ], "source": [ "p_111 = e6c_hkl.forward(1, 1, 1)\n", "print(f\"{p_111=}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Move each real (real-space positioner) to the computed $(111)$ reflection position `p_111`." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e6c_hkl.position=Hklpy2DiffractometerPseudoPos(h=0.999999999997, k=0.999999999998, l=1.000000000001)\n", "e6c_hkl.real_position=Hklpy2DiffractometerRealPos(mu=0, omega=113.608391926862, chi=80.226182466798, phi=130.002672432183, gamma=0, delta=-24.50984311379)\n", "e6c_hkl.core.extras={'h2': 1, 'k2': 1, 'l2': 0, 'psi': 12}\n" ] } ], "source": [ "e6c_hkl.move_reals(p_111)\n", "print(f\"{e6c_hkl.position=}\")\n", "print(f\"{e6c_hkl.real_position=}\")\n", "print(f\"{e6c_hkl.core.extras=}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Compute $\\psi$ at fixed $Q$ and $hkl_2$\n", "\n", "We'll use the `\"psi\"` engine to compute $\\psi$, given a sample & orientation,\n", "${hkl}_2$, and the real-space motor positions." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e6c_psi.core.mode='psi_vertical'\n", "e6c_psi.core.extras={'h2': 0, 'k2': 0, 'l2': 0}\n" ] } ], "source": [ "print(f\"{e6c_psi.core.mode=}\")\n", "print(f\"{e6c_psi.core.extras=}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Same sample and lattice" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Sample(name='vibranium', lattice=Lattice(a=6.28319, system='cubic'))" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "e6c_psi.add_sample(\"vibranium\", 2 * math.pi, digits=5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Copy orientation from `hkl` instance. Note the `psi` and `hkl` UB matrices are\n", "not exactly equal. Equal to about 5 decimal places.)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e6c_psi.sample.UB=[[0.034882054037, 0.999391435978, -0.0], [0.0, 0.0, 1.0], [0.999391435978, -0.034882054037, -0.0]]\n", "e6c_psi.sample.U=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]\n", "e6c_hkl.sample.UB=[[0.034882054037, 0.999391435978, -0.0], [0.0, 0.0, 1.0], [0.999391435978, -0.034882054037, -0.0]]\n", "e6c_hkl.sample.U=[[0.034882054037, 0.999391435978, 0.0], [0.0, 0.0, 1.0], [0.999391435978, -0.034882054037, 0.0]]\n" ] } ], "source": [ "e6c_psi.sample.UB = e6c_hkl.sample.UB\n", "\n", "print(f\"{e6c_psi.sample.UB=!r}\")\n", "print(f\"{e6c_psi.sample.U=!r}\")\n", "\n", "print(f\"{e6c_hkl.sample.UB=!r}\")\n", "print(f\"{e6c_hkl.sample.U=!r}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Set ${hkl}_2=(1, 1, 0)$. As above, describe these parameters in a Python dictionary." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e6c_psi.core.extras={'h2': 1, 'k2': 1, 'l2': 0}\n" ] } ], "source": [ "e6c_psi.core.extras = dict(h2=1, k2=1, l2=0)\n", "print(f\"{e6c_psi.core.extras=}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Set real-space axis positions from `p_111` (above)." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "e6c_psi.pseudo_axis_names=['psi']\n", "e6c_psi.core.solver_pseudo_axis_names=['psi']\n", "e6c_psi.position=Hklpy2DiffractometerPseudoPos(psi=11.999985086114)\n", "e6c_psi.real_position=Hklpy2DiffractometerRealPos(mu=0, omega=113.608391926862, chi=80.226182466798, phi=130.002672432183, gamma=0, delta=-24.50984311379)\n" ] } ], "source": [ "e6c_psi.move_reals(p_111)\n", "print(f\"{e6c_psi.pseudo_axis_names=}\")\n", "print(f\"{e6c_psi.core.solver_pseudo_axis_names=}\")\n", "print(f\"{e6c_psi.position=}\")\n", "print(f\"{e6c_psi.real_position=}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Compare `hkl` and `psi` reports." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hklpy2Diffractometer(prefix='', name='e6c_hkl', settle_time=0.0, timeout=None, egu='', limits=(0, 0), source='computed', read_attrs=['beam', 'beam.wavelength', 'beam.energy', 'h', 'h.readback', 'h.setpoint', 'k', 'k.readback', 'k.setpoint', 'l', 'l.readback', 'l.setpoint', 'mu', 'omega', 'chi', 'phi', 'gamma', 'delta'], configuration_attrs=['solver_signature', 'beam', 'beam.source_type', 'beam.wavelength_units', 'beam.energy_units', 'h', 'k', 'l'], concurrent=True)\n", "wavelength=1.54\n", "h=1.0, k=1.0, l=1.0\n", "mu=0, omega=113.6084, chi=80.2262, phi=130.0027, gamma=0, delta=-24.5098\n", "h2=1 k2=1 l2=0 psi=12\n", "Hklpy2Diffractometer(prefix='', name='e6c_psi', settle_time=0.0, timeout=None, egu='', limits=(0, 0), source='computed', read_attrs=['beam', 'beam.wavelength', 'beam.energy', 'psi', 'psi.readback', 'psi.setpoint', 'mu', 'omega', 'chi', 'phi', 'gamma', 'delta'], configuration_attrs=['solver_signature', 'beam', 'beam.source_type', 'beam.wavelength_units', 'beam.energy_units', 'psi'], concurrent=True)\n", "wavelength=1.0\n", "psi=12.0\n", "mu=0, omega=113.6084, chi=80.2262, phi=130.0027, gamma=0, delta=-24.5098\n", "h2=1 k2=1 l2=0\n" ] } ], "source": [ "print(e6c_hkl)\n", "e6c_hkl.wh()\n", "print(e6c_psi)\n", "e6c_psi.wh()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Scan $\\psi$ at fixed $Q$ and $hkl_2$\n", "\n", "Setup the bluesky tools needed to run scans and review data." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "import databroker\n", "\n", "from bluesky import RunEngine\n", "from bluesky.callbacks.best_effort import BestEffortCallback\n", "from ophyd.sim import noisy_det\n", "\n", "from hklpy2 import ConfigurationRunWrapper\n", "\n", "# Save orientation of the diffractometer.\n", "crw = ConfigurationRunWrapper(e6c_hkl)\n", "\n", "bec = BestEffortCallback()\n", "bec.disable_plots()\n", "cat = databroker.temp().v2\n", "RE = RunEngine()\n", "RE.subscribe(cat.v1.insert)\n", "RE.subscribe(bec)\n", "RE.preprocessors.append(crw.wrapper)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Scan $\\psi$ over a wide range in coarse steps.\n", "\n", "---\n", "\n", "**NOTE**\n", "\n", "> **ⓘ** Since $\\psi$ is an *extra* axis, it is only available with\n", "> certain operation modes, such as `\"psi_constant_vertical\"`. Be sure to set\n", "> that before scanning. The plan will raise a `KeyError` if the axis name is\n", "> not recognized. Any extra axes are not ophyd objects since they are defined\n", "> only when certain modes are selected. A custom plan is provided which scans\n", "> an extra axis, while holding any pseudos or reals, and other extras at\n", "> constant values.\n", "\n", "---\n", "\n", "This example chooses $Q=(002)$ and $hkl_2=(120)$. (The reference $hkl_2$\n", "was chosen to be perpendicular to $Q$.) Save the `uid` from the scan for later\n", "reference.\n", "\n", "To control the solution space, we adjust the low limit of both $\\varphi$ and\n", "$\\omega$ so their ranges are limited to $0..180^o$.\n", "\n", "The `e6c_hkl` diffractometer is added as a detector here so that all the\n", "positioner values will be available for plotting later." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "Transient Scan ID: 1 Time: 2025-04-09 22:34:11\n", "Persistent Unique Scan ID: '0a427fcd-af67-4ae1-a6e7-ecf715168ab7'\n", "New stream: 'primary'\n", "+-----------+------------+------------+--------------------+-------------------------+---------------------+------------+------------+------------+------------+---------------+-------------+-------------+---------------+---------------+\n", "| seq_num | time | noisy_det | e6c_hkl_extras_psi | e6c_hkl_beam_wavelength | e6c_hkl_beam_energy | e6c_hkl_h | e6c_hkl_k | e6c_hkl_l | e6c_hkl_mu | e6c_hkl_omega | e6c_hkl_chi | e6c_hkl_phi | e6c_hkl_gamma | e6c_hkl_delta |\n", "+-----------+------------+------------+--------------------+-------------------------+---------------------+------------+------------+------------+------------+---------------+-------------+-------------+---------------+---------------+\n", "| 1 | 22:34:11.5 | 0.917 | 0.000 | 1.540 | 8.051 | -0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 155.434 | 0 | -28.375 |\n", "| 2 | 22:34:11.5 | 0.937 | 10.714 | 1.540 | 8.051 | 0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 144.720 | 0 | -28.375 |\n", "| 3 | 22:34:11.5 | 1.019 | 21.429 | 1.540 | 8.051 | -0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 134.005 | 0 | -28.375 |\n", "| 4 | 22:34:11.5 | 0.937 | 32.143 | 1.540 | 8.051 | 0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 123.291 | 0 | -28.375 |\n", "| 5 | 22:34:11.5 | 0.942 | 42.857 | 1.540 | 8.051 | 0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 112.577 | 0 | -28.375 |\n", "| 6 | 22:34:11.5 | 0.970 | 53.571 | 1.540 | 8.051 | 0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 101.863 | 0 | -28.375 |\n", "| 7 | 22:34:11.6 | 1.021 | 64.286 | 1.540 | 8.051 | 0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 91.148 | 0 | -28.375 |\n", "| 8 | 22:34:11.6 | 0.912 | 75.000 | 1.540 | 8.051 | 0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 80.434 | 0 | -28.375 |\n", "| 9 | 22:34:11.6 | 0.988 | 85.714 | 1.540 | 8.051 | -0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 69.720 | 0 | -28.375 |\n", "| 10 | 22:34:11.6 | 0.999 | 96.429 | 1.540 | 8.051 | -0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 59.005 | 0 | -28.375 |\n", "| 11 | 22:34:11.6 | 0.973 | 107.143 | 1.540 | 8.051 | -0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 48.291 | 0 | -28.375 |\n", "| 12 | 22:34:11.6 | 1.086 | 117.857 | 1.540 | 8.051 | -0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 37.577 | 0 | -28.375 |\n", "| 13 | 22:34:11.7 | 0.966 | 128.571 | 1.540 | 8.051 | 0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 26.863 | 0 | -28.375 |\n", "| 14 | 22:34:11.7 | 0.996 | 139.286 | 1.540 | 8.051 | -0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 16.148 | 0 | -28.375 |\n", "| 15 | 22:34:11.7 | 1.015 | 150.000 | 1.540 | 8.051 | -0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 5.434 | 0 | -28.375 |\n", "+-----------+------------+------------+--------------------+-------------------------+---------------------+------------+------------+------------+------------+---------------+-------------+-------------+---------------+---------------+\n", "generator scan_extra ['0a427fcd'] (scan num: 1)\n", "\n", "\n", "\n" ] } ], "source": [ "e6c_hkl.core.mode = \"psi_constant_vertical\"\n", "e6c_hkl.core.constraints[\"phi\"].low_limit = 0\n", "e6c_hkl.core.constraints[\"omega\"].low_limit = 0\n", "(uid,) = RE(\n", " e6c_hkl.scan_extra(\n", " [noisy_det, e6c_hkl],\n", " axis=\"psi\",\n", " start=0,\n", " finish=150,\n", " num=15,\n", " pseudos=dict(h=0, k=0, l=2),\n", " extras=dict(h2=1, k2=2, l2=0),\n", " ),\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot any motions\n", "\n", "The only real-space axis to be moved by this scan is $\\varphi$. Plot $\\phi$ *vs.*\n", "$\\psi$.\n", "\n", "axis | data name\n", "--- | ---\n", "$\\varphi$ | `e6c_hkl_phi`\n", "$\\psi$ | `e6c_hkl_extras_psi`\n", "---\n", "\n", "**NOTE**\n", "\n", "> **ⓘ** *Extra* axes are named with the `_extras` label inserted in the\n", "> name.\n", "\n", "---\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/prjemian/.conda/envs/hklpy2/lib/python3.13/site-packages/databroker/intake_xarray_core/base.py:23: FutureWarning: The return type of `Dataset.dims` will be changed to return a set of dimension names in future, in order to be more consistent with `DataArray.dims`. To access a mapping from dimension names to lengths, please use `Dataset.sizes`.\n", " 'dims': dict(self._ds.dims),\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from apstools.utils import plotxy\n", "\n", "run = cat[uid]\n", "\n", "# Compose a title from current conditions.\n", "pos = e6c_hkl.full_position(digits=0)\n", "Q = f\"({pos['h']:.0f}, {pos['k']:.0f}, {pos['l']:.0f})\"\n", "hkl2 = f\"({pos['h2']:.0f}, {pos['k2']:.0f} ,{pos['l2']:.0f})\"\n", "title = f\"$Q={Q}$ and $hkl_2={hkl2}$\"\n", "\n", "plotxy(run, \"e6c_hkl_extras_psi\", \"e6c_hkl_phi\", stats=False, title=title)" ] } ], "metadata": { "kernelspec": { "display_name": "hklpy2", "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.13.2" } }, "nbformat": 4, "nbformat_minor": 4 }