def test_add_array(self):
array_name = 'some_array'
data_array = DataArray(array_name,
'label',
preset_data=np.array([1, 2, 3, 4, 5]))
data_set = DataSet()
data_set.add_array(data_array)
self.assertListEqual(list(data_array), list(data_set.some_array))
self.assertListEqual(list(data_array),
list(data_set.data_arrays[array_name]))
self.assertIs(data_set.some_array, data_set.data_arrays[array_name])
def test_integrate_with_data_set_io_add_array(self):
io_reader, io_writer = MemoryDataSetIOFactory.get_reader_writer_pair()
data_set_consumer = DataSet(storage_reader=io_reader)
some_array = DataArray('some_array', 'label', shape=(5, 5))
data_set_producer = DataSet(storage_writer=io_writer)
data_set_producer.add_array(some_array)
data_set_consumer.sync_from_storage(-1)
self.assertTrue(hasattr(data_set_consumer, 'some_array'))
self.assertEqual('some_array', data_set_consumer.some_array.name)
self.assertEqual((5, 5), data_set_consumer.some_array.shape)
self.assertIsNot(some_array, data_set_consumer.some_array)
def test_add_array_duplicate_raises_error(self):
name = 'some_array'
data_array = DataArray(name,
'label',
preset_data=np.array([1, 2, 3, 4, 5]))
data_set = DataSet()
data_set.add_array(data_array)
with self.assertRaises(ValueError) as error:
data_set.add_array(data_array)
self.assertEqual(
("DataSet already contains an array with the name '{}'".format(
name), ), error.exception.args)
def test_add_array_with_bad_name(self):
data_array = DataArray('this is not a good name',
'label',
preset_data=np.array([1, 2, 3, 4, 5]))
data_set = DataSet()
with self.assertRaisesRegex(
SyntaxError,
"'this is not a good name' is an invalid name for an identifier."
):
data_set.add_array(data_array)
data_array.name = 99
with self.assertRaisesRegex(
ValueError, "Array name has to be string, not <class 'int'>"):
data_set.add_array(data_array)
def __dummy_data_set(period, sample_rate, width, resolution):
time_data = TestProcessSawtooth2D.__dummy_time_data(period, sample_rate)
set_array = DataArray('ScopeTime', 'Time', unit='seconds', is_setpoint=True, preset_data=time_data)
scope_data_1 = TestProcessSawtooth2D.__dummy_scope_data(time_data, resolution[0], period, width[0])
data_array_1 = TestProcessSawtooth2D.__dummy_data_array(set_array, scope_data_1, channel_index=1, trace_number=1)
scope_data_2 = TestProcessSawtooth2D.__dummy_scope_data(time_data, resolution[1], period, width[1])
data_array_2 = TestProcessSawtooth2D.__dummy_data_array(set_array, scope_data_2, channel_index=2, trace_number=2)
data_set = DataSet()
data_set.user_data = {'resolution': resolution, 'width': width}
data_set.add_array(data_array_1)
data_set.add_array(data_array_2)
return data_set
def test_sync_from_storage_array_update(self):
mock_queue = MagicMock()
with patch('qilib.data_set.mongo_data_set_io_reader.MongoDataSetIO') as mock_io, patch(
'qilib.data_set.mongo_data_set_io_reader.Thread') as thread, \
patch('qilib.data_set.mongo_data_set_io_reader.Queue', return_value=mock_queue):
reader = MongoDataSetIOReader(name='test')
thread.assert_called_once()
mock_io.assert_called_once_with('test',
None,
create_if_not_found=False,
collection='data_sets',
database='qilib')
data_set = DataSet(storage_reader=reader)
data_array = DataArray(name='test_array',
label='lab',
shape=(2, 2))
data_set.add_array(data_array)
mock_queue.get.return_value = {
'updateDescription': {
'updatedFields': {
'array_updates': [[[0, 0], {
'test_array': 42
}], [[0, 1], {
'test_array': 25
}]]
}
}
}
data_set.sync_from_storage(-1)
self.assertListEqual([42, 25], list(data_set.test_array[0]))
mock_queue.get.return_value = {
'updateDescription': {
'updatedFields': {
'array_updates.1': [1, {
'test_array': [67, 67]
}]
}
}
}
data_set.sync_from_storage(-1)
self.assertListEqual([67, 67], list(data_set.test_array[1]))
def run_process(self, signal_data: DataSet) -> DataSet:
""" Extracts a 2D image from a readout dot responce measured with an acquisition device.
Args:
signal_data: The readout dot reponse data coming from the acquisition device. The data
user data of the data set should contain the width and resolution settings.
Returns:
A data set which contains a 2D image with the charge stability diagram.
"""
width_x, width_y = signal_data.user_data['width']
resolution_x, resolution_y = signal_data.user_data['resolution']
output_signal_data = DataSet(user_data=signal_data.user_data)
for data_array in signal_data.data_arrays.values():
ProcessSawtooth2D.__check_sample_count_slow_sawtooth(
data_array, width_y)
ProcessSawtooth2D.__check_sample_count_fast_sawtooth(
data_array, width_x, resolution_x, resolution_y)
ProcessSawtooth2D.__check_matching_cuttoff(width_x, width_y,
resolution_x,
resolution_y)
sample_count = len(data_array)
samples_sawtooth_x = int(sample_count / resolution_y)
samples_edge_x = int(sample_count / resolution_y * width_x)
samples_egde_y = int(sample_count * width_y)
offsets = np.arange(0,
samples_egde_y,
samples_sawtooth_x,
dtype=np.int)
identifier = f'{data_array.name}_SawtoothProcessed2D'
sliced_data = np.array(
[data_array[o:o + samples_edge_x] for o in offsets])
result_data = DataArray(identifier,
data_array.label,
preset_data=sliced_data)
output_signal_data.add_array(result_data)
return output_signal_data
def test_save_to_storage(self):
data_set = DataSet()
data_set.name = 'TheName'
data_set.time_stamp = datetime.datetime(2018, 12, 24, 18)
data_set.user_data = {'Data': 'stuff'}
data_set.default_array_name = 'TheDefault'
data_set.add_array(self.data_array)
writer = MagicMock()
data_set.add_storage_writer(writer)
expected_calls = [
call.sync_metadata_to_storage('name', 'TheName'),
call.sync_metadata_to_storage('time_stamp',
datetime.datetime(2018, 12, 24, 18)),
call.sync_metadata_to_storage('user_data', {'Data': 'stuff'}),
call.sync_metadata_to_storage('default_array_name', 'TheDefault')
]
writer.assert_has_calls(expected_calls)
writer.sync_add_data_array_to_storage.assert_called()
def run_process(self, signal_data: DataSet) -> DataSet:
""" Extracts a 1D image from a readout dot responce measured with an acquisition device
Args:
signal_data: The readout dot reponse data coming from the acquisition device. The data
user data of the data set should contain the width and resolution settings.
Returns:
A data set which contains a 1D image with the charge stability diagram
"""
data_set = DataSet(user_data=signal_data.user_data)
width = data_set.user_data['width']
for data_array in signal_data.data_arrays.values():
sample_count = len(data_array)
sliced_data = data_array[:int(sample_count * width)]
identifier = f'{data_array.name}_SawtoothProcessed1D'
data_set.add_array(DataArray(identifier, data_array.label, preset_data=sliced_data))
return data_set
def test_add_array_set_arrays_mismatch(self):
some_points = DataArray('some_points',
'label',
is_setpoint=True,
preset_data=np.array([1, 2, 3, 4, 5]))
some_array = DataArray('some_array',
'label',
set_arrays=[some_points],
shape=(5, ))
other_points = DataArray('other_points',
'label',
is_setpoint=True,
preset_data=np.array([1, 2, 3, 4, 5]))
other_array = DataArray('other_array',
'label',
set_arrays=[other_points],
shape=(5, ))
data_set = DataSet()
data_set.add_array(some_array)
with self.assertRaises(ValueError) as error:
data_set.add_array(other_array)
self.assertEqual(("Set point arrays do not match.", ),
error.exception.args)
set_arrays=[set_array])
data_set = DataSet()
data_set.user_data = {
'resolution': resolution,
'width': width,
'processing': processing
}
data_array_x = create_dummy_data_array(width=width[0],
processing=processing,
sawteeth_count=1,
channel_index=1,
trace_number=1)
data_set.add_array(data_array_x)
data_array_y = create_dummy_data_array(width=width[1],
processing=processing,
sawteeth_count=resolution[1],
channel_index=2,
trace_number=2)
data_set.add_array(data_array_y)
# EXAMPLE PRCCESSING 2D SAWTOOTH
signal_processor = SignalProcessorRunner()
signal_processor.add_signal_processor(ProcessSawtooth2D())
processed_data_set = signal_processor.run(data_set)
# PLOTTING
