pcdsdevices.lens.LensStackBase

class pcdsdevices.lens.LensStackBase(x_prefix, y_prefix, z_prefix, lens_set, z_offset, z_dir, E, att_obj, lcls_obj=None, mono_obj=None, *args, **kwargs)

Class for Be lens macros and safe operations.

x, y, z: real motors that move the position of the lens set calib_z, beam_size pseudo motors

An ophyd PseudoPositioner relates one or more pseudo (virtual) axes to one or more real (physical) axes via forward and inverse calculations.

The purpose of this class is using the motor that moves the z stage of BeLensStack so that we can scan the focal size. What needs to be done is move the x motor and then the combination motor that when the z motor moves we also move the x and y to compensate for the stage not being perfect.

What do we usually do: For each lens pack that is in, tweak x and y until the fixture on YAG screen is as pretty as it can be - save this position. Move the z motor on one extreme to the furthest upstream position, and then figure out the optimal x and y for each lens pack. Move the motor to the other side, the most downstream side and do the same thing. Save the x and y here as well.

So this focus motor, moves three motors in combination. The z is used for the main calculations records, to get a focal spot size, and x and y are moved based on the tweak that was done at the beginning.

In general, it saves an x, y, z at the ends of motion, the idea being that the beam is a line that is not colinear with any one axis, so we draw a line in 3D space to follow the center of the beam.

The scientist workflow is basically the same as before: you call one function (align) with low beam to find the centers of the lenses, then you have two pseudo motors (calib_z, beam_size) that magically put the lens in the right spot.

Notes

Use pcdscalc.be_lens_cals.configure_defaults function to set some default parameters used in some calculations for different hutches. Use pcdscalc.set_lens_set_to_file to set the lens sets file

Ophyd Device Components

Attribute	Class	Suffix	Docs	Kind	Notes
x (FCpt)	IMS	{self.x_prefix}		normal
y (FCpt)	IMS	{self.y_prefix}		normal
z (FCpt)	IMS	{self.z_prefix}		normal
calib_z	PseudoSingleInterface			normal
beam_size	PseudoSingleInterface			normal

Methods

align(z_position=None, edge_offset=20)

Generate equations for aligning the beam based on user input.

This program uses two points, one made on the lower limit and the other made on the upper limit, after the user uses the tweak function to put the beam into alignment, and uses those two points to make two equations to determine a y- and x-position for any z-value the user wants that will keep the beam focused. The beam line will be saved in a file in the presets folder, and can be used with the pseudo positioner on the z-axis. If called with an integer, automatically moves the z-motor.

Parameters:

• z_position (number, optional)

• edge_offset (number, optional)

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.

forward(pseudo_pos)

Run a forward(pseudo -> real) calculation.

Calculate a RealPosition from a given PseudoPosition. calc_distance_for_size calculates distance for beam size (fwhm size)

Parameters:

pseudo_pos (PseudoPosition) – Pseudo position to move to.

Returns:

RealPosition

Raises:

AttributeError – If pseudo motor is not setup for use.

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)

Run an inverse (real -> pseudo) calculation.

calc_beam_fwhm returns fwhm (Full width at half maximum) size for certain lenses configuration and energy at a given distance.

Parameters:

real_pos (RealPosition)

Returns:

PseudoPosition

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

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

Moves z to pos and x and y to their calibrated offset positions. If safe is True, then ._make_safe() gets called TODO: should i have a safe attribute here like the old code?

Parameters:

• position – Pseudo position to move to.

• wait (bool, optional) – Defaults to True

• timeout (float, optional) – Maximum time to wait for the motion. If None, the default timeout for this positioner is used.

• 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.

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

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.

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(position)

Adjust all offsets so that the pseudo position matches the input.

This will raise an AttributeError if any of the real motors is missing a set_current_position method.

Parameters:

position (PseudoPos) – The 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()

Call the tweak function from pcdsdevice.interface.

Use the Left arrow to move x motor left. Use the Right arrow to move x motor right. Use the Down arrow to move y motor down. Use the Up arrow to move y motor up. Use Shift & Up arrow to scale*2. Use Shift & Down arrow to scale/2. Press q to quit.

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

egu

The engineering units (EGU) for positions

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

timeout

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