def test_validate_raises_ValueError_for_detector_with_invalid_frames_per_step(
self):
nCycles = 1
generator = CompoundGenerator([StaticPointGenerator(nCycles)], [], [],
duration=0.0)
imaging_exposure_time = 0.1
diffraction_exposure_time = 0.3
bad_imaging_frames_per_step = DetectorTable(
[True, True, True],
["imagingDetector", "diffDetector", "PandA"],
["ML-IMAGING-01", "ML-DIFF-01", "ML-PANDA-01"],
[imaging_exposure_time, diffraction_exposure_time, 0.0],
[3, 1, 2],
)
bad_diffraction_frames_per_step = DetectorTable(
[True, True, True],
["imagingDetector", "diffDetector", "PandA"],
["ML-IMAGING-01", "ML-DIFF-01", "ML-PANDA-01"],
[imaging_exposure_time, diffraction_exposure_time, 0.0],
[1, 10, 2],
)
self.assertRaises(ValueError, self.o.on_validate, generator, {},
bad_imaging_frames_per_step)
self.assertRaises(
ValueError,
self.o.on_validate,
generator,
{},
bad_diffraction_frames_per_step,
)
def test_only_one_det(self):
# Disable one detector
self.b.configure(
self.make_generator(),
self.tmpdir,
detectors=DetectorTable.from_rows(
[(False, "SLOW", "slow", 0.0, 0), [True, "FAST", "fast", 0.0, 1]]
),
)
assert self.b.state.value == "Armed"
assert self.bs.state.value == "Ready"
assert self.bf.state.value == "Armed"
self.b.completedSteps.put_value(2)
assert self.b.state.value == "Armed"
assert self.bs.state.value == "Ready"
assert self.bf.state.value == "Armed"
self.b.run()
assert self.b.state.value == "Finished"
assert self.bs.state.value == "Ready"
assert self.bf.state.value == "Finished"
self.b.reset()
assert self.b.state.value == "Ready"
assert self.bs.state.value == "Ready"
assert self.bf.state.value == "Ready"
self.b.abort()
assert self.b.state.value == "Aborted"
assert self.bs.state.value == "Aborted"
assert self.bf.state.value == "Aborted"
def test_validate(self):
compound = self.make_generator()
detectors = DetectorTable.from_rows([[True, "DET", "DETECTOR", 0.0,
1]])
ret = self.b.validate(compound, self.tmpdir, detectors=detectors)
assert list(ret["detectors"].rows()) == [[
True, "DET", "DETECTOR", 0.098995, 1
]]
def get_detector_table(detector_mri, frames_per_step, enabled=True):
return DetectorTable(
[enabled, True],
["detector", "panda"],
[detector_mri, "ML-PANDA-01"],
[1.0, 0.0],
[frames_per_step, 1],
)
def test_system_defined_exposure(self):
xs = LineGenerator("x", "mm", 0.0, 0.3, 4)
ys = LineGenerator("y", "mm", 0.0, 0.1, 2)
generator = CompoundGenerator([ys, xs], [], [], 1.0)
generator.prepare()
detectors = DetectorTable.from_rows([[True, "det", "DET", 0.1, 5]])
b = self.scan.block_view()
b.configure(generator, self.tmpdir, detectors=detectors)
self.check_pulse_mocks(0.1, 0.2, 0.05, 5)
def test_breakpoints_with_pause(self):
breakpoints = [2, 3, 10, 2]
self.b.configure(
generator=self.make_generator_breakpoints(),
fileDir=self.tmpdir,
detectors=DetectorTable.from_rows(
[[False, "SLOW", "slow", 0.0, 1], [True, "FAST", "fast", 0.0, 1]]
),
axesToMove=["x"],
breakpoints=breakpoints,
)
assert self.ct.configure_params.generator.size == 17
self.checkSteps(self.b, 2, 0, 17)
self.checkSteps(self.bf, 2, 0, 17)
self.checkState(self.b, RunnableStates.ARMED)
self.b.run()
self.checkSteps(self.b, 5, 2, 17)
self.checkSteps(self.bf, 5, 2, 17)
self.checkState(self.b, RunnableStates.ARMED)
# rewind
self.b.pause(lastGoodStep=1)
self.checkSteps(self.b, 2, 1, 17)
self.checkSteps(self.bf, 2, 1, 17)
self.checkState(self.b, RunnableStates.ARMED)
self.b.run()
self.checkSteps(self.b, 5, 2, 17)
self.checkSteps(self.bf, 5, 2, 17)
self.checkState(self.b, RunnableStates.ARMED)
self.b.run()
self.checkSteps(self.b, 15, 5, 17)
self.checkSteps(self.bf, 15, 5, 17)
self.checkState(self.b, RunnableStates.ARMED)
self.b.run()
self.checkSteps(self.b, 17, 15, 17)
self.checkSteps(self.bf, 17, 15, 17)
self.checkState(self.b, RunnableStates.ARMED)
# rewind
self.b.pause(lastGoodStep=11)
self.checkSteps(self.b, 15, 11, 17)
self.checkSteps(self.bf, 15, 11, 17)
self.checkState(self.b, RunnableStates.ARMED)
self.b.run()
self.checkSteps(self.b, 17, 15, 17)
self.checkSteps(self.bf, 17, 15, 17)
self.checkState(self.b, RunnableStates.ARMED)
self.b.run()
self.checkSteps(self.b, 17, 17, 17)
self.checkSteps(self.bf, 17, 17, 17)
self.checkState(self.b, RunnableStates.FINISHED)
def _get_detector_table(self, imaging_exposure_time,
diffraction_exposure_time):
return DetectorTable(
[True, True, True],
["imagingDetector", "diffDetector", "PandA"],
["ML-IMAGING-01", "ML-DIFF-01", "ML-PANDA-01"],
[imaging_exposure_time, diffraction_exposure_time, 0.0],
[1, 1, 2],
)
def test_configure_raises_ValueError_with_missing_detector(self):
self.set_motor_attributes()
nCycles = 1
generator = CompoundGenerator([StaticPointGenerator(nCycles)], [], [],
duration=0.0)
generator.prepare()
exposure_time = 0.01
detectors_without_diffraction = DetectorTable(
[True, True],
["imagingDetector", "PandA"],
["ML-IMAGING-01", "ML-PANDA-01"],
[exposure_time, 0.0],
[1, 2],
)
detectors_without_imaging = DetectorTable(
[True, True],
["diffDetector", "PandA"],
["ML-DIFF-01", "ML-PANDA-01"],
[exposure_time, 0.0],
[1, 2],
)
self.assertRaises(
ValueError,
self.o.on_configure,
self.context,
0,
nCycles,
{},
generator,
detectors_without_diffraction,
[],
)
self.assertRaises(
ValueError,
self.o.on_configure,
self.context,
0,
nCycles,
{},
generator,
detectors_without_imaging,
[],
)
def test_configure_raises_ValueError_when_exposure_is_zero(self):
nCycles = 1
generator = CompoundGenerator([StaticPointGenerator(nCycles)], [], [],
duration=0.0)
imaging_exposure_time = 0.1
diffraction_exposure_time = 0.3
detectors_with_imaging_zero_exposure = DetectorTable(
[False, True, True],
["imagingDetector", "diffDetector", "PandA"],
["ML-IMAGING-01", "ML-DIFF-01", "ML-PANDA-01"],
[imaging_exposure_time, 0.0, 0.0],
[1, 1, 2],
)
detectors_with_diffraction_zero_exposure = DetectorTable(
[True, False, True],
["imagingDetector", "diffDetector", "PandA"],
["ML-IMAGING-01", "ML-DIFF-01", "ML-PANDA-01"],
[0.0, diffraction_exposure_time, 0.0],
[1, 1, 2],
)
self.assertRaises(
ValueError,
self.o.on_configure,
self.context,
0,
nCycles,
{},
generator,
detectors_with_imaging_zero_exposure,
[],
)
self.assertRaises(
ValueError,
self.o.on_configure,
self.context,
0,
nCycles,
{},
generator,
detectors_with_diffraction_zero_exposure,
[],
)
def test_configure_raises_ValueError_with_invalid_frames_per_step(self):
self.set_motor_attributes()
nCycles = 1
generator = CompoundGenerator([StaticPointGenerator(nCycles)], [], [],
duration=0.0)
generator.prepare()
imaging_exposure_time = 0.01
diffraction_exposure_time = 1.0
detectors_with_bad_imaging_frames_per_step = DetectorTable(
[True, True, True],
["imagingDetector", "diffDetector", "PandA"],
["ML-IMAGING-01", "ML-DIFF-01", "ML-PANDA-01"],
[imaging_exposure_time, diffraction_exposure_time, 0.0],
[3, 1, 2],
)
detectors_with_bad_diffraction_frames_per_step = DetectorTable(
[True, True, True],
["imagingDetector", "diffDetector", "PandA"],
["ML-IMAGING-01", "ML-DIFF-01", "ML-PANDA-01"],
[imaging_exposure_time, diffraction_exposure_time, 0.0],
[1, 10, 2],
)
self.assertRaises(
ValueError,
self.o.on_configure,
self.context,
0,
nCycles,
{},
generator,
detectors_with_bad_imaging_frames_per_step,
[],
)
self.assertRaises(
ValueError,
self.o.on_configure,
self.context,
0,
nCycles,
{},
generator,
detectors_with_bad_diffraction_frames_per_step,
[],
)
def test_setting_exposure_on_no_exposure_det_fails(self):
with self.assertRaises(BadValueError) as cm:
self.b.validate(
self.make_generator(),
self.tmpdir,
detectors=DetectorTable.from_rows(
[(True, "FAST", "fast", 0.0, 1), (True, "SLOW", "slow", 0.5, 1)]
),
)
assert str(cm.exception) == "Detector SLOW doesn't take exposure"
def test_bad_det_mri(self):
# Send mismatching rows
with self.assertRaises(AssertionError) as cm:
self.b.configure(
self.make_generator(),
self.tmpdir,
axesToMove=(),
detectors=DetectorTable.from_rows([(True, "SLOW", "fast", 0.0, 0)]),
)
assert str(cm.exception) == "SLOW has mri slow, passed fast"
def test_guessing_frames_and_exposure(self):
self.slow_multi.active = True
ret = self.b.validate(
self.make_generator(),
self.tmpdir,
detectors=DetectorTable.from_rows([(True, "FAST", "fast", 0.0, 0)]),
)
assert list(ret.detectors.rows()) == [
[True, "FAST", "fast", 0.99895, 1],
[False, "SLOW", "slow", 0, 0],
]
def test_validate_returns_exposures(self):
ret = self.b.validate(
self.make_generator(),
self.tmpdir,
detectors=DetectorTable.from_rows(
[(True, "SLOW", "slow", 0.0, 1), (True, "FAST", "fast", 0.0, 1)]
),
)
assert list(ret.detectors.rows()) == [
[True, "SLOW", "slow", 0.0, 1],
[True, "FAST", "fast", 0.99895, 1],
]
def test_guessing_frames_1(self):
ret = self.b.validate(
self.make_generator(),
self.tmpdir,
detectors=DetectorTable.from_rows(
[(True, "FAST", "fast", 0.5, 0), (True, "SLOW", "slow", 0.0, 1)]
),
)
assert list(ret.detectors.rows()) == [
[True, "FAST", "fast", 0.5, 1],
[True, "SLOW", "slow", 0.0, 1],
]
def test_on_validate_tweaks_zero_duration(self):
points = StaticPointGenerator(10)
generator = CompoundGenerator([points], [], [], 0.0)
generator.prepare()
# Disable the detector
detectors = DetectorTable.from_rows([[False, "det", "DET", 0.0, 5]])
# Expected duration is 2 clock cycles
expected_duration = 2 * 8.0e-9
b = self.scan.block_view()
params = b.validate(generator, self.tmpdir, detectors=detectors)
self.assertEqual(expected_duration, params["generator"]["duration"])
def test_multi_frame_no_infos_fails(self):
with self.assertRaises(BadValueError) as cm:
self.b.configure(
self.make_generator(),
self.tmpdir,
detectors=DetectorTable.from_rows(
[(True, "SLOW", "slow", 0.0, 1), (True, "FAST", "fast", 0.0, 5)]
),
)
assert str(cm.exception) == (
"There are no trigger multipliers setup for Detector 'FAST' "
"so framesPerStep can only be 0 or 1 for this row in the detectors "
"table"
)
def test_on_validate_raises_AssertionError_for_negative_duration(self):
xs = LineGenerator("x", "mm", 0.0, 0.3, 4)
ys = LineGenerator("y", "mm", 0.0, 0.1, 2)
generator = CompoundGenerator([ys, xs], [], [], -1.0)
generator.prepare()
# Disable the detector
detectors = DetectorTable.from_rows([[False, "det", "DET", 0.0, 5]])
b = self.scan.block_view()
self.assertRaises(AssertionError,
b.validate,
generator,
self.tmpdir,
detectors=detectors)
def test_validate_raises_ValueError_for_missing_detector(self):
nCycles = 1
generator = CompoundGenerator([StaticPointGenerator(nCycles)], [], [],
duration=0.0)
imaging_exposure_time = 0.1
diffraction_exposure_time = 0.3
table_without_imaging_detector = DetectorTable(
[True, True],
["diffDetector", "PandA"],
["ML-DIFF-01", "ML-PANDA-01"],
[diffraction_exposure_time, 0.0],
[1, 2],
)
table_without_diffraction_detector = DetectorTable(
[True, True],
["imagingDetector", "PandA"],
["ML-IMAGING-01", "ML-PANDA-01"],
[imaging_exposure_time, 0.0],
[1, 2],
)
self.assertRaises(
ValueError,
self.o.on_validate,
generator,
{},
table_without_imaging_detector,
)
self.assertRaises(
ValueError,
self.o.on_validate,
generator,
{},
table_without_diffraction_detector,
)
def test_validate_raises_ValueError_when_detector_not_enabled(self):
nCycles = 1
generator = CompoundGenerator([StaticPointGenerator(nCycles)], [], [],
duration=0.0)
imaging_exposure_time = 0.1
diffraction_exposure_time = 0.3
detectors_with_imaging_disabled = DetectorTable(
[False, True, True],
["imagingDetector", "diffDetector", "PandA"],
["ML-IMAGING-01", "ML-DIFF-01", "ML-PANDA-01"],
[imaging_exposure_time, diffraction_exposure_time, 0.0],
[1, 1, 2],
)
detectors_with_diffraction_disabled = DetectorTable(
[True, False, True],
["imagingDetector", "diffDetector", "PandA"],
["ML-IMAGING-01", "ML-DIFF-01", "ML-PANDA-01"],
[imaging_exposure_time, diffraction_exposure_time, 0.0],
[1, 1, 2],
)
self.assertRaises(
ValueError,
self.o.on_validate,
generator,
{},
detectors_with_imaging_disabled,
)
self.assertRaises(
ValueError,
self.o.on_validate,
generator,
{},
detectors_with_diffraction_disabled,
)
def test_configure_multiple_no_exposure(self):
xs = LineGenerator("x", "mm", 0.0, 0.3, 4)
ys = LineGenerator("y", "mm", 0.0, 0.1, 2)
generator = CompoundGenerator([ys, xs], [], [], 1.0)
generator.prepare()
detectors = DetectorTable.from_rows([[True, "det", "DET", 0.0, 5]])
self.o.on_configure(self.context, generator, detectors)
assert self.o.generator_duration == 1.0
assert self.o.frames_per_step == 5
# Detector would normally be configured by DetectorChildPart
detector = self.process.block_view("DET")
spg = StaticPointGenerator(5, axes=["det_frames_per_step"])
ex = SquashingExcluder(axes=["det_frames_per_step", "x"])
generatormultiplied = CompoundGenerator([ys, xs, spg], [ex], [], 0.2)
detector.configure(generatormultiplied, self.tmpdir)
self.o.on_post_configure()
self.check_pulse_mocks(0.19899, 0.2, 0.000505, 5)
def test_breakpoints_tomo(self):
breakpoints = [2, 3, 10, 2]
# Configure RunnableController(mri='top')
self.b.configure(
generator=self.make_generator_breakpoints(),
fileDir=self.tmpdir,
detectors=DetectorTable.from_rows(
[[False, "SLOW", "slow", 0.0, 1], [True, "FAST", "fast", 0.0, 1]]
),
axesToMove=["x"],
breakpoints=breakpoints,
)
assert self.ct.configure_params.generator.size == 17
self.checkSteps(self.b, 2, 0, 17)
self.checkSteps(self.bf, 2, 0, 17)
assert self.b.state.value == "Armed"
assert self.bs.state.value == "Ready"
assert self.bf.state.value == "Armed"
self.b.run()
self.checkSteps(self.b, 5, 2, 17)
self.checkSteps(self.bf, 5, 2, 17)
assert self.b.state.value == "Armed"
assert self.bs.state.value == "Ready"
assert self.bf.state.value == "Armed"
self.b.run()
self.checkSteps(self.b, 15, 5, 17)
assert self.b.state.value == "Armed"
assert self.bs.state.value == "Ready"
assert self.bf.state.value == "Armed"
self.b.run()
self.checkSteps(self.b, 17, 15, 17)
assert self.b.state.value == "Armed"
assert self.bs.state.value == "Ready"
assert self.bf.state.value == "Armed"
self.b.run()
self.checkSteps(self.b, 17, 17, 17)
self.checkSteps(self.bf, 17, 17, 17)
assert self.b.state.value == "Finished"
assert self.bs.state.value == "Ready"
assert self.bf.state.value == "Finished"
def test_multi_frame_fast_det(self):
self.fast_multi.active = True
self.b.configure(
self.make_generator(),
self.tmpdir,
detectors=DetectorTable.from_rows(
[(True, "SLOW", "slow", 0.0, 1), (True, "FAST", "fast", 0.0, 5)]
),
)
assert self.b.completedSteps.value == 0
assert self.b.totalSteps.value == 6
assert self.b.configuredSteps.value == 6
assert self.bs.completedSteps.value == 0
assert self.bs.totalSteps.value == 6
assert self.bs.configuredSteps.value == 6
assert self.bf.completedSteps.value == 0
assert self.bf.totalSteps.value == 30
assert self.bf.configuredSteps.value == 30
def test_not_paused_when_resume(self):
# Set it up to do 6 steps
self.b.configure(
self.make_generator(),
self.tmpdir,
axesToMove=(),
detectors=DetectorTable.from_rows(
[(True, "FAST", "fast", 0, 1), (True, "SLOW", "slow", 0, 1)]
),
)
assert self.b.completedSteps.value == 0
assert self.b.totalSteps.value == 6
assert self.b.configuredSteps.value == 1
# Do one step
self.b.run()
assert self.b.completedSteps.value == 1
assert self.b.totalSteps.value == 6
assert self.b.configuredSteps.value == 2
assert self.b.state.value == "Armed"
assert self.bs.state.value == "Armed"
assert self.bf.state.value == "Armed"
# Now do a second step but pause before the second one is done
f = self.b.run_async()
self.context.sleep(0.2)
assert self.b.state.value == "Running"
assert self.bf.state.value == "Armed"
assert self.bs.state.value == "Running"
self.b.pause()
assert self.b.state.value == "Paused"
assert self.bf.state.value == "Armed"
assert self.bs.state.value == "Paused"
assert self.b.completedSteps.value == 1
assert self.b.totalSteps.value == 6
assert self.b.configuredSteps.value == 2
self.b.resume()
self.context.wait_all_futures(f)
assert self.b.completedSteps.value == 2
assert self.b.totalSteps.value == 6
assert self.b.configuredSteps.value == 3
def test_adding_faulty_fails(self):
t = LayoutTable.from_rows([["BAD", "faulty", 0, 0, True]])
self.b.layout.put_value(t)
assert list(self.b.configure.meta.defaults["detectors"].rows()) == [
[True, "FAST", "fast", 0.0, 1],
[True, "SLOW", "slow", 0.0, 1],
[True, "BAD", "faulty", 0.0, 1],
]
with self.assertRaises(BadValueError) as cm:
self.b.configure(self.make_generator(), self.tmpdir)
assert str(cm.exception) == (
"Detector BAD was faulty at init and is unusable. "
"If the detector is now working please restart Malcolm"
)
self.b.configure(
self.make_generator(),
self.tmpdir,
detectors=DetectorTable.from_rows([(False, "BAD", "faulty", 0.0, 1)]),
)
self.b.reset()
t = LayoutTable.from_rows([["BAD", "faulty", 0, 0, False]])
self.b.layout.put_value(t)
self.test_init()
self.b.configure(self.make_generator(), self.tmpdir)
def test_validate(self):
detector_table = DetectorTable([True], ["PandA"], ["ML-PANDA-01"], [1.0], [2])
self.part_under_test.on_validate(context=self.context, detectors=detector_table)
