def test_soft_averages_hard_sweep_1D(self):
sweep_pts = np.arange(50)
self.MC.soft_avg(1)
self.MC.set_sweep_function(None_Sweep(sweep_control='hard'))
self.MC.set_sweep_points(sweep_pts)
self.MC.set_detector_function(det.Dummy_Detector_Hard(noise=.4))
noisy_dat = self.MC.run('noisy_dat')
noisy_dset = noisy_dat["dset"]
x = noisy_dset[:, 0]
y = [np.sin(x / np.pi), np.cos(x/np.pi)]
yn_0 = abs(noisy_dset[:, 1] - y[0])
yn_1 = abs(noisy_dset[:, 2] - y[1])
d = self.MC.detector_function
self.assertEqual(d.times_called, 1)
self.MC.soft_avg(5000)
self.MC.set_sweep_function(None_Sweep(sweep_control='hard'))
self.MC.set_sweep_points(sweep_pts)
self.MC.set_detector_function(d)
avg_dat = self.MC.run('averaged_dat')
avg_dset = avg_dat["dset"]
yavg_0 = abs(avg_dset[:, 1] - y[0])
yavg_1 = abs(avg_dset[:, 2] - y[1])
np.testing.assert_array_almost_equal(x, sweep_pts)
self.assertGreater(np.mean(yn_0), np.mean(yavg_0))
self.assertGreater(np.mean(yn_1), np.mean(yavg_1))
np.testing.assert_array_almost_equal(yavg_0, np.zeros(len(x)),
decimal=2)
np.testing.assert_array_almost_equal(yavg_1, np.zeros(len(x)),
decimal=2)
self.assertEqual(d.times_called, 5001)
def test_persist_mode(self):
sweep_pts = np.linspace(0, 10, 5)
self.MC.persist_mode(True)
self.MC.set_sweep_function(None_Sweep(sweep_control='hard'))
self.MC.set_sweep_points(sweep_pts)
self.MC.set_detector_function(det.Dummy_Detector_Hard())
dat = self.MC.run('1D_hard')
dset = dat["dset"]
x = dset[:, 0]
y = [np.sin(x / np.pi), np.cos(x/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])
d = self.MC.detector_function
self.assertEqual(d.times_called, 1)
persist_dat = self.MC._persist_dat
x_p = persist_dat[:, 0]
y0_p = persist_dat[:, 1]
y1_p = persist_dat[:, 2]
np.testing.assert_array_almost_equal(x, x_p)
np.testing.assert_array_almost_equal(y0, y0_p)
np.testing.assert_array_almost_equal(y1, y1_p)
self.MC.clear_persitent_plot()
self.assertEqual(self.MC._persist_dat, None)
def test_hard_sweep_2D(self):
"""
Hard inner loop, soft outer loop
"""
sweep_pts = np.linspace(10, 20, 3)
sweep_pts_2D = np.linspace(0, 10, 5)
self.MC.live_plot_enabled(False)
self.MC.set_sweep_function(None_Sweep(sweep_control='hard'))
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_Hard())
dat = self.MC.run('2D_hard', mode='2D')
dset = dat["dset"]
x = dset[:, 0]
y = dset[:, 1]
z = self.data = [np.sin(x / np.pi), np.cos(x/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])
d = self.MC.detector_function
self.assertEqual(d.times_called, 5)
self.MC.live_plot_enabled(True)
def test_multi_detector_basics(self):
def dummy_function_1(val_a, val_b):
return val_a
def dummy_function_2(val_a, val_b):
return val_a + val_b
# Testing input of a simple dict
x = self.mock_parabola.x
d0 = det.Function_Detector(dummy_function_1,
value_names=['a'],
value_units=['my_unit'],
msmt_kw={
'val_a': x,
'val_b': 1
})
d1 = det.Function_Detector(dummy_function_2,
value_names=['b'],
value_units=None,
msmt_kw={
'val_a': x,
'val_b': 1
})
dm = det.Multi_Detector([d0, d1], det_idx_suffix=False)
assert dm.value_names == ['a', 'b']
assert dm.value_units == ['my_unit', 'a.u.']
dm_suffix = det.Multi_Detector([d0, d1], det_idx_suffix=True)
assert dm_suffix.value_names == ['a_det0', 'b_det1']
assert dm_suffix.value_units == ['my_unit', 'a.u.']
dh = det.Dummy_Detector_Hard()
with pytest.raises(ValueError):
dm = det.Multi_Detector([dh, d0])
def test_multi_detector_hard(self):
sweep_pts = np.linspace(0, 10, 5)
d0 = det.Dummy_Detector_Hard()
d1 = det.Dummy_Detector_Hard()
dm = det.Multi_Detector([d0, d1])
self.MC.set_sweep_function(None_Sweep(sweep_control='hard'))
self.MC.set_sweep_points(sweep_pts)
self.MC.set_detector_function(dm)
dat = self.MC.run('Multi_hard')
dset = dat['dset']
x = dset[:, 0]
y = [np.sin(x / np.pi), np.cos(x / np.pi)]
np.testing.assert_array_almost_equal(x, sweep_pts)
np.testing.assert_array_almost_equal(y[0], dset[:, 1])
np.testing.assert_array_almost_equal(y[1], dset[:, 2])
np.testing.assert_array_almost_equal(y[0], dset[:, 3])
np.testing.assert_array_almost_equal(y[1], dset[:, 4])
def test_soft_averages_hard_sweep_2D(self):
self.MC.soft_avg(1)
self.MC.live_plot_enabled(False)
sweep_pts = np.arange(5)
sweep_pts_2D = np.linspace(5, 10, 5)
self.MC.set_sweep_function(None_Sweep(sweep_control="hard"))
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_Hard(noise=0.2))
noisy_dat = self.MC.run("2D_hard", mode="2D")
noisy_dset = noisy_dat["dset"]
x = noisy_dset[:, 0]
y = noisy_dset[:, 1]
z = [np.sin(x / np.pi), np.cos(x / np.pi)]
z0 = abs(noisy_dset[:, 2] - z[0])
z1 = abs(noisy_dset[:, 3] - z[1])
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)
d = self.MC.detector_function
self.assertEqual(d.times_called, 5)
self.MC.set_sweep_function(None_Sweep(sweep_control="hard"))
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.soft_avg(1000)
avg_dat = self.MC.run("averaged_dat", mode="2D")
avg_dset = avg_dat["dset"]
x = avg_dset[:, 0]
y = avg_dset[:, 1]
zavg_0 = abs(avg_dset[:, 2] - z[0])
zavg_1 = abs(avg_dset[:, 3] - z[1])
np.testing.assert_array_almost_equal(x, x_tiled)
self.assertGreater(np.mean(z0), np.mean(zavg_0))
self.assertGreater(np.mean(z1), np.mean(zavg_1))
np.testing.assert_array_almost_equal(zavg_0,
np.zeros(len(x)),
decimal=2)
np.testing.assert_array_almost_equal(zavg_1,
np.zeros(len(x)),
decimal=2)
self.assertEqual(d.times_called, 5 * 1000 + 5)
self.MC.live_plot_enabled(True)
def test_hard_sweep_1D(self):
sweep_pts = np.linspace(0, 10, 5)
self.MC.set_sweep_function(None_Sweep(sweep_control='hard'))
self.MC.set_sweep_points(sweep_pts)
self.MC.set_detector_function(det.Dummy_Detector_Hard())
dat = self.MC.run('1D_hard')
dset = dat['dset']
x = dset[:, 0]
y = [np.sin(x / np.pi), np.cos(x/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])
d = self.MC.detector_function
self.assertEqual(d.times_called, 1)
