Ctrl+K

NSLS-II TARDIS Configuration#

This notebook documents some calculations using a simulation of the Tardis diffractometer (an E6C variation) at NSLS-II. The connections with the EPICS motors have been replaced with simulated motors for this example.

Using the E6C geometry from libhkl, @cmazzoli found that, in this geometry, with the “lifting_detector_mu” mode, the following mapping applies:

libhkl

TARDIS

mu

theta

gamma

delta

delta

gamma

phi

None

chi

None

omega

None

  • The diffractometer geometry with angle and axis definitions are depicted below

4b8cbc8b1a654fb4af0bcdb1a8bc265e

Begin by instantiating a calculation engine of the appropriate geometry, and configuring its mode as lifting_detector_mu . We must reach into the hkl.calc module to import CalcE6C.

[1]:

from hkl.calc import CalcE6C

tardis_calc = CalcE6C()

# what modes are available?
print(f"Available modes: {tardis_calc.engine.modes = }")
print(f"{tardis_calc.physical_axes = }")
print(f"{tardis_calc.pseudo_axes = }")

Available modes: tardis_calc.engine.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']
tardis_calc.physical_axes = OrderedDict([('mu', 0.0), ('omega', 0.0), ('chi', 0.0), ('phi', 0.0), ('gamma', 0.0), ('delta', 0.0)])
tardis_calc.pseudo_axes = OrderedDict([('h', 0.0), ('k', 0.0), ('l', 0.0)])

[2]:

tardis_calc.engine.mode = 'lifting_detector_mu'

Next, seed the calculation engine with a parameterized sample and wavelength (or energy).

NOTE: length units are in Angstrom, angles are in degrees, and energy is in keV.

[3]:

from hkl import Lattice

# lattice cell lengths are in Angstrom, angles are in degrees
lattice = Lattice(a=9.069, b=9.069, c=10.390, alpha=90.0, beta=90.0, gamma=120.0)
sample = tardis_calc.new_sample('sample1', lattice=lattice)

print(f"{sample = }")

sample = HklSample(name='sample1', lattice=LatticeTuple(a=9.069, b=9.069, c=10.39, alpha=90.0, beta=90.0, gamma=119.99999999999999), 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.],
       [0., 1., 0.],
       [0., 0., 1.]]), UB=array([[ 7.99999720e-01,  3.99999860e-01, -6.41365809e-17],
       [ 0.00000000e+00,  6.92820080e-01, -6.41365809e-17],
       [ 0.00000000e+00,  0.00000000e+00,  6.04733908e-01]]), reflections=[])

[4]:

tardis_calc.wavelength = 1.61198  # in Angstrom

# just to check
print(f"Energy: {tardis_calc.energy = } keV")

Energy: tardis_calc.energy = 7.691422871251505 keV

Now, apply constraints appropriate for TARDIS’ geometry. This includes setting limits on the acceptable ranges of motion, initial (and constant!) values, and whether or not a particular axis should be factored into the fitting function that produces the forward and inverse solutions.

Since we are working with a hkl.calc.CalcRecip object, we do not have access to the convenience of the apply_constraints() method provided by the hkl.diffract.Diffractometer class. We have to set the constraints the hard way. These are the same steps implemented within apply_constraints().

NOTE: physical motors should be checked that limits are in place prior to initiating any motion. Note also that none of the calculations below are associated with any physical motors, and that there is no connection between “limit” values used in the calculation, and soft-limit values that may be present in a control system for physical motors.

[5]:

# Theta
mu = tardis_calc['mu']
mu.limits = (-181, 181)
mu.value = 0

# we don't have it. Fix to 0
phi = tardis_calc['phi']
phi.limits = (0, 0)
phi.value = 0

# we don't have it. Fix to 0
chi = tardis_calc['chi']
chi.limits = (0, 0)
chi.value = 0

# we don't have it!! Fix to 0
omega = tardis_calc['omega']
omega.limits = (0, 0)
omega.value = 0

# NOTE: Tardis detector stage names are swapped from canonical names!
# delta
gamma = tardis_calc['gamma']
gamma.limits = (-5, 180)
gamma.value = 0

# gamma
delta = tardis_calc['delta']
delta.limits = (-5, 180)
delta.value = 0

We can take a look at the UB matrix, but thus far, it won’t be very interesting

[6]:

