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