pcdsdevices.ccm.CCMEnergy

class pcdsdevices.ccm.CCMEnergy(*args, **kwargs)

CCM energy motor.

Calculates the current CCM energy using the alio position, and requests moves to the alio based on energy requests.

Presents itself like a motor.

Parameters:: prefix (str) – The PV prefix of the Alio motor, e.g. XPP:MON:MPZ:07A

Ophyd Device Components
Attribute	Class	Suffix	Docs	Kind	Notes
theta0_deg (FCpt)	`EpicsSignal`	`{_constants_prefix}:THETA0`	Reference angle for the first crystal in deg.	config	Inherited from `CCMConstantsMixin`
dspacing (FCpt)	`EpicsSignal`	`{_constants_prefix}:DSPACING`	Crystal lattice spacing.	config	Inherited from `CCMConstantsMixin`
gr (FCpt)	`EpicsSignal`	`{_constants_prefix}:GR`	The radius of the sapphire ball connected to the Alio stage in mm.	config	Inherited from `CCMConstantsMixin`
gd (FCpt)	`EpicsSignal`	`{_constants_prefix}:GD`	Distance between the rotation axis and the center of the sapphire sphere located on the Alio stage in mm.	config	Inherited from `CCMConstantsMixin`
energy	`PseudoSingleInterface`		PseudoSingle that moves the calculated CCM selected energy in keV.	hinted
alio	`CCMAlio`		The motor that rotates the CCM crystal.	normal
theta_deg	`InternalSignal`		The crystal angle in degrees.	normal
wavelength	`InternalSignal`		The wavelength picked by the CCM in Angstroms.	normal
resolution	`InternalSignal`		A measure of how finely we can control the ccm output at this position in eV/um.	normal

Methods

alio_to_energy(alio: float) → float

Converts alio to energy.

Parameters:: alio (float) – The alio position in mm
Returns:: energy (float) – The photon energy (color) in keV.

camonitor()

Shows a live-updating motor position in the terminal.

This will be the value that is returned by the position attribute.

This method ends cleanly at a ctrl+c or after a call to end_monitor_thread(), which may be useful when this is called in a background thread.

check_single(pseudo_single, single_pos): Check if a new position for a single pseudo positioner is valid

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.

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 (OrderedDict) – The keys must be strings and the values must be dict-like with the event_model.event_descriptor.data_key schema.

end_monitor_thread(): Stop a camonitor() or wm_update() that is running in another thread.

energy_to_alio(energy: float) → float

Converts energy to alio.

Parameters:: energy (float) – The photon energy (color) in keV.
Returns:: alio (float) – The alio position in mm

forward(pseudo_pos: namedtuple) → namedtuple

PseudoPositioner interface function for calculating the setpoint.

Converts the requested energy to the real position of the alio.

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.

inverse(real_pos: namedtuple) → namedtuple

PseudoPositioner interface function for calculating the readback.

Converts the real position of the alio to the calculated energy.

move(*args, kill=True, wait=True, **kwargs)

Overwrite the move method to add a PID kill at the end of each move.

Context: the PID loop keeps looking for the final position forever. The motor thus runs at too high duty cycles, heats up and causes vacuum spikes in the chamber. This has led to MPS trips. In addition, there is serious potential to fry the motor itself, as it is run too intensively.

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

mv(position, timeout=None, wait=False, log=True)

Absolute move to a position.

Parameters:

position – Desired end position.
timeout (float, optional) – If provided, the mover will throw an error if motion takes longer than timeout to complete. If omitted, the mover’s default timeout will be use.
wait (bool, optional) – If True, wait for motion completion before returning. Defaults to False.
log (bool, optional) – If True, logs the move at INFO level.

mv_ginput(timeout=None)

Moves to a location the user clicks on.

If there are existing plots, this will be the position on the most recently active plot. If there are no existing plots, an empty plot will be created with the motor’s limits as the range.

mvr(delta, timeout=None, wait=False, log=True)

Relative move from this position.

Parameters:

delta (float) – Desired change in position.
timeout (float, optional) – If provided, the mover will throw an error if motion takes longer than timeout to complete. If omitted, the mover’s default timeout will be use.
wait (bool, optional) – If True, wait for motion completion before returning. Defaults to False.
log (bool, optional) – If True, logs the move at INFO level.

post_elog_status(): Post device status to the primary elog, if possible.

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 (OrderedDict) – The keys must be strings and the values must be dict-like with the keys {'value', 'timestamp'}

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.

reset_calc_constant_defaults(confirm: bool = True) → None

Put the default values into the ccm constants.

This can be useful if values were reset due to autosave errors or if they’ve otherwise accidentally been set to crazy values.

This relies on the default values in ccm.py being set up reasonably: theta0_deg = 15.1027 dspacing = 3.1356011499587773 gr = 3.175 gd = 231.303

Parameters:: confirm (bool, optional) – If True, we’ll ask for confirmation from the user before doing the reset. This is because an accidental reset can cost some time as we scramble to figure out what the values should be restored to.

screen()

Open a screen for controlling the device.

Default behavior is the typhos screen, but this method can be overridden for more specialized screens.

set(position, **kwargs)

