def plot_wave_raw(wave_raw, samplerate=None, station=None): ''' Plot the raw wave Arguments: wave_raw (array): raw data which represents the waveform Returns: plot (QtPlot): the plot showing the data ''' if samplerate is None: if station is None: raise Exception('There is no station') samplerate = 1 / station.awg.getattr('AWG_clock') else: samplerate = samplerate horz_var = np.arange(0, len(wave_raw) * samplerate, samplerate) x = DataArray(name='time(s)', label='time (s)', preset_data=horz_var, is_setpoint=True) y = DataArray(label='sweep value (mV)', preset_data=wave_raw, set_arrays=(x, )) plot = QtPlot(x, y) return plot
def test_nest_empty(self): data = DataArray() self.assertEqual(data.shape, ()) mock_set_array = 'not really an array but we don\'t check' mock_set_array2 = 'another one' data.nest(2, action_index=44, set_array=mock_set_array) data.nest(3, action_index=66, set_array=mock_set_array2) # the array doesn't exist until you initialize it self.assertIsNone(data.ndarray) # but other attributes are set self.assertEqual(data.shape, (3, 2)) self.assertEqual(data.action_indices, (66, 44)) self.assertEqual(data.set_arrays, (mock_set_array2, mock_set_array)) data.init_data() self.assertEqual(data.ndarray.shape, (3, 2)) # after initializing data, you can't nest anymore because this isn't # a preset array with self.assertRaises(RuntimeError): data.nest(4)
def test_full_write(self): formatter = GNUPlotFormat() location = self.locations[0] data = DataSet1D(name="test_full_write", location=location) formatter.write(data, data.io, data.location) with open(location + '/x_set.dat') as f: self.assertEqual(f.read(), file_1d()) # check that we can add comment lines randomly into the file # as long as it's after the first three lines, which are comments # with well-defined meaning, # and that we can un-quote the labels lines = file_1d().split('\n') lines[1] = lines[1].replace('"', '') lines[3:3] = ['# this data is awesome!'] lines[6:6] = ['# the next point is my favorite.'] with open(location + '/x_set.dat', 'w') as f: f.write('\n'.join(lines)) # normally this would be just done by data2 = load_data(location) # but we want to work directly with the Formatter interface here data2 = DataSet(location=location) formatter.read(data2) self.checkArraysEqual(data2.x_set, data.x_set) self.checkArraysEqual(data2.y, data.y) # data has been saved self.assertEqual(data.y.last_saved_index, 4) # data2 has been read back in, should show the same # last_saved_index self.assertEqual(data2.y.last_saved_index, 4) # while we're here, check some errors on bad reads # first: trying to read into a dataset that already has the # wrong size x = DataArray(name='x_set', label='X', preset_data=(1., 2.)) y = DataArray(name='y', label='Y', preset_data=(3., 4.), set_arrays=(x, )) data3 = new_data(arrays=(x, y), location=location + 'XX') # initially give it a different location so we can make it without # error, then change back to the location we want. data3.location = location with LogCapture() as logs: formatter.read(data3) self.assertTrue('ValueError' in logs.value, logs.value) # no problem reading again if only data has changed, it gets # overwritten with the disk copy data2.x_set[2] = 42 data2.y[2] = 99 formatter.read(data2) self.assertEqual(data2.x_set[2], 3) self.assertEqual(data2.y[2], 5)
def makeDataSet2Dplain(xname, x, yname, y, zname='measured', z=None, xunit=None, yunit=None, zunit=None, location=None, loc_record=None): """ Make DataSet with one 2D array and two setpoint arrays Arguments: xname (string): the name of the setpoint x array. x (array or ndarray or list): the x setpoint data. yname (string): the name of the setpoint y array. y (array or ndarray or list): the y setpoint data. zname (str or list of str): the name of the measured array. z (array or list or None): optional the measured data. xunit (str or None): optional, the unit of the values stored in x. yunit (str or None): optional, the unit of the values stored in y. zunit (str or None): optional, the unit of the measured data. location (str, callable, bool or None): If you provide a string, it must be an unused location in the io manager. Can also be: - a callable `location provider` with one required parameter \ (the io manager), and one optional (`record` dict), \ which returns a location string when called. - `False` - denotes an only-in-memory temporary DataSet. loc_record (dict or None): If location is a callable, this will be passed to it as `record`. Raises: See _make_data_set for the ValueError and TypeError exceptions that can be raised Returns: The resulting dataset. """ setpoint_datay = np.array(y) setpoint_datax = np.array(x) setpoint_dataxy = np.tile(setpoint_datax, [setpoint_datay.size, 1]) preset_data = np.NaN * np.ones((setpoint_datay.size, setpoint_datax.size)) setpointy = DataArray(name=yname, array_id=yname, preset_data=setpoint_datay, unit=yunit, is_setpoint=True) setpointx = DataArray(name=xname, array_id=xname, preset_data=setpoint_dataxy, unit=xunit, set_arrays=(setpointy,), is_setpoint=True) if isinstance(zname, (str, qcodes.Parameter)): if isinstance(z, np.ndarray): measured_data_list = [z] else: measured_data_list = z measurement_list = [zname] else: measured_data_list = z measurement_list = zname measurement_unit = zunit data_set, _ = _make_data_set(measured_data_list, measurement_list, measurement_unit, location, loc_record, preset_data, [setpointy, setpointx]) data_set.last_write = -1 return data_set
def test_init_data_error(self): data = DataArray(preset_data=[1, 2]) data.shape = (3, ) # not sure when this would happen... but if you call init_data # and it notices an inconsistency between shape and the actual # data that's already there, it raises an error with self.assertRaises(ValueError): data.init_data()
def test_attributes(self): pname = 'Betty Sue' plabel = 'The best apple pie this side of Wenatchee' pfullname = 'bert' class MockParam: name = pname label = plabel def __init__(self, full_name=None): self.full_name = full_name name = 'Oscar' label = 'The grouch. GRR!' fullname = 'ernie' array_id = 24601 set_arrays = ('awesomeness', 'chocolate content') shape = 'Ginornous' action_indices = (1, 2, 3, 4, 5) p_data = DataArray(parameter=MockParam(pfullname), name=name, label=label, full_name=fullname) p_data2 = DataArray(parameter=MockParam(pfullname)) # explicitly given name and label override parameter vals self.assertEqual(p_data.name, name) self.assertEqual(p_data.label, label) self.assertEqual(p_data.full_name, fullname) self.assertEqual(p_data2.name, pname) self.assertEqual(p_data2.label, plabel) self.assertEqual(p_data2.full_name, pfullname) # test default values self.assertIsNone(p_data.array_id) self.assertEqual(p_data.shape, ()) self.assertEqual(p_data.action_indices, ()) self.assertEqual(p_data.set_arrays, ()) self.assertIsNone(p_data.ndarray) np_data = DataArray(name=name, label=label, array_id=array_id, set_arrays=set_arrays, shape=shape, action_indices=action_indices) self.assertEqual(np_data.name, name) self.assertEqual(np_data.label, label) # no full name or parameter - use name self.assertEqual(np_data.full_name, name) # test simple assignments self.assertEqual(np_data.array_id, array_id) self.assertEqual(np_data.set_arrays, set_arrays) self.assertEqual(np_data.shape, shape) self.assertEqual(np_data.action_indices, action_indices) name_data = DataArray(name=name) self.assertEqual(name_data.label, name) blank_data = DataArray() self.assertIsNone(blank_data.name)
def test_edit_and_mark(self): data = DataArray(preset_data=[[1, 2], [3, 4]]) self.assertEqual(data[0].tolist(), [1, 2]) self.assertEqual(data[0, 1], 2) data.modified_range = None self.assertIsNone(data.last_saved_index) self.assertEqual(len(data), 2) data[0] = np.array([5, 6]) data[1, 0] = 7 self.assertEqual(data.ndarray.tolist(), [[5, 6], [7, 4]]) self.assertEqual(data.modified_range, (0, 2)) # as if we saved the first two points... the third should still # show as modified data.mark_saved(1) self.assertEqual(data.last_saved_index, 1) self.assertEqual(data.modified_range, (2, 2)) # now we save the third point... no modifications left. data.mark_saved(2) self.assertEqual(data.last_saved_index, 2) self.assertEqual(data.modified_range, None) data.clear_save() self.assertEqual(data.last_saved_index, None) self.assertEqual(data.modified_range, (0, 2))
def DataSetCombined(location=None, name=None): # Complex DataSet with two 1D and two 2D arrays x = DataArray(name='x', label='X!', preset_data=(16., 17.), is_setpoint=True) y1 = DataArray(name='y1', label='Y1 value', preset_data=(18., 19.), set_arrays=(x, )) y2 = DataArray(name='y2', label='Y2 value', preset_data=(20., 21.), set_arrays=(x, )) yset = DataArray(name='y', label='Y', preset_data=(22., 23., 24.), is_setpoint=True) yset.nest(2, 0, x) z1 = DataArray(name='z1', label='Z1', preset_data=((25., 26., 27.), (28., 29., 30.)), set_arrays=(x, yset)) z2 = DataArray(name='z2', label='Z2', preset_data=((31., 32., 33.), (34., 35., 36.)), set_arrays=(x, yset)) return new_data(arrays=(x, y1, y2, yset, z1, z2), location=location, name=name)
def test_edit_and_mark_slice(self): data = DataArray(preset_data=[[1] * 5] * 6) self.assertEqual(data.shape, (6, 5)) data.modified_range = None data[:4:2, 2:] = 2 self.assertEqual(data.tolist(), [[1, 1, 2, 2, 2], [1, 1, 1, 1, 1], [1, 1, 2, 2, 2], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]]) self.assertEqual(data.modified_range, (2, 14))
def test_repr(self): array2d = [[1, 2], [3, 4]] arrayrepr = repr(np.array(array2d)) array_id = (3, 4) data = DataArray(preset_data=array2d) self.assertEqual(repr(data), 'DataArray[2,2]:\n' + arrayrepr) data.array_id = array_id self.assertEqual(repr(data), 'DataArray[2,2]: ' + str(array_id) + '\n' + arrayrepr)
def resampleImage(im): """ Resample the image so it has the similar sample rates (samples/mV) in both axis. Args: im (DataArray): input image. Returns: imr (numpy array): resampled image. setpoints (list of 2 numpy arrays): setpoint arrays from resampled image. """ setpoints = im.set_arrays mVrange = [abs(setpoints[0][-1] - setpoints[0][0]), abs(setpoints[1][0, -1] - setpoints[1][0, 0])] samprates = [im.shape[0] // mVrange[0], im.shape[1] // mVrange[1]] factor = int(max(samprates) // min(samprates)) if factor >= 2: axis = int(samprates[0] - samprates[1] < 0) if axis == 0: facrem = im.shape[0] % factor if facrem > 0: im = im[:-facrem, :] facrem = facrem + 1 im = im.reshape(im.shape[0] // factor, factor, im.shape[1]).mean(1) spy = np.linspace(setpoints[0][0], setpoints[ 0][-facrem], im.shape[0]) spx = np.tile(np.expand_dims(np.linspace( setpoints[1][0, 0], setpoints[1][0, -1], im.shape[1]), 0), im.shape[0]) setpointy = DataArray(name='Resampled_' + setpoints[0].array_id, array_id='Resampled_' + setpoints[0].array_id, label=setpoints[0].label, unit=setpoints[0].unit, preset_data=spy, is_setpoint=True) setpointx = DataArray(name='Resampled_' + setpoints[1].array_id, array_id='Resampled_' + setpoints[1].array_id, label=setpoints[1].label, unit=setpoints[1].unit, preset_data=spx, is_setpoint=True) setpoints = [setpointy, setpointx] else: facrem = im.shape[1] % factor if facrem > 0: im = im[:, :-facrem] facrem = facrem + 1 im = im.reshape(im.shape[0], im.shape[1] // factor, factor).mean(-1) spx = np.tile(np.expand_dims(np.linspace(setpoints[1][0, 0], setpoints[ 1][0, -facrem], im.shape[1]), 0), [im.shape[0], 1]) idx = setpoints[1].array_id if idx is None: idx = 'x' idy = setpoints[1].array_id if idy is None: idy = 'y' setpointx = DataArray(name='Resampled_' + idx, array_id='Resampled_' + idy, label=setpoints[1].label, unit=setpoints[1].unit, preset_data=spx, is_setpoint=True) setpoints = [setpoints[0], setpointx] return im, setpoints
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 test_array(self): # DataSet with one 2D array with 4 x 6 points yy, xx = np.meshgrid(np.arange(0, 10, .5), range(3)) zz = xx ** 2 + yy ** 2 # outer setpoint should be 1D xx = xx[:, 0] x = DataArray(name='x', label='X', preset_data=xx, is_setpoint=True) y = DataArray(name='y', label='Y', preset_data=yy, set_arrays=(x,), is_setpoint=True) z = DataArray(name='z', label='Z', preset_data=zz, set_arrays=(x, y)) self.assertTrue(z.size, 60) self.assertTupleEqual(z.shape, (3, 20)) return z
def DataSet2D(location=None, name=None): # DataSet with one 2D array with 4 x 6 points yy, xx = numpy.meshgrid(range(4), range(6)) zz = xx**2 + yy**2 # outer setpoint should be 1D xx = xx[:, 0] x = DataArray(name='x', label='X', preset_data=xx, is_setpoint=True) y = DataArray(name='y', label='Y', preset_data=yy, set_arrays=(x, ), is_setpoint=True) z = DataArray(name='z', label='Z', preset_data=zz, set_arrays=(x, y)) return new_data(arrays=(x, y, z), location=location, name=name)
def fit_addition_line(dataset, trimborder=True): """Fits a FermiLinear function to the addition line and finds the middle of the step. Args: dataset (qcodes dataset): The 1d measured data of addition line. trimborder (bool): determines if the edges of the data are taken into account for the fit. Returns: m_addition_line (float): x value of the middle of the addition line result_dict (dict): dictionary with the following results: fit parameters (array): fit parameters of the Fermi Linear function parameters initial guess (array): parameters of initial guess dataset fit (qcodes dataset): dataset with fitted Fermi Linear function dataset initial guess (qcodes dataset):dataset with guessed Fermi Linear function See also: FermiLinear and fitFermiLinear """ y_array = dataset.default_parameter_array() setarray = y_array.set_arrays[0] x_data = np.array(setarray) y_data = np.array(y_array) if trimborder: cut_index = max(min(int(x_data.size / 40), 100), 1) x_data = x_data[cut_index:-cut_index] y_data = y_data[cut_index:-cut_index] setarray = setarray[cut_index:-cut_index] m_addition_line, result_dict = fit_addition_line_array(x_data, y_data, trimborder=False) y_initial_guess = FermiLinear( x_data, *list(result_dict['parameters initial guess'])) dataset_guess = DataArray(name='fit', label='fit', preset_data=y_initial_guess, set_arrays=(setarray, )) y_fit = FermiLinear(x_data, *list(result_dict['fit parameters'])) dataset_fit = DataArray(name='fit', label='fit', preset_data=y_fit, set_arrays=(setarray, )) return m_addition_line, { 'dataset fit': dataset_fit, 'dataset initial guess': dataset_guess }
def DataSet1D(location=None, name=None): # DataSet with one 1D array with 5 points # TODO: since y lists x as a set_array, it should automatically # set is_setpoint=True for x, shouldn't it? Any reason we woundn't # want that? x = DataArray(name='x', label='X', preset_data=(1., 2., 3., 4., 5.), is_setpoint=True) y = DataArray(name='y', label='Y', preset_data=(3., 4., 5., 6., 7.), set_arrays=(x, )) return new_data(arrays=(x, y), location=location, name=name)
def _make_setpoint_array(self, shape, i, prev_setpoints, vals, name, label, unit): if vals is None: vals = self._default_setpoints(shape) elif isinstance(vals, DataArray): # can't simply use the DataArray, even though that's # what we're going to return here, because it will # get nested (don't want to alter the original) # DataArrays do have the advantage though of already including # name and label, so take these if they exist if vals.name is not None: name = vals.name if vals.label is not None: label = vals.label # extract a copy of the numpy array vals = np.array(vals.ndarray) else: # turn any sequence into a (new) numpy array vals = np.array(vals) if vals.shape != shape: raise ValueError('nth setpoint array should have shape matching ' 'the first n dimensions of shape.') if name is None: name = 'index{}'.format(i) return DataArray(name=name, label=label, set_arrays=prev_setpoints, shape=shape, preset_data=vals, unit=unit, is_setpoint=True)
def test_default_parameter(self): # Test whether the default_array function works m = DataSet2D() # test we can run with default arguments name = m.default_parameter_name() # test with paramname name = m.default_parameter_name(paramname='z') self.assertEqual(name, 'z') # test we can get the array instead of the name array = m.default_parameter_array(paramname='z') self.assertEqual(array, m.z) # first non-setpoint array array = m.default_parameter_array() self.assertEqual(array, m.z) # test with metadata m.metadata = dict({'default_parameter_name': 'x_set'}) name = m.default_parameter_name() self.assertEqual(name, 'x_set') # test the fallback: no name matches, no non-setpoint array x = DataArray(name='x', label='X', preset_data=(1., 2., 3., 4., 5.), is_setpoint=True) m = new_data(arrays=(x, ), name='onlysetpoint') name = m.default_parameter_name(paramname='dummy') self.assertEqual(name, 'x_set')
def test_default_parameter(self): loc_fmt = 'data/{date}/#{counter}_{name}_{date}_{time}' rcd = {'name': 'test_default_parameter'} loc_provider = FormatLocation(fmt=loc_fmt, record=rcd) # Test whether the default_array function works m = DataSet2D(location=loc_provider) # test we can run with default arguments name = m.default_parameter_name() # test with paramname name = m.default_parameter_name(paramname='z') self.assertEqual(name, 'z') # test we can get the array instead of the name array = m.default_parameter_array(paramname='z') self.assertEqual(array, m.z) # first non-setpoint array array = m.default_parameter_array() self.assertEqual(array, m.z) # test with metadata m.metadata = dict({'default_parameter_name': 'x_set'}) name = m.default_parameter_name() self.assertEqual(name, 'x_set') # test the fallback: no name matches, no non-setpoint array x = DataArray(name='x', label='X', preset_data=(1., 2., 3., 4., 5.), is_setpoint=True) m = new_data(arrays=(x, ), name='onlysetpoint') name = m.default_parameter_name(paramname='dummy') self.assertEqual(name, 'x_set')
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 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_complete(self): array = DataArray(name='y', shape=(5,)) array.init_data() data = new_data(arrays=(array,), location=False) self.syncing_array = array self.sync_index = 0 data.sync = self.mock_sync bf = DataSet.background_functions bf['fail'] = self.failing_func bf['log'] = self.logging_func with LogCapture() as logs: # grab info and warnings but not debug messages logging.getLogger().setLevel(logging.INFO) data.complete(delay=0.001) logs = logs.value expected_logs = [ 'waiting for DataSet <False> to complete', 'DataSet: 0% complete', 'RuntimeError: it is called failing_func for a reason!', 'background at index 1', 'DataSet: 20% complete', 'RuntimeError: it is called failing_func for a reason!', 'background function fail failed twice in a row, removing it', 'background at index 2', 'DataSet: 40% complete', 'background at index 3', 'DataSet: 60% complete', 'background at index 4', 'DataSet: 80% complete', 'background at index 5', 'DataSet <False> is complete' ] log_index = 0 for line in expected_logs: self.assertIn(line, logs, logs) try: log_index_new = logs.index(line, log_index) except ValueError: raise ValueError('line {} not found after {} in: \n {}'.format( line, log_index, logs)) self.assertTrue(log_index_new >= log_index, logs) log_index = log_index_new + len(line) + 1 # +1 for \n self.assertEqual(log_index, len(logs), logs)
def makeDataSet1Dplain(xname, x, yname, y=None, xunit=None, yunit=None, location=None, loc_record=None): """ Make DataSet with one 1D array and one setpoint array Arguments: xname (string): the name of the setpoint array x (array or ndarray or list): the setpoint data yname (str or qcodes.Parameter or list): the name of the measured array y (array or ndarray or list): the measured data xunit (str or None): optional, the unit of the values stored in x array. yunit (str or None): optional, the unit of the values stored in y array. location (str, callable, bool or None): If you provide a string, it must be an unused location in the io manager. Can also be: - a callable `location provider` with one required parameter \ (the io manager), and one optional (`record` dict), \ which returns a location string when called. - `False` - denotes an only-in-memory temporary DataSet. loc_record (dict or None): If location is a callable, this will be passed to it as `record`. Raises: See _make_data_set for the ValueError and TypeError exceptions that can be raised Returns: The resulting dataset. """ setpoint_data = np.array(x) preset_data = np.NaN * np.ones(setpoint_data.size) if y is not None: y = np.array(y) setpoint = DataArray(name=xname, array_id=xname, preset_data=setpoint_data, unit=xunit, is_setpoint=True) if isinstance(yname, (str, qcodes.Parameter)): measured_data_list = [y] measurement_list = [yname] else: measured_data_list = y measurement_list = yname measurement_unit = yunit data_set, _ = _make_data_set(measured_data_list, measurement_list, measurement_unit, location, loc_record, preset_data, [setpoint]) return data_set
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 test_xarray_conversions(self): da = DataSet1D(name="TestDataArray_test_xarray_conversions").x_set xarray_dictionary = data_array_to_xarray_dictionary(da) xarray_dataarray = da.to_xarray() da_transformed = DataArray.from_xarray(xarray_dataarray) for key in ["name", "unit", "label"]: self.assertEqual(da.name, da_transformed.name)
def containers(self): """ Finds the data arrays that will be created by the actions in this loop, and nests them inside this level of the loop. Recursively calls `.containers` on any enclosed actions. """ loop_size = len(self.sweep_values) data_arrays = [] loop_array = DataArray(parameter=self.sweep_values.parameter, is_setpoint=True) loop_array.nest(size=loop_size) data_arrays = [loop_array] # hack set_data into actions new_actions = self.actions[:] if hasattr(self.sweep_values, "parameters"): for parameter in self.sweep_values.parameters: new_actions.append(parameter) for i, action in enumerate(new_actions): if hasattr(action, 'containers'): action_arrays = action.containers() elif hasattr(action, 'get'): # this action is a parameter to measure # note that this supports lists (separate output arrays) # and arrays (nested in one/each output array) of return values action_arrays = self._parameter_arrays(action) else: # this *is* covered but the report misses it because Python # optimizes it away. See: # https://bitbucket.org/ned/coveragepy/issues/198 continue # pragma: no cover for array in action_arrays: array.nest(size=loop_size, action_index=i, set_array=loop_array) data_arrays.extend(action_arrays) return data_arrays
def makeDataSet1D(p, yname='measured', y=None, location=None, loc_record=None, return_names=False): """ Make DataSet with one or multiple 1D arrays and one setpoint array. Arguments: p (qcodes.SweepFixedValues): the setpoint array of data yname (str or list of str or Parameter or list of Parameter): when type is str or list of str : the name of measured array(s) when type is parameter or list of parameter: the measured Parameters y (array or list of array or None): optional (measured) data to fill the DataSet location (str, callable, bool or None): If you provide a string, it must be an unused location in the io manager. Can also be: - a callable `location provider` with one required parameter \ (the io manager), and one optional (`record` dict), \ which returns a location string when called. - `False` - denotes an only-in-memory temporary DataSet. loc_record (dict or None): If location is a callable, this will be passed to it as `record`. return_names (bool): if True return array names in output Raises: See _make_data_set for the ValueError and TypeError exceptions that can be raised See _check_parameter for the TypeError exceptions that can be raised Returns: Depending on parameter return_names True: The resulting dataset and a tuple with the names of the added arrays (setpoint and measurements). False: The resulting dataset. """ _check_parameter(p) setpoint_data = np.array(p) preset_data = np.NaN * np.ones(setpoint_data.size) setpoint = DataArray(name=p.name, array_id=p.name, label=p.parameter.label, unit=p.parameter.unit, preset_data=setpoint_data, is_setpoint=True) if isinstance(yname, (str, qcodes.Parameter)): measured_data_list = [y] measurement_list = [yname] else: measured_data_list = y measurement_list = yname measurement_unit = None data_set, measure_names = _make_data_set(measured_data_list, measurement_list, measurement_unit, location, loc_record, preset_data, [setpoint]) data_set.metadata['default_parameter_name'] = measure_names[0] if return_names: set_names = setpoint.name return data_set, (set_names, measure_names) else: return data_set
def seperate_data(data_set, location, NewIO, formatter, qubit_num=1, repetition=100, sweep_arrays=None, sweep_names=None): #this function will seperate the raw data for each experiment (appended to the same seqeunce) #into different data files. This will make plotting and data handling easier. start = 0 end = 0 seperated_data = [] for count, array in enumerate(sweep_arrays): end = start + len(sweep_arrays[count]) - 1 seperated_data.append( DataSet(location=location + '_' + sweep_names[count] + '_set', io=NewIO, formatter=formatter)) for parameter in data_set.arrays: if parameter.endswith( 'set') and data_set.arrays[parameter].ndarray.ndim > 1: name = sweep_names[count] + '_set' else: name = parameter if data_set.arrays[parameter].ndarray.ndim > 1: seperated_data[count].add_array( DataArray( preset_data=data_set.arrays[parameter][:, start:end], name=name, array_id=name, is_setpoint=True)) else: seperated_data[count].add_array( DataArray(preset_data=data_set.arrays[parameter], name=name, array_id=name, is_setpoint=True)) start = end + 1 return seperated_data
def test_dataset_with_missing_attrs(self): data1 = new_data(formatter=self.formatter, location=self.loc_provider, name='test_missing_attr') arr = DataArray(array_id='arr', preset_data=np.linspace(0, 10, 21)) data1.add_array(arr) data1.write() # data2 = DataSet(location=data1.location, formatter=self.formatter) # data2.read() data2 = load_data(location=data1.location, formatter=self.formatter) # cannot use the check arrays equal as I expect the attributes # to not be equal np.testing.assert_array_equal(data2.arrays['arr'], data1.arrays['arr'])
def scan_inside_awg( name, label, ): data = dig.get() pulse_length = sweep_loop1['para1'] if 'para1' in sweep_loop1 else 1 data = np.array([data]) pulse_length = np.array([pulse_length]) data_array = DataArray( preset_data=data, name='digitizer', ) pulse_array = DataArray(preset_data=pulse_length, name=name + '_set', is_setpoint=True) set_array = DataArray(preset_data=np.array([1]), name='none_set', array_id='pulse_length_set', is_setpoint=True) data_set = new_data( arrays=[set_array, pulse_array, data_array], location=data_location, loc_record={ 'name': experiment_name, 'label': sweep_type }, io=data_IO, ) return data_set