def process_dataarray(
dataset: DataSet,
input_array_name: str,
output_array_name: Optional[str],
processing_function: Callable,
label: Optional[str] = None,
unit: Optional[str] = None,
) -> DataSet:
""" Apply a function to a DataArray in a DataSet
Args:
dataset: Input dataset containing the data array
input_array_name: Name of the data array to be processed
output_array_nane: Name of the output array or None to operate in place
processing_function: Method to apply to the data array
label: Label for the output array
unit: Unit for the output array
"""
array = dataset.default_parameter_array(input_array_name)
data = processing_function(np.array(array))
if label is None:
label = array.label
if unit is None:
unit = array.unit
if output_array_name is None:
array.ndarray[:] = data
else:
data_array = DataArray(array_id=output_array_name,
name=output_array_name,
label=label,
set_arrays=array.set_arrays,
preset_data=data,
unit=unit)
dataset.add_array(data_array)
return dataset
def test_reading_into_existing_data_array(self):
data = DataSet1D(location=self.loc_provider, name='test_read_existing')
# closing before file is written should not raise error
self.formatter.write(data)
data2 = DataSet(location=data.location, formatter=self.formatter)
d_array = DataArray(
name='dummy',
array_id='x_set', # existing array id in data
label='bla',
unit='a.u.',
is_setpoint=False,
set_arrays=(),
preset_data=np.zeros(5))
data2.add_array(d_array)
# test if d_array refers to same as array x_set in dataset
self.assertTrue(d_array is data2.arrays['x_set'])
data2.read()
# test if reading did not overwrite dataarray
self.assertTrue(d_array is data2.arrays['x_set'])
# Testing if data was correctly updated into dataset
self.checkArraysEqual(data2.arrays['x_set'], data.arrays['x_set'])
self.checkArraysEqual(data2.arrays['y'], data.arrays['y'])
self.formatter.close_file(data)
self.formatter.close_file(data2)
def test_to_server(self, gdm_mock):
mock_dm = MockDataManager()
mock_dm.needs_restart = True
gdm_mock.return_value = mock_dm
data = DataSet(location='Venus',
data_manager=True,
mode=DataMode.PUSH_TO_SERVER)
self.assertEqual(mock_dm.needs_restart, False, data)
self.assertEqual(mock_dm.data_set, data)
self.assertEqual(data.data_manager, mock_dm)
self.assertEqual(data.mode, DataMode.PUSH_TO_SERVER)
# cannot write except in LOCAL mode
with self.assertRaises(RuntimeError):
data.write()
# now do what the DataServer does with this DataSet: init_on_server
# fails until there is an array
with self.assertRaises(RuntimeError):
data.init_on_server()
data.add_array(MockArray())
data.init_on_server()
self.assertEqual(data.noise.ready, True)
# we can only add a given array_id once
with self.assertRaises(ValueError):
data.add_array(MockArray())
def convert_to_probability(
data_set,
location,
NewIO,
formatter,
threshold,
qubit_num=1,
repetition=100,
):
for parameter in data_set.arrays:
if len(data_set.arrays[parameter].ndarray.shape
) == 2 and parameter.endswith('set'):
data_set_new = DataSet(location=location +
'_average_probability_' + parameter,
io=NewIO,
formatter=formatter)
# data_set = convert_to_01_state(data_set, threshold, qubit_num, repetition, name, unit, sweep_array)
qubit_data_array = []
set_array = []
for parameter in data_set.arrays:
data_array = data_set.arrays[parameter].ndarray
dimension_1 = data_array.shape[0]
arrayid = data_set.arrays[parameter].array_id
if parameter.endswith(
'set'): ## or data_set.arrays[parameter].is_setpoint
set_array.append(
DataArray(preset_data=data_array,
name=parameter,
array_id=arrayid,
is_setpoint=True))
elif not parameter.endswith('set'):
dimension_2 = data_array.shape[1]
probability_data = np.ndarray(shape=(dimension_1, dimension_2))
for k in range(dimension_1):
for l in range(dimension_2):
probability_data[k][l] = np.average(data_array[k][l])
qubit_data_array.append(
DataArray(preset_data=probability_data,
name=parameter,
array_id=arrayid,
is_setpoint=False))
for array in set_array:
data_set_new.add_array(array)
for q in range(qubit_num):
data_set_new.add_array(qubit_data_array[q])
return data_set_new
def convert_to_01_state(data_set, threshold, qubit_num=1, repetition=100):
#data_set = convert_to_ordered_data(data_set, qubit_num, repetition, name, unit, sweep_array)
qubit_data_array = []
set_array = []
for parameter in data_set.arrays:
data_array = data_set.arrays[parameter].ndarray
dimension_1 = data_array.shape[0]
array_id = data_set.arrays[parameter].array_id
if parameter.endswith(
'set'): ## or data_set.arrays[parameter].is_setpoint
set_array.append(
DataArray(preset_data=data_array,
name=parameter,
array_id=array_id,
is_setpoint=True))
elif not parameter.endswith('set'):
dimension_2 = data_array.shape[1]
data = np.ndarray(shape=(dimension_1, dimension_2, repetition))
for k in range(dimension_1):
for l in range(dimension_2):
for j in range(repetition):
data[k][l][j] = 1 if np.min(
data_array[k][l][j * seg_size:(j + 1) *
seg_size]) <= threshold else 0
qubit_data_array.append(
DataArray(preset_data=data,
name=parameter,
array_id=array_id,
is_setpoint=False))
data_set_new = DataSet(location=new_location + '_01_state',
io=NewIO,
formatter=formatter)
for array in set_array:
data_set_new.add_array(array)
for q in range(qubit_num):
data_set_new.add_array(qubit_data_array[q])
return data_set_new
def average_probability(data_set, location, NewIO, formatter, qubit_num=1):
for parameter in data_set.arrays:
if len(data_set.arrays[parameter].ndarray.shape
) == 2 and parameter.endswith('set'):
data_set_new = DataSet(location=location +
'_average_probability_data_' + parameter,
io=NewIO,
formatter=formatter)
for parameter in data_set.arrays:
if len(data_set.arrays[parameter].ndarray.shape) == 2:
data = deepcopy(data_set.arrays[parameter].ndarray)
data = np.average(data, axis=0)
is_setpoint = data_set.arrays[parameter].is_setpoint
name = data_set.arrays[parameter].name
array_id = data_set.arrays[parameter].array_id
data_set_new.add_array(
DataArray(preset_data=data,
name=name,
array_id=array_id,
is_setpoint=is_setpoint))
return data_set_new
def majority_vote(data_set,
threshold,
qubit_num=1,
repetition=100,
name='frequency',
unit='GHz',
sweep_array=None,
average=False):
data_set = convert_to_01_state(data_set, threshold, qubit_num, repetition,
name, unit, sweep_array)
set_array = []
for parameter in data_set.arrays:
data_array = data_set.arrays[parameter].ndarray
dimension_1 = data_array.shape[0]
arrayid = data_set.arrays[parameter].array_id
if parameter.endswith(
'set'): ## or data_set.arrays[parameter].is_setpoint
set_array.append(
DataArray(preset_data=data_array,
name=parameter,
array_id=arrayid,
is_setpoint=True))
dimension_2 = len(sweep_array) if sweep_array is not None else 2
# dimension_1 = 5
vote_data = np.ndarray(shape=(dimension_1, dimension_2, repetition))
average_vote_data = np.ndarray(shape=(dimension_1, dimension_2))
name = 'vote'
arrayid = 'vote'
for k in range(dimension_1):
for l in range(dimension_2):
for repe in range(repetition):
voter = np.array([
data_set.digitizerqubit_1[k][l][repe],
data_set.digitizerqubit_2[k][l][repe],
data_set.digitizerqubit_3[k][l][repe],
])
vote_data[k][l][repe] = 1 if np.sum(voter) >= 2 else 0
if average:
average_vote_data[k][l] = np.average(vote_data[k][l])
print('average: ', average_vote_data[k][l])
data = vote_data if not average else average_vote_data
vote_data_array = DataArray(preset_data=data,
name=name,
array_id=arrayid,
is_setpoint=False)
data_set_new = DataSet(location=new_location,
io=NewIO,
formatter=formatter)
for array in set_array:
data_set_new.add_array(array)
data_set_new.add_array(vote_data_array)
return data_set_new
def convert_to_ordered_data(data_set,
qubit_num=1,
repetition=100,
name='frequency',
unit='GHz',
sweep_array=None):
qubit_data_array = []
set_array = []
for parameter in data_set.arrays:
data_array = data_set.arrays[parameter].ndarray
dimension_1 = data_array.shape[0]
array_name = parameter
array_id = data_set.arrays[parameter].array_id
if parameter.endswith('set'):
if data_array.ndim == 2 and parameter.startswith('index'):
dimension_2 = int(data_array.shape[-1] / 2 / (repetition + 1) /
seg_size / qubit_num)
sweep_array = sweep_array if sweep_array is not None else np.linspace(
0, dimension_2 - 1, dimension_2)
data_array = np.array(
[sweep_array for k in range(dimension_1)])
array_name = name + '_set'
array_id = name + '_set'
if data_array.ndim != 3 or not parameter.startswith('index'):
set_array.append(
DataArray(preset_data=data_array,
name=array_name,
array_id=array_id,
is_setpoint=True))
elif not parameter.endswith('set') and data_array.ndim == 2:
data_num = int(data_array.shape[-1] / 2 / (repetition + 1) *
repetition)
qubit_data_num = int(data_num / qubit_num)
dimension_2 = int(data_array.shape[-1] / 2 / (repetition + 1) /
seg_size / qubit_num)
qubit_data = np.ndarray(shape=(qubit_num, dimension_1, dimension_2,
int(qubit_data_num / dimension_2)))
for k in range(dimension_1):
raw_data = data_array[k][::2]
raw_marker = data_array[k][1::2]
for seg in range(seg_size * qubit_num * dimension_2):
if raw_marker[seg] > 0.2: ## a better threshold ???
break
data = raw_data[seg:data_num + seg]
print('seg', seg)
data_reshape = data.reshape(int(data_num / seg_size), seg_size)
print('data_shape', data_reshape.shape)
for l in range(dimension_2):
for q in range(qubit_num):
qubit_data[q][k][l] = data_reshape[qubit_num * l +
q::dimension_2 *
qubit_num].reshape(
seg_size *
repetition, )
n = 2 if q == 0 else q
if q >= 2:
n = q + 1
qubit_data_array.append(
DataArray(preset_data=qubit_data[q],
name=parameter + 'qubit_%d' % (n),
array_id=array_id + 'qubit_%d' % (n),
is_setpoint=False))
elif not parameter.endswith('set') and data_array.ndim == 3:
data_num = int(data_array.shape[-1] / 2 / (repetition + 1) *
repetition)
qubit_data_num = int(data_num / qubit_num)
dimension_2 = data_array.shape[1]
print('qubit_num, dimension_1, dimension_2, int(qubit_data_num)',
qubit_num, dimension_1, dimension_2, int(qubit_data_num))
qubit_data = np.ndarray(shape=(qubit_num, dimension_1, dimension_2,
int(qubit_data_num)))
for k in range(dimension_1):
for l in range(dimension_2):
raw_data = data_array[k][l][::2]
raw_marker = data_array[k][l][1::2]
for seg in range(seg_size * qubit_num):
if raw_marker[seg] > 0.2: ## a better threshold ???
break
data = raw_data[
seg:data_num +
seg] ## here data consists both data from qubit1 and qubit2
for q in range(qubit_num):
data_reshape = data.reshape(int(data_num / seg_size),
seg_size)
qubit_data[q][k][l] = data_reshape[
q::qubit_num].reshape(seg_size * repetition, )
n = 2 if q == 0 else q
qubit_data_array.append(
DataArray(preset_data=qubit_data[q],
name=parameter + 'qubit_%d' % (n),
array_id=array_id + 'qubit_%d' % (n),
is_setpoint=False))
data_set_new = DataSet(location=new_location + '_ordered_raw_data',
io=NewIO,
formatter=formatter)
for array in set_array:
data_set_new.add_array(array)
for q in range(qubit_num):
data_set_new.add_array(qubit_data_array[q])
return data_set_new
def convert_to_probability(data_set,
threshold,
loop_num,
qubit_num=1,
name='frequency',
unit='GHz',
sweep_array=None):
data_set = convert_to_01_state(data_set, threshold, loop_num, qubit_num,
name, unit, sweep_array)
qubit_data_array = []
for parameter in data_set.arrays:
data_array = data_set.arrays[parameter]
dimension_1 = data_array.shape[0]
arrayid = data_set.arrays[parameter].array_id
if parameter[
-3:] == 'set': ## or data_set.arrays[parameter].is_setpoint
if len(data_array.shape) == 1:
set_array1 = DataArray(preset_data=data_array.ndarray,
name=parameter,
array_id=arrayid,
is_setpoint=True)
if len(data_array.shape
) == 2 and not parameter.startswith('index'):
set_array2 = DataArray(preset_data=data_array.ndarray,
name=parameter,
array_id=arrayid,
is_setpoint=True)
elif parameter[-3:] != 'set':
seg_num = int(data_set.arrays[parameter].shape[1])
data = np.ndarray(shape=(dimension_1, loop_num))
setpara = np.ndarray(shape=(dimension_1, loop_num))
for k in range(dimension_1):
# data_k = []
# setpara_k = []
state = np.ndarray(shape=(loop_num, int(seg_num / loop_num)))
for i in range(seg_num):
loop = i % loop_num
sweep = i // loop_num
state[loop][sweep] = data_array.ndarray[k][i]
for j in range(loop_num):
setpara[k][j] = j
probability = np.average(state[j])
data[k][j] = probability
if loop_num > 1 and sweep_array is not None:
setpara[k] = sweep_array
set_array3 = DataArray(preset_data=setpara,
name=name,
array_id=name + '_set',
is_setpoint=True)
# if loop_num == 1:
# data = data.T[0]
qubit_data_array.append(
DataArray(preset_data=data,
name=parameter,
array_id=arrayid,
is_setpoint=False))
data_set_new = DataSet(location=new_location,
io=NewIO,
formatter=formatter)
data_set_new.add_array(set_array1)
data_set_new.add_array(set_array2)
if loop_num > 1:
data_set_new.add_array(set_array3)
for q in range(qubit_num):
data_set_new.add_array(qubit_data_array[q])
return data_set_new
def convert_to_01_state(data_set,
threshold,
loop_num,
qubit_num,
name='frequency',
unit='GHz',
sweep_array=None):
data_set = convert_to_ordered_data(data_set, loop_num, qubit_num, name,
unit, sweep_array)
qubit_data_array = []
for parameter in data_set.arrays:
data_array = data_set.arrays[parameter]
dimension_1 = data_array.shape[0]
arrayid = data_set.arrays[parameter].array_id
if parameter[
-3:] == 'set': ## or data_set.arrays[parameter].is_setpoint
if len(data_array.shape) == 1:
set_array1 = DataArray(preset_data=data_array.ndarray,
name=parameter,
array_id=arrayid,
is_setpoint=True)
elif len(data_array.shape
) == 2 and not parameter.startswith('index'):
set_array2 = DataArray(preset_data=data_array.ndarray,
name=parameter,
array_id=arrayid,
is_setpoint=True)
elif parameter[-3:] != 'set':
seg_num = int(data_set.arrays[parameter].shape[1] / seg_size)
data = np.ndarray(shape=(dimension_1, seg_num))
setpara = np.ndarray(shape=(dimension_1, seg_num))
for k in range(dimension_1):
for j in range(seg_num):
setpara[k][j] = j
for i in range(seg_size):
if data_array.ndarray[k][j * seg_size +
i] <= threshold:
data[k][j] = 1
break
if i == seg_size - 1:
data[k][j] = 0
set_array3 = DataArray(preset_data=setpara,
name=name,
array_id=name + '_set',
is_setpoint=True)
qubit_data_array.append(
DataArray(preset_data=data,
name=parameter,
array_id=arrayid,
is_setpoint=False))
data_set_new = DataSet(location=new_location,
io=NewIO,
formatter=formatter)
data_set_new.add_array(set_array1)
data_set_new.add_array(set_array2)
if loop_num > 1:
data_set_new.add_array(set_array3)
for q in range(qubit_num):
data_set_new.add_array(qubit_data_array[q])
return data_set_new
def convert_to_ordered_data(data_set,
loop_num,
qubit_num,
name='frequency',
unit='GHz',
sweep_array=None):
# Dimension = '1D'
for parameter in data_set.arrays:
data_array = data_set.arrays[parameter]
dimension_1 = data_array.shape[0]
arrayid = data_set.arrays[parameter].array_id
if parameter.endswith('set'):
if data_array.ndarray.ndim == 1:
set_array1 = DataArray(preset_data=data_array.ndarray,
name=parameter,
array_id=arrayid,
is_setpoint=True)
elif data_array.ndarray.ndim == 2 and not parameter.startswith(
'index'):
set_array2 = DataArray(preset_data=data_array.ndarray,
name=parameter,
array_id=arrayid,
is_setpoint=True)
elif not parameter.endswith('set'):
data_num = int(data_set.arrays[parameter].shape[1] / 2 /
(repetition + 1) * repetition)
qubit_data_num = int(data_num / qubit_num)
data = np.ndarray(shape=(dimension_1, data_num))
marker = np.ndarray(shape=(dimension_1, data_num))
setpara = np.ndarray(shape=(dimension_1, qubit_data_num))
qubit_data = np.ndarray(shape=(qubit_num, dimension_1,
qubit_data_num))
qubit_data_array = []
for k in range(dimension_1):
raw_data = data_array[k][::2]
raw_marker = data_array[k][1::2]
for seg in range(seg_size * loop_num):
if raw_marker[seg] > 0.1: ## a better threshold ???
break
data[k] = raw_data[seg:data_num + seg]
marker[k] = raw_marker[seg:data_num + seg]
if sweep_array is None:
setpara[k] = np.linspace(0, data_num - 1, qubit_data_num)
else:
sa = np.vstack(
[np.repeat(sweep_array, int(seg_size), axis=0)] *
repetition)
setpara[k] = sa.reshape(sa.size, )
if qubit_num > 1:
data_reshape = data[k].reshape(int(data_num / seg_size),
seg_size)
for q in range(qubit_num):
qubit_data[q][k] = np.append(
np.array([]), data_reshape[q::qubit_num])
elif qubit_num == 1:
qubit_data[0][k] = data[k]
set_array3 = DataArray(preset_data=setpara,
name=name,
array_id=name + '_set',
is_setpoint=True)
for q in range(qubit_num):
qubit_data_array.append(
DataArray(preset_data=qubit_data[q],
name=parameter + 'qubit_%d' % (q + 1),
array_id=arrayid + 'qubit_%d' % (q + 1),
is_setpoint=False))
data_set_new = DataSet(location=new_location,
io=NewIO,
formatter=formatter)
data_set_new.add_array(set_array1)
data_set_new.add_array(set_array2)
if loop_num != 1:
data_set_new.add_array(set_array3)
for q in range(qubit_num):
data_set_new.add_array(qubit_data_array[q])
# data_set_new.add_array(data_array4)
return data_set_new
