def test_composite_tags(self):
"""
Test the tags setter, add_tags_recursive, remove_tags_recursive
"""
exp1 = FakeExperiment([0, 2])
exp2 = FakeExperiment([1, 3])
par_exp = BatchExperiment([exp1, exp2])
expdata = par_exp.run(FakeBackend()).block_for_results()
data1 = expdata.child_data(0)
data2 = expdata.child_data(1)
expdata.tags = ["a", "c", "a"]
data1.tags = ["b"]
self.assertEqual(sorted(expdata.tags), ["a", "c"])
self.assertEqual(sorted(data1.tags), ["b"])
self.assertEqual(sorted(data2.tags), [])
expdata.add_tags_recursive(["d", "c"])
self.assertEqual(sorted(expdata.tags), ["a", "c", "d"])
self.assertEqual(sorted(data1.tags), ["b", "c", "d"])
self.assertEqual(sorted(data2.tags), ["c", "d"])
expdata.remove_tags_recursive(["a", "b"])
self.assertEqual(sorted(expdata.tags), ["c", "d"])
self.assertEqual(sorted(data1.tags), ["c", "d"])
self.assertEqual(sorted(data2.tags), ["c", "d"])
def test_parallel_options(self):
"""
Test parallel experiments overriding sub-experiment run and transpile options.
"""
# These options will all be overridden
exp0 = FakeExperiment([0])
exp0.set_transpile_options(optimization_level=1)
exp2 = FakeExperiment([2])
exp2.set_experiment_options(dummyoption="test")
exp2.set_run_options(shots=2000)
exp2.set_transpile_options(optimization_level=1)
exp2.analysis.set_options(dummyoption="test")
par_exp = ParallelExperiment([exp0, exp2])
with self.assertWarnsRegex(
Warning,
"Sub-experiment run and transpile options"
" are overridden by composite experiment options.",
):
self.assertEqual(par_exp.experiment_options, Options())
self.assertEqual(par_exp.run_options, Options(meas_level=2))
self.assertEqual(par_exp.transpile_options,
Options(optimization_level=0))
self.assertEqual(par_exp.analysis.options, Options())
par_exp.run(FakeBackend())
def test_job_splitting(self, max_experiments):
"""Test job splitting"""
num_circuits = 10
backend = FakeBackend(max_experiments=max_experiments)
class Experiment(FakeExperiment):
"""Fake Experiment to test job splitting"""
def circuits(self, backend=None):
"""Generate fake circuits"""
qc = QuantumCircuit(1)
qc.measure_all()
return num_circuits * [qc]
exp = Experiment(1)
expdata = exp.run(backend)
job_ids = expdata.job_ids
# Comptue expected number of jobs
if max_experiments is None:
num_jobs = 1
else:
num_jobs = num_circuits // max_experiments
if num_circuits % max_experiments:
num_jobs += 1
self.assertEqual(len(job_ids), num_jobs)
def test_analysis_replace_results_false(self):
"""
Test replace_results of composite experiment data
"""
exp1 = FakeExperiment([0, 2])
exp2 = FakeExperiment([1, 3])
par_exp = BatchExperiment([exp1, exp2])
data1 = par_exp.run(FakeBackend()).block_for_results()
# Additional data not part of composite experiment
exp3 = FakeExperiment([0, 1])
extra_data = exp3.run(FakeBackend()).block_for_results()
data1.add_child_data(extra_data)
# Replace results
data2 = par_exp.analysis.run(data1).block_for_results()
self.assertNotEqual(data1.experiment_id, data2.experiment_id)
self.assertEqual(len(data1.child_data()), len(data2.child_data()))
for sub1, sub2 in zip(data1.child_data(), data2.child_data()):
self.assertNotEqual(sub1.experiment_id, sub2.experiment_id)
def test_analysis_replace_results_true(self):
"""
Test replace results when analyzing composite experiment data
"""
exp1 = FakeExperiment([0, 2])
exp2 = FakeExperiment([1, 3])
par_exp = ParallelExperiment([exp1, exp2])
data1 = par_exp.run(FakeBackend()).block_for_results()
# Additional data not part of composite experiment
exp3 = FakeExperiment([0, 1])
extra_data = exp3.run(FakeBackend()).block_for_results()
data1.add_child_data(extra_data)
# Replace results
data2 = par_exp.analysis.run(data1,
replace_results=True).block_for_results()
self.assertEqual(data1, data2)
self.assertEqual(len(data1.child_data()), len(data2.child_data()))
for sub1, sub2 in zip(data1.child_data(), data2.child_data()):
self.assertEqual(sub1, sub2)
def test_nested_composite(self):
"""
Test nested parallel experiments.
"""
exp1 = FakeExperiment([0, 2])
exp2 = FakeExperiment([1, 3])
exp3 = ParallelExperiment([exp1, exp2])
exp4 = BatchExperiment([exp3, exp1])
exp5 = ParallelExperiment([exp4, FakeExperiment([4])])
nested_exp = BatchExperiment([exp5, exp3])
expdata = nested_exp.run(FakeBackend()).block_for_results()
status = expdata.status()
self.assertEqual(status.name, "DONE")
def setUp(self):
super().setUp()
self.backend = FakeBackend()
self.share_level = "hey"
exp1 = FakeExperiment([0, 2])
exp2 = FakeExperiment([1, 3])
par_exp = ParallelExperiment([exp1, exp2])
exp3 = FakeExperiment([0, 1, 2, 3])
batch_exp = BatchExperiment([par_exp, exp3])
self.rootdata = batch_exp.run(backend=self.backend).block_for_results()
self.assertEqual(len(self.rootdata.child_data()), 2)
self.rootdata.share_level = self.share_level
def experiment(
self,
experiment_id: str,
json_decoder: Type[json.JSONDecoder] = json.JSONDecoder) -> Dict:
"""Retrieve a previously stored experiment.
Args:
experiment_id: Experiment ID.
json_decoder: Custom JSON decoder to use to decode the retrieved experiment.
Returns:
A dictionary containing the retrieved experiment data.
"""
db_entry = copy.deepcopy(self.database[experiment_id])
db_entry["backend"] = FakeBackend()
return db_entry