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 == '')
