Diffractometer

Caution

work-in-progress

concept:

User builds a subclass of DiffractometerBase(), adding a variety of positioners as ophyd Components. In an instance of that subclass, user sets backend_solver by calling solver_factory(). In this call, the user specifies the solver, the geometry, and defines which Components (of the diffractometer) are to be used as pseudos and reals. The backend implements forward(), inverse(), and all related support, for only the pseudos and reals that are identified.

A Solver is not needed to:

• define subclass of DiffractometerBase() and create instance

• create instance of Sample()

• create instance of Lattice()

• create instance of WavelengthBase() subclass

• create instance of SolverBase() subclass

• set wavelength

• list available solvers: (solvers())

• review saved orientation details

A Solver is needed to:

• list available Solver geometries

• list a Solver geometry’s required pseudo_axis_names, real_axis_names, extra_axis_names, modes

• create instance of Reflection()

• define or compute a \(UB\) matrix (calculateOrientation())

• forward() and inverse()

• determine the diffractometer position

• save or restore orientation details

• refine lattice parameters

The DiffractometerBase() class should be a thin interface. Most real diffractometer capability should be provided in the Operations() class (or one of its attributes, such as solver and sample)

Operations-related methods and properties

auto_assign_axes()	Automatically assign diffractometer axes to this solver.
forward(pseudos[, wavelength])	Compute real-space coordinates from pseudos (hkl -> angles).
inverse(reals[, wavelength])	Compute pseudo-space coordinates from reals (angles -> hkl).
position	Pseudo motor position namedtuple
pseudo_axis_names	Names of all the pseudo axes, in order of appearance.
real_axis_names	Names of all the real axes, in order of appearance.
wh([digits, full])	Concise report of the current diffractometer positions.

Sample-related methods and properties

add_reflection(pseudos[, reals, wavelength, ...])	Add a new reflection with this geometry to the selected sample.
add_sample(name, a[, b, c, alpha, beta, ...])	Add a new sample.
sample	Current sample object.
samples	Dictionary of samples.

Solver-related methods and properties

geometry	Name of backend Solver geometry.
solver	Name of backend Solver (library).
solver_name	Backend Solver library name.

Related methods and properties from other classes

assign_axes(pseudos, reals)	Designate attributes for use by the PseudoPositioner class.
extra_axis_names	Ordered list of any extra axis names (such as x, y, z).
lattice	Sample crystal lattice.
refine_lattice()	Refine the lattice parameters from 3 or more reflections.
reflections	Ordered dictionary of orientation reflections.
set_solver(name, geometry, **kwargs)	Create an instance of the backend Solver library and geometry.
U	Return the matrix, U, crystal orientation on the diffractometer.
UB	Return the crystal orientation matrix, UB.

Source Code Documentation

Base class for all diffractometers

DiffractometerBase([prefix, solver, ...])	Base class for all diffractometers.
pick_first_item(now, solutions)	Choose first item from list.

class hklpy2.diffract.DiffractometerBase(prefix: str = '', *, solver: str = None, geometry: str = None, solver_kwargs: dict = {}, pseudos: list[str] = None, reals: list[str] = None, **kwargs)

Bases: PseudoPositioner

Base class for all diffractometers.

Parameters

• solver (str) : Name of Solver library. (default: unspecified)

• geometry: (str) : Name of Solver geometry. (default: unspecified)

• solver_kwargs (dict) : Any additional keyword arguments needed by Solver library. (default: empty)

• pseudos ([str]) : List of diffractometer axis names to be used as pseudo axes. (default: unspecified)

• reals ([str]) : List of diffractometer axis names to be used as real axes. (default: unspecified)

(ophyd) Components

(ophyd) Attribute Components

geometry	Name of backend Solver geometry.
solver	Name of backend Solver (library).
wavelength	Wavelength of incident radiation.

Python Methods

add_reflection(pseudos[, reals, wavelength, ...])	Add a new reflection with this geometry to the selected sample.
add_sample(name, a[, b, c, alpha, beta, ...])	Add a new sample.
auto_assign_axes()	Automatically assign diffractometer axes to this solver.
forward(pseudos[, wavelength])	Compute real-space coordinates from pseudos (hkl -> angles).
inverse(reals[, wavelength])	Compute pseudo-space coordinates from reals (angles -> hkl).
wh([digits, full])	Concise report of the current diffractometer positions.

Python Properties

