def test_drift_stream(self):
escan = self.ebeam
detector = self.sed
ccd = self.ccd
# Create the stream
sems = stream.SEMStream("test sem", detector, detector.data, escan)
ars = stream.ARStream("test ar", ccd, ccd.data, escan)
sas = stream.SEMARMDStream("test sem-ar", sems, ars)
# Long acquisition
ccd.exposureTime.value = 1e-02 # s
sems.dcPeriod.value = 5
sems.dcRegion.value = (0.525, 0.525, 0.6, 0.6)
sems.dcDwellTime.value = 1e-04
escan.dwellTime.value = 1e-02
ars.roi.value = (0.4, 0.4, 0.6, 0.6)
ars.repetition.value = (5, 5)
start = time.time()
f = sas.acquire()
x = f.result()
dur = time.time() - start
logging.debug("Acquisition took %g s", dur)
self.assertTrue(f.done())
def test_drift_stream(self):
escan = self.ebeam
detector = self.sed
ccd = self.ccd
# Create the stream
sems = stream.SEMStream("test sem", detector, detector.data, escan)
ars = stream.ARSettingsStream("test ar", ccd, ccd.data, escan)
sas = stream.SEMARMDStream("test sem-ar", [sems, ars])
# Long acquisition
ccd.exposureTime.value = 1e-02 # s
dc = leech.AnchorDriftCorrector(escan, detector)
dc.period.value = 5
dc.roi.value = (0.525, 0.525, 0.6, 0.6)
dc.dwellTime.value = 1e-04
sems.leeches.append(dc)
escan.dwellTime.value = 1e-02
ars.roi.value = (0.4, 0.4, 0.6, 0.6)
ars.repetition.value = (5, 5)
start = time.time()
for l in sas.leeches:
l.series_start()
f = sas.acquire()
x = f.result()
for l in sas.leeches:
l.series_complete(x)
dur = time.time() - start
logging.debug("Acquisition took %g s", dur)
self.assertTrue(f.done())
def test_guess_mode(self):
# test guess mode for ar
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
ars = stream.ARSettingsStream("test ar", self.ccd, self.ccd.data,
self.ebeam)
sas = stream.SEMARMDStream("test sem-ar", sems, ars)
guess = self.optmngr.guessMode(ars)
self.assertEqual(guess, "ar")
guess = self.optmngr.guessMode(sas)
self.assertEqual(guess, "ar")
# test guess mode for spectral-dedicated
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
specs = stream.SpectrumSettingsStream("test spec", self.spec,
self.spec.data, self.ebeam)
sps = stream.SEMSpectrumMDStream("test sem-spec", sems, specs)
guess = self.optmngr.guessMode(specs)
self.assertIn(guess, ("spectral", "spectral-dedicated"))
guess = self.optmngr.guessMode(sps)
self.assertIn(guess, ("spectral", "spectral-dedicated"))
def test_progressive_future(self):
"""
Test .acquire interface (should return a progressive future with updates)
"""
self.image = None
self.done = False
self.updates = 0
# Create the stream
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
ars = stream.ARStream("test ar", self.ccd, self.ccd.data, self.ebeam)
sas = stream.SEMARMDStream("test sem-ar", sems, ars)
ars.roi.value = (0.1, 0.1, 0.8, 0.8)
self.ccd.binning.value = (4, 4) # hopefully always supported
# Long acquisition
self.ccd.exposureTime.value = 0.2 # s
ars.repetition.value = (2, 3)
exp_shape = ars.repetition.value[::-1]
num_ar = numpy.prod(ars.repetition.value)
# Start acquisition
timeout = 1 + 1.5 * sas.estimateAcquisitionTime()
f = sas.acquire()
f.add_update_callback(self.on_progress_update)
f.add_done_callback(self.on_done)
data = f.result(timeout)
self.assertEqual(len(data), num_ar + 1)
self.assertEqual(data[0].shape, exp_shape)
self.assertGreaterEqual(self.updates,
4) # at least a couple of updates
self.assertEqual(self.left, 0)
self.assertTrue(self.done)
self.assertTrue(not f.cancelled())
# short acquisition
self.done = False
self.updates = 0
self.ccd.exposureTime.value = 0.02 # s
ars.repetition.value = (5, 4)
exp_shape = ars.repetition.value[::-1]
num_ar = numpy.prod(ars.repetition.value)
# Start acquisition
timeout = 1 + 1.5 * sas.estimateAcquisitionTime()
f = sas.acquire()
f.add_update_callback(self.on_progress_update)
f.add_done_callback(self.on_done)
data = f.result(timeout)
self.assertEqual(len(data), num_ar + 1)
self.assertEqual(data[0].shape, exp_shape)
self.assertGreaterEqual(self.updates, 5) # at least a few updates
self.assertEqual(self.left, 0)
self.assertTrue(self.done)
self.assertTrue(not f.cancelled())
def test_sync_sem_ccd(self):
"""
try acquisition with fairly complex SEM/CCD stream
"""
# Create the streams and streamTree
semsur = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
sems = stream.SEMStream("test sem cl", self.sed, self.sed.data,
self.ebeam)
ars = stream.ARSettingsStream("test ar", self.ccd, self.ccd.data,
self.ebeam)
semars = stream.SEMARMDStream("test SEM/AR", [sems, ars])
st = stream.StreamTree(streams=[semsur, semars])
# SEM survey settings are via the current hardware settings
self.ebeam.dwellTime.value = self.ebeam.dwellTime.range[0]
# SEM/AR settings are via the AR stream
ars.roi.value = (0.1, 0.1, 0.8, 0.8)
mx_brng = self.ccd.binning.range[1]
binning = tuple(min(4, mx) for mx in mx_brng) # try binning 4x4
self.ccd.binning.value = binning
self.ccd.exposureTime.value = 1 # s
ars.repetition.value = (2, 3)
num_ar = numpy.prod(ars.repetition.value)
est_time = acq.estimateTime(st.getProjections())
# prepare callbacks
self.start = None
self.end = None
self.updates = 0
self.done = 0
# Run acquisition
start = time.time()
f = acq.acquire(st.getProjections())
f.add_update_callback(self.on_progress_update)
f.add_done_callback(self.on_done)
data, e = f.result()
dur = time.time() - start
self.assertGreaterEqual(dur, est_time /
2) # Estimated time shouldn't be too small
self.assertIsInstance(data[0], model.DataArray)
self.assertIsNone(e)
self.assertEqual(len(data), num_ar + 2)
thumb = acq.computeThumbnail(st, f)
self.assertIsInstance(thumb, model.DataArray)
self.assertGreaterEqual(self.updates, 1) # at least one update at end
self.assertLessEqual(self.end, time.time())
self.assertTrue(not f.cancelled())
time.sleep(0.1)
self.assertEqual(self.done, 1)
def test_set_path_stream(self):
# test guess mode for ar
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
ars = stream.ARSettingsStream("test ar", self.ccd, self.ccd.data,
self.ebeam)
sas = stream.SEMARMDStream("test sem-ar", sems, ars)
self.optmngr.setPath(ars).result()
# Assert that actuator was moved according to mode given
self.assert_pos_as_in_mode(self.lenswitch, "ar")
self.assert_pos_as_in_mode(self.slit, "ar")
self.assert_pos_as_in_mode(self.specgraph, "ar")
self.assertEqual(self.spec_det_sel.position.value, {'rx': 0})
self.assertAlmostEqual(self.spec_sel.position.value["x"], 0.022)
# Change positions back
self.optmngr.setPath("mirror-align").result()
self.optmngr.setPath(sas).result()
# Assert that actuator was moved according to mode given
self.assert_pos_as_in_mode(self.lenswitch, "ar")
self.assert_pos_as_in_mode(self.slit, "ar")
self.assert_pos_as_in_mode(self.specgraph, "ar")
self.assertEqual(self.spec_det_sel.position.value, {'rx': 0})
self.assertAlmostEqual(self.spec_sel.position.value["x"], 0.022)
# test guess mode for spectral-dedicated
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
specs = stream.SpectrumSettingsStream("test spec", self.spec,
self.spec.data, self.ebeam)
sps = stream.SEMSpectrumMDStream("test sem-spec", sems, specs)
self.optmngr.setPath(specs).result()
# Assert that actuator was moved according to mode given
self.assert_pos_as_in_mode(self.lenswitch, "spectral")
# No slit/spectrograph as they are not affecting the detector
self.assertAlmostEqual(self.spec_sel.position.value["x"], 0.026112848)
# Change positions back
self.optmngr.setPath("chamber-view").result()
self.optmngr.setPath(sps).result()
# Assert that actuator was moved according to mode given
self.assert_pos_as_in_mode(self.lenswitch, "spectral")
self.assertAlmostEqual(self.spec_sel.position.value["x"], 0.026112848)
def test_sync_future_cancel(self):
self.image = None
# Create the stream
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
ars = stream.ARStream("test ar", self.ccd, self.ccd.data, self.ebeam)
sas = stream.SEMARMDStream("test sem-ar", sems, ars)
ars.roi.value = (0.1, 0.1, 0.8, 0.8)
self.ccd.binning.value = (4, 4) # hopefully always supported
# Long acquisition
self.updates = 0
self.ccd.exposureTime.value = 0.2 # s
ars.repetition.value = (2, 3)
# Start acquisition
f = sas.acquire()
f.add_update_callback(self.on_progress_update)
f.add_done_callback(self.on_done)
time.sleep(self.ccd.exposureTime.value) # wait a bit
f.cancel()
self.assertGreaterEqual(self.updates, 1) # at least at the end
self.assertEqual(self.left, 0)
self.assertTrue(f.cancelled())
# short acquisition
self.updates = 0
self.ccd.exposureTime.value = 0.02 # s
ars.repetition.value = (5, 4)
# Start acquisition
f = sas.acquire()
f.add_update_callback(self.on_progress_update)
f.add_done_callback(self.on_done)
time.sleep(self.ccd.exposureTime.value) # wait a bit
f.cancel()
self.assertGreaterEqual(self.updates, 1) # at least at the end
self.assertEqual(self.left, 0)
self.assertTrue(f.cancelled())
def test_guess_mode(self):
# test guess mode for ar
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
ars = stream.ARSettingsStream("test ar", self.ccd, self.ccd.data,
self.ebeam)
sas = stream.SEMARMDStream("test sem-ar", sems, ars)
guess = self.optmngr.guessMode(ars)
self.assertEqual(guess, "ar")
guess = self.optmngr.guessMode(sas)
self.assertEqual(guess, "ar")
# test guess mode for spectral
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
specs = stream.SpectrumSettingsStream("test spec", self.spec,
self.spec.data, self.ebeam)
sps = stream.SEMSpectrumMDStream("test sem-spec", sems, specs)
guess = self.optmngr.guessMode(specs)
self.assertEqual(guess, "spectral")
guess = self.optmngr.guessMode(sps)
self.assertEqual(guess, "spectral")
# test guess mode for cli
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
cls = stream.SpectrumSettingsStream("test cl", self.cld, self.cld.data,
self.ebeam)
sls = stream.SEMSpectrumMDStream("test sem-cl", sems, cls)
guess = self.optmngr.guessMode(cls)
self.assertEqual(guess, "cli")
guess = self.optmngr.guessMode(sls)
self.assertEqual(guess, "cli")
def test_leech(self):
"""
try acquisition with leech
"""
# Create the streams and streamTree
semsur = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
sems = stream.SEMStream("test sem cl", self.sed, self.sed.data,
self.ebeam)
ars = stream.ARSettingsStream("test ar", self.ccd, self.ccd.data,
self.ebeam)
semars = stream.SEMARMDStream("test SEM/AR", [sems, ars])
st = stream.StreamTree(streams=[semsur, semars])
pcd = Fake0DDetector("test")
pca = ProbeCurrentAcquirer(pcd)
sems.leeches.append(pca)
semsur.leeches.append(pca)
# SEM survey settings are via the current hardware settings
self.ebeam.dwellTime.value = self.ebeam.dwellTime.range[0]
# SEM/AR settings are via the AR stream
ars.roi.value = (0.1, 0.1, 0.8, 0.8)
mx_brng = self.ccd.binning.range[1]
binning = tuple(min(4, mx) for mx in mx_brng) # try binning 4x4
self.ccd.binning.value = binning
self.ccd.exposureTime.value = 1 # s
ars.repetition.value = (2, 3)
num_ar = numpy.prod(ars.repetition.value)
pca.period.value = 10 # Only at beginning and end
est_time = acq.estimateTime(st.getProjections())
# prepare callbacks
self.start = None
self.end = None
self.updates = 0
self.done = 0
# Run acquisition
start = time.time()
f = acq.acquire(st.getProjections())
f.add_update_callback(self.on_progress_update)
f.add_done_callback(self.on_done)
data, e = f.result()
dur = time.time() - start
self.assertGreaterEqual(dur, est_time /
2) # Estimated time shouldn't be too small
self.assertIsInstance(data[0], model.DataArray)
self.assertIsNone(e)
self.assertEqual(len(data), num_ar + 2)
thumb = acq.computeThumbnail(st, f)
self.assertIsInstance(thumb, model.DataArray)
self.assertGreaterEqual(self.updates, 1) # at least one update at end
self.assertLessEqual(self.end, time.time())
self.assertTrue(not f.cancelled())
time.sleep(0.1)
self.assertEqual(self.done, 1)
for da in data:
pcmd = da.metadata[model.MD_EBEAM_CURRENT_TIME]
self.assertEqual(len(pcmd), 2)
def test_sync_path_guess(self):
"""
try synchronized acquisition using the Optical Path Manager
"""
# Create the streams and streamTree
opmngr = path.OpticalPathManager(self.microscope)
semsur = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
sems = stream.SEMStream("test sem cl", self.sed, self.sed.data,
self.ebeam)
ars = stream.ARSettingsStream("test ar",
self.ccd,
self.ccd.data,
self.ebeam,
opm=opmngr)
semars = stream.SEMARMDStream("test SEM/AR", [sems, ars])
specs = stream.SpectrumSettingsStream("test spec",
self.spec,
self.spec.data,
self.ebeam,
opm=opmngr)
sps = stream.SEMSpectrumMDStream("test sem-spec", [sems, specs])
st = stream.StreamTree(streams=[semsur, semars, sps])
# SEM survey settings are via the current hardware settings
self.ebeam.dwellTime.value = self.ebeam.dwellTime.range[0]
# SEM/AR/SPEC settings are via the AR stream
ars.roi.value = (0.1, 0.1, 0.8, 0.8)
specs.roi.value = (0.2, 0.2, 0.7, 0.7)
mx_brng = self.ccd.binning.range[1]
binning = tuple(min(4, mx) for mx in mx_brng) # try binning 4x4
self.ccd.binning.value = binning
self.ccd.exposureTime.value = 1 # s
ars.repetition.value = (2, 3)
specs.repetition.value = (3, 2)
num_ar = numpy.prod(ars.repetition.value)
est_time = acq.estimateTime(st.getProjections())
# prepare callbacks
self.start = None
self.end = None
self.updates = 0
self.done = 0
# Run acquisition
start = time.time()
f = acq.acquire(st.getProjections())
f.add_update_callback(self.on_progress_update)
f.add_done_callback(self.on_done)
data, e = f.result()
dur = time.time() - start
self.assertGreaterEqual(dur, est_time /
2) # Estimated time shouldn't be too small
self.assertIsInstance(data[0], model.DataArray)
self.assertIsNone(e)
self.assertEqual(len(data), num_ar + 4)
thumb = acq.computeThumbnail(st, f)
self.assertIsInstance(thumb, model.DataArray)
self.assertGreaterEqual(self.updates, 1) # at least one update at end
self.assertLessEqual(self.end, time.time())
self.assertTrue(not f.cancelled())
# assert optical path configuration
exp_pos = path.SPARC_MODES["spectral"][1]
self.assertEqual(self.lenswitch.position.value, exp_pos["lens-switch"])
self.assertEqual(self.spec_det_sel.position.value,
exp_pos["spec-det-selector"])
self.assertEqual(self.ar_spec_sel.position.value,
exp_pos["ar-spec-selector"])
time.sleep(0.1)
self.assertEqual(self.done, 1)
def test_acq_ar(self):
"""
Test short & long acquisition for AR
"""
# Create the stream
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
ars = stream.ARStream("test ar", self.ccd, self.ccd.data, self.ebeam)
sas = stream.SEMARMDStream("test sem-ar", sems, ars)
ars.roi.value = (0.1, 0.1, 0.8, 0.8)
self.ccd.binning.value = (4, 4) # hopefully always supported
# Long acquisition (small rep to avoid being too long)
# The acquisition method is different for time > 0.1 s, but we had bugs
# with dwell time > 4s, so let's directly test both.
self.ccd.exposureTime.value = 5 # s
ars.repetition.value = (2, 3)
exp_shape = ars.repetition.value[::-1]
num_ar = numpy.prod(ars.repetition.value)
# Start acquisition
timeout = 1 + 1.5 * sas.estimateAcquisitionTime()
start = time.time()
f = sas.acquire()
# wait until it's over
data = f.result(timeout)
dur = time.time() - start
logging.debug("Acquisition took %g s", dur)
self.assertTrue(f.done())
self.assertEqual(len(data), len(sems.raw) + len(ars.raw))
self.assertEqual(len(sems.raw), 1)
self.assertEqual(sems.raw[0].shape, exp_shape)
self.assertEqual(len(ars.raw), num_ar)
md = ars.raw[0].metadata
self.assertIn(model.MD_POS, md)
self.assertIn(model.MD_AR_POLE, md)
# Short acquisition (< 0.1s)
self.ccd.exposureTime.value = 0.03 # s
ars.repetition.value = (30, 20)
exp_shape = ars.repetition.value[::-1]
num_ar = numpy.prod(ars.repetition.value)
# Start acquisition
timeout = 1 + 1.5 * sas.estimateAcquisitionTime()
start = time.time()
f = sas.acquire()
# wait until it's over
data = f.result(timeout)
dur = time.time() - start
logging.debug("Acquisition took %g s", dur)
self.assertTrue(f.done())
self.assertEqual(len(data), len(sems.raw) + len(ars.raw))
self.assertEqual(len(sems.raw), 1)
self.assertEqual(sems.raw[0].shape, exp_shape)
self.assertEqual(len(ars.raw), num_ar)
md = ars.raw[0].metadata
self.assertIn(model.MD_POS, md)
self.assertIn(model.MD_AR_POLE, md)
def test_set_path_stream(self):
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
ars = stream.ARSettingsStream("test ar", self.ccd, self.ccd.data,
self.ebeam)
sas = stream.SEMARMDStream("test sem-ar", sems, ars)
self.optmngr.setPath(ars).result()
# Assert that actuator was moved according to mode given
self.assert_pos_as_in_mode(self.lenswitch, "ar")
self.assert_pos_as_in_mode(self.slit, "ar")
self.assert_pos_as_in_mode(self.specgraph, "ar")
self.assertEqual(self.spec_det_sel.position.value, {'rx': 0})
# Change positions back
self.optmngr.setPath("mirror-align").result()
self.optmngr.setPath(sas).result()
# Assert that actuator was moved according to mode given
self.assert_pos_as_in_mode(self.lenswitch, "ar")
self.assert_pos_as_in_mode(self.slit, "ar")
self.assert_pos_as_in_mode(self.specgraph, "ar")
self.assertEqual(self.spec_det_sel.position.value, {'rx': 0})
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
specs = stream.SpectrumSettingsStream("test spec", self.spec,
self.spec.data, self.ebeam)
sps = stream.SEMSpectrumMDStream("test sem-spec", sems, specs)
self.optmngr.setPath(specs).result()
# Assert that actuator was moved according to mode given
self.assertEqual(self.spec_det_sel.position.value,
{'rx': 1.5707963267948966})
self.assertEqual(self.cl_det_sel.position.value, {'x': 0.01})
# Change positions back
self.optmngr.setPath("chamber-view").result()
self.optmngr.setPath(sps).result()
# Assert that actuator was moved according to mode given
self.assert_pos_as_in_mode(self.lenswitch, "spectral")
self.assert_pos_as_in_mode(self.slit, "spectral")
self.assert_pos_as_in_mode(self.specgraph, "spectral")
self.assertEqual(self.spec_det_sel.position.value,
{'rx': 1.5707963267948966})
self.assertEqual(self.cl_det_sel.position.value, {'x': 0.01})
sems = stream.SEMStream("test sem", self.sed, self.sed.data,
self.ebeam)
specs = stream.SpectrumSettingsStream("test spec",
self.spec_integrated,
self.spec_integrated.data,
self.ebeam)
sps = stream.SEMSpectrumMDStream("test sem-spec", sems, specs)
# Change positions back
self.optmngr.setPath("chamber-view").result()
self.optmngr.setPath(specs).result()
# Assert that actuator was moved according to mode given
self.assert_pos_as_in_mode(self.lenswitch, "spectral-integrated")
self.assert_pos_as_in_mode(self.slit, "spectral-integrated")
self.assert_pos_as_in_mode(self.specgraph, "spectral-integrated")
self.assertEqual(self.spec_det_sel.position.value, {'rx': 0})
self.assertEqual(self.cl_det_sel.position.value, {'x': 0.01})
# Check the focus is remembered before going to chamber-view
orig_focus = self.focus.position.value
# Change positions back
self.optmngr.setPath("chamber-view").result()
self.focus.moveRel({"z": 1e-3}).result()
self.optmngr.setPath(sps).result()
# Assert that actuator was moved according to mode given
self.assert_pos_as_in_mode(self.lenswitch, "spectral")
self.assert_pos_as_in_mode(self.slit, "spectral")
self.assert_pos_as_in_mode(self.specgraph, "spectral")
self.assertEqual(self.spec_det_sel.position.value, {'rx': 0})
self.assertEqual(self.cl_det_sel.position.value, {'x': 0.01})
self.assertEqual(self.focus.position.value, orig_focus)
