def test_soft_sweep_1D(self):
sweep_pts = np.linspace(0, 10, 30)
self.MC.set_sweep_function(None_Sweep())
self.MC.set_sweep_points(sweep_pts)
self.MC.set_detector_function(det.Dummy_Detector_Soft())
dat = self.MC.run('1D_soft')
dset = dat["dset"]
x = dset[:, 0]
xr = np.arange(len(x))/15
y = np.array([np.sin(xr/np.pi), np.cos(xr/np.pi)])
y0 = dset[:, 1]
y1 = dset[:, 2]
np.testing.assert_array_almost_equal(x, sweep_pts)
np.testing.assert_array_almost_equal(y0, y[0, :])
np.testing.assert_array_almost_equal(y1, y[1, :])
# Test that the return dictionary has the right entries
dat_keys = set(['dset', 'opt_res_dset', 'sweep_parameter_names',
'sweep_parameter_units',
'value_names', 'value_units'])
self.assertEqual(dat_keys, set(dat.keys()))
self.assertEqual(dat['sweep_parameter_names'], ['pts'])
self.assertEqual(dat['sweep_parameter_units'], ['arb. unit'])
self.assertEqual(dat['value_names'], ['I', 'Q'])
self.assertEqual(dat['value_units'], ['V', 'V'])
def test_soft_sweep_2D_with_reading_of_set_parameter(self):
sweep_pts = np.linspace(0, 10, 30)
sweep_pts_2D = np.linspace(0, 10, 5)
self.MC.set_sweep_function(None_Sweep_With_Parameter_Returned(
sweep_control='soft'))
self.MC.set_sweep_function_2D(None_Sweep_With_Parameter_Returned(
sweep_control='soft'))
self.MC.set_sweep_points(sweep_pts)
self.MC.set_sweep_points_2D(sweep_pts_2D)
self.MC.set_detector_function(det.Dummy_Detector_Soft())
dat = self.MC.run('2D_soft', mode='2D')
dset = dat["dset"]
x = dset[:, 0]
y = dset[:, 1]
xr = np.arange(len(sweep_pts)*len(sweep_pts_2D))/15
z = np.array([np.sin(xr/np.pi), np.cos(xr/np.pi)])
z0 = dset[:, 2]
z1 = dset[:, 3]
# The +0.1 is to test if the return value is matching
x_tiled = np.tile(sweep_pts+0.1, len(sweep_pts_2D))
y_rep = np.repeat(sweep_pts_2D+0.1, len(sweep_pts))
np.testing.assert_array_almost_equal(x, x_tiled)
np.testing.assert_array_almost_equal(y, y_rep)
np.testing.assert_array_almost_equal(z0, z[0, :])
np.testing.assert_array_almost_equal(z1, z[1, :])
def test_save_exp_metadata(self):
metadata_dict = {
"intParam": 1,
"floatParam": 2.5e-3,
"strParam": "spam",
"listParam": [1, 2, 3, 4],
"arrayParam": np.array([4e5, 5e5]),
"dictParam": {
"a": 1,
"b": 2
},
"tupleParam": (3, "c"),
}
old_a_tools_datadir = a_tools.datadir
a_tools.datadir = self.MC.datadir()
sweep_pts = np.linspace(0, 10, 30)
self.MC.set_sweep_function(None_Sweep())
self.MC.set_sweep_points(sweep_pts)
self.MC.set_detector_function(det.Dummy_Detector_Soft())
self.MC.run("test_exp_metadata", exp_metadata=metadata_dict)
a = ma.MeasurementAnalysis(label="test_exp_metadata", auto=False)
a_tools.datadir = old_a_tools_datadir
loaded_dict = read_dict_from_hdf5(
{}, a.data_file["Experimental Data"]["Experimental Metadata"])
np.testing.assert_equal(metadata_dict, loaded_dict)
def test_data_resolution(self):
# This test will fail if the data is saved as 32 bit floats
sweep_pts = [3e9+1e-3, 3e9+2e-3]
self.MC.set_sweep_function(None_Sweep())
self.MC.set_sweep_points(sweep_pts)
self.MC.set_detector_function(det.Dummy_Detector_Soft())
dat = self.MC.run('1D_soft')
x = dat['dset'][:, 0]
np.testing.assert_array_almost_equal(x, sweep_pts, decimal=5)
def fake_folder(self, folder_name):
'''
Give folder_name in the form of a string.
Creates a folder with the desired folder name containing a dummy measurement.
'''
if isinstance(folder_name, str):
sweep_pts = np.linspace(0, 10, 3)
self.MC.set_sweep_function(swf.None_Sweep())
self.MC.set_sweep_points(sweep_pts)
self.MC.set_detector_function(det.Dummy_Detector_Soft())
dat = self.MC.run(folder_name)
else:
raise ValueError('Please enter a string as the folder name!')
def test_progress_callback(self):
progress_param = ManualParameter('progress', initial_value=0)
def set_progress_param_callable(progress):
progress_param(progress)
self.MC.on_progress_callback(set_progress_param_callable)
self.assertEqual(progress_param(), 0)
sweep_pts = np.linspace(0, 10, 30)
self.MC.set_sweep_function(None_Sweep())
self.MC.set_sweep_points(sweep_pts)
self.MC.set_detector_function(det.Dummy_Detector_Soft())
dat = self.MC.run('1D_soft')
self.assertEqual(progress_param(), 100)
def test_soft_sweep_2D_function_calls(self):
sweep_pts = np.arange(0, 30, 1)
sweep_pts_2D = np.arange(0, 5, 1)
s1 = None_Sweep_idx(sweep_control='soft')
s2 = None_Sweep_idx(sweep_control='soft')
self.MC.set_sweep_function(s1)
self.MC.set_sweep_function_2D(s2)
self.MC.set_sweep_points(sweep_pts)
self.MC.set_sweep_points_2D(sweep_pts_2D)
self.MC.set_detector_function(det.Dummy_Detector_Soft())
self.assertEqual(s1.num_calls, 0)
self.assertEqual(s2.num_calls, 0)
self.MC.run('2D_soft', mode='2D')
# Test that the 2D scan only gets called 5 times (when it changes)
# The 1D value always changes and as such should always be called
self.assertEqual(s1.num_calls, 30*5)
self.assertEqual(s2.num_calls, 5)
def test_soft_sweep_2D(self):
sweep_pts = np.linspace(0, 10, 30)
sweep_pts_2D = np.linspace(0, 10, 5)
self.MC.set_sweep_function(None_Sweep(sweep_control='soft'))
self.MC.set_sweep_function_2D(None_Sweep(sweep_control='soft'))
self.MC.set_sweep_points(sweep_pts)
self.MC.set_sweep_points_2D(sweep_pts_2D)
self.MC.set_detector_function(det.Dummy_Detector_Soft())
dat = self.MC.run('2D_soft', mode='2D')
dset = dat["dset"]
x = dset[:, 0]
y = dset[:, 1]
xr = np.arange(len(sweep_pts)*len(sweep_pts_2D))/15
z = np.array([np.sin(xr/np.pi), np.cos(xr/np.pi)])
z0 = dset[:, 2]
z1 = dset[:, 3]
x_tiled = np.tile(sweep_pts, len(sweep_pts_2D))
y_rep = np.repeat(sweep_pts_2D, len(sweep_pts))
np.testing.assert_array_almost_equal(x, x_tiled)
np.testing.assert_array_almost_equal(y, y_rep)
np.testing.assert_array_almost_equal(z0, z[0, :])
np.testing.assert_array_almost_equal(z1, z[1, :])