print(f"{tardis_calc.sample.UB = }")

tardis_calc.sample.UB = array([[ 7.99999720e-01,  3.99999860e-01, -6.41365809e-17],
       [ 0.00000000e+00,  6.92820080e-01, -6.41365809e-17],
       [ 0.00000000e+00,  0.00000000e+00,  6.04733908e-01]])

Add two, known reflections and the motor positions associated with those hkl values. Here, we are using values from @cmazolli’s ESRF notes:

(3,3,0): del = 64.449, gam = -0.871, th = 25.285
(5,2,0): del = 79.712, gam = -1.374, th = 46.816

NOTE: the translation of gamma==delta, delta==gamma, and mu==theta is being used

[7]:

r1 = tardis_calc.sample.add_reflection(3, 3, 0,
                           position=tardis_calc.Position(gamma=64.449, mu=25.285, chi=0.0, phi=0.0, omega=0.0, delta=-0.871))

r2 = tardis_calc.sample.add_reflection(5, 2, 0,
                           position=tardis_calc.Position(gamma=79.712, mu=46.816, chi=0.0, phi=0.0, omega=0.0, delta=-1.374))

[8]:

print(f"{tardis_calc.sample.reflections = }")

tardis_calc.sample.reflections = [(h=3.0, k=3.0, l=0.0), (h=5.0, k=2.0, l=0.0)]

Now a UB matrix can be computed.

[9]:

tardis_calc.sample.compute_UB(r1, r2)

[9]:

array([[ 0.31323551, -0.4807593 ,  0.01113654],
       [ 0.73590724,  0.63942704,  0.01003773],
       [-0.01798898, -0.00176066,  0.60454803]])

Compare some libhkl-generated results with those from @cmazolli’s notes:

# Experimentally found reflections @ Lambda = 1.61198 A
# (4, 4, 0) = [90.628, 38.373, 0, 0, 0, -1.156]
# (4, 1, 0) = [56.100, 40.220, 0, 0, 0, -1.091]
# @ Lambda = 1.60911
# (6, 0, 0) = [75.900, 61.000, 0, 0, 0, -1.637]
# @ Lambda = 1.60954
# (3, 2, 0) = [53.090, 26.144, 0, 0, 0, -.933]
# (5, 4, 0) = [106.415, 49.900, 0, 0, 0, -1.535]
# (4, 5, 0) = [106.403, 42.586, 0, 0, 0, -1.183]

[10]:

print(f"{tardis_calc.forward((4,4,0)) = }")

tardis_calc.forward((4,4,0)) = (PosCalcE6C(mu=38.37622128052063, omega=0.0, chi=0.0, phi=0.0, gamma=90.63030469353308, delta=-1.1613181970939916),)

[11]:

print(f"{tardis_calc.forward((4,1,0)) = }")

tardis_calc.forward((4,1,0)) = (PosCalcE6C(mu=40.219919777570965, omega=0.0, chi=0.0, phi=0.0, gamma=56.09704093977083, delta=-1.0836608655032929),)

Change wavelength here to 1.60911 Angstrom. Note the difference below in delta (TARDIS’ gamma axis)

[12]:

# change wavelength (Angstrom)
tardis_calc.wavelength = 1.60911
print(f"{tardis_calc.forward((6,0,0)) = }")

tardis_calc.forward((6,0,0)) = (PosCalcE6C(mu=60.99346591074179, omega=0.0, chi=0.0, phi=0.0, gamma=75.84521749189145, delta=-1.5839501607961701),)

[13]:

tardis_calc.wavelength = 1.60954
print(f"{tardis_calc.forward((3,2,0)) = }")
print(f"{tardis_calc.forward((5,4,0)) = }")
print(f"{tardis_calc.forward((4,5,0)) = }")

tardis_calc.forward((3,2,0)) = (PosCalcE6C(mu=26.173823521308144, omega=0.0, chi=0.0, phi=0.0, gamma=53.05207622287554, delta=-0.8437995840438257),)
tardis_calc.forward((5,4,0)) = (PosCalcE6C(mu=49.892322604056034, omega=0.0, chi=0.0, phi=0.0, gamma=106.32053081067252, delta=-1.423656049079967),)
tardis_calc.forward((4,5,0)) = (PosCalcE6C(mu=42.54926633295045, omega=0.0, chi=0.0, phi=0.0, gamma=106.31894239326303, delta=-1.1854071532601609),)