pseudo_axis_names	Names of all the pseudo axes, in order of appearance.
real_axis_names	Names of all the real axes, in order of appearance.
sample	Current sample object.
samples	Dictionary of samples.
solver_name	Backend Solver library name.

add_reflection(pseudos, reals=None, wavelength=None, name=None, replace: bool = False) → Reflection

Add a new reflection with this geometry to the selected sample.

Parameters

• pseudos (various): pseudo-space axes and values.

• reals (various): dictionary of real-space axes and values.

• wavelength (float): Wavelength of incident radiation. If None, diffractometer’s current wavelength will be assigned.

• name (str): Reference name for this reflection. If None, a random name will be assigned.

• replace (bool): If True, replace existing reflection of this name. (default: False)

add_sample(name: str, a: float, b: float = None, c: float = None, alpha: float = 90.0, beta: float = None, gamma: float = None, digits: int = 4, replace: bool = False) → Sample

Add a new sample.

auto_assign_axes()

Automatically assign diffractometer axes to this solver.

See also

hklpy2.ops.Operations.auto_assign_axes()

A Solver geometry specifies expected pseudo, real, and extra axes for its .forward() and .inverse() coordinate transformations.

This method assigns this diffractometer’s:

• first PseudoSingle axes to the pseudo axes expected by the selected Solver.

• first Positioner axes (or subclass, such as EpicsMotor or SoftPositioner) to the real axes expected by the selected Solver.

• any remaining PseudoSingle and Positioner axes to the extra axes expected by the selected Solver.

Any diffractometer axes not expected by the Solver will not be assigned.

forward(pseudos: dict, wavelength: float = None) → tuple

Compute real-space coordinates from pseudos (hkl -> angles).

geometry

Name of backend Solver geometry.

inverse(reals: dict, wavelength: float = None) → tuple

Compute pseudo-space coordinates from reals (angles -> hkl).

property pseudo_axis_names

Names of all the pseudo axes, in order of appearance.

Example:

>>> fourc.pseudo_axis_names
['h', 'k', 'l']

property real_axis_names

Names of all the real axes, in order of appearance.

Example:

