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_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.ARStream("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.getStreams())
# prepare callbacks
self.past = None
self.left = None
self.updates = 0
self.done = 0
# Run acquisition
start = time.time()
f = acq.acquire(st.getStreams())
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.assertEqual(self.left, 0)
self.assertEqual(self.done, 1)
self.assertTrue(not f.cancelled())
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_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)