{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Scan $\\psi$ at fixed $Q$ and $hkl_2$\n",
"\n",
"This **hklpy** notebook demonstrates a diffractometer scan of angle $\\psi$, the\n",
"component of the reference vector ($hkl_2$) that is perpendicular to the\n",
"scattering vector ($Q$). In this schematic:\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",
"First, setup bluesky and build the diffractometer object."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from bluesky import plan_stubs as bps\n",
"from bluesky import preprocessors as bpp\n",
"from bluesky import RunEngine\n",
"from bluesky.callbacks.best_effort import BestEffortCallback\n",
"from hkl import A_KEV\n",
"from hkl import new_lattice\n",
"from hkl import SimulatedE4CV\n",
"from hkl.diffract import Diffractometer\n",
"from hkl.util import libhkl\n",
"from ophyd import Signal\n",
"from ophyd.sim import noisy_det\n",
"import databroker\n",
"import math\n",
"import numpy\n",
"\n",
"bec = BestEffortCallback()\n",
"cat = databroker.temp().v2\n",
"RE = RunEngine()\n",
"RE.subscribe(cat.v1.insert)\n",
"RE.subscribe(bec)\n",
"bec.disable_plots()\n",
"\n",
"UserUnits = libhkl.UnitEnum.USER\n",
"\n",
"diffractometer = SimulatedE4CV(\"\", name=\"diffractometer\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Configure the real-space axes so they are reported in LiveTable. Also, the\n",
"orientation reflections should be reported with other configuration information,\n",
"not as primary data."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"for item in diffractometer.real_positioners:\n",
" item.kind = \"hinted\"\n",
"diffractometer.reflections.kind = \"config\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Add a sample of *vibranium*. The cubic lattice constant is exactly $2\\pi$."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"HklSample(name='vibranium', lattice=LatticeTuple(a=6.283185307179586, b=6.283185307179586, c=6.283185307179586, alpha=90.0, beta=90.0, gamma=90.0), ux=Parameter(name='None (internally: ux)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), uy=Parameter(name='None (internally: uy)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), uz=Parameter(name='None (internally: uz)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), U=array([[1., 0., 0.],\n",
" [0., 1., 0.],\n",
" [0., 0., 1.]]), UB=array([[ 1.000000e+00, -6.123234e-17, -6.123234e-17],\n",
" [ 0.000000e+00, 1.000000e+00, -6.123234e-17],\n",
" [ 0.000000e+00, 0.000000e+00, 1.000000e+00]]), reflections=[])"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"diffractometer.calc.new_sample(\"vibranium\", lattice=new_lattice(2 * math.pi))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Set the diffractometer's wavelength by setting the X-ray photon energy.\n",
"Orient the sample with two observed reflections and compute the $UB$ orientation matrix."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[-5.55111433e-17, -1.11022287e-16, -1.00000000e+00],\n",
" [ 0.00000000e+00, 1.00000000e+00, -1.72254627e-16],\n",
" [ 1.00000000e+00, -6.12323400e-17, -1.16743483e-16]])"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"diffractometer.energy.put(A_KEV / 1.54) # (8.0509 keV)\n",
"\n",
"om = 29.35355\n",
"tth = 2 * om\n",
"r1 = diffractometer.calc.sample.add_reflection(\n",
" 4,\n",
" 0,\n",
" 0,\n",
" position=diffractometer.calc.Position(tth=tth, omega=om, chi=0, phi=0),\n",
")\n",
"\n",
"r2 = diffractometer.calc.sample.add_reflection(\n",
" 0,\n",
" 4,\n",
" 0,\n",
" position=diffractometer.calc.Position(tth=tth, omega=om, chi=90, phi=0),\n",
")\n",
"\n",
"diffractometer.calc.sample.compute_UB(r1, r2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## bluesky plan_stub to move $\\psi$\n",
"\n",
"Create a bluesky plan stub to move $\\psi$ given $hkl_2$ and $Q$.\n",
"\n",
"\n",
"\n",
"This plan stub has been generalized to set all the extra parameters. It makes\n",
"no assumption about any specific diffractometer geometry. The default `mode`\n",
"can be changed with a keyword argument. When using keyword `test=True`, the\n",
"number of `digits` reported can be changed with a keyword argument.\n",
"\n",
"It is helpful to have a separate plan stub (a plan that does not generate any\n",
"data streams) to perform the steps needed to change the $\\psi$ value. For the\n",
"forward computation (hkl to angles), the procedure is:\n",
"\n",
"1. select the diffractometer mode\n",
"2. set the extra parameters ($hkl_2$ and $\\psi$)\n",
"3. compute angles from `forward(Q)`\n",
"4. move diffractometer to the computed angles\n",
"\n",
" \n",
"\n",
"**NOTE**:\n",
"The $\\psi$ rotation angle is an *extra* diffractometer parameter, only available\n",
"as defined by certain diffractometer modes. It is not defined as an ophyd\n",
"`Signal` object. It cannot be scanned directly with any of the standard bluesky\n",
"plans, nor can it be moved with `bps.mv()`. A custom plan is needed to scan\n",
"$\\psi$."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"def move_psi_forward(\n",
" dfrct: Diffractometer,\n",
" Q: dict, # (h, k, l)\n",
" extras: dict, # (h2, k2, l2, psi)\n",
" mode: str = \"psi_constant\",\n",
" test: bool = False,\n",
" digits: int = 5,\n",
"):\n",
" \"\"\"\n",
" Set extras and compute forward solution given 'Q' & reference reflection 'hkl_2'.\n",
"\n",
" EXAMPLE::\n",
"\n",
" RE(\n",
" move_psi_forward(\n",
" diffractometer,\n",
" Q=dict(h=2, k=1, l=0),\n",
" extras=dict(h2=2, k2=2, l2=0, psi=25),\n",
" )\n",
" )\n",
" \"\"\"\n",
" dfrct.engine.mode = mode\n",
" extras = [extras[k] for k in dfrct.calc.parameters]\n",
" dfrct.calc.engine._engine.parameters_values_set(extras, UserUnits)\n",
"\n",
" # TODO: When test=True, can any moves be avoided?\n",
" solution = dfrct.forward(list(Q.values()))\n",
"\n",
" reals = [] # convert to ophyd real positioner objects\n",
" for k, v in solution._asdict().items():\n",
" reals.append(getattr(dfrct, k))\n",
" reals.append(v)\n",
" if test:\n",
"\n",
" def pos_dict(pos_tuple):\n",
" # fmt: off\n",
" return {\n",
" k: round(v, digits) or 0 \n",
" for k, v in pos_tuple._asdict().items()\n",
" }\n",
" # fmt: on\n",
"\n",
" result = pos_dict(dfrct.position)\n",
" result.update(pos_dict(dfrct.real_position))\n",
" result.update(\n",
" dict(\n",
" zip(\n",
" dfrct.calc.parameters,\n",
" dfrct.calc.engine._engine.parameters_values_get(UserUnits),\n",
" )\n",
" )\n",
" )\n",
" print(result)\n",
" else:\n",
" yield from bps.mv(*reals)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## bluesky plan to scan extra parameters such as $\\psi$\n",
"\n",
"Create a generalized bluesky plan that can scan $\\psi$ given $Q$ & $hkl_2$.\n",
"The values of $hkl_2$ are described as constants in the ``extras`` input\n",
"dictionary. The `axis` parameter is `psi` in this example. The `pseudos`\n",
"parameter contains the values of $Q$.\n",
"\n",
"Do not provide a ``reals`` keyword. That's a future feature. It must remain at\n",
"the default value of `None` for this example."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"def scan_extra_parameter(\n",
" dfrct: Diffractometer = None,\n",
" detectors: list = [],\n",
" axis: str = None, # name of extra parameter to be scanned\n",
" start: float = None,\n",
" finish: float = None,\n",
" num: int = None,\n",
" pseudos: dict = None, # h, k, l\n",
" reals: dict = None, # angles\n",
" extras: dict = {}, # define all but the 'axis', these will remain constant\n",
" md: dict = None,\n",
"):\n",
" \"\"\"\n",
" Scan one (or more) extra diffractometer parameter(s), such as psi.\n",
"\n",
" - iterate extras as decribed:\n",
" - set extras\n",
" - solution = forward(pseudos)\n",
" - move to solution\n",
" - trigger detectors\n",
" - read all controls\n",
" \"\"\"\n",
" # if pseudos is None and reals is None:\n",
" # raise SolverError(\"Must define either pseudos or reals.\")\n",
" # if pseudos is not None and reals is not None:\n",
" # raise SolverError(\"Cannot define both pseudos and reals.\")\n",
" forwardTransformation = reals is None\n",
"\n",
" _md = {\n",
" \"diffractometer\": {\n",
" \"name\": dfrct.name,\n",
" \"geometry\": dfrct.calc.geometry_name,\n",
" \"engine\": dfrct.engine.name,\n",
" \"mode\": dfrct.engine.mode,\n",
" \"extra_axes\": dfrct.calc.parameters,\n",
" },\n",
" \"axis\": axis,\n",
" \"start\": start,\n",
" \"finish\": finish,\n",
" \"num\": num,\n",
" \"pseudos\": pseudos,\n",
" \"reals\": reals,\n",
" \"extras\": extras,\n",
" \"transformation\": \"forward\" if forwardTransformation else \"inverse\",\n",
" }\n",
" _md.update(md or {})\n",
"\n",
" # Make a Signal for psi so it can be reported in LiveTable and any stored data.\n",
" signal = Signal(name=axis, value=start)\n",
" all_controls = detectors\n",
" all_controls.append(dfrct)\n",
" all_controls.append(signal)\n",
" # TODO: controls.append(extras_device) # TODO: need Device to report ALL extras\n",
" all_controls = list(set(all_controls))\n",
"\n",
" @bpp.stage_decorator(detectors)\n",
" @bpp.run_decorator(md=_md)\n",
" def _inner():\n",
" for value in numpy.linspace(start, finish, num=num):\n",
" # note the new position for reporting later\n",
" yield from bps.mv(signal, value)\n",
"\n",
" # move\n",
" extras.update({axis: value})\n",
" if forwardTransformation:\n",
" yield from move_psi_forward(dfrct, Q=pseudos, extras=extras)\n",
" else:\n",
" pass # TODO: inverse\n",
"\n",
" # trigger\n",
" group = \"scan_extra_parameter_detectors\"\n",
" for item in detectors:\n",
" yield from bps.trigger(item, group=group)\n",
" yield from bps.wait(group=group)\n",
"\n",
" # read & record the data point\n",
" yield from bps.create(\"primary\")\n",
" for item in all_controls:\n",
" yield from bps.read(item)\n",
" yield from bps.save()\n",
"\n",
" return (yield from _inner())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Scan $\\psi$ over a wide range in coarse steps. This example chooses $Q=(210)$\n",
"and $hkl_2=(1 \\bar2 0)$. (The reference $hkl_2$ was chosen to be perpendicular\n",
"to $Q$.) Save the `uid` from the scan for later reference."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"\n",
"Transient Scan ID: 2 Time: 2024-09-05 15:57:02\n",
"Persistent Unique Scan ID: 'c9c96fe0-c712-433a-abf6-ea1548c8dbd8'\n",
"New stream: 'primary'\n",
"+-----------+------------+------------+------------------+------------------+------------------+----------------------+--------------------+--------------------+--------------------+------------+\n",
"| seq_num | time | noisy_det | diffractometer_h | diffractometer_k | diffractometer_l | diffractometer_omega | diffractometer_chi | diffractometer_phi | diffractometer_tth | psi |\n",
"+-----------+------------+------------+------------------+------------------+------------------+----------------------+--------------------+--------------------+--------------------+------------+\n",
"| 1 | 15:57:02.9 | 1.050 | 2.000 | 1.000 | -0.000 | -79.339 | -90.000 | -90.000 | -31.808 | 0.000 |\n",
"| 2 | 15:57:03.0 | 1.074 | 2.000 | 1.000 | 0.000 | -79.006 | -81.313 | -94.382 | -31.808 | 9.722 |\n",
"| 3 | 15:57:03.0 | 1.072 | 2.000 | 1.000 | -0.000 | -77.970 | -72.678 | -98.972 | -31.808 | 19.444 |\n",
"| 4 | 15:57:03.0 | 1.085 | 2.000 | 1.000 | -0.000 | -76.109 | -64.157 | -104.015 | -31.808 | 29.167 |\n",
"| 5 | 15:57:03.0 | 0.901 | 2.000 | 1.000 | -0.000 | -73.189 | -55.838 | -109.835 | -31.808 | 38.889 |\n",
"| 6 | 15:57:03.0 | 0.944 | 2.000 | 1.000 | -0.000 | -68.806 | -47.853 | -116.906 | -31.808 | 48.611 |\n",
"| 7 | 15:57:03.0 | 0.960 | 2.000 | 1.000 | -0.000 | -62.300 | -40.424 | -125.944 | -31.808 | 58.333 |\n",
"| 8 | 15:57:03.0 | 0.957 | 2.000 | 1.000 | -0.000 | -52.679 | -33.940 | -137.984 | -31.808 | 68.056 |\n",
"| 9 | 15:57:03.0 | 0.935 | 2.000 | 1.000 | 0.000 | -38.852 | -29.055 | -154.156 | -31.808 | 77.778 |\n",
"| 10 | 15:57:03.0 | 0.919 | 2.000 | 1.000 | 0.000 | -20.890 | -26.674 | -174.424 | -31.808 | 87.500 |\n",
"| 11 | 15:57:03.0 | 0.935 | 2.000 | 1.000 | 0.000 | -1.790 | -27.460 | 164.179 | -31.808 | 97.222 |\n",
"| 12 | 15:57:03.0 | 0.975 | 2.000 | 1.000 | 0.000 | 14.333 | -31.174 | 145.735 | -31.808 | 106.944 |\n",
"| 13 | 15:57:03.0 | 1.087 | 2.000 | 1.000 | 0.000 | 26.007 | -36.938 | 131.684 | -31.808 | 116.667 |\n",
"| 14 | 15:57:03.0 | 1.023 | 2.000 | 1.000 | 0.000 | 33.972 | -43.944 | 121.251 | -31.808 | 126.389 |\n",
"| 15 | 15:57:03.1 | 0.995 | 2.000 | 1.000 | 0.000 | 39.344 | -51.679 | 113.277 | -31.808 | 136.111 |\n",
"| 16 | 15:57:03.1 | 0.947 | 2.000 | 1.000 | -0.000 | 42.951 | -59.847 | 106.885 | -31.808 | 145.833 |\n",
"| 17 | 15:57:03.1 | 0.980 | 2.000 | 1.000 | -0.000 | 45.319 | -68.277 | 101.491 | -31.808 | 155.556 |\n",
"| 18 | 15:57:03.1 | 0.988 | 2.000 | 1.000 | -0.000 | 46.758 | -76.862 | 96.702 | -31.808 | 165.278 |\n",
"| 19 | 15:57:03.1 | 1.095 | 2.000 | 1.000 | 0.000 | 47.443 | -85.529 | 92.241 | -31.808 | 175.000 |\n",
"+-----------+------------+------------+------------------+------------------+------------------+----------------------+--------------------+--------------------+--------------------+------------+\n",
"generator scan_extra_parameter ['c9c96fe0'] (scan num: 2)\n",
"\n",
"\n",
"\n"
]
}
],
"source": [
"uid, = RE(\n",
" scan_extra_parameter(\n",
" diffractometer,\n",
" detectors=[noisy_det,],\n",
" pseudos=dict(h=2, k=1, l=0),\n",
" axis=\"psi\",\n",
" start=0,\n",
" finish=175,\n",
" num=19,\n",
" extras=dict(h2=1, k2=-2, l2=0),\n",
" ),\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Get the run data from the catalog using the `uid` as an index. View the\n",
"metadata from that run."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Start({'axis': 'psi',\n",
" 'diffractometer': {'engine': 'hkl',\n",
" 'extra_axes': ['h2', 'k2', 'l2', 'psi'],\n",
" 'geometry': 'E4CV',\n",
" 'mode': 'psi_constant',\n",
" 'name': 'diffractometer'},\n",
" 'extras': {'h2': 1, 'k2': -2, 'l2': 0},\n",
" 'finish': 175,\n",
" 'num': 19,\n",
" 'plan_name': 'scan_extra_parameter',\n",
" 'plan_type': 'generator',\n",
" 'pseudos': {'h': 2, 'k': 1, 'l': 0},\n",
" 'reals': None,\n",
" 'scan_id': 2,\n",
" 'start': 0,\n",
" 'time': 1725569822.9740038,\n",
" 'transformation': 'forward',\n",
" 'uid': 'c9c96fe0-c712-433a-abf6-ea1548c8dbd8',\n",
" 'versions': {'bluesky': '1.13.0a5.dev23+g997eb228', 'ophyd': '1.9.0'}})"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"run = cat[uid]\n",
"run.metadata[\"start\"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create plots of each diffractometer *real* axis *v*. $\\psi$ to show how the axes\n",
"moved during the scan. Use the axis names as recorded in the databroker\n",
"catalog.\n",
"\n",
"**Note**:\n",
"Detector axes (such as `tth`) remain constant as shown in the LiveTable. The plots show variations past the 6th decimal place due to machine precision."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"