Move to a new position asynchronously

Parameters:: position (PseudoPosition) – Position for the all of the pseudo axes
Returns:: status (MoveStatus)

set_current_position(energy: float) → None

Adjust the offset to make input energy the current position.

This changes the value of the theta0 PV.

set_position(position)

Alias for set_current_position.

Will fail if the motor does not have set_current_position.

status() → str: Returns a str with the current pv values for the device.

stop(success=False): Stop the Device and all (instantiated) subdevices

summary()

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) – StatusBase object which will be marked as complete when the device is ready to be read.

tweak(scale=0.1)

Control this motor using the arrow keys.

Use left arrow to step negative and right arrow to step positive. Use up arrow to increase step size and down arrow to decrease step size. Press q or ctrl+c to quit.

Parameters:: scale (float) – starting step size, default = 0.1

umv(position, timeout=None, log=True, newline=True)

Move to a position, wait, and update with a progress bar.

Parameters:

position (float) – Desired end position.
timeout (float, optional) – If provided, the mover will throw an error if motion takes longer than timeout to complete. If omitted, the mover’s default timeout will be use.
log (bool, optional) – If True, logs the move at INFO level.
newline (bool, optional) – If True, inserts a newline after the updates.

umvr(delta, timeout=None, log=True, newline=True)

Relative move from this position, wait, and update with a progress bar.

Parameters:

delta (float) – Desired change in position.
timeout (float, optional) – If provided, the mover will throw an error if motion takes longer than timeout to complete. If omitted, the mover’s default timeout will be use.
log (bool, optional) – If True, logs the move at INFO level.
newline (bool, optional) – If True, inserts a newline after the updates.

wait(timeout=None)

warn_invalid_constants(only_new: bool = False) → None

Warn if we have invalid values for our calculation constants.

The motivation here is twofold: 1. It should be easy for the user to know what is wrong and

why. The calculations should not be opaque.

The user should still be able to do “something” if there is an issue here.

For values to be valid, the PVs need to be connected and all but theta0 must be nonzero. Theta0 should also not be zero, but it doesn’t break the math and someone could conceivably set it to zero during debug.

If this isn’t satisfied, we will show an appropriate warning message when this method is called. The intention is for this to pop up whenever we run the forward/inverse calculations.

For more detail, consider the following failure modes: 1. The constant PVs don’t connect and never connect

In this case, we must warn that the constants IOC is off

We should use the default values in calculations

The constant PVs connect, but their values are zero

In this case, we must warn that the constant values were lost

We should use the default values in calculations

The constant PVs connect, but disconnect later

In this case, we should warn that the IOC died

We should continue using the last known good values

Parameters:: only_new (bool, optional) – If False, the default, always show us the warnings. If True, do not show warnings if they have not changed.

wm(): Get the mover’s current positon (where motor).

wm_update()

Shows a live-updating motor position in the terminal.

This will be the value that is returned by the position attribute.

This method ends cleanly at a ctrl+c or after a call to end_monitor_thread(), which may be useful when this is called in a background thread.

Attributes

composite_egu: The composite engineering units (EGU) from all PseudoSingles

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

configuration_attrs

connected

dspacing_val

The dspacing value currently used in calculations.

This is the crystal lattice spacing.

This will be the value from the PV if things are working properly, otherwise it will fall back to the default value.

This is necessary because a value of 0 is nonphysical and in the case of a disconnected value the show must go on.

egu: The engineering units (EGU) for positions

gd_val

The gd value currently used in calculations.

This is the distance between the rotation axis and the center of the sapphire sphere located on the Alio stage in mm.

This will be the value from the PV if things are working properly, otherwise it will fall back to the default value.

This is necessary because a value of 0 is nonphysical and in the case of a disconnected value the show must go on.

gr_val

The gr value currently used in calculations.

This is the radius of the sapphire ball connected to the Alio stage in mm.

This will be the value from the PV if things are working properly, otherwise it will fall back to the default value.

This is necessary because a value of 0 is nonphysical and in the case of a disconnected value the show must go on.

high_limit: All PseudoSingle high limits as a namedtuple

hints

kind

limits: All PseudoSingle limits as a namedtuple

low_limit: All PseudoSingle low limits as a namedtuple

moving

position: Pseudo motor position namedtuple

pseudo_positioners

Pseudo positioners instances in a namedtuple

Returns:: positioner_instances (PseudoPosition)

real_position: Real motor position namedtuple

real_positioners

Real positioners instances in a namedtuple

Returns:: positioner_instances (RealPosition)

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

settle_time: Amount of time to wait after moves to report status completion

subscriptions: ClassVar[FrozenSet[str]] = frozenset({'_req_done', 'acq_done', 'done_moving', 'readback', 'start_moving'})

target: Last commanded target positions

theta0_deg_val

The theta0 value currently used in calculations.

This is the reference angle for the first crystal in deg.

This will be the value from the PV if things are working properly, otherwise it will fall back to the default value.

theta0_rad_val

The theta0 value currently used in calculations.

This is the reference angle for the first crystal in rad.

This will be the value from the PV if things are working properly, otherwise it will fall back to the default value.

timeout: Amount of time to wait before to considering a motion as failed