def _stage():
_heater_status = yield from rd(mag6t.field.switch_heater)
if _heater_status != 'On':
# Click current ramp button
yield from mv(mag6t.field.ramp_button, 1)
# Wait for the supply current to match the magnet.
target = yield from rd(mag6t.field.current)
function = _difference_check(target, tolerance=0.01)
yield from abs_set(signal,
mag6t.field.supply_current,
function,
wait=True)
# Turn on persistance switch heater.
yield from mv(mag6t.field.switch_heater, 'On')
yield from sleep(2)
# Wait for the heater to be on.
function = _status_check(target=[3])
yield from abs_set(signal,
mag6t.field.magnet_status,
function,
wait=True)
# Click current ramp button
yield from mv(mag6t.field.ramp_button, 1)
def test_blackfly(RE, db, shutter, noise):
for cycle in [
None,
cycler("blackfly_det_image", [np.ones(BLACKFLY_IMG_SIZE)])
]:
det = det_factory(
cycle=cycle,
data_key="blackfly_det_image",
shutter=shutter,
noise=noise,
size=BLACKFLY_IMG_SIZE,
)
RE.subscribe(db.insert, "all")
RE(bs.abs_set(shctl1, XPD_SHUTTER_CONF["open"], wait=True))
uid = RE(bp.count([det]))
for name, doc in db.restream(db[-1], fill=True):
if name == "event":
db_img = doc["data"]["blackfly_det_image"]
assert db_img.squeeze().shape == BLACKFLY_IMG_SIZE
assert uid is not None
if shutter:
RE(bs.abs_set(shctl1, XPD_SHUTTER_CONF["close"], wait=True))
uid = RE(bp.count([det]))
for name, doc in db.restream(db[-1], fill=True):
if name == "event":
db_img = doc["data"]["blackfly_det_image"]
assert db_img.squeeze().shape == BLACKFLY_IMG_SIZE
assert np.allclose(db_img, np.zeros_like(db_img))
assert uid is not None
def inner_expo(exposure):
"""private function to configure pe1c with continuous acquisition mode
cs studio configuration doesn't propagate to python level
"""
yield from bps.abs_set(
xpd_configuration["area_det"].cam.acquire_time,
glbl["frame_acq_time"],
wait=True,
)
print('l50')
# compute number of frames
acq_time = xpd_configuration["area_det"].cam.acquire_time.get()
print('l53')
# _check_mini_expo(exposure, acq_time)
num_frame = np.ceil(exposure / acq_time)
print('l56')
computed_exposure = num_frame * acq_time
yield from bps.abs_set(xpd_configuration["area_det"].images_per_set,
num_frame,
wait=True)
print('l61')
# print exposure time
print("INFO: requested exposure time = {} - > computed exposure time"
"= {}".format(exposure, computed_exposure))
print('l67')
return num_frame, acq_time, computed_exposure
def test_dets_shutter(RE, db, name, fp):
det = det_factory(cycle=build_image_cycle(fp), shutter=shctl1)
RE.subscribe(db.insert, "all")
uid = RE(bp.count([det]))
cycle2 = build_image_cycle(fp)
cg = cycle2()
# With the shutter down
RE(bs.abs_set(shctl1, XPD_SHUTTER_CONF["close"], wait=True))
uid = RE(bp.count([det]))
for name, doc in db.restream(db[-1], fill=True):
if name == "event":
assert_array_equal(
doc["data"]["pe1_image"],
np.zeros_like(doc["data"]["pe1_image"]),
)
assert uid is not None
# With the shutter up
RE(bs.abs_set(shctl1, XPD_SHUTTER_CONF["open"], wait=True))
print('outside shutter id =', id(shctl1))
print('outside shutter status =', shctl1.get())
uid = RE(bp.count([det]))
for name, doc in db.restream(db[-1], fill=True):
if name == "event":
assert_array_equal(doc["data"]["pe1_image"], next(cg)["pe1_image"])
assert uid is not None
def configure_area_det(det, md: Dict[str, Union[int, float]]):
"""
Yield the message to configure the area detector with time per frame and number of frames per exposure
according to the required exposure time. Update the metadata.
Parameters
----------
det
The area detector.
md
A dictionary to configure the area detector. It is the output of calc_exposure.
It contains the key value pairs:
{
'sp_time_per_frame': acq_time (float),
'sp_num_frames': num_frame (int),
'sp_requested_exposure': exposure (float),
'sp_computed_exposure': computed_exposure (float)
}
Yields
------
msg
Message to configure the area detector.
"""
acq_time = md.get('sp_time_per_frame')
num_frame = md.get('sp_num_frames')
yield from bps.abs_set(det.cam.acquire_time, acq_time, wait=True)
if hasattr(det, "images_per_set"):
yield from bps.abs_set(det.images_per_set, num_frame, wait=True)
def test_sigint_three_hits(RE, hw):
motor = hw.motor
motor.delay = 0.3
pid = os.getpid()
def sim_kill(n=1):
for j in range(n):
print('KILL')
os.kill(pid, signal.SIGINT)
lp = RE.loop
motor.loop = lp
lp.call_later(.02, sim_kill, 3)
lp.call_later(.02, sim_kill, 3)
lp.call_later(.02, sim_kill, 3)
start_time = ttime.time()
with pytest.raises(RunEngineInterrupted):
RE(
finalize_wrapper(abs_set(motor, 1, wait=True),
abs_set(motor, 0, wait=True)))
end_time = ttime.time()
assert end_time - start_time < 0.2 # not enough time for motor to cleanup
RE.abort() # now cleanup
done_cleanup_time = ttime.time()
assert done_cleanup_time - end_time > 0.3
def configure_cam_detector(detector: tp.Any, acquire_time: float,
images_per_set: int) -> tp.Generator:
"""Configure the acquire_time of the cam opponent in detector and the images_per_set of the detector."""
print("acquire_time -> {}; images_per_set -> {}; exposure -> {}".format(
acquire_time, images_per_set, acquire_time * images_per_set))
yield from bps.abs_set(detector.cam.acquire_time, acquire_time, wait=True)
yield from bps.abs_set(detector.images_per_set, images_per_set, wait=True)
def test_sigint_three_hits(RE, hw):
motor = hw.motor
motor.delay = 0.3
pid = os.getpid()
def sim_kill(n=1):
for j in range(n):
print('KILL')
os.kill(pid, signal.SIGINT)
lp = RE.loop
motor.loop = lp
lp.call_later(.02, sim_kill, 3)
lp.call_later(.02, sim_kill, 3)
lp.call_later(.02, sim_kill, 3)
start_time = ttime.time()
with pytest.raises(RunEngineInterrupted):
RE(finalize_wrapper(abs_set(motor, 1, wait=True),
abs_set(motor, 0, wait=True)))
end_time = ttime.time()
assert end_time - start_time < 0.2 # not enough time for motor to cleanup
RE.abort() # now cleanup
done_cleanup_time = ttime.time()
assert done_cleanup_time - end_time > 0.3
def MED(init_gas, other_gas, minT, maxT, num_steps, num_steady, num_trans, num_loops=2):
"""
1. Start flowing the initial gas.
2. Scan the temperature from minT to maxT in `num_steps` evenly-spaced steps.
3. Hold temperature at maxT and take `num_steady` images.
4. Repeat (2) and (3) `num_loops` times.
5. Switch the gas to `other_gas` and take `num_trans` acquisitions.
6. Switch it back and take another `num_trans` acquisitions.
Example
-------
Set the gasses. They can be in any other, nothing to do with
the order they are used in the plan.
>>> gas.gas_list = ['O2', 'CO2']
Optionally, preview the plan.
>>> print_summary(MED('O2', 'C02', 200, 300, 21, 20, 60))
Execute it.
>>> RE(MED('O2', 'C02', 200, 300, 21, 20, 60))
"""
# Step 1
yield from abs_set(gas, init_gas)
# Steps 2 and 3 in a loop.
for _ in range(num_loops):
yield from subs_wrapper(scan([pe1, gas.current_gas], eurotherm, minT, maxT, num_steps),
LiveTable([eurotherm, gas.current_gas]))
yield from subs_wrapper(count([pe1], num_steady), LiveTable([]))
# Step 4
yield from abs_set(gas, other_gas)
yield from subs_wrapper(count([pe1], num_steady), LiveTable([]))
# Step 6
yield from abs_set(gas, init_gas)
yield from subs_wrapper(count([pe1], num_steady), LiveTable([]))
def fix_epu():
# move the energy setpoint to where the energy really is
yield from bps.abs_set(pgm.energy, pgm.energy.position, wait=True)
# set the interpolator to look at what it was looking at before
# the scan. This should be the energy set point.
yield from bps.abs_set(epu1.flt.input_pv, 'XF:23ID2-OP{Mono}Enrgy-SP CP MS', wait=True)
yield from bps.abs_set(epu1.flt.output_deadband, 0, wait=True)
def fly_scan(E0, mono_speed, device_dict, parent):
# Initial settings
flyer = device_dict['energyFlyer']
parent.subscribe_callback()
parent.toLog("A new fly scan is started!", color='blue')
# Set to fly scan speed
yield from bps.abs_set(flyer.fly_motor_speed, mono_speed)
# Do fly scan
yield from bpp.monitor_during_wrapper(bp.fly([flyer]), [
device_dict['ENC_fly_counter'], device_dict['I0_fly_counter'],
device_dict['It_fly_counter'], device_dict['If_fly_counter'],
device_dict['Ir_fly_counter']
])
# Set to normal speed
yield from bps.abs_set(flyer.fly_motor_speed, parent._orig_mono_speed)
# Move to E0
yield from stop_and_mv(dcm, E0)
parent.unsubscribe_callback()
# Decrease remaining scan-number
num_scan = int(parent.control.number_of_scan_edit.value())
if num_scan > 1:
_submit(parent.control.number_of_scan_edit.setValue, num_scan - 1)
cooling_time = parent.control.flyControl.flyCoolTime.value()
parent.toLog(
"Cooling dcm. The next scan starts after {} seconds.".format(
cooling_time))
yield from bps.sleep(cooling_time)
def clean_up():
# move the energy setpoint to where the energy really is
yield from bps.abs_set(pgm.energy, pgm.energy.position, wait=True)
# set the interpolator to look at what it was looking at before
# the scan. This should be the energy set point.
yield from bps.abs_set(epu1.flt.input_pv, old_link, wait=True)
yield from bps.abs_set(epu1.flt.output_deadband, old_db, wait=True)
def recover_mirrors():
m2_xu, m2_xd, m2_yu, m2_ydo, m2_ydi = user_ns['m2_xu'], user_ns['m2_xd'], user_ns['m2_yu'], user_ns['m2_ydo'], user_ns['m2_ydi']
m3_xu, m3_xd, m3_yu, m3_ydo, m3_ydi = user_ns['m3_xu'], user_ns['m3_xd'], user_ns['m3_yu'], user_ns['m3_ydo'], user_ns['m3_ydi']
yield from abs_set(m2_yu.home_signal, 1)
yield from abs_set(m2_xu.home_signal, 1)
yield from abs_set(m3_yu.home_signal, 1)
yield from abs_set(m3_xu.home_signal, 1)
yield from sleep(1.0)
print('Begin homing lateral and vertical motors in M2 and M3:\n')
hvalues = (m2_yu.hocpl.get(), m2_ydo.hocpl.get(), m2_ydi.hocpl.get(), m2_xu.hocpl.get(), m2_xd.hocpl.get(),
m3_yu.hocpl.get(), m3_ydo.hocpl.get(), m3_ydi.hocpl.get(), m3_xu.hocpl.get(), m3_xd.hocpl.get())
while any(v == 0 for v in hvalues):
hvalues = (m2_yu.hocpl.get(), m2_ydo.hocpl.get(), m2_ydi.hocpl.get(), m2_xu.hocpl.get(), m2_xd.hocpl.get(),
m3_yu.hocpl.get(), m3_ydo.hocpl.get(), m3_ydi.hocpl.get(), m3_xu.hocpl.get(), m3_xd.hocpl.get())
strings = ['m2_yu', 'm2_ydo', 'm2_ydi', 'm2_xu', 'm2_xd', 'm3_yu', 'm3_ydo', 'm3_ydi', 'm3_xu', 'm3_xd',]
for i,v in enumerate(hvalues):
strings[i] = go_msg(strings[i]) if hvalues[i] == 1 else error_msg(strings[i])
print(' '.join(strings), end='\r')
yield from sleep(1.0)
print('\n')
yield from mv(m2_yu, MODEDATA['m2_yu']['E'],
m2_ydo, MODEDATA['m2_ydo']['E'],
m2_ydi, MODEDATA['m2_ydi']['E'],
m2_xu, MODEDATA['m2_xu']['E'],
m2_xd, MODEDATA['m2_xd']['E'],
m3_yu, MODEDATA['m3_yu']['E'],
m3_ydo, MODEDATA['m3_ydo']['E'],
m3_ydi, MODEDATA['m3_ydi']['E'],
m3_xu, MODEDATA['m3_xu']['E'],
m3_xd, MODEDATA['m3_xd']['E'])
def set_integration_plan(time=0.5):
'''
set integration times for electrometers and Struck from a plan
'''
yield from abs_set(user_ns['vor'].auto_count_time, time, wait=True)
yield from abs_set(user_ns['quadem1'].averaging_time, time, wait=True)
yield from abs_set(user_ns['dualio'].averaging_time, time, wait=True)
def _configure_area_det(exposure):
"""private function to configure pe1c with continuous acquisition mode"""
det = xpd_configuration["area_det"]
# cs studio configuration doesn't propagate to python level
yield from bps.abs_set(det.cam.acquire_time, glbl["frame_acq_time"])
acq_time = det.cam.acquire_time.get()
_check_mini_expo(exposure, acq_time)
if hasattr(det, "images_per_set"):
# compute number of frames
num_frame = np.ceil(exposure / acq_time)
yield from bps.abs_set(det.images_per_set, num_frame)
else:
# The dexela detector does not support `images_per_set` so we just
# use whatever the user asks for as the thing
# TODO: maybe put in warnings if the exposure is too long?
num_frame = 1
computed_exposure = num_frame * acq_time
# print exposure time
print(
"INFO: requested exposure time = {} - > computed exposure time"
"= {}".format(exposure, computed_exposure)
)
return num_frame, acq_time, computed_exposure
def clean_up():
# move the energy setpoint to where the energy really is
yield from bps.abs_set(pgm.energy, pgm.energy.position, wait=True)
# set the interpolator to look at what it was looking at before
# the scan. This should be the energy set point.
yield from bps.abs_set(epu1.flt.input_pv, old_link, wait=True)
yield from bps.abs_set(epu1.flt.output_deadband, old_db, wait=True)
def tune_plan(step=0):
'''
Tune 2nd crystal pitch from a plan. Argument is a value for the step, so a relative motion.
'''
yield from abs_set(dcm_pitch.kill_cmd, 1, wait=True)
yield from mvr(dcm_pitch, step)
yield from sleep(1.0)
yield from abs_set(dcm_pitch.kill_cmd, 1, wait=True)
def cleanup_plan():
yield from mv(user_ns['slits3'].vsize, slit_height)
yield from abs_set(user_ns['_locked_dwell_time'], 0.5, wait=True)
yield from sleep(1.0)
yield from abs_set(motor.kill_cmd, 1, wait=True)
yield from sleep(1.0)
yield from user_ns['dcm'].kill_plan()
yield from resting_state_plan()
def slit_scan_fiducialize(slits,
yag,
x_width=0.01,
y_width=0.01,
samples=10,
filters=None,
centroid='detector_stats2_centroid_y'):
"""
Assists beam alignment by setting the slits to a w,h and checking,
returning the centroid position.
Parameters
----------
slits : pcdsdevices.slits.Slits
Ophyd slits object from pcdsdevices.slits.Slits
yag : pcdsdevices.pim.PIM
Detector to fidicuialize. This plan assumes the detector is stated and
inserted
x_width : float
x dimensions of the gap in the slits. EGU: mm
y_width : float
y dimensions of the gap in the slits. EGU: mm
samples : int
Returned measurements are averages over multiple samples. samples arg
determines the number of samples to average over for returned data
filters : dict, optional
Key, callable pairs of event keys and single input functions that
evaluate to True or False. For more infromation see
:meth:`.apply_filters`
centroid : str, optional
Key to gather centroid information
Returns
-------
float
return centroid position in pixel space, single axis
"""
# Set slits and imager, wait together
group = str(uuid.uuid4())
yield from abs_set(yag, "IN", group=group)
yield from abs_set(slits, x_width, group=group)
yield from plan_wait(group=group)
#Collect data from yags
yag_measurements = yield from measure_average([yag],
num=samples,
filters=filters)
#Extract centroid positions from yag_measurments dict
centroid = yag_measurements[field_prepend(centroid, yag)]
return centroid
def fix_epu():
# move the energy setpoint to where the energy really is
yield from bps.abs_set(pgm.energy, pgm.energy.position, wait=True)
# set the interpolator to look at what it was looking at before
# the scan. This should be the energy set point.
yield from bps.abs_set(epu1.flt.input_pv,
'XF:23ID2-OP{Mono}Enrgy-SP CP MS',
wait=True)
yield from bps.abs_set(epu1.flt.output_deadband, 0, wait=True)
def tweak_bct(step):
dm3_bct = user_ns['dm3_bct']
if step is None:
step = 0
yield from abs_set(dm3_bct.kill_cmd,1, wait=True)
print('Moving from %.4f to %.4f' % (dm3_bct.user_readback.get(), dm3_bct.user_readback.get() + step))
yield from mvr(dm3_bct, step)
time.sleep(3.0)
yield from abs_set(dm3_bct.kill_cmd,1, wait=True)
def multi_edge(*, edge_list=None):
if edge_list is None:
edge_list = list(EDGE_MAP)
# edge_list = sorted(edge_list, key=lambda k: EDGE_MAP[k]['start'])
cy = cycler('edge', edge_list)
for inp in cy:
yield from XAS_edge_scan(**inp)
yield from bps.abs_set(valve_diag3_close, 1)
yield from bps.abs_set(valve_mir3_close, 1)
def multi_sample_edge(*, edge_list=None, sample_list=None):
if sample_list is None:
sample_list = list(SAMPLE_MAP)
if edge_list is None:
edge_list = list(EDGE_MAP)
# edge_list = sorted(edge_list, key=lambda k: EDGE_MAP[k]['start'])
cy = cycler('edge', edge_list) * cycler('sample_name', sample_list)
for inp in cy:
if pass_filter(**inp):
yield from edge_ascan(**inp)
yield from bps.abs_set(valve_diag3_close, 1)
yield from bps.abs_set(valve_mir3_close, 1)
def move_m3(target=5):
alpha = 9002 # distance M3 to Be window
beta = 9637 # distance M3 to xafs_yu
gamma = 10792 # distance M3 to xafs_ydo/xafs_ydi
#bnot = 46.11 # BCT position in mode D/E
#unot = 132 # xafs_yu position in mode D/E
#dnot = 132 # xafs_ydo/xafs_ydi position in mode D/E
bnot = 29.57 # BCT position in mode D/E
unot = 111.6 # xafs_yu position in mode D/E
dnot = 109.9 # xafs_ydo/xafs_ydi position in mode D/E
thetanot = 0 # angle in mR of M3 in mode A
#thetanot = 3.5 # angle in mR of M3 in mode D/E
theta = target - thetanot
#correction = 0.8 * tan(theta/1000) / tan(1.5/1000)
correction = 0.0 * tan(theta / 1000) / tan(1.5 / 1000)
bct = bnot - alpha * tan((2 * theta) / 1000) + correction - 0.6
upstr = unot - beta * tan((2 * theta) / 1000) + correction
dnstr = dnot - gamma * tan((2 * theta) / 1000) + correction
print(
'\nThe M3 target is %.2f mRad relative to the beam incident on M3\n' %
target)
print('Move M3 pitch to %.2f mRad' % (thetanot - theta))
print('\t BCT: %.2f' % bct)
print('\t xafs_yu: %.2f' % upstr)
print('\t xafs_yd: %.2f' % dnstr)
print('\t (correction): %.2f' % correction)
print('')
action = input("Begin moving motors> [Y/n then Enter] ")
if action.lower() == 'q' or action.lower() == 'n':
yield from null()
return
RE.msg_hook = None
BMM_log_info(
'Moving mirror 3: target = %.2f, M3 pitch = %.2f\nBCT -> %.2f, yu -> %.2f, yd -> %.2f, correction = %.2f'
% (target, thetanot - theta, bct, upstr, dnstr, correction))
yield from abs_set(dm3_bct.kill_cmd, 1, wait=True) # and after
yield from mv(m3.pitch, thetanot - theta, dm3_bct, bct, xafs_table.yu,
upstr, xafs_table.ydo, dnstr, xafs_table.ydi, dnstr)
yield from sleep(2.0)
yield from abs_set(dm3_bct.kill_cmd, 1, wait=True) # and after
RE.msg_hook = BMM_msg_hook
BMM_log_info(motor_status())
def count_dets(_dets, _full_md):
_count_plan = bp.count(_dets, md=_full_md)
_count_plan = bpp.subs_wrapper(_count_plan, LiveTable(_dets))
_count_plan = bpp.finalize_wrapper(
_count_plan,
bps.abs_set(xpd_configuration['shutter'],
XPD_SHUTTER_CONF['close'],
wait=True))
yield from bps.abs_set(xpd_configuration['shutter'],
XPD_SHUTTER_CONF['open'],
wait=True)
yield from _count_plan
def nano_y_scan_and_fly(*args, extra_dets=None, **kwargs):
kwargs.setdefault('xmotor', nano_stage.sy)
kwargs.setdefault('ymotor', nano_stage.sx)
kwargs.setdefault('flying_zebra', nano_flying_zebra)
yield from abs_set(nano_flying_zebra.fast_axis, 'NANOVER')
yield from abs_set(nano_flying_zebra.slow_axis, 'NANOHOR')
_xs = kwargs.pop('xs', xs)
if extra_dets is None:
extra_dets = []
dets = [_xs] + extra_dets
yield from scan_and_fly_base(dets, *args, **kwargs)
def inner():
# Prepare Camera
yield from bps.mv(cam.acquire, 0) # Stop camera...
yield from bps.sleep(.5) # ...and wait for the pipeline to empty.
yield from bps.mv(
cam.trigger_mode,
"Sync In 1", # External Trigger
cam.array_counter,
0,
)
if use_roi4:
yield from bps.mv(cam.min_x, roi.min_xyz.min_x.get(), cam.min_y,
roi.min_xyz.min_y.get(), cam.size.size_x,
roi.size.x.get(), cam.size.size_y,
roi.size.y.get())
# Prepare TIFF Plugin
yield from bps.mv(tiff.file_write_mode, "Stream", tiff.num_capture,
steps, tiff.auto_save, 1, tiff.auto_increment, 1,
tiff.file_path, folder, tiff.file_name, filename,
tiff.file_template, "%s%s_%d.tif", tiff.file_number,
1, tiff.enable, 1)
yield from bps.abs_set(tiff.capture, 1)
yield from bps.abs_set(cam.acquire, 1) # wait=False
# Move to the starting positions
yield from bps.mv(
gonio.py,
start_y - slack_y,
gonio.pz,
start_z - slack_z,
)
# Set velocity for the scan
yield from bps.mv(gonio.py.velocity, speed_y, gonio.pz.velocity,
speed_z)
# Arm Zebra
yield from bps.abs_set(zebra.pos_capt.arm.arm, 1)
# Wait Zebra armed
while not zebra2.download_status.get():
time.sleep(0.1)
# Go
yield from bps.mv(gonio.py, end_y + slack_y, gonio.pz, end_z + slack_z)
yield from bps.abs_set(tiff.capture, 0)
print(f"{cam.array_counter.get()} images captured")
def multi_sample_edge(*, edge_list=None, sample_list=None):
if sample_list is None:
sample_list = list(SAMPLE_MAP)
if edge_list is None:
edge_list = list(EDGE_MAP)
# edge_list = sorted(edge_list, key=lambda k: EDGE_MAP[k]['start'])
cy = cycler('edge', edge_list) * cycler('sample_name', sample_list)
for inp in cy:
if pass_filter(**inp):
yield from edge_ascan(**inp)
yield from bps.abs_set(valve_diag3_close, 1)
yield from bps.abs_set(valve_mir3_close, 1)
def move_m2(target=3.5):
alpha = 10907 # distance M2 to Be window
beta = 11542 # distance M2 to xafs_yu
gamma = 12697 # distance M2 to xafs_ydo/xafs_ydi
bnot = 50.2 # BCT position in mode A
unot = 136 - 0.83 # xafs_yu position in mode A
dnot = 136 - 0.92 # xafs_ydo/xafs_ydi position in mode D/E
#bnot = 35.14 # BCT position in mode A
#unot = 120.04 # xafs_yu position in mode A
#dnot = 117.96 # xafs_ydo/xafs_ydi position in mode D/E
thetanot = 3.5 # angle in mR of M2 in mode A
#thetanot = 4.428 # angle in mR of M2 in mode A
theta = target - thetanot
correction = 0 # 0.8 * tan(theta/1000) / tan(1.5/1000)
bct = bnot - alpha * tan((2 * theta) / 1000) + correction + 1.218
upstr = unot - beta * tan((2 * theta) / 1000) + correction
dnstr = dnot - gamma * tan((2 * theta) / 1000) + correction
print(
'\nThe M2 target is %.2f mRad relative to the beam incident on M2\n' %
target)
print('Move M2 pitch to %.2f mRad' % (thetanot - theta))
print('\t BCT: %.2f' % bct)
print('\t xafs_yu: %.2f' % upstr)
print('\t xafs_yd: %.2f' % dnstr)
print('\t (correction): %.2f' % correction)
print('')
action = input("Begin moving motors? [Y/n then Enter] ")
if action.lower() == 'q' or action.lower() == 'n':
yield from null()
return
RE.msg_hook = None
BMM_log_info(
'Moving mirror 2: target = %.2f, M2 pitch = %.2f\nBCT -> %.2f, yu -> %.2f, yd -> %.2f, correction = %.2f'
% (target, thetanot - theta, bct, upstr, dnstr, correction))
yield from abs_set(dm3_bct.kill_cmd, 1, wait=True)
yield from mv(m2.pitch, thetanot - theta, dm3_bct, bct, xafs_table.yu,
upstr, xafs_table.ydo, dnstr, xafs_table.ydi, dnstr)
yield from sleep(2.0)
yield from abs_set(dm3_bct.kill_cmd, 1, wait=True) # and after
RE.msg_hook = BMM_msg_hook
BMM_log_info(motor_status())
def move_to_start_fly():
"See http://nsls-ii.github.io/bluesky/plans.html#the-per-step-hook"
# row_str = short_uid('row')
# yield from abs_set(xmotor, row_start, group=row_str)
# yield from one_1d_step([temp_nanoKB], motor, step)
# yield from bps.wait(group=row_str)
row_str = short_uid('row')
yield from bps.checkpoint()
yield from bps.abs_set(xmotor, row_start, group=row_str)
yield from bps.abs_set(motor, step, group=row_str)
yield from bps.wait(group=row_str)
yield from bps.trigger_and_read([temp_nanoKB, motor])
def _shutter_step(detectors, motor, step):
""" customized step to ensure shutter is open before
reading at each motor point and close shutter after reading
"""
yield from bps.checkpoint()
yield from bps.abs_set(motor, step, wait=True)
yield from bps.abs_set(
xpd_configuration["shutter"], XPD_SHUTTER_CONF["open"], wait=True
)
yield from bps.sleep(glbl['shutter_sleep'])
yield from bps.trigger_and_read(list(detectors) + [motor])
yield from bps.abs_set(
xpd_configuration["shutter"], XPD_SHUTTER_CONF["close"], wait=True
)
def setup_dc(self, enable, period, off_time, verify=True):
enable = 1 if enable else 0
period = int(period)
off_time = int(off_time)
wait_group = 'anc_set_dc'
yield from bps.abs_set(self.dc_period, period,
group=wait_group)
yield from bps.abs_set(self.dc_off_time, off_time,
group=wait_group)
yield from bps.abs_set(self.dc_enable, enable,
group=wait_group)
if verify:
yield from bps.wait(group=wait_group)
def fast_shutter_wrapper(plan):
update_metadata()
if USE_FAST_SHUTTER:
plan = bpp.pchain(
bps.abs_set(fast_shutter.output,
FastShutter.OPEN_SHUTTER,
settle_time=FastShutter.SETTLE_TIME), plan)
plan = bpp.finalize_wrapper(
plan,
bps.abs_set(fast_shutter.output,
FastShutter.CLOSE_SHUTTER,
settle_time=FastShutter.SETTLE_TIME))
return (yield from plan)
def close_shutter_stub():
"""simple function to return a generator that yields messages to
close the shutter"""
yield from bps.abs_set(
xpd_configuration["shutter"], XPD_SHUTTER_CONF["close"], wait=True
)
yield from bps.checkpoint()
def go_plan():
ret = (yield from bps.abs_set(pgm.fly.fly_start, 1))
st = StatusBase()
enum_map = pgm.fly.scan_status.describe()[
pgm.fly.scan_status.name]['enum_strs']
def _done_cb(value, old_value, **kwargs):
print(f'Old value {old_value} -> new value {value}')
print(
f'Old value type {type(old_value)} -> new value {type(value)}')
try:
old_value = enum_map[int(old_value)]
except (TypeError, ValueError):
...
try:
value = enum_map[int(value)]
except (TypeError, ValueError):
...
if old_value != value and value == 'Ready':
st._finished()
pgm.fly.scan_status.clear_sub(_done_cb)
if ret is not None:
pgm.fly.scan_status.subscribe(_done_cb, run=False)
else:
st._finished()
print('SIM MODE')
return st
def change_epu_flt_link(new_target):
v = (yield from bps.read(epu1.flt.input_pv))
if v is None:
return
n = epu1.flt.input_pv.name
cur_pv = v[n]['value']
pts = cur_pv.split(' ', maxsplit=1)
new_pv = ' '.join([new_target] + pts[1:])
yield from bps.abs_set(epu1.flt.input_pv, new_pv)
def move():
yield from checkpoint()
grp = short_uid("set")
for motor, pos in step.items():
if pos == pos_cache[motor]:
# This step does not move this motor.
continue
yield from abs_set(motor, pos, group=grp)
pos_cache[motor] = pos
yield from wait(group=grp)
def _epu_ramp(dets, start, stop):
def go_plan():
return (yield from bps.abs_set(epu1.gap, stop, wait=False))
def inner_plan():
yield from trigger_and_read(dets)
yield from bps.abs_set(epu1.gap, start, wait=True)
return (yield from (ramp_plan(go_plan(), pgm.energy,
inner_plan, period=None, md=md)))
def _ct_dark_cleanup(oldnumim, gain_bit_dict, gain_state,
dark_sh_dict, dark_shutter_state):
print('\nReturning to intial conditions (pre-count).')
yield from bps.abs_set(fccd.cam.num_images, oldnumim, wait=True)
yield from bps.mv(fccd.cam.fcric_gain, gain_state)
yield from bps.mv(inout, dark_sh_dict.get(dark_shutter_state))
yield from bps.sleep(fccd.cam.acquire_period.value)
print('\tTotal images per trigger are NOW:\t {}'.format(
fccd.cam.num_images.setpoint))
print('\tFCCD FCRIC gain value is NOW:\t\t {}\n\n'.format(
gain_bit_dict.get(fccd.cam.fcric_gain.value)))
def open_all_valves(valve_list):
'''Open all the listed valves
Parameters
----------
valve_list : sequence
The valves to open
'''
for v in valve_list:
yield from bps.abs_set(v, 1, group='valve_set')
yield from bps.wait('valve_set')
# sleep might not be needed
yield from bps.sleep(2)
def go_plan():
ret = (yield from bps.abs_set(pgm.fly.fly_start, 1))
st = StatusBase()
enum_map = pgm.fly.scan_status.describe()[pgm.fly.scan_status.name]['enum_strs']
def _done_cb(value, old_value, **kwargs):
old_value = enum_map[int(old_value)]
value = enum_map[int(value)]
if old_value != value and value == 'Ready':
st._finished()
pgm.fly.scan_status.clear_sub(_done_cb)
if ret is not None:
pgm.fly.scan_status.subscribe(_done_cb, run=False)
else:
st._finished()
print('SIM MODE')
return st
def multi_part_ascan(DETS, motor1, steps, motor2, asc_p):
for d in steps:
yield from bps.abs_set(motor1, d, wait=True)
yield from bp.scan(DETS, motor2, *asc_p)
def edge_ascan(sample_name, edge, md=None):
'''Run a multi-edge nexafs scan for single sample and edge
Parameters
----------
sample_name : str
Base sample name
sample_position : float
Postion of sample on manipulator arm
edge : str
Key into EDGE_MAP
'''
if md is None:
md = {}
local_md = {'plan_name': 'edge_ascan'}
local_md['edge'] = edge
md = ChainMap(md, local_md)
e_scan_params = EDGE_MAP[edge]
# TODO configure the vortex
det_settings = DET_SETTINGS[edge]
sample_props = SAMPLE_MAP[sample_name]
# sample_props = list(sample_manager.find(name=sample_name))
local_md.update(sample_props)
# init_group = 'ME_INIT_' + str(uuid.uuid4())
yield from bps.abs_set(ioxas_x, sample_props['pos'], wait=True)
# yield from bps.mov(appes_x, sample_props['pos_x'])
# yield from bps.mov(appes_y, sample_props['pos_y'])
yield from bps.abs_set(feedback, 0, wait=True)
yield from bps.abs_set(pgm_energy, e_scan_params['start'], wait=True)
yield from bps.abs_set(epu1table, e_scan_params['epu_table'], wait=True)
yield from bps.abs_set(epu1offset, e_scan_params['epu1offset'], wait=True)
yield from bps.sleep(15)
yield from bps.abs_set(m1b1_fp, 100)
yield from bps.abs_set(feedback, 1, wait=True)
yield from bps.sleep(5)
yield from bps.abs_set(feedback, 0, wait=True)
yield from bps.abs_set(vortex_x, det_settings['vortex_pos'], wait=True)
yield from bps.abs_set(sample_sclr_gain, det_settings['samplegain'], wait=True)
yield from bps.abs_set(sample_sclr_decade, det_settings['sampledecade'], wait=True)
yield from bps.abs_set(aumesh_sclr_gain, det_settings['aumeshgain'], wait=True)
yield from bps.abs_set(aumesh_sclr_decade, det_settings['aumeshdecade'], wait=True)
yield from bps.abs_set(sclr_time, det_settings['sclr_time'], wait=True)
# yield from open_all_valves(all_valves)
# yield from bp.wait(init_group)
# TODO make this an ohypd obj!!!!!!
#caput('XF:23IDA-PPS:2{PSh}Cmd:Opn-Cmd',1)
# yield from bp.sleep(2)
# TODO make this an ohypd obj!!!!!!
# TODO ask stuart
#caput('XF:23IDA-OP:2{Mir:1A-Ax:FPit}Mtr_POS_SP',50)
yield from bps.sleep(5)
# yield from bps.configure(vortex, VORTEX_SETTINGS[edge])
# yield from bps.sleep(2)
yield from bps.abs_set(vortex.mca.rois.roi4.lo_chan, det_settings['vortex_low'], wait=True)
yield from bps.abs_set(vortex.mca.rois.roi4.hi_chan, det_settings['vortex_high'], wait=True)
yield from bps.abs_set(vortex.mca.preset_real_time, det_settings['vortex_time'], wait=True)
# lp_list = []
# for n in ['sclr_ch4', 'vortex_mca_rois_roi4_count']:
# fig = plt.figure(edge + ': ' + n)
# lp = bs.callbacks.LivePlot(n, 'pgm_energy_readback', fig=fig)
# lp_list.append(lp)
# class norm_plot(bs.callbacks.LivePlot):
# def event(self,doc):
# try:
# doc.data['norm_intensity'] = doc.data['sclr_ch4']/doc.data['sclr_ch3']
# except KeyError:
# pass
# super().event(doc)
# for n in ['sclr_ch4']:
# fig = plt.figure(edge + ': ' + n)
# lp = bs.callbacks.LivePlot(n, 'pgm_energy_readback', fig=fig)
# lp = norm_plot('norm_intensity', 'pgm_energy_readback', fig=fig)
# lp_list.append(lp)
dets = [sclr, vortex, norm_ch4, ring_curr]
for channel in ['mca.rois.roi2.count','mca.rois.roi3.count','mca.rois.roi4.count']:
getattr(vortex, channel).kind = 'hinted'
for channel in ['mca.rois.roi2.count','mca.rois.roi3.count']:
getattr(vortex, channel).kind = 'normal'
for channel in ['channels.chan3','channels.chan4']:
getattr(sclr, channel).kind = 'hinted'
for channel in ['channels.chan2']:
getattr(sclr, channel).kind = 'normal'
scan_kwargs = {'start': e_scan_params['stop'],
'stop': e_scan_params['start'],
'velocity': e_scan_params['velocity'],
'deadband': e_scan_params['deadband'],
'md': md}
ret = []
for j in range(e_scan_params['scan_count']):
tmp_pos = sample_props['pos'] + (j-((e_scan_params['scan_count']-1)/2))*e_scan_params['intervals']
# yield from bps.mov(appes_y, tmp_pos)
yield from bps.mov(ioxas_x, tmp_pos)
yield from bps.abs_set(pgm_energy, e_scan_params['stop'], wait=True)
yield from open_all_valves(all_valves)
res = yield from bpp.subs_wrapper(E_ramp(dets, **scan_kwargs), {'stop': save_csv})
yield from bps.abs_set(valve_diag3_close, 1, wait=True)
yield from bps.abs_set(valve_mir3_close, 1, wait=True)
yield from bps.sleep(5)
if res is None:
res = []
ret.extend(res)
if not ret:
return ret
# hdr = db[ret[0]]
# redo_count = how_many_more_times_to_take_data(hdr)
# for j in range(redo_count):
# res = yield from bpp.subs_wrapper(ascan(*scan_args, md=md), lp)
# ret.extend(res)
# new_count_time = compute_new_count_time(hdr, old_count_time)
# if new_count_time != old_count_time:
# yield from bps.configure(vortex, {'count_time': new_count_time})
# res = yield from bpp.subs_wrapper(ascan(*scan_args, md=md), lp)
# ret.extend(res)
return ret
def ct_dark(numim=None, detectors=None, gain_std=0):
"""Collect dark images for fccd and add metadata tag for dark and gain.
The pre-count shutter & gain states preserved.
Parameters
-----------
numim: int
Number of images to be measured. If different from current
setting, the number of images will revert back to the original
after the scan is complete.
detectors: list
List of detectors to be recorded.
Default = [fccd]
gain_std: int
List of detectors to be recorded.
Default = 0 (which is 'Auto' or x8, the most sensitive gain)
Returns
-------
"""
if detectors is None:
detectors = [fccd]
try:
# TODO figureout kwargs and self to mkae up to line 44 a
# single definition
oldnumim = fccd.cam.num_images.value
# Printing info
print(
'\nStarting procedure to acquire darks '
'{:3.3}Hz or {:3.3f}s.\n'.format(
1/fccd.cam.acquire_time.value, fccd.cam.acquire_time.value))
print('\tCurrent number of images = {}.\n'.format(
fccd.cam.num_images.value))
yield from bps.sleep(.3)
if numim is not None:
print('\tSetting to {} images.\n'.format(numim))
yield from bps.abs_set(fccd.cam.num_images, numim, wait=True)
dark_shutter_state = inout.status.value
dark_sh_dict = {'Inserted': 'In', 'Not Inserted': 'Out'}
gain_state = fccd.cam.fcric_gain.value
gain_bit_dict = {0: 'auto', 1: 'x2', 2: 'x1'}
yield from bps.mv(inout, 'In')
# This has to be 2 until we can selectively remove dark images
# get_fastccd_images()
yield from bps.sleep(fccd.cam.acquire_period.value*2.01)
# SET TO 1 TO ARM FOR NEXT EVENT so that the FastCCD1 is
# already bkg subt
yield from bps.mv(fccd.fccd1.capture_bgnd, 1)
# take darks
yield from _ct_dark(detectors, gain_std, gain_bit_dict)
# Putting things back
yield from _ct_dark_cleanup(oldnumim, gain_bit_dict,
gain_state, dark_sh_dict,
dark_shutter_state)
except Exception:
yield from _ct_dark_cleanup(oldnumim, gain_bit_dict, gain_state,
dark_sh_dict, dark_shutter_state)
raise
except KeyboardInterrupt:
yield from _ct_dark_cleanup(oldnumim, gain_bit_dict,
gain_state, dark_sh_dict,
dark_shutter_state)
raise
def go_plan():
return (yield from bps.abs_set(epu1.gap, stop, wait=False))
def _run_E_ramp(dets, start, stop, velocity, deadband, *, md=None):
if md is None:
md = {}
md = ChainMap(md, {'plan_args': {'dets': list(map(repr, dets)),
'start': start,
'stop': stop,
'velocity': velocity,
'deadband': deadband},
'plan_name': 'E_ramp',
'motors': [pgm.energy.name]})
# put the energy at the starting value
yield from bps.abs_set(pgm.energy, start, wait=True)
yield from bps.abs_set(pgm.fly.start_sig, start, wait=True)
yield from bps.abs_set(pgm.fly.stop_sig, stop, wait=True)
yield from bps.abs_set(pgm.fly.velocity, velocity, wait=True)
# TODO do this with stage
old_db = epu1.flt.output_deadband.get()
yield from bps.abs_set(epu1.flt.output_deadband, deadband)
# get the old vlaue
v = (yield from bps.read(epu1.flt.input_pv))
if v is None:
old_link = ''
else:
n = epu1.flt.input_pv.name
old_link = v[n]['value']
# define a clean up plan
def clean_up():
# move the energy setpoint to where the energy really is
yield from bps.abs_set(pgm.energy, pgm.energy.position, wait=True)
# set the interpolator to look at what it was looking at before
# the scan. This should be the energy set point.
yield from bps.abs_set(epu1.flt.input_pv, old_link, wait=True)
yield from bps.abs_set(epu1.flt.output_deadband, old_db, wait=True)
# change to track the readout energy
yield from change_epu_flt_link(pgm_energy.readback.pvname)
def go_plan():
ret = (yield from bps.abs_set(pgm.fly.fly_start, 1))
st = StatusBase()
enum_map = pgm.fly.scan_status.describe()[pgm.fly.scan_status.name]['enum_strs']
def _done_cb(value, old_value, **kwargs):
old_value = enum_map[int(old_value)]
value = enum_map[int(value)]
if old_value != value and value == 'Ready':
st._finished()
pgm.fly.scan_status.clear_sub(_done_cb)
if ret is not None:
pgm.fly.scan_status.subscribe(_done_cb, run=False)
else:
st._finished()
print('SIM MODE')
return st
def inner_plan():
yield from trigger_and_read(dets)
print(md)
rp = ramp_plan(go_plan(), pgm.energy,
inner_plan, period=None, md=md)
return (yield from bpp.finalize_wrapper(rp, clean_up()))
