def test_measure_average(RE, one_bounce_system):
logger.debug("test_measure_average")
#Load motor and yag
_, mot, det = one_bounce_system
#Fake event storage
centroids = []
readbacks = []
col_c = collector(det.name + '_detector_stats2_centroid_x', centroids)
col_r = collector(mot.name + '_pitch', readbacks)
#Run plan
RE(run_wrapper(measure_average([det, mot], delay=0.1, num=5)),
subs={'event':[col_c, col_r]})
#Check events
assert centroids == [250.,250.,250.,250.,250.]
assert readbacks == [0.,0.,0.,0.,0.]
#Clear from last test
centroids.clear()
readbacks.clear()
#Run with array of delays
RE(run_wrapper(measure_average([det, mot], delay=[0.1], num=2)),
subs={'event':[col_c, col_r]})
#Check events
assert centroids == [250., 250.]
assert readbacks == [0., 0.]
#Invalid delay settings
with pytest.raises(ValueError):
RE(run_wrapper(measure_average([det, mot], delay=[0.1], num=3)))
def test_fiducialize(RE, fiducialized_yag):
fake_slits, fake_yag = fiducialized_yag
#collector callbacks aggregate data from 'yield from' returns in lists
center = []
measuredcenter = collector("centroid", center)
#Run plan with sufficiently large max_width
RE(run_wrapper(
fiducialize(fake_slits,
fake_yag,
start=0.1,
step_size=1.0,
centroid='centroid',
samples=1)),
subs={'event': [measuredcenter]})
#First shot is blocked second is not
assert center == [0.0, 0.3]
#Run plan with insufficiently large max_width
with pytest.raises(BeamNotFoundError):
RE(
run_wrapper(
fiducialize(fake_slits,
fake_yag,
start=0.1,
step_size=1.0,
max_width=0.25,
centroid='centroid',
samples=1)), )
def test_slit_scan_area_compare(RE):
fake_slits = Mover(
"slits",
OrderedDict([
('xwidth', (lambda x, y: x)),
('ywidth', (lambda x, y: y)),
]), {
'x': 0,
'y': 0
})
fake_yag = Reader(
'fake_yag', {
'xwidth': (lambda: fake_slits.read()['xwidth']['value']),
'ywidth': (lambda: fake_slits.read()['ywidth']['value']),
})
# collector callbacks aggregate data from 'yield from' in the given lists
xwidths = []
ywidths = []
measuredxwidths = collector("xwidth", xwidths)
measuredywidths = collector("ywidth", ywidths)
#test two basic positions
RE(run_wrapper(slit_scan_area_comp(fake_slits, fake_yag, 1.0, 1.0, 2)),
subs={'event': [measuredxwidths, measuredywidths]})
RE(run_wrapper(slit_scan_area_comp(fake_slits, fake_yag, 1.1, 1.5, 2)),
subs={'event': [measuredxwidths, measuredywidths]})
# excpect error if both measurements <= 0
with pytest.raises(ValueError):
RE(run_wrapper(slit_scan_area_comp(fake_slits, fake_yag, 0.0, 0.0, 2)),
subs={'event': [measuredxwidths, measuredywidths]})
# expect error if one measurement <= 0
with pytest.raises(ValueError):
RE(run_wrapper(slit_scan_area_comp(fake_slits, fake_yag, 1.1, 0.0, 2)),
subs={'event': [measuredxwidths, measuredywidths]})
logger.debug(xwidths)
logger.debug(ywidths)
assert xwidths == [
1.0,
1.0,
1.1,
1.1,
0.0,
0.0,
1.1,
1.1,
]
assert ywidths == [
1.0,
1.0,
1.5,
1.5,
0.0,
0.0,
0.0,
0.0,
]
def test_slit_scan_fiducialize(RE, fiducialized_yag):
fake_slits, fake_yag = fiducialized_yag
#collector callbacks aggregate data from 'yield from' returns in lists
center = []
measuredcenter = collector("centroid", center)
#Run plan with wide slits
RE(run_wrapper(
slit_scan_fiducialize(fake_slits,
fake_yag,
x_width=1.0,
y_width=1.0,
centroid='centroid',
samples=1)),
subs={'event': [measuredcenter]})
assert center == [0.3]
#collector callbacks aggregate data from 'yield from' returns in lists
center = []
measuredcenter = collector("centroid", center)
#Run plan with narrow slits
RE(run_wrapper(
slit_scan_fiducialize(fake_slits,
fake_yag,
centroid='centroid',
samples=1)),
subs={'event': [measuredcenter]})
assert center == [0.0]
def test_match_condition_success_no_stop(RE, mot_and_sig):
logger.debug("test_match_condition_success_no_stop")
mot, sig = mot_and_sig
mot.delay = 0
# Delay has no purpose if we aren't going to stop
def condition(x):
if 5 < x < 7:
return True
elif 10 < x < 16:
return True
return False
RE(run_wrapper(match_condition(sig, condition, mot, 20, has_stop=False)))
assert 12 < mot.position < 14
# Motor should end in the middle of the largest True region
mot.move(0, wait=True)
def condition(x):
return 10 < x < 16
RE(run_wrapper(match_condition(sig, condition, mot, 20, has_stop=False)))
assert 12 < mot.position < 14
mot.move(0, wait=True)
def condition(x):
return x > 10
RE(run_wrapper(match_condition(sig, condition, mot, 20, has_stop=False)))
assert 14 < mot.position < 16
def test_iterwalk_raises_RuntimeError_on_motion_timeout(
RE, lcls_two_bounce_system):
logger.debug("test_iterwalk_raises_RuntimeError_on_motion_timeout")
s, m1, m2, y1, y2 = lcls_two_bounce_system
# Center pixels of yag
center_pix = [y1.size[0] / 2] * 2
goal = [p + 300 for p in center_pix]
# Define a bad set command
def bad_set(yag, cmd=None, **kwargs):
logger.info("{0}Setting Attributes. (BAD)".format(yag.log_pref))
logger.debug("{0}Setting: CMD:{1}, {2} (BAD)".format(
yag.log_pref, cmd, kwargs))
return Status(done=True, success=False)
# Patch yag set command
y1.set = lambda cmd, **kwargs: bad_set(y1, cmd, **kwargs)
plan = run_wrapper(
iterwalk([y1, y2], [m1, m2],
goal,
starts=None,
first_steps=1,
gradients=None,
detector_fields='detector_stats2_centroid_x',
motor_fields='pitch',
tolerances=TOL,
system=None,
averages=1,
overshoot=0,
max_walks=5,
timeout=None))
# Check a RunTimError is raised
with pytest.raises(RuntimeError):
RE(plan)
# Reload system
s, m1, m2, y1, y2 = lcls_two_bounce_system
# Patch yag set command
y2.set = lambda cmd, **kwargs: bad_set(y2, cmd, **kwargs)
plan = run_wrapper(
iterwalk([y1, y2], [m1, m2],
goal,
starts=None,
first_steps=1e-6,
gradients=None,
detector_fields='detector_stats2_centroid_x',
motor_fields='pitch',
tolerances=TOL,
system=None,
averages=1,
overshoot=0,
max_walks=5,
timeout=None))
# Check a RunTimError is raised
with pytest.raises(RuntimeError):
RE(plan)
def test_walk_to_pixel(RE, one_bounce_system):
logger.debug("test_walk_to_pixel")
_, mot, det = one_bounce_system
##########################
# Test on simple devices #
##########################
simple_motor = Mover('motor', {'motor' : lambda x : x}, {'x' :0})
simple_det = Reader('det',
{'det' : lambda : 5*simple_motor.read()['motor']['value'] + 2})
#Naive step
plan = run_wrapper(walk_to_pixel(simple_det, simple_motor, 200, 0, first_step=1e-6,
tolerance=10, average=None,
target_fields=['det', 'motor'],
max_steps=3))
RE(plan)
assert np.isclose(simple_det.read()['det']['value'], 200, atol=1)
simple_motor.set(0.)
#Gradient
simple_motor = Mover('motor', {'motor' : lambda x : x}, {'x' :0})
simple_det = Reader('det',
{'det' : lambda : 5*simple_motor.read()['motor']['value'] + 2})
plan = run_wrapper(walk_to_pixel(simple_det, simple_motor, 200, 0,
gradient=1.6842e+06,
tolerance=10, average=None,
target_fields=['det', 'motor'],
max_steps=3))
RE(plan)
assert np.isclose(simple_det.read()['det']['value'], 200, atol=1)
##########################
# Test on full model #
##########################
#Naive step
plan = run_wrapper(walk_to_pixel(det, mot, 200, 0, first_step=1e-6,
tolerance=10, average=None,
target_fields=['detector_stats2_centroid_x',
'pitch'], max_steps=3))
RE(plan)
assert np.isclose(det.read()[det.name +
'_detector_stats2_centroid_x']['value'], 200,
atol=1)
mot.set(0.)
#Gradient
plan = run_wrapper(walk_to_pixel(det, mot, 200, 0, gradient=1.6842e+06,
tolerance=10, average=None,
target_fields=['detector_stats2_centroid_x',
'pitch'], max_steps=3))
RE(plan)
assert np.isclose(det.read()[det.name +
'_detector_stats2_centroid_x']['value'], 200,
atol=10)
def test_process_det_data_returns_correct_detector_dict(sim_det_01, RE):
resize = 1.0
kernel = (9, 9)
uint_mode = "clip"
thresh_mode = "otsu"
thresh_factor = 3
det_01 = sim_det_01
# Fake event storage
array_data = []
array_count = []
col_images = collector(det_01.image.array_data.name, array_data)
col_count = collector(det_01.image.array_counter.name, array_count)
# A test plan that reads the data 10 times and process the data
def test_plan(det):
read_data = yield from measure([det], num=10)
array_signal = det.image.array_data
size_signal = det.image.array_size
proc_dict = process_det_data(read_data,
array_signal,
size_signal,
kernel=kernel,
resize=resize,
uint_mode=uint_mode,
thresh_mode=thresh_mode)
assert (len(proc_dict) == 20)
# Run the plan
RE(run_wrapper(test_plan(det_01)), subs={'event': [col_count, col_images]})
def test_characterize_returns_correct_detector_dict(sim_det_01, RE):
resize = 1.0
kernel = (9, 9)
uint_mode = "scale"
thresh_mode = "otsu"
thresh_factor = 3
min_area = 100
det_01 = sim_det_01
array_str = "image.array_data"
size_str = "image.array_size"
# Fake event storage
array_data = []
array_count = []
col_images = collector(det_01.image.array_data.name, array_data)
col_count = collector(det_01.image.array_counter.name, array_count)
# A test plan that reads the data 10 times and process the data
def test_plan(det, sig, size):
proc_dict = yield from characterize(det,
array_str,
size_str,
num=10,
kernel=kernel,
resize=resize,
uint_mode=uint_mode,
min_area=min_area,
thresh_factor=thresh_factor)
assert (len(proc_dict) == 20)
# Run the plan
RE(run_wrapper(test_plan(det_01, "image.array_data", "image.array_size")),
subs={'event': [col_count, col_images]})
def test_homs_fiducialize(RE, fiducialized_yag_set):
#set of independant (slit,yag) tuples
fset = fiducialized_yag_set
slit_set, yag_set = list(zip(*fset))
yag_set = [
PIM("TEST"),
PIM("TEST"),
PIM("TEST"),
]
center = []
measuredcenter = collector("TST:TEST_detector_stats2_centroid_y", center)
state = []
measuredstate = collector("TST:TEST_states", state)
RE(run_wrapper(
homs_fiducialize(slit_set,
yag_set,
x_width=.6,
y_width=.6,
samples=2,
centroid='detector_stats2_centroid_y')),
subs={'event': [measuredcenter, measuredstate]})
#print(fset[0][0].read()['xwidth']['value'])
#print(fset[1][0].read()['xwidth']['value'])
#print(center)
#print(state)
for x in yag_set:
assert x.read()['TST:TEST_states']['value'] == 'OUT', "yag not removed"
for index, _ in enumerate(center):
assert center[index] == 0.0, 'measurment incorrect'
def test_beam_statistics(RE, resize, kernel, uint_mode, thresh_mode, min_area,
thresh_factor, filter_kernel, image_num, cent_num,
image_delay, ad_data, image_data,
lcls_two_bounce_system):
_, _, _, y1, y2 = lcls_two_bounce_system
array_str = "image1.array_data"
size_str = "image1.array_size"
def test_plan():
stats = yield from beam_statistics([y1, y2],
array_field=array_str,
size_field=size_str,
cent_num=cent_num,
image_num=image_num,
kernel=kernel,
resize=resize,
uint_mode=uint_mode,
thresh_factor=thresh_factor,
filter_kernel=filter_kernel,
thresh_mode=thresh_mode,
md="all",
image_delay=image_delay,
ad_data=ad_data,
image_data=image_data)
for _, det in stats.items():
for key, val in det.items():
if key == "md":
continue
assert (not np.isnan(val) or not np.isinf(val) or not None)
RE(run_wrapper(test_plan()))
def test_beam_statistics_raises_runtimeerror_on_timeout(
RE, resize, kernel, uint_mode, thresh_mode, min_area, thresh_factor,
filter_kernel, num, delay, ad_data, image_data,
lcls_two_bounce_system):
_, _, _, y1, y2 = lcls_two_bounce_system
array_str = "image1.array_data"
size_str = "image1.array_size"
def test_plan():
stats = yield from beam_statistics([y1, y2],
array_field=array_str,
size_field=size_str,
num=num,
kernel=kernel,
resize=resize,
uint_mode=uint_mode,
thresh_factor=thresh_factor,
filter_kernel=filter_kernel,
thresh_mode=thresh_mode,
md="all",
image_delay=delay,
ad_data=ad_data,
image_data=image_data,
timeout=-1)
with pytest.raises(RuntimeError):
RE(run_wrapper(test_plan()))
def test_beam_statistics_raises_runtimeerror_on_stuck_motor(
RE, resize, kernel, uint_mode, thresh_mode, min_area, thresh_factor,
filter_kernel, num, delay, ad_data, image_data,
lcls_two_bounce_system):
_, _, _, y1, y2 = lcls_two_bounce_system
array_str = "image1.array_data"
size_str = "image1.array_size"
# Set the motor set_and_wait timeout to be 1s
y1.timeout = 1
# Make the motor 'stuck' by it always reading back 'OUT'
y1.states._get_readback = lambda: "OUT"
def test_plan():
stats = yield from beam_statistics([y1, y2],
array_field=array_str,
size_field=size_str,
num=num,
kernel=kernel,
resize=resize,
uint_mode=uint_mode,
thresh_factor=thresh_factor,
filter_kernel=filter_kernel,
thresh_mode=thresh_mode,
md="all",
image_delay=delay,
ad_data=ad_data,
image_data=image_data,
pim_timeout=1)
with pytest.raises(RuntimeError):
RE(run_wrapper(test_plan()))
def test_match_condition_fail_no_stop(RE, mot_and_sig):
logger.debug("test_match_condition_fail_no_stop")
mot, sig = mot_and_sig
mot.delay = 0
RE(
run_wrapper(
match_condition(sig, lambda x: x > 50, mot, 40, has_stop=False)))
assert mot.position == 40
def test_iterwalk(RE, lcls_two_bounce_system, goal1, goal2, first_steps,
gradients, tolerances, overshoot, max_walks):
logger.debug(
"test_iterwalk with goal1=%s, goal2=%s, first_steps=%s, " +
"gradients=%s, tolerances=%s, overshoot=%.2f, max_walks=%s", goal1,
goal2, first_steps, gradients, tolerances, overshoot, max_walks)
s, m1, m2, y1, y2 = lcls_two_bounce_system
goal1 += y1.size[0] / 2
goal2 += y2.size[0] / 2
goal = [goal1, goal2]
plan = run_wrapper(
iterwalk([y1, y2], [m1, m2],
goal,
starts=None,
first_steps=first_steps,
gradients=gradients,
detector_fields='detector_stats2_centroid_x',
motor_fields='pitch',
tolerances=tolerances,
system=[m1, m2, y1, y2],
averages=1,
overshoot=overshoot,
max_walks=max_walks,
timeout=None))
RE(plan)
assert np.isclose(y1.read()[y1.name +
'_detector_stats2_centroid_x']['value'],
goal[0],
atol=tolerances)
assert np.isclose(y2.read()[y2.name +
'_detector_stats2_centroid_x']['value'],
goal[1],
atol=tolerances)
# Make sure we actually read all the groups as we went
m1_reads = 0
m2_reads = 0
y1_reads = 0
y2_reads = 0
saves = 0
for msg in RE.msg_hook.msgs:
if msg.command == 'read':
if msg.obj == m1:
m1_reads += 1
if msg.obj == m2:
m2_reads += 1
if msg.obj == y1:
y1_reads += 1
if msg.obj == y2:
y2_reads += 1
if msg.command == 'save':
saves += 1
assert saves > 0
assert all(
map(lambda x: x == saves, [m1_reads, m2_reads, y1_reads, y2_reads]))
def test_recover_threshold_timeout_failure(RE, mot_and_sig):
logger.debug("test_recover_threshold_timeout_failure")
mot, sig = mot_and_sig
# Make the motor slower to guarantee a timeout
mot.n_steps = 5000
RE(run_wrapper(recover_threshold(sig, 50, mot, +1, timeout=0.1)))
pos = mot.position
assert not 49 < pos < 51
assert mot.position not in (100, -100)
def test_measure(RE):
#Simplest implementation
plan = run_wrapper(measure([det,motor], num=5, delay=0.01))
#Fake callback storage
shots = list()
cb = collector('det', shots)
#Run simple
RE(plan, subs={'event' : cb})
assert shots == [1.0, 1.0, 1.0, 1.0, 1.0]
#Create counting detector
index = 0
def count():
nonlocal index
index += 1
return index
counter = Reader('det', {'intensity' : count})
#Filtered implementation
plan = run_wrapper(measure([counter],
filters = {'intensity' : lambda x : x > 2},
#num=5, delay=[0.01, 0.02, 0.03, 0.04]))
num=5))
#Fake callback storage
shots = list()
cb = collector('intensity', shots)
#Run filtered
RE(plan, subs={'event' : cb})
assert shots == [1, 3, 4, 5, 6, 7] #2 is skipped, because read is called
#by `describe`, which is called by RE
#after first read
# Make sure an exception is raised when we fail too many filter checks
counter = Reader('det', {'intensity' : count})
plan = run_wrapper(measure([counter],
filters = {'intensity' : lambda x : False},
num=500))
with pytest.raises(FilterCountError):
RE(plan)
def test_verify_all_answers(RE, fake_yags):
yags, ans = fake_yags
ok_queue = Queue()
# Check that all correct returns True, near correct returns True, and
# completely wrong returns False.
RE(
run_wrapper(
verify_and_stash(ok_queue, yags, 'detector_stats2_centroid_x', ans,
1)))
RE(
run_wrapper(
verify_and_stash(ok_queue, yags, 'detector_stats2_centroid_x',
[a + 5 for a in ans], 6)))
RE(
run_wrapper(
verify_and_stash(ok_queue, yags, 'detector_stats2_centroid_x',
[a + 5 for a in ans], 1)))
assert ok_queue.get() is True, "Exactly correct rejected!"
assert ok_queue.get() is True, "Within tolerance rejected!"
assert ok_queue.get() is False, "Outside of tolerance accepted!"
def test_iterwalk_raises_RuntimeError_on_failed_walk_to_pixel(
RE, lcls_two_bounce_system):
logger.debug("test_iterwalk_raises_RuntimeError_on_failed_walk_to_pixel")
s, m1, m2, y1, y2 = lcls_two_bounce_system
# Center pixels of yag
center_pix = [y1.size[0] / 2] * 2
goal = [p + 300 for p in center_pix]
# Define a bad set command
def bad_set(mirror, cmd=None, **kwargs):
logger.info("{0}Setting Attributes. (BAD)".format(mirror.log_pref))
logger.debug("{0}Setting: CMD:{1}, {2} (BAD)".format(
mirror.log_pref, cmd, kwargs))
err = 0.1
if cmd in ("IN", "OUT"):
pass # If these were removable we'd implement it here
elif cmd is not None:
# Here is where we move the pitch motor if a value is set
cmd += err
mirror.sim_pitch = cmd
return mirror.pitch.set(cmd)
mirror.sim_x = kwargs.get('x', mirror.sim_x)
mirror.sim_z = kwargs.get('z', mirror.sim_z)
mirror.sim_pitch = kwargs.get('pitch', mirror.sim_pitch)
for motor in mirror.motors:
motor_params = motor.read()
for key in kwargs.keys():
if key in motor_params:
# Add error term to sets
motor.set(kwargs[key] + err)
return Status(done=True, success=True)
# Patch yag set command
m1.set = lambda cmd, **kwargs: bad_set(m1, cmd, **kwargs)
plan = run_wrapper(
iterwalk([y1, y2], [m1, m2],
goal,
starts=None,
first_steps=1e-6,
gradients=None,
detector_fields='sim_x',
motor_fields='pitch',
tolerances=TOL,
system=None,
averages=1,
overshoot=0,
max_walks=5,
timeout=None))
# Check a RunTimError is raised
with pytest.raises(RuntimeError):
RE(plan)
def test_measure_centroid(RE, one_bounce_system):
logger.debug("test_measure_centroid")
#Load motor and yag
_, mot, det = one_bounce_system
#Fake event storage
centroids = []
col_c = collector(det.name + '_detector_stats2_centroid_x', centroids)
#Run plan
# assert 0
RE(run_wrapper(measure_centroid(det, average=5,
target_field='detector_stats2_centroid_x')),
subs={'event':[col_c]})
#Check events
assert centroids == [250.,250.,250.,250.,250.]
def test_nonrewindable_detector(fresh_RE, motor_det, start_state, msg_seq):
class FakeSig:
def get(self):
return False
motor, det = motor_det
det.rewindable = FakeSig()
RE = fresh_RE
RE.rewindable = start_state
m_col = MsgCollector()
RE.msg_hook = m_col
RE(bp.run_wrapper(bp.trigger_and_read([motor, det])))
assert [m.command for m in m_col.msgs] == msg_seq
def test_nonrewindable_detector(fresh_RE, motor_det, start_state, msg_seq):
class FakeSig:
def get(self):
return False
motor, det = motor_det
det.rewindable = FakeSig()
RE = fresh_RE
RE.rewindable = start_state
m_col = MsgCollector()
RE.msg_hook = m_col
RE(bp.run_wrapper(bp.trigger_and_read([motor, det])))
assert [m.command for m in m_col.msgs] == msg_seq
def test_verify_all_readers(RE, fake_yags):
yags, ans = fake_yags
ok = False
RE(
run_wrapper(
verify_all(yags[1:],
'detector_stats2_centroid_x',
ans,
5,
other_readers=yags[0],
other_fields='detector_stats2_centroid_y')))
for msg in RE.msg_hook.msgs:
if msg.command == 'read' and yags[0] is msg.obj:
ok = True
break
assert ok, ("We didn't find our extra reader in the collected messages")
def test_intreupted_with_callbacks(fresh_RE, int_meth, stop_num, msg_num):
RE = fresh_RE
docs = defaultdict(list)
def collector_cb(name, doc):
nonlocal docs
docs[name].append(doc)
RE.msg_hook = MsgCollector()
RE(subs_wrapper(run_wrapper(pause()), {'all': collector_cb}))
getattr(RE, int_meth)()
assert len(docs['start']) == 1
assert len(docs['event']) == 0
assert len(docs['descriptor']) == 0
assert len(docs['stop']) == stop_num
assert len(RE.msg_hook.msgs) == msg_num
def test_verify_all_array(RE, fake_yags):
yags, ans = fake_yags
ok_queue = Queue()
# Last let's make sure we can get a list of bools that correspond correctly
# to the yag that was wrong
ans[0] = ans[0] + 25
RE(
run_wrapper(
verify_and_stash(ok_queue,
yags,
'detector_stats2_centroid_x',
ans,
5,
summary=False)))
ok_list = ok_queue.get()
assert not ok_list[0], "Wrong element bool i=0"
for i in range(1, len(ans)):
assert ok_list[i], "Wrong element bool i={}".format(i)
def test_fitwalk(RE):
#Create simulated devices
motor = Mover('motor', {'motor' : lambda x : x}, {'x' :0})
det = Reader('det',
{'centroid' : lambda : 5*motor.read()['motor']['value'] + 2})
#Assemble linear fitting callback
linear = LinearFit('centroid', 'motor', average=1)
#Assemble parabolic fitting callback
parabola = ParabolicFit('centroid', 'motor', average=1)
#Create plan
walk = fitwalk([det], motor, [parabola, linear], 89.4,
average=1, tolerance = 0.5)
#Call with RunEngine
RE(run_wrapper(walk))
#Check we hit our target
assert np.isclose(det.read()['centroid']['value'], 89.4, 0.5)
def test_sim_det_interfaces_with_bluesky_correctly(sim_det_01, sim_det_02, RE):
global_data = None
det_01 = sim_det_01
det_02 = sim_det_02
im_filter = lambda image: contour_area_filter(image, uint_mode="clip")
# Fake event storage
array_data = []
array_count = []
col_images = collector(det_01.image.array_data.name, array_data)
col_count = collector(det_01.image.array_counter.name, array_count)
# A test plan that just reads the data 10 times
def test_plan(det):
read_data = yield from measure([det], num=10)
# Include the counter in the read
det_01.image.read_attrs = ["array_data", "array_counter"]
# Run the plan
RE(run_wrapper(test_plan(det_01)), subs={'event': [col_count, col_images]})
# Check the each image against the count
im_filter = lambda image: contour_area_filter(image, uint_mode="clip")
for count, array in zip(array_count, array_data):
try:
array_size = [int(val) for val in det_01.image.array_size.get()]
if array_size == [0, 0, 0]:
raise RuntimeError('Invalid image')
if array_size[-1] == 0:
array_size = array_size[:-1]
image = np.array(array).reshape(array_size)
idx = count - 1
cent, bbox = detect(image, uint_mode="clip", filters=im_filter)
assert (idx % 4 != 3 or idx == 0)
except NoBeamDetected:
assert (idx % 4 == 3)
def test_measure_average_system(RE, lcls_two_bounce_system):
logger.debug("test_measure_average_system")
_, m1, m2, y1, y2 = lcls_two_bounce_system
centroids = []
readbacks = []
col_c = collector(y1.name + '_detector_stats2_centroid_x', centroids)
col_r = collector(m1.name + '_pitch', readbacks)
RE(run_wrapper(measure_average([y1, m1, y2, m2],
delay=0.1, num=5)),
subs={'event':[col_c, col_r]})
assert centroids == [y1.detector._get_readback_centroid_x()] * 5
assert readbacks == [m1.position] * 5
# RE.msg_hook is a message collector
m1_reads = 0
m2_reads = 0
y1_reads = 0
y2_reads = 0
saves = 0
for msg in RE.msg_hook.msgs:
if msg.command == 'read':
if msg.obj == m1:
m1_reads += 1
if msg.obj == m2:
m2_reads += 1
if msg.obj == y1:
y1_reads += 1
if msg.obj == y2:
y2_reads += 1
if msg.command == 'save':
saves += 1
assert saves > 0
assert all(map(lambda x: x == saves,
[m1_reads, m2_reads, y1_reads, y2_reads]))
def test_match_condition_success(RE, mot_and_sig):
logger.debug("test_match_condition_success")
mot, sig = mot_and_sig
RE(run_wrapper(match_condition(sig, lambda x: x > 10, mot, 20)))
assert mot.position < 11
def test_match_condition_fail(RE, mot_and_sig):
logger.debug("test_match_condition_fail")
mot, sig = mot_and_sig
RE(run_wrapper(match_condition(sig, lambda x: x > 50, mot, 40)))
assert mot.position == 40
def test_match_condition_timeout(RE, mot_and_sig):
logger.debug("test_match_condition_timeout")
mot, sig = mot_and_sig
RE(run_wrapper(match_condition(sig, lambda x: x > 9, mot, 5, timeout=0.3)))
assert mot.position < 5
