def test_makedataset2d_shape_measuredata_second_nok(self): p1 = ManualParameter('dummy1') p2 = ManualParameter('dummy2') x = p1[0:10:1] y = p2[0:4:1] measure_names = ['measured1', 'measured2'] preset_data = [ np.ones((len(x), len(y))), np.ones((len(x) + 1, len(y))) ] with patch('sys.stdout', new_callable=io.StringIO) as mock_stdout: stream_handler = logging.StreamHandler(sys.stdout) logger.addHandler(stream_handler) _ = qtt.data.makeDataSet2D(x, y, measure_names, preset_data=preset_data, return_names=False) # Verify warning print_string = mock_stdout.getvalue() self.assertRegex( print_string, 'Shape of measured data .* does not match setpoint shape .*') logger.removeHandler(stream_handler)
def test_makeDataSet2D(): from qcodes import ManualParameter p = ManualParameter('dummy') p2 = ManualParameter('dummy2') ds = makeDataSet2D(p[0:10:1], p2[0:4:1], ['m1', 'm2']) _ = diffDataset(ds)
def test_makedataset2d_type_measurement_names_nok(self): p1 = ManualParameter('dummy1') p2 = ManualParameter('dummy2') x = p1[0:10:1] y = p2[0:4:1] measure_names = [2] self.assertRaisesRegex(TypeError, 'Type of measurement names must be str or qcodes.Parameter', qtt.data.makeDataSet2D, x, y, measure_names, return_names=False)
def test_makedataset2d_shape_measuredata_list_nok2(self): p1 = ManualParameter('dummy1') p2 = ManualParameter('dummy2') x = p1[0:10:1] y = p2[0:4:1] measure_names = ['measured1'] preset_data = [np.ones((len(x), len(y))).shape, np.ones((len(x), len(y))).shape] self.assertRaisesRegex(ValueError, 'The number of measurement names 1 does not match the number of measurements 2', qtt.data.makeDataSet2D, x, y, measure_names, preset_data=preset_data, return_names=False)
def test_makedataset2d_type_parameter_nok1(self): p1 = ManualParameter('dummy1') p2 = ManualParameter('dummy2') x = p1[0:10:1] y = p2[0:4:1] x.parameter = 4 measure_names = 'measured' self.assertRaisesRegex(TypeError, 'Type of parameter.parameter must be qcodes.Parameter', qtt.data.makeDataSet2D, x, y, measure_names, return_names=False)
def test_makedataset2d_preset_data_no_list(self): p1 = ManualParameter('dummy1') p2 = ManualParameter('dummy2') x = p1[0:10:1] y = p2[0:4:1] m1 = ManualParameter('measurement1') measure_names = [m1] preset_data = np.ones((len(x), len(y))) self.assertRaisesRegex(ValueError, 'The number of measurement names 1 does not match the number of measurements 10', qtt.data.makeDataSet2D, x, y, measure_names, preset_data=preset_data, return_names=False)
def test_makedataset2d_not_return_names(self): p1 = ManualParameter('dummy1') p2 = ManualParameter('dummy2') x = p1[0:10:1] y = p2[0:4:1] measure_names = 'measured' # preset_data = np.ones((len(x), len(y))) data_set = qtt.data.makeDataSet2D(x, y, measure_names, return_names=False) # check attribute self.assertTrue(np.array_equal(data_set.dummy1, x)) self.assertTrue(data_set.dummy2.shape, data_set.measured.shape) self.assertTrue(data_set.measured.shape == np.ones((len(x), len(y))).shape) # check array self.assertTrue(data_set.arrays['measured'].shape == np.ones((len(x), len(y))).shape)
def test_makedataset1d_type_parameter_nok1(self): dummy_parameter = ManualParameter('dummy') x = dummy_parameter[0:10:1] x.parameter = 4 self.assertRaisesRegex( TypeError, 'Type of parameter.parameter must be qcodes.Parameter', qtt.data.makeDataSet1D, x, [1, 2], None)
def test_makedataset1d_shape_measuredata_list_nok1(self): dummy_parameter = ManualParameter('dummy') x = dummy_parameter[0:10:1] yname = ['measured1', 'measured2'] y = np.arange(len(x)).reshape((len(x))) self.assertRaisesRegex(ValueError, 'The number of measurement names 2 does not match the number of measurements 10', qtt.data.makeDataSet1D, x, yname, y, return_names=False)
def test_makedataset1d_type_measurement_names_nok(self): dummy_parameter = ManualParameter('dummy') x = dummy_parameter[0:10:1] self.assertRaisesRegex( TypeError, 'Type of measurement names must be str or qcodes.Parameter', qtt.data.makeDataSet1D, x, [1, 2], None)
def test_makedataset2d_type_parameter_nok2(self): p1 = ManualParameter('dummy1') x = p1[0:10:1] y = 'wrong type' measure_names = 'measured' self.assertRaisesRegex(TypeError, 'Type of parameter must be qcodes.SweepFixedValues', qtt.data.makeDataSet2D, x, y, measure_names, return_names=False)
def test_makedataset1d_no_data(self): dummy_parameter = ManualParameter('dummy') x = dummy_parameter[0:10:1] y = None data_set = qtt.data.makeDataSet1D(x, ['y1', 'y2'], y, return_names=False) self.assertTrue(np.array_equal(data_set.dummy, x)) self.assertTrue(data_set.y1.shape == (10,)) self.assertTrue(data_set.y2.shape == (10,))
def test_makedataset2d_shape_measure_names_parameters(self): p1 = ManualParameter('dummy1') p2 = ManualParameter('dummy2') x = p1[0:10:1] y = p2[0:4:1] m1 = ManualParameter('measurement1') m2 = ManualParameter('measurement2') measure_names = [m1, m2] preset_data = [np.ones((len(x), len(y))), np.ones((len(x), len(y)))] data_set = qtt.data.makeDataSet2D(x, y, measure_names, preset_data=preset_data, return_names=False) # check attribute self.assertTrue(np.array_equal(data_set.dummy1, x)) self.assertTrue(np.array_equal(data_set.measurement1, preset_data[0])) self.assertTrue(np.array_equal(data_set.measurement2, preset_data[1])) # check array self.assertTrue(np.array_equal(data_set.arrays['measurement1'], preset_data[0])) self.assertTrue(np.array_equal(data_set.arrays['measurement2'], preset_data[1]))
def test_makedataset2d_return_names(self): p1 = ManualParameter('dummy1') p2 = ManualParameter('dummy2') x = p1[0:10:1] y = p2[0:4:1] measure_names = 'measured' data_set, tuple_names = qtt.data.makeDataSet2D(x, y, measure_names, return_names=True) # check attribute self.assertTrue(np.array_equal(data_set.dummy1, x)) self.assertTrue(data_set.dummy2.shape, data_set.measured.shape) self.assertTrue(data_set.measured.shape == np.ones((len(x), len(y))).shape) # check array self.assertTrue(data_set.arrays['measured'].shape == np.ones((len(x), len(y))).shape) # check return names self.assertTrue(tuple_names[0][0] == 'dummy1') self.assertTrue(tuple_names[0][1] == 'dummy2') self.assertTrue(tuple_names[1][0] == 'measured')
def test_makedataset1dplain_type_yname_parameter(self): x = np.arange(0, 10) yname = ManualParameter('dummy') data_set = qtt.data.makeDataSet1Dplain('x', x, yname) # check attribute self.assertTrue(np.array_equal(data_set.x, x)) self.assertTrue(data_set.dummy.shape == np.ones(len(x)).shape) # check array self.assertTrue(data_set.arrays['dummy'].shape == np.ones(len(x)).shape)
def test_makedataset1d_not_return_names(self): dummy_parameter = ManualParameter('dummy') x = dummy_parameter[0:10:1] yname = 'measured' y = np.arange(len(x)).reshape((len(x))) data_set = qtt.data.makeDataSet1D(x, yname, y, return_names=False) # check attribute self.assertTrue(np.array_equal(data_set.measured, y)) # check array self.assertTrue(np.array_equal(data_set.arrays['measured'], y))
def test_makedataset1d_return_names(self): dummy_parameter = ManualParameter('dummy') x = dummy_parameter[0:10:1] y = None data_set, tuple_names = qtt.data.makeDataSet1D(x, ['y1', 'y2'], y, return_names=True) self.assertTrue(np.array_equal(data_set.dummy, x)) # check return names self.assertTrue(tuple_names[0] == 'dummy') self.assertTrue(tuple_names[1][0] == 'y1') self.assertTrue(tuple_names[1][1] == 'y2')
def test_get_sampling_frequency_m4i(self): expected_value = 12.345e6 m4i_digitizer = M4i('test') m4i_digitizer.sample_rate = ManualParameter('sample_rate', initial_value=expected_value) actual_value = get_sampling_frequency(m4i_digitizer) self.assertEqual(expected_value, actual_value) m4i_digitizer.close()
def setup(self, bench_param): # Init DB self.tmpdir = tempfile.mkdtemp() qcodes.config["core"]["db_location"] = os.path.join( self.tmpdir, 'temp.db') qcodes.config["core"]["db_debug"] = False initialise_database() # Create experiment self.experiment = new_experiment("test-experiment", sample_name="test-sample") # Create measurement meas = Measurement(self.experiment) x1 = ManualParameter('x1') x2 = ManualParameter('x2') x3 = ManualParameter('x3') y1 = ManualParameter('y1') y2 = ManualParameter('y2') meas.register_parameter(x1, paramtype=bench_param['paramtype']) meas.register_parameter(x2, paramtype=bench_param['paramtype']) meas.register_parameter(x3, paramtype=bench_param['paramtype']) meas.register_parameter(y1, setpoints=[x1, x2, x3], paramtype=bench_param['paramtype']) meas.register_parameter(y2, setpoints=[x1, x2, x3], paramtype=bench_param['paramtype']) self.parameters = [x1, x2, x3, y1, y2] # Create the Runner context manager self.runner = meas.run() # Enter Runner and create DataSaver self.datasaver = self.runner.__enter__() # Create values for parameters for _ in range(len(self.parameters)): self.values.append(np.random.rand(bench_param['n_values']))
def test_makedataset1d_shape_measuredata_nok(self): dummy_parameter = ManualParameter('dummy') x = dummy_parameter[0:10:1] y = [np.arange(len(x)+1)] with patch('sys.stdout', new_callable=io.StringIO) as mock_stdout: stream_handler = logging.StreamHandler(sys.stdout) logger.addHandler(stream_handler) data_set = qtt.data.makeDataSet1D(x, 'y', y, return_names=False) self.assertTrue(np.array_equal(data_set.dummy, x)) self.assertTrue(np.array_equal(data_set.y, y)) # Verify warning print_string = mock_stdout.getvalue() self.assertRegex(print_string, 'Shape of measured data .* does not match setpoint shape .*' ) logger.removeHandler(stream_handler)
def _multiplier(self, multiplier: Union[int, float, Parameter]): if isinstance(multiplier, Parameter): self._multiplier_parameter = multiplier else: self._multiplier_parameter = ManualParameter( 'multiplier', initial_value=multiplier)
from qtt.measurements.scans import delta_time, update_dictionary #%% Setup a live plotting window plotQ = QtPlot(window_title='Live plot', interval=.5) plotQ.setGeometry(100, 100, 600, 400) plotQ.update() qtt.live.liveplotwindow = plotQ #%% Mock instruments # # The experiment we simulate is a sequence running on the AWG that does: initialize, # apply a pulse with a certain frequency, measure the charge sensor. The resulting # data of the charge sensor is thresholded to obtain spin up or down frequency = ManualParameter('frequency', initial_value=10e6, unit='Hz') elzermann_threshold = ManualParameter('threshold', initial_value=.85, unit='a.u.') class digitizer_class(qcodes.Instrument): def __init__(self, name, frequency, ntraces=12, **kwargs): """ Dummy instrument Resonance frequency at 10 MHz """ super().__init__(name, **kwargs) self.frequency = frequency self.ntraces = ntraces
def test_makedataset2d_diffdataset(): p1 = ManualParameter('dummy1') p2 = ManualParameter('dummy2') ds = qtt.data.makeDataSet2D(p1[0:10:1], p2[0:4:1], ['m1', 'm2']) _ = diffDataset(ds)
def test_determine_parameter_unit_ok(self): dummy_parameter = ManualParameter('dummy') unit = determine_parameter_unit(dummy_parameter) self.assertTrue(unit == '')