HKL PseudoPositioner Use#

Let’s explore the idea of an hkl ‘motor’

[14]:

from ophyd import Component as Cpt
from ophyd import (PseudoSingle, EpicsMotor)
from hkl import SimulatedE6C

# FIXME: hack to get around what should have been done at init of tardis_calc instance
tardis_calc._lock_engine = True

class Tardis(SimulatedE6C): ...

# class Tardis(E6C):
#     h = Cpt(PseudoSingle, '')
#     k = Cpt(PseudoSingle, '')
#     l = Cpt(PseudoSingle, '')

#     theta = Cpt(EpicsMotor, 'XF:31IDA-OP{Tbl-Ax:X1}Mtr')
#     omega = Cpt(EpicsMotor, 'XF:31IDA-OP{Tbl-Ax:X2}Mtr')
#     chi = Cpt(EpicsMotor, 'XF:31IDA-OP{Tbl-Ax:X3}Mtr')
#     phi = Cpt(EpicsMotor, 'XF:31IDA-OP{Tbl-Ax:X4}Mtr')
#     delta = Cpt(EpicsMotor, 'XF:31IDA-OP{Tbl-Ax:X5}Mtr')
#     gamma = Cpt(EpicsMotor, 'XF:31IDA-OP{Tbl-Ax:X6}Mtr')

# re-map Tardis' axis names onto what an E6C expects
name_map = {
    # tardis: E6C
    'mu': 'theta',
    'omega': 'omega',
    'chi': 'chi',
    'phi': 'phi',
    'gamma': 'delta',
    'delta': 'gamma',
    }

tardis = Tardis(
    '', # no prefix
    name='tardis', # local name
    calc_inst=tardis_calc, # the calc engine setup above
    # energy=tardis_calc.energy, # FIXME: unexpected keyword argument
)
tardis.calc.physical_axis_names = name_map
print(f"{tardis.calc.physical_axis_names = }")

tardis.calc.physical_axis_names = ['theta', 'omega', 'chi', 'phi', 'delta', 'gamma']

[15]:

print(f"{tardis.real_position = }")

tardis.real_position = TardisRealPos(mu=0, omega=0, chi=0, phi=0, gamma=0, delta=0)

[16]:

print(f"{tardis.connected = }")

tardis.connected = True

[17]:

print(f"Energy: {tardis.energy.get() = } keV")

Energy: tardis.energy.get() = 8.0 keV

Move to (101) reflection#

[18]:

tardis.move((1,0,1), wait=False)

[18]:

MoveStatus(done=False, pos=tardis, elapsed=0.0, success=False, settle_time=0.0)

[19]:

status = _

[20]:

print(f"{status.done = }")

status.done = True

[21]:

print(f"{tardis.real_position = }")

tardis.real_position = TardisRealPos(mu=32.61342481972243, omega=0.0, chi=0.0, phi=0.0, gamma=12.011255441335317, delta=8.64179902840924)

[22]:

print(f"{tardis.position = }")

tardis.position = TardisPseudoPos(h=1.0000000000000002, k=-5.667215834780817e-16, l=1.0)

Move to (102) reflection#

[23]:

tardis.move((1,0,2))

[23]:

MoveStatus(done=True, pos=tardis, elapsed=0.0, success=True, settle_time=0.0)

[24]:

tardis.h.describe()

[24]:

OrderedDict([('tardis_h',
              {'source': 'PY:tardis_h.position',
               'dtype': 'number',
               'shape': [],
               'upper_ctrl_limit': 0,
               'lower_ctrl_limit': 0,
               'units': ''}),
             ('tardis_h_setpoint',
              {'source': 'PY:tardis_h.target',
               'dtype': 'integer',
               'shape': [],
               'upper_ctrl_limit': 0,
               'lower_ctrl_limit': 0,
               'units': ''})])

[25]:

tardis.h.read()

[25]:

OrderedDict([('tardis_h', {'value': 1.0, 'timestamp': 1700539353.9169118}),
             ('tardis_h_setpoint',
              {'value': 1, 'timestamp': 1700539353.9169252})])

[26]:

tardis.describe()

[26]:

