def continuous_acquisition(self, offset, active_interval, passive_interval,
repetitions, integ_time):
"""Executes measurement running the TGGeneration and Acquisition actions
according the test parameters. Checks the lengths of the acquired data.
"""
# obtaining elements created in the BasePoolTestCase.setUp
tg_1_1 = self.tgs['_test_tg_1_1']
tg_ctrl_1 = tg_1_1.get_controller()
ct_1_1 = self.cts['_test_ct_1_1'] # hw synchronized
ct_2_1 = self.cts['_test_ct_2_1'] # sw synchronized
ct_ctrl_1 = ct_1_1.get_controller()
ct_ctrl_1.set_ctrl_par("synchronization", AcqSynch.HardwareTrigger)
ct_ctrl_2 = ct_2_1.get_controller()
self.channel_names.append('_test_ct_1_1')
self.channel_names.append('_test_ct_2_1')
conf_ct_ctrl_1 = createTimerableControllerConfiguration(ct_ctrl_1,
[ct_1_1])
conf_ct_ctrl_2 = createTimerableControllerConfiguration(ct_ctrl_2,
[ct_2_1])
hw_ctrls = get_timerable_ctrls([conf_ct_ctrl_1],
acq_mode=AcqMode.Timer)
sw_ctrls = get_timerable_ctrls([conf_ct_ctrl_2],
acq_mode=AcqMode.Timer)
sw_master = sw_ctrls[0].master
conf_tg_ctrl_1 = createControllerConfiguration(tg_ctrl_1, [tg_1_1])
synch_ctrls = get_acq_ctrls([conf_tg_ctrl_1])
# creating synchronization action
self.synchronization = self.create_action(PoolSynchronization,
[tg_1_1])
self.synchronization.add_listener(self)
# add_listeners
self.add_listeners([ct_1_1, ct_2_1])
# creating acquisition actions
self.hw_acq = self.create_action(PoolAcquisitionHardware, [ct_1_1])
self.sw_acq = self.create_action(PoolAcquisitionSoftware, [ct_2_1])
self.sw_acq_args = (sw_ctrls, integ_time, sw_master)
self.sw_acq_kwargs = dict(synch=True)
total_interval = active_interval + passive_interval
group = {
SynchParam.Delay: {SynchDomain.Time: offset},
SynchParam.Active: {SynchDomain.Time: active_interval},
SynchParam.Total: {SynchDomain.Time: total_interval},
SynchParam.Repeats: repetitions
}
synch_description = [group]
# get the current number of jobs
jobs_before = get_thread_pool().qsize
self.hw_acq.run(hw_ctrls, integ_time, repetitions, 0)
self.synchronization.run(synch_ctrls, synch_description)
# waiting for acquisition and synchronization to finish
while (self.hw_acq.is_running()
or self.sw_acq._is_busy()
or self.synchronization.is_running()):
time.sleep(.1)
self.do_asserts(repetitions, jobs_before)
def acquire(self, integ_time, repetitions, latency_time):
"""Acquire with a dummy C/T synchronized by a hardware start
trigger from a dummy T/G."""
self.prepare(integ_time, repetitions, latency_time, 1)
conf_ct_ctrl_1 = createTimerableControllerConfiguration(
self.channel_ctrl, [self.channel])
ctrls = get_timerable_ctrls([conf_ct_ctrl_1], AcqMode.Timer)
conf_tg_ctrl_1 = createControllerConfiguration(self.tg_ctrl,
[self.tg])
synch_ctrls = get_acq_ctrls([conf_tg_ctrl_1])
self.synchronization = self.create_action(PoolSynchronization,
[self.tg])
# add data listeners
self.add_listeners([self.channel])
# creating acquisition actions
self.acquisition = self.create_action(PoolAcquisitionHardware,
[self.channel])
self.acq_args = ([conf_ct_ctrl_1], integ_time, repetitions)
# prepare synchronization description
total_interval = integ_time + latency_time
group = {
SynchParam.Delay: {SynchDomain.Time: 0},
SynchParam.Active: {SynchDomain.Time: integ_time},
SynchParam.Total: {SynchDomain.Time: total_interval},
SynchParam.Repeats: repetitions
}
synch_description = [group]
# get the current number of jobs
jobs_before = get_thread_pool().qsize
self.acquisition.run(ctrls, integ_time, repetitions, 0)
self.synchronization.run(synch_ctrls, synch_description)
self.wait_finish()
self.do_asserts(repetitions, jobs_before)
def acquire(self, integ_time, repetitions, latency_time):
"""Acquire with a dummy C/T synchronized by a hardware start
trigger from a dummy T/G."""
self.ct_ctrl_1.set_ctrl_par("synchronization", AcqSynch.HardwareStart)
conf_ct_ctrl_1 = createTimerableControllerConfiguration(
self.ct_ctrl_1, [self.ct_1_1])
ctrls = get_timerable_ctrls([conf_ct_ctrl_1], AcqMode.Timer)
conf_tg_ctrl_1 = createControllerConfiguration(self.tg_ctrl_1,
[self.tg_1_1])
synch_ctrls = get_acq_ctrls([conf_tg_ctrl_1])
self.synchronization = self.create_action(PoolSynchronization,
[self.tg_1_1])
# add data listeners
self.add_listeners([self.ct_1_1])
# creating acquisition actions
self.acquisition = self.create_action(PoolAcquisitionHardware,
[self.ct_1_1])
self.acq_args = ([conf_ct_ctrl_1], integ_time, repetitions)
# prepare synchronization description
total_interval = integ_time + latency_time
group = {
SynchParam.Delay: {SynchDomain.Time: 0},
SynchParam.Active: {SynchDomain.Time: integ_time},
SynchParam.Total: {SynchDomain.Time: total_interval},
SynchParam.Repeats: repetitions
}
synchronization = [group]
# get the current number of jobs
jobs_before = get_thread_pool().qsize
self.acquisition.run(ctrls, integ_time, repetitions, 0)
self.synchronization.run(synch_ctrls, synchronization)
self.wait_finish()
self.do_asserts(repetitions, jobs_before)
def acquire(self, integ_time, repetitions, latency_time):
"""Acquire with a dummy C/T synchronized by a hardware start
trigger from a dummy T/G."""
self.prepare(integ_time, repetitions, latency_time, 1)
conf_ct_ctrl_1 = createTimerableControllerConfiguration(
self.channel_ctrl, [self.channel])
ctrls = get_timerable_ctrls([conf_ct_ctrl_1], AcqMode.Timer)
master = ctrls[0].master
# creating synchronization action
self.synchronization = self.create_action(PoolSynchronization,
[self.tg])
self.synchronization.add_listener(self)
# add_listeners
self.add_listeners([self.channel])
# creating acquisition actions
self.acquisition = self.create_action(PoolAcquisitionSoftware,
[self.channel])
# Since we deposit the software acquisition action on the PoolThread's
# queue we can not rely on the action's state - one may still wait
# in the queue (its state has not changed to running yet) and we would
# be depositing another one. This way we may be starting multiple
# times the same action (with the same elements involved), what results
# in "already involved in operation" errors.
# Use an external Event flag to mark if we have any software
# acquisition action pending.
self.acq_busy = threading.Event()
self.acquisition.add_finish_hook(self.acq_busy.clear)
self.acq_args = (ctrls, integ_time, master, None)
self.acq_kwargs = {}
total_interval = integ_time + latency_time
group = {
SynchParam.Delay: {
SynchDomain.Time: 0
},
SynchParam.Active: {
SynchDomain.Time: integ_time
},
SynchParam.Total: {
SynchDomain.Time: total_interval
},
SynchParam.Repeats: repetitions
}
synchronization = [group]
# get the current number of jobs
jobs_before = get_thread_pool().qsize
self.synchronization.run([], synchronization)
self.wait_finish()
self.do_asserts(repetitions, jobs_before, strict=False)
def acquire(self, integ_time, repetitions, latency_time):
"""Acquire with a dummy C/T synchronized by a hardware start
trigger from a dummy T/G."""
self.ct_ctrl_1.set_ctrl_par("synchronization", AcqSynch.SoftwareStart)
conf_ct_ctrl_1 = createTimerableControllerConfiguration(
self.ct_ctrl_1, [self.ct_1_1])
ctrls = get_timerable_ctrls([conf_ct_ctrl_1], AcqMode.Timer)
master = ctrls[0].master
# creating synchronization action
self.synchronization = self.create_action(PoolSynchronization,
[self.tg_1_1])
self.synchronization.add_listener(self)
# add_listeners
self.add_listeners([self.ct_1_1])
# creating acquisition actions
self.acquisition = self.create_action(PoolAcquisitionSoftwareStart,
[self.ct_1_1])
self.acq_args = (ctrls, integ_time, master, repetitions, 0)
self.acq_kwargs = {}
total_interval = integ_time + latency_time
group = {
SynchParam.Delay: {
SynchDomain.Time: 0
},
SynchParam.Active: {
SynchDomain.Time: integ_time
},
SynchParam.Total: {
SynchDomain.Time: total_interval
},
SynchParam.Repeats: repetitions
}
synchronization = [group]
# get the current number of jobs
jobs_before = get_thread_pool().qsize
self.synchronization.run([], synchronization)
self.wait_finish()
self.do_asserts(repetitions, jobs_before)
def continuous_acquisition(self, offset, active_interval, passive_interval,
repetitions, integ_time):
"""Executes measurement running the TGGeneration and Acquisition actions
according the test parameters. Checks the lengths of the acquired data.
"""
# obtaining elements created in the BasePoolTestCase.setUp
tg_1_1 = self.tgs['_test_tg_1_1']
tg_ctrl_1 = tg_1_1.get_controller()
ct_1_1 = self.cts['_test_ct_1_1'] # hw synchronized
ct_2_1 = self.cts['_test_ct_2_1'] # sw synchronized
ct_ctrl_1 = ct_1_1.get_controller()
ct_ctrl_1.set_ctrl_par("synchronization", AcqSynch.HardwareTrigger)
ct_ctrl_2 = ct_2_1.get_controller()
self.channel_names.append('_test_ct_1_1')
self.channel_names.append('_test_ct_2_1')
conf_ct_ctrl_1 = createTimerableControllerConfiguration(
ct_ctrl_1, [ct_1_1])
conf_ct_ctrl_2 = createTimerableControllerConfiguration(
ct_ctrl_2, [ct_2_1])
hw_ctrls = get_timerable_ctrls([conf_ct_ctrl_1],
acq_mode=AcqMode.Timer)
sw_ctrls = get_timerable_ctrls([conf_ct_ctrl_2],
acq_mode=AcqMode.Timer)
sw_master = sw_ctrls[0].master
conf_tg_ctrl_1 = createControllerConfiguration(tg_ctrl_1, [tg_1_1])
synch_ctrls = get_acq_ctrls([conf_tg_ctrl_1])
# creating synchronization action
self.synchronization = self.create_action(PoolSynchronization,
[tg_1_1])
self.synchronization.add_listener(self)
# add_listeners
self.add_listeners([ct_1_1, ct_2_1])
# creating acquisition actions
self.hw_acq = self.create_action(PoolAcquisitionHardware, [ct_1_1])
self.sw_acq = self.create_action(PoolAcquisitionSoftware, [ct_2_1])
# Since we deposit the software acquisition action on the PoolThread's
# queue we can not rely on the action's state - one may still wait
# in the queue (its state has not changed to running yet) and we would
# be depositing another one. This way we may be starting multiple
# times the same action (with the same elements involved), what results
# in "already involved in operation" errors.
# Use an external Event flag to mark if we have any software
# acquisition action pending.
self.sw_acq_busy = threading.Event()
self.sw_acq.add_finish_hook(self.sw_acq_busy.clear)
self.sw_acq_args = (sw_ctrls, integ_time, sw_master)
self.sw_acq_kwargs = {}
total_interval = active_interval + passive_interval
group = {
SynchParam.Delay: {
SynchDomain.Time: offset
},
SynchParam.Active: {
SynchDomain.Time: active_interval
},
SynchParam.Total: {
SynchDomain.Time: total_interval
},
SynchParam.Repeats: repetitions
}
synchronization = [group]
# get the current number of jobs
jobs_before = get_thread_pool().qsize
self.hw_acq.run(hw_ctrls, integ_time, repetitions, 0)
self.synchronization.run(synch_ctrls, synchronization)
# waiting for acquisition and synchronization to finish
while (self.hw_acq.is_running() or self.sw_acq.is_running()
or self.synchronization.is_running()):
time.sleep(.1)
self.do_asserts(repetitions, jobs_before)
def continuous_acquisition(self, offset, active_interval, passive_interval,
repetitions, integ_time):
"""Executes measurement running the TGGeneration and Acquisition actions
according the test parameters. Checks the lengths of the acquired data.
"""
# obtaining elements created in the BasePoolTestCase.setUp
tg_1_1 = self.tgs['_test_tg_1_1']
tg_ctrl_1 = tg_1_1.get_controller()
ct_1_1 = self.cts['_test_ct_1_1'] # hw synchronized
ct_2_1 = self.cts['_test_ct_2_1'] # sw synchronized
ct_ctrl_1 = ct_1_1.get_controller()
ct_ctrl_1.set_ctrl_par("synchronization", AcqSynch.HardwareTrigger)
ct_ctrl_2 = ct_2_1.get_controller()
self.channel_names.append('_test_ct_1_1')
self.channel_names.append('_test_ct_2_1')
conf_ct_ctrl_1 = createTimerableControllerConfiguration(ct_ctrl_1,
[ct_1_1])
conf_ct_ctrl_2 = createTimerableControllerConfiguration(ct_ctrl_2,
[ct_2_1])
hw_ctrls = get_timerable_ctrls([conf_ct_ctrl_1],
acq_mode=AcqMode.Timer)
sw_ctrls = get_timerable_ctrls([conf_ct_ctrl_2],
acq_mode=AcqMode.Timer)
sw_master = sw_ctrls[0].master
conf_tg_ctrl_1 = createControllerConfiguration(tg_ctrl_1, [tg_1_1])
synch_ctrls = get_acq_ctrls([conf_tg_ctrl_1])
# creating synchronization action
self.synchronization = self.create_action(PoolSynchronization,
[tg_1_1])
self.synchronization.add_listener(self)
# add_listeners
self.add_listeners([ct_1_1, ct_2_1])
# creating acquisition actions
self.hw_acq = self.create_action(PoolAcquisitionHardware, [ct_1_1])
self.sw_acq = self.create_action(PoolAcquisitionSoftware, [ct_2_1])
# Since we deposit the software acquisition action on the PoolThread's
# queue we can not rely on the action's state - one may still wait
# in the queue (its state has not changed to running yet) and we would
# be depositing another one. This way we may be starting multiple
# times the same action (with the same elements involved), what results
# in "already involved in operation" errors.
# Use an external Event flag to mark if we have any software
# acquisition action pending.
self.sw_acq_busy = threading.Event()
self.sw_acq.add_finish_hook(self.sw_acq_busy.clear)
self.sw_acq_args = (sw_ctrls, integ_time, sw_master)
self.sw_acq_kwargs = {}
total_interval = active_interval + passive_interval
group = {
SynchParam.Delay: {SynchDomain.Time: offset},
SynchParam.Active: {SynchDomain.Time: active_interval},
SynchParam.Total: {SynchDomain.Time: total_interval},
SynchParam.Repeats: repetitions
}
synchronization = [group]
# get the current number of jobs
jobs_before = get_thread_pool().qsize
self.hw_acq.run(hw_ctrls, integ_time, repetitions, 0)
self.synchronization.run(synch_ctrls, synchronization)
# waiting for acquisition and synchronization to finish
while (self.hw_acq.is_running()
or self.sw_acq.is_running()
or self.synchronization.is_running()):
time.sleep(.1)
self.do_asserts(repetitions, jobs_before)