>>> fourc.real_axis_names
['omega', 'chi, 'phi', 'tth']

property sample

Current sample object.

property samples

Dictionary of samples.

solver

Name of backend Solver (library).

property solver_name

Backend Solver library name.

wavelength

Wavelength of incident radiation.

wh(digits=4, full=False)

Concise report of the current diffractometer positions.

Inherited members, from ophyd.PseudoPositioner

Base class for all diffractometers

DiffractometerBase([prefix, solver, ...])	Base class for all diffractometers.
pick_first_item(now, solutions)	Choose first item from list.

class hklpy2.diffract.DiffractometerBase(prefix: str = '', *, solver: str = None, geometry: str = None, solver_kwargs: dict = {}, pseudos: list[str] = None, reals: list[str] = None, **kwargs)

Base class for all diffractometers.

Parameters

• solver (str) : Name of Solver library. (default: unspecified)

• geometry: (str) : Name of Solver geometry. (default: unspecified)

• solver_kwargs (dict) : Any additional keyword arguments needed by Solver library. (default: empty)

• pseudos ([str]) : List of diffractometer axis names to be used as pseudo axes. (default: unspecified)

• reals ([str]) : List of diffractometer axis names to be used as real axes. (default: unspecified)

(ophyd) Components

(ophyd) Attribute Components

geometry	Name of backend Solver geometry.
solver	Name of backend Solver (library).
wavelength	Wavelength of incident radiation.

Python Methods

add_reflection(pseudos[, reals, wavelength, ...])	Add a new reflection with this geometry to the selected sample.
add_sample(name, a[, b, c, alpha, beta, ...])	Add a new sample.
auto_assign_axes()	Automatically assign diffractometer axes to this solver.
forward(pseudos[, wavelength])	Compute real-space coordinates from pseudos (hkl -> angles).
inverse(reals[, wavelength])	Compute pseudo-space coordinates from reals (angles -> hkl).
wh([digits, full])	Concise report of the current diffractometer positions.

Python Properties

pseudo_axis_names	Names of all the pseudo axes, in order of appearance.
real_axis_names	Names of all the real axes, in order of appearance.
sample	Current sample object.
samples	Dictionary of samples.
solver_name	Backend Solver library name.

class OphydAttrList(device, kind, remove_kind, recurse_key)

list proxy to migrate away from Device.read_attrs and Device.config_attrs

append(value)

S.append(value) – append value to the end of the sequence

clear() → None -- remove all items from S

count(value) → integer -- return number of occurrences of value

extend(values)

S.extend(iterable) – extend sequence by appending elements from the iterable

index(value[, start[, stop]]) → integer -- return first index of value.

Raises ValueError if the value is not present.

Supporting start and stop arguments is optional, but recommended.

insert(index, object)

S.insert(index, value) – insert value before index

pop([index]) → item -- remove and return item at index (default last).

Raise IndexError if list is empty or index is out of range.

remove(value)

S.remove(value) – remove first occurrence of value. Raise ValueError if the value is not present.

reverse()

S.reverse() – reverse IN PLACE

_concurrent_move(real_pos, **kwargs)

Move all real positioners to a certain position, in parallel

_done_acquiring(**kwargs)

Call when acquisition has completed.

_done_moving(success=True)

Call this when motion has completed. Runs SUB_DONE subscription.

_get_components_of_kind(kind)

Get names of components that match a specific kind

_get_kind(name)

Get a Kind for a given Component

If the Component is instantiated, it will be retrieved directly from that object.

If the Component is lazy and not yet instantiated, the default value as specified by the Component class will be used. This is stashed away in _component_kinds.

classmethod _get_pseudo_positioners()

Inspect the components and find the pseudo positioners

All PseudoSingle (and subclassed) components will be returned, by default.

The built-in mechanism to override the list of pseudo positioners on a PseudoPositioner is to define ‘_pseudo’ on the class-level. It should be a list of attribute names.

Yields:

(attr, component)

classmethod _get_real_positioners()

Inspect the components and find the real positioners

All Positioner components which are not `PseudoSingle`s will be returned, by default.

The built-in mechanism to override the list of real positioners on a PseudoPositioner is to define ‘_real’ on the class-level. It should be a list of attribute names. This allows you to group real motors logically on the device but not have them included in motions or calculations.

Yields:

(attr, component)

classmethod _initialize_device()

Initializes the Device and all of its Components

Initializes the following attributes from the Components::

• _sig_attrs - dict of attribute name to Component

• component_names - a list of attribute names used for components

• _device_tuple - An auto-generated namedtuple based on all existing Components in the Device

• _sub_devices - a list of attributes which hold a Device

• _required_for_connection - a dictionary of object-to-description for additional things that block this from being reported as connected

_instantiate_component(attr)

Create a Component specifically for this Device

classmethod _pseudo_position_tuple()

A namedtuple for a pseudo motor position

This is automatically generated at the class-level for all PseudoSingle-based positioners.

_real_finished(status=None, *, obj=None)

Callback: A single real positioner has finished moving.

Used for asynchronous motion, if all have finished moving then fire a callback (via Positioner._done_moving)

_real_pos_update(obj=None, value=None, **kwargs)

Callback: A single real positioner has moved

classmethod _real_position_tuple()

A namedtuple for a real motor position

This is automatically generated at the class-level for all non-PseudoSingle-based positioners.

_repr_info()

Yields pairs of (key, value) to generate the object repr

_reset_sub(event_type)

Remove all subscriptions in an event type

_run_subs(*args, sub_type, **kwargs)

Run a set of subscription callbacks

Only the kwarg sub_type is required, indicating the type of callback to perform. All other positional arguments and kwargs are passed directly to the callback function.

The host object will be injected into kwargs as ‘obj’ unless that key already exists.

If the timestamp is None, then it will be replaced by the current time.

No exceptions are raised if the callback functions fail.

_sequential_move(real_pos, timeout=None, **kwargs)

Move all real positioners to a certain position, in series

_set_kind(name, kind)

Set the Kind for a given Component

_set_position(value, **kwargs)

Set the current internal position, run the readback subscription

_setup_move(position, status)

Move requested to position

This is a customization of SoftPositioner’s _setup_move method which is what gets called when a motion request happens.

Parameters:

• position (PseudoPosition) – Position to move to (already verified by check_value)

• status (MoveStatus) – Status object created by PositionerBase.move()

_summary()

Return a string summarizing the structure of the Device.

_update_position()

Update the internal position based on all of the real positioners

classmethod add_instantiation_callback(callback, fail_if_late=False)

Register a callback which will receive each OphydObject instance.

Parameters:

• callback (callable) – Expected signature: f(ophydobj_instance)

• fail_if_late (boolean) – If True, verify that OphydObj has not yet been instantiated and raise RuntimeError if it has, as a way of verify that no instances will be “missed” by this registry. False by default.

add_reflection(pseudos, reals=None, wavelength=None, name=None, replace: bool = False) → Reflection

Add a new reflection with this geometry to the selected sample.

Parameters

• pseudos (various): pseudo-space axes and values.

• reals (various): dictionary of real-space axes and values.

• wavelength (float): Wavelength of incident radiation. If None, diffractometer’s current wavelength will be assigned.

• name (str): Reference name for this reflection. If None, a random name will be assigned.

• replace (bool): If True, replace existing reflection of this name. (default: False)

add_sample(name: str, a: float, b: float = None, c: float = None, alpha: float = 90.0, beta: float = None, gamma: float = None, digits: int = 4, replace: bool = False) → Sample

Add a new sample.

auto_assign_axes()

Automatically assign diffractometer axes to this solver.

See also

hklpy2.ops.Operations.auto_assign_axes()

A Solver geometry specifies expected pseudo, real, and extra axes for its .forward() and .inverse() coordinate transformations.

This method assigns this diffractometer’s:

• first PseudoSingle axes to the pseudo axes expected by the selected Solver.

• first Positioner axes (or subclass, such as EpicsMotor or SoftPositioner) to the real axes expected by the selected Solver.

• any remaining PseudoSingle and Positioner axes to the extra axes expected by the selected Solver.

Any diffractometer axes not expected by the Solver will not be assigned.

check_single(pseudo_single, single_pos)

Check if a new position for a single pseudo positioner is valid

check_value(pseudo_pos)

Check if a new position for all pseudo positioners is valid

First checks limits against those set for individual pseudo axes. Second, calculates forward(pseudo_pos) => real_pos and checks it against the real positioners.

NOTE: If you have limits that are coupled together or are somehow more complicated than the above procedure, you should redefine this method in your subclass.

clear_sub(cb, event_type=None)

Remove a subscription, given the original callback function

See also subscribe(), unsubscribe()

Parameters:

• cb (callable) – The callback

• event_type (str, optional) – The event to unsubscribe from (if None, removes it from all event types)

property composite_egu

The composite engineering units (EGU) from all PseudoSingles

property concurrent

If concurrent is set, motors will move concurrently (in parallel)

configure(d: Dict[str, Any]) → Tuple[Dict[str, Any], Dict[str, Any]]

Configure the device for something during a run

This default implementation allows the user to change any of the configuration_attrs. Subclasses might override this to perform additional input validation, cleanup, etc.

Parameters:

d (dict) – The configuration dictionary. To specify the order that the changes should be made, use an OrderedDict.

Returns:

• (old, new) tuple of dictionaries

• Where old and new are pre- and post-configure configuration states.

property connected

If the device is connected.

Subclasses should override this

describe() → OrderedDictType[str, Dict[str, Any]]

Provide schema and meta-data for read().

This keys in the OrderedDict this method returns must match the keys in the OrderedDict return by read().

This provides schema related information, (ex shape, dtype), the source (ex PV name), and if available, units, limits, precision etc.

Returns:

data_keys – The keys must be strings and the values must be dict-like with the event_model.event_descriptor.data_key schema.

Return type:

OrderedDict

describe_configuration() → OrderedDictType[str, Dict[str, Any]]

Provide schema & meta-data for read_configuration()

This keys in the OrderedDict this method returns must match the keys in the OrderedDict return by read().

This provides schema related information, (ex shape, dtype), the source (ex PV name), and if available, units, limits, precision etc.

Returns:

data_keys – The keys must be strings and the values must be dict-like with the event_model.event_descriptor.data_key schema.

Return type:

OrderedDict

destroy()

Disconnect and destroy all signals on the Device

property dotted_name: str

Return the dotted name

property egu

The engineering units (EGU) for positions

property event_types

Events that can be subscribed to via obj.subscribe

forward(pseudos: dict, wavelength: float = None) → tuple

Compute real-space coordinates from pseudos (hkl -> angles).

geometry

Name of backend Solver geometry.

get(**kwargs)

Get the value of all components in the device

Keyword arguments are passed onto each signal.get(). Components beginning with an underscore will not be included.

classmethod get_device_tuple()

The device tuple type associated with an Device class

This is a tuple representing the full state of all components and dynamic device sub-components.

get_instantiated_signals(*, attr_prefix=None)

Yields all of the instantiated signals in a device hierarchy

Parameters:

attr_prefix (string, optional) – The attribute prefix. If None, defaults to self.name

Yields:

(fully_qualified_attribute_name, signal_instance)

property high_limit

All PseudoSingle high limits as a namedtuple

inverse(reals: dict, wavelength: float = None) → tuple

Compute pseudo-space coordinates from reals (angles -> hkl).

property limits

All PseudoSingle limits as a namedtuple

property low_limit

All PseudoSingle low limits as a namedtuple

move(position, wait=True, timeout=None, moved_cb=None)

Move to a specified position, optionally waiting for motion to complete.

Parameters:

• position – Position to move to

• moved_cb (callable) – Call this callback when movement has finished. This callback must accept one keyword argument: ‘obj’ which will be set to this positioner instance.

• wait (bool, optional) – Wait until motion has completed

• timeout (float, optional) – Maximum time to wait for a motion

Returns:

status

Return type:

MoveStatus

Raises:

• TimeoutError – When motion takes longer than timeout

• ValueError – On invalid positions

• RuntimeError – If motion fails other than timing out

move_single(pseudo, position, **kwargs)

Move one PseudoSingle axis to a position

All other positioners will use their current setpoint/target value, if available. Failing that, their current readback value will be used (see PseudoSingle.sync and PseudoSingle.target).

Parameters:

• pseudo (PseudoSingle) – PseudoSingle positioner to move

• position (float) – Position only for the PseudoSingle

• kwargs (dict) – Passed onto move

property moving

Whether or not the motor is moving

Returns:

moving

Return type:

bool

property name

name of the device

property parent

The parent of the ophyd object.

If at the top of its hierarchy, parent will be None

pause() → None

Attempt to ‘pause’ the device.

This is called when ever the RunEngine is interrupted.

A device may have internal state that means plans can not safely be re-wound. This method may: put the device in a ‘paused’ state and/or raise NoReplayAllowed to indicate that the plan can not be rewound.

Raises:

bluesky.run_engine.NoReplayAllowed –

property position

Pseudo motor position namedtuple

property pseudo_axis_names

Names of all the pseudo axes, in order of appearance.

Example:

>>> fourc.pseudo_axis_names
['h', 'k', 'l']

property pseudo_positioners

Pseudo positioners instances in a namedtuple

Returns:

positioner_instances

Return type:

PseudoPosition

put(dev_t, **kwargs)

Put a value to all components of the device

Keyword arguments are passed onto each signal.put()

Parameters:

dev_t (DeviceTuple or tuple) – The device tuple with the value(s) to put (see get_device_tuple)

read() → OrderedDictType[str, Dict[str, Any]]

Read data from the device.

This method is expected to be as instantaneous as possible, with any substantial acquisition time taken care of in trigger().

The OrderedDict returned by this method must have identical keys (in the same order) as the OrderedDict returned by describe().

By convention, the first key in the return is the ‘primary’ key and maybe used by heuristics in bluesky.

The values in the ordered dictionary must be dict (-likes) with the keys {'value', 'timestamp'}. The 'value' may have any type, the timestamp must be a float UNIX epoch timestamp in UTC.

Returns:

data – The keys must be strings and the values must be dict-like with the keys {'value', 'timestamp'}

Return type:

OrderedDict

read_configuration() → OrderedDictType[str, Dict[str, Any]]

Dictionary mapping names to value dicts with keys: value, timestamp

To control which fields are included, change the Component kinds on the device, or modify the configuration_attrs list.

property real_axis_names

Names of all the real axes, in order of appearance.

Example:

>>> fourc.real_axis_names
['omega', 'chi, 'phi', 'tth']

property real_position

Real motor position namedtuple

property real_positioners

Real positioners instances in a namedtuple

Returns:

positioner_instances

Return type:

RealPosition

property report

A report on the object.

resume() → None

Resume a device from a ‘paused’ state.

This is called by the bluesky.run_engine.RunEngine when it resumes from an interruption and is responsible for ensuring that the device is ready to take data again.

property root

Walk parents to find ultimate ancestor (parent’s parent…).

property sample

Current sample object.

property samples

Dictionary of samples.

property sequential

If sequential is set, motors will move in the sequence they were defined in (i.e., in series)

set(position, **kwargs)

Move to a new position asynchronously

Parameters:

position (PseudoPosition) – Position for the all of the pseudo axes

Returns:

status

Return type:

MoveStatus

property settle_time

Amount of time to wait after moves to report status completion

solver

Name of backend Solver (library).

property solver_name

Backend Solver library name.

stage() → List[object]

Stage the device for data collection.

This method is expected to put the device into a state where repeated calls to trigger() and read() will ‘do the right thing’.

Staging not idempotent and should raise RedundantStaging if staged twice without an intermediate unstage().

This method should be as fast as is feasible as it does not return a status object.

The return value of this is a list of all of the (sub) devices stage, including it’s self. This is used to ensure devices are not staged twice by the RunEngine.

This is an optional method, if the device does not need staging behavior it should not implement stage (or unstage).

Returns:

devices – list including self and all child devices staged

Return type:

list

stop(success=False)

Stop the Device and all (instantiated) subdevices

subscribe(callback, event_type=None, run=True)

Subscribe to events this event_type generates.

The callback will be called as cb(*args, **kwargs) with the values passed to _run_subs with the following additional keys:

sub_type : the string value of the event_type obj : the host object, added if ‘obj’ not already in kwargs

if the key ‘timestamp’ is in kwargs _and_ is None, then it will be replaced with the current time before running the callback.

The *args, **kwargs passed to _run_subs will be cached as shallow copies, be aware of passing in mutable data.

Warning

If the callback raises any exceptions when run they will be silently ignored.

Parameters:

• callback (callable) –

  A callable function (that takes kwargs) to be run when the event is generated. The expected signature is

  def cb(*args, obj: OphydObject, sub_type: str, **kwargs) -> None:
  

  The exact args/kwargs passed are whatever are passed to _run_subs

• event_type (str, optional) –

  The name of the event to subscribe to (if None, defaults to the default sub for the instance - obj._default_sub)

  This maps to the sub_type kwargs in _run_subs

• run (bool, optional) – Run the callback now

See also

clear_sub, _run_subs

Returns:

cid – id of callback, can be passed to unsubscribe to remove the callback

Return type:

int

property target

Last commanded target positions

property timeout

Amount of time to wait before to considering a motion as failed

to_pseudo_tuple(*args, **kwargs)

Convert arguments to a PseudoPosition namedtuple and kwargs

to_real_tuple(*args, **kwargs)

Convert arguments to a RealPosition namedtuple and kwargs

trigger() → StatusBase

Trigger the device and return status object.

This method is responsible for implementing ‘trigger’ or ‘acquire’ functionality of this device.

If there is an appreciable time between triggering the device and it being able to be read (via the read() method) then this method is also responsible for arranging that the StatusBase object returned by this method is notified when the device is ready to be read.

If there is no delay between triggering and being readable, then this method must return a StatusBase object which is already completed.

Returns:

status – StatusBase object which will be marked as complete when the device is ready to be read.

Return type:

StatusBase

unstage() → List[object]

Unstage the device.

This method returns the device to the state it was prior to the last stage call.

This method should be as fast as feasible as it does not return a status object.

This method must be idempotent, multiple calls (without a new call to ‘stage’) have no effect.

Returns:

devices – list including self and all child devices unstaged

Return type:

list

unsubscribe(cid)

Remove a subscription

See also subscribe(), clear_sub()

Parameters:

cid (int) – token return by subscribe()

wait_for_connection(all_signals=False, timeout=2.0)

Wait for signals to connect

Parameters:

• all_signals (bool, optional) – Wait for all signals to connect (including lazy ones)

• timeout (float or None) – Overall timeout

classmethod walk_components()

Walk all components in the Device hierarchy

Yields:

ComponentWalk – Where ancestors is all ancestors of the signal, including the top-level device walk_components was called on.

walk_signals(*, include_lazy=False)

Walk all signals in the Device hierarchy

EXPERIMENTAL: This method is experimental, and there are tentative plans to change its API in a way that may not be backward-compatible.

Parameters:

include_lazy (bool, optional) – Include not-yet-instantiated lazy signals

Yields:

ComponentWalk – Where ancestors is all ancestors of the signal, including the top-level device walk_signals was called on.

classmethod walk_subdevice_classes()

Walk all sub-Devices classes in the Device hierarchy

Yields:

(dotted_name, subdevice_class)

walk_subdevices(*, include_lazy=False)

Walk all sub-Devices in the hierarchy

EXPERIMENTAL: This method is experimental, and there are tentative plans to change its API in a way that may not be backward-compatible.

Yields:

(dotted_name, subdevice_instance)

wavelength

Wavelength of incident radiation.

wh(digits=4, full=False)

Concise report of the current diffractometer positions.