OrderedDict([('tardis_h',
              {'source': 'PY:tardis_h.position',
               'dtype': 'number',
               'shape': [],
               'upper_ctrl_limit': 0,
               'lower_ctrl_limit': 0,
               'units': ''}),
             ('tardis_h_setpoint',
              {'source': 'PY:tardis_h.target',
               'dtype': 'integer',
               'shape': [],
               'upper_ctrl_limit': 0,
               'lower_ctrl_limit': 0,
               'units': ''}),
             ('tardis_k',
              {'source': 'PY:tardis_k.position',
               'dtype': 'number',
               'shape': [],
               'upper_ctrl_limit': 0,
               'lower_ctrl_limit': 0,
               'units': ''}),
             ('tardis_k_setpoint',
              {'source': 'PY:tardis_k.target',
               'dtype': 'integer',
               'shape': [],
               'upper_ctrl_limit': 0,
               'lower_ctrl_limit': 0,
               'units': ''}),
             ('tardis_l',
              {'source': 'PY:tardis_l.position',
               'dtype': 'number',
               'shape': [],
               'upper_ctrl_limit': 0,
               'lower_ctrl_limit': 0,
               'units': ''}),
             ('tardis_l_setpoint',
              {'source': 'PY:tardis_l.target',
               'dtype': 'integer',
               'shape': [],
               'upper_ctrl_limit': 0,
               'lower_ctrl_limit': 0,
               'units': ''}),
             ('tardis_mu',
              {'source': 'computed',
               'dtype': 'number',
               'shape': [],
               'units': '',
               'lower_ctrl_limit': -180,
               'upper_ctrl_limit': 180}),
             ('tardis_omega',
              {'source': 'computed',
               'dtype': 'number',
               'shape': [],
               'units': '',
               'lower_ctrl_limit': -180,
               'upper_ctrl_limit': 180}),
             ('tardis_chi',
              {'source': 'computed',
               'dtype': 'number',
               'shape': [],
               'units': '',
               'lower_ctrl_limit': -180,
               'upper_ctrl_limit': 180}),
             ('tardis_phi',
              {'source': 'computed',
               'dtype': 'number',
               'shape': [],
               'units': '',
               'lower_ctrl_limit': -180,
               'upper_ctrl_limit': 180}),
             ('tardis_gamma',
              {'source': 'computed',
               'dtype': 'number',
               'shape': [],
               'units': '',
               'lower_ctrl_limit': -180,
               'upper_ctrl_limit': 180}),
             ('tardis_delta',
              {'source': 'computed',
               'dtype': 'number',
               'shape': [],
               'units': '',
               'lower_ctrl_limit': -180,
               'upper_ctrl_limit': 180})])

[27]:

tardis.read()

[27]:

OrderedDict([('tardis_h', {'value': 1.0, 'timestamp': 1700539353.9169118}),
             ('tardis_h_setpoint',
              {'value': 1, 'timestamp': 1700539353.9169252}),
             ('tardis_k',
              {'value': -1.0351079150284598e-17,
               'timestamp': 1700539353.9170356}),
             ('tardis_k_setpoint',
              {'value': 0, 'timestamp': 1700539353.917049}),
             ('tardis_l',
              {'value': 1.9999999999999998, 'timestamp': 1700539353.9170997}),
             ('tardis_l_setpoint',
              {'value': 2, 'timestamp': 1700539353.9171119}),
             ('tardis_mu',
              {'value': 42.936333275662705, 'timestamp': 1700539353.9886892}),
             ('tardis_omega', {'value': 0.0, 'timestamp': 1700539353.9886923}),
             ('tardis_chi', {'value': 0.0, 'timestamp': 1700539353.9886947}),
             ('tardis_phi', {'value': 0.0, 'timestamp': 1700539353.9886968}),
             ('tardis_gamma',
              {'value': 12.143148125839154, 'timestamp': 1700539353.9886992}),
             ('tardis_delta',
              {'value': 17.765469685728892, 'timestamp': 1700539353.9887023})])

[28]:

print(f"{tardis.position = }")

tardis.position = TardisPseudoPos(h=1.0, k=-1.0351079150284598e-17, l=1.9999999999999998)

[29]:

print(f"{tardis.real_position = }")

tardis.real_position = TardisRealPos(mu=42.936333275662705, omega=0.0, chi=0.0, phi=0.0, gamma=12.143148125839154, delta=17.765469685728892)
On this page
Show Source