def test_probability_balanced(self):
"""Test if p=0.5 is returned when counts are balanced and prior is flat."""
node = Probability(outcome="1")
# balanced counts with a flat prior will yield p = 0.5
data = {"1": 512, "0": 512}
processed_data = node(data=np.asarray([data]))
self.assertAlmostEqual(unp.nominal_values(processed_data), 0.5)
def test_validation(self):
"""Test the validation mechanism."""
for validate, error in [(False, AttributeError), (True, DataProcessorError)]:
processor = DataProcessor("counts")
processor.append(Probability("00", validate=validate))
with self.assertRaises(error):
processor({"counts": [0, 1, 2]})
def test_populations(self):
"""Test that counts are properly converted to a population."""
processor = DataProcessor("counts")
processor.append(Probability("00"))
new_data = processor(self.exp_data_lvl2.data[0])
self.assertEqual(new_data[0], 0.4)
self.assertEqual(new_data[1], 0.4 * (1 - 0.4) / 10)
def test_variance_not_zero(self):
"""Test if finite variance is computed at max or min probability."""
node = Probability(outcome="1")
data = {"1": 1024, "0": 0}
processed_data = node(data=np.asarray([data]))
self.assertGreater(unp.std_devs(processed_data), 0.0)
self.assertLessEqual(unp.nominal_values(processed_data), 1.0)
data = {"1": 0, "0": 1024}
processed_data = node(data=np.asarray([data]))
self.assertGreater(unp.std_devs(processed_data), 0.0)
self.assertGreater(unp.nominal_values(processed_data), 0.0)
def test_populations(self):
"""Test that counts are properly converted to a population."""
processor = DataProcessor("counts")
processor.append(Probability("00"))
# Test on a single datum.
new_data, error = processor(self.exp_data_lvl2.data(0))
self.assertEqual(new_data, 0.4)
self.assertEqual(error, np.sqrt(0.4 * (1 - 0.4) / 10))
# Test on all the data
new_data, error = processor(self.exp_data_lvl2.data())
self.assertTrue(np.allclose(new_data, np.array([0.4, 0.2])))
def test_bad_analysis(self):
"""Test the Rabi analysis."""
experiment_data = ExperimentData()
thetas = np.linspace(0.0, np.pi / 4, 31)
amplitudes = np.linspace(0.0, 0.95, 31)
experiment_data.add_data(
self.simulate_experiment_data(thetas, amplitudes, shots=200))
data_processor = DataProcessor("counts", [Probability(outcome="1")])
experiment_data = OscillationAnalysis().run(
experiment_data, data_processor=data_processor, plot=False)
result = experiment_data.analysis_results()
self.assertEqual(result[0].quality, "bad")
def test_good_analysis(self):
"""Test the Rabi analysis."""
experiment_data = ExperimentData()
thetas = np.linspace(-np.pi, np.pi, 31)
amplitudes = np.linspace(-0.25, 0.25, 31)
expected_rate, test_tol = 2.0, 0.2
experiment_data.add_data(
self.simulate_experiment_data(thetas, amplitudes, shots=400))
data_processor = DataProcessor("counts", [Probability(outcome="1")])
experiment_data = OscillationAnalysis().run(
experiment_data, data_processor=data_processor, plot=False)
result = experiment_data.analysis_results(0)
self.assertEqual(result.quality, "good")
self.assertAlmostEqual(result.value[1], expected_rate, delta=test_tol)
def test_populations(self):
"""Test that counts are properly converted to a population."""
processor = DataProcessor("counts")
processor.append(Probability("00", alpha_prior=1.0))
# Test on a single datum.
new_data = processor(self.exp_data_lvl2.data(0))
self.assertAlmostEqual(float(unp.nominal_values(new_data)), 0.41666667)
self.assertAlmostEqual(float(unp.std_devs(new_data)), 0.13673544235706114)
# Test on all the data
new_data = processor(self.exp_data_lvl2.data())
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
np.array([0.41666667, 0.25]),
)
def test_end_to_end_restless_standard_processor(self, pi_ratio):
"""Test the restless experiment with a standard processor end to end."""
error = -np.pi * pi_ratio
backend = MockRestlessFineAmp(error, np.pi, "x")
amp_exp = FineXAmplitude(0, backend)
# standard data processor.
standard_processor = DataProcessor("counts", [Probability("01")])
amp_exp.analysis.set_options(data_processor=standard_processor)
# enable a restless measurement setting.
amp_exp.enable_restless(rep_delay=1e-6,
override_processor_by_restless=False)
expdata = amp_exp.run(backend)
self.assertExperimentDone(expdata)
result = expdata.analysis_results(1)
d_theta = result.value.n
self.assertTrue(abs(d_theta - error) > 0.01)
# check that the fit amplitude is much smaller than 1.
amp_fit = expdata.analysis_results(0).value[0]
self.assertTrue(amp_fit < 0.05)
def test_json(self):
"""Check if the node is serializable."""
node = Probability(outcome="00", alpha_prior=0.2)
self.assertRoundTripSerializable(node, check_func=self.json_equiv)
