{ "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](../geometry_tables.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.solver.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.solver.modes=['psi_vertical']\n" ] } ], "source": [ "print(f\"{e6c_hkl.core.solver.modes=}\")\n", "print(f\"{e6c_psi.core.solver.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.solver.mode='bissector_vertical'\n", "e6c_hkl.core.solver.extras={}\n", "e6c_hkl.core.solver.mode='psi_constant_vertical'\n", "e6c_hkl.core.solver.extras={'h2': 1.0, 'k2': 0.0, 'l2': 0.0, 'psi': 0.0}\n", "e6c_psi.core.solver.mode='psi_vertical'\n", "e6c_psi.core.solver.extras={'h2': 1.0, 'k2': 1.0, 'l2': 1.0}\n" ] } ], "source": [ "e6c_hkl.core.solver.mode = \"bissector_vertical\"\n", "print(f\"{e6c_hkl.core.solver.mode=}\")\n", "print(f\"{e6c_hkl.core.solver.extras=}\")\n", "\n", "e6c_hkl.core.solver.mode = \"psi_constant_vertical\"\n", "print(f\"{e6c_hkl.core.solver.mode=}\")\n", "print(f\"{e6c_hkl.core.solver.extras=}\")\n", "\n", "# \"psi\" engine has only one mode, do not need to set it\n", "print(f\"{e6c_psi.core.solver.mode=}\")\n", "print(f\"{e6c_psi.core.solver.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.core.solver.UB=[[0.034882054037, 0.999391435978, -0.0], [0.0, 0.0, 1.0], [0.999391435978, -0.034882054037, -0.0]]\n", "e6c_hkl.core.solver.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.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.core.solver.UB=!r}\")\n", "print(f\"{e6c_hkl.core.solver.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.039253278732, chi=0, phi=1.998995273774, gamma=0, delta=14.078506557465))" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "e6c_hkl.core.solver.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.solver.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.solver.extras={'h2': 1.0, 'k2': 1.0, 'l2': 0.0, 'psi': 12.0}\n" ] } ], "source": [ "e6c_hkl.core.solver.extras = dict(h2=1, k2=1, l2=0, psi=12)\n", "print(f\"{e6c_hkl.core.solver.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=66.391607045542, chi=99.77381778179, phi=-49.997332854696, gamma=0, delta=24.509844391026)\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=1.000000009255, k=0.999999994159, l=0.999999984039)\n", "e6c_hkl.real_position=Hklpy2DiffractometerRealPos(mu=0, omega=66.391607045542, chi=99.77381778179, phi=-49.997332854696, gamma=0, delta=24.509844391026)\n", "e6c_hkl.core.solver.extras={'h2': 1.0, 'k2': 1.0, 'l2': 0.0, 'psi': 12.0}\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.solver.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.solver.mode='psi_vertical'\n", "e6c_psi.core.solver.extras={'h2': 1.0, 'k2': 1.0, 'l2': 1.0}\n" ] } ], "source": [ "print(f\"{e6c_psi.core.solver.mode=}\")\n", "print(f\"{e6c_psi.core.solver.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.core.solver.UB=[[0.034882112737, 0.999391462637, -7.7669e-08], [-1.1035e-07, 3.7043e-08, 0.999999954315], [0.999391567978, -0.034881973051, -8.4609e-08]]\n", "e6c_psi.core.solver.U=[[0.034882108064, 0.999391434092, -3.3171e-08], [-1.1035e-07, 3.7043e-08, 1.0], [0.999391434092, -0.034882108064, 1.11575e-07]]\n", "e6c_hkl.core.solver.UB=[[0.034882054037, 0.999391435978, -0.0], [0.0, 0.0, 1.0], [0.999391435978, -0.034882054037, -0.0]]\n", "e6c_hkl.core.solver.U=[[0.034882054037, 0.999391435978, 0.0], [0.0, 0.0, 1.0], [0.999391435978, -0.034882054037, 0.0]]\n" ] } ], "source": [ "e6c_psi.core.solver.UB = e6c_hkl.core.solver.UB\n", "\n", "print(f\"{e6c_psi.core.solver.UB=!r}\")\n", "print(f\"{e6c_psi.core.solver.U=!r}\")\n", "\n", "print(f\"{e6c_hkl.core.solver.UB=!r}\")\n", "print(f\"{e6c_hkl.core.solver.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.solver.extras={'h2': 1.0, 'k2': 1.0, 'l2': 0.0}\n" ] } ], "source": [ "e6c_psi.core.solver.extras = dict(h2=1, k2=1, l2=0)\n", "print(f\"{e6c_psi.core.solver.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=132.03129879634)\n", "e6c_psi.real_position=Hklpy2DiffractometerRealPos(mu=0, omega=66.391607045542, chi=99.77381778179, phi=-49.997332854696, gamma=0, delta=24.509844391026)\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=['h', 'h.readback', 'h.setpoint', 'k', 'k.readback', 'k.setpoint', 'l', 'l.readback', 'l.setpoint', 'mu', 'omega', 'chi', 'phi', 'gamma', 'delta'], configuration_attrs=['geometry', 'solver', 'wavelength', 'h', 'k', 'l'], concurrent=True)\n", "h=1.0, k=1.0, l=1.0\n", "wavelength=1.54\n", "mu=0, omega=66.3916, chi=99.7738, phi=-49.9973, gamma=0, delta=24.5098\n", "h2=1.0 k2=1.0 l2=0 psi=12.0\n", "Hklpy2Diffractometer(prefix='', name='e6c_psi', settle_time=0.0, timeout=None, egu='', limits=(0, 0), source='computed', read_attrs=['psi', 'psi.readback', 'psi.setpoint', 'mu', 'omega', 'chi', 'phi', 'gamma', 'delta'], configuration_attrs=['geometry', 'solver', 'wavelength', 'psi'], concurrent=True)\n", "psi=132.0313\n", "wavelength=1.0\n", "mu=0, omega=66.3916, chi=99.7738, phi=-49.9973, gamma=0, delta=24.5098\n", "h2=1.0 k2=1.0 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-03-26 13:07:53\n", "Persistent Unique Scan ID: '2d161957-ee99-431d-bfa4-e5c9f0d6610d'\n", "New stream: 'primary'\n", "+-----------+------------+------------+------------+------------+------------+---------------+-------------+-------------+---------------+---------------+------------+--------------------+\n", "| seq_num | time | 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 | noisy_det | e6c_hkl_extras_psi |\n", "+-----------+------------+------------+------------+------------+------------+---------------+-------------+-------------+---------------+---------------+------------+--------------------+\n", "| 1 | 13:07:53.9 | -0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 155.434 | 0 | -28.375 | 0.913 | 0.000 |\n", "| 2 | 13:07:53.9 | 0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 144.720 | 0 | -28.375 | 1.065 | 10.714 |\n", "| 3 | 13:07:53.9 | 0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 134.005 | 0 | -28.375 | 0.908 | 21.429 |\n", "| 4 | 13:07:53.9 | 0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 123.291 | 0 | -28.375 | 0.913 | 32.143 |\n", "| 5 | 13:07:53.9 | -0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 112.577 | 0 | -28.375 | 1.077 | 42.857 |\n", "| 6 | 13:07:53.9 | -0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 101.863 | 0 | -28.375 | 1.074 | 53.571 |\n", "| 7 | 13:07:54.0 | 0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 91.148 | 0 | -28.375 | 0.970 | 64.286 |\n", "| 8 | 13:07:54.0 | -0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 80.434 | 0 | -28.375 | 0.928 | 75.000 |\n", "| 9 | 13:07:54.0 | -0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 69.720 | 0 | -28.375 | 0.902 | 85.714 |\n", "| 10 | 13:07:54.0 | -0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 59.005 | 0 | -28.375 | 0.986 | 96.429 |\n", "| 11 | 13:07:54.0 | -0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 48.291 | 0 | -28.375 | 1.045 | 107.143 |\n", "| 12 | 13:07:54.0 | 0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 37.577 | 0 | -28.375 | 1.062 | 117.857 |\n", "| 13 | 13:07:54.0 | -0.000 | -0.000 | 2.000 | 0 | 165.812 | 90.000 | 26.863 | 0 | -28.375 | 0.916 | 128.571 |\n", "| 14 | 13:07:54.0 | 0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 16.148 | 0 | -28.375 | 1.024 | 139.286 |\n", "| 15 | 13:07:54.0 | -0.000 | 0.000 | 2.000 | 0 | 165.812 | 90.000 | 5.434 | 0 | -28.375 | 0.996 | 150.000 |\n", "+-----------+------------+------------+------------+------------+------------+---------------+-------------+-------------+---------------+---------------+------------+--------------------+\n", "generator scan_extra ['2d161957'] (scan num: 1)\n", "\n", "\n", "\n" ] } ], "source": [ "e6c_hkl.core.solver.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 }