def test_run_batch():
program = ParentProgram(
[
cirq.Circuit(
cirq.X(Q)**sympy.Symbol('t'), cirq.measure(Q, key='m')),
cirq.Circuit(
cirq.X(Q)**sympy.Symbol('x'), cirq.measure(Q, key='m2')),
],
None,
)
job = SimulatedLocalJob(
job_id='test_job',
processor_id='test1',
parent_program=program,
repetitions=100,
sweeps=[
cirq.Points(key='t', points=[1, 0]),
cirq.Points(key='x', points=[0, 1])
],
)
assert job.execution_status() == quantum.enums.ExecutionStatus.State.READY
results = job.batched_results()
assert np.all(results[0][0].measurements['m'] == 1)
assert np.all(results[0][1].measurements['m'] == 0)
assert np.all(results[1][0].measurements['m2'] == 0)
assert np.all(results[1][1].measurements['m2'] == 1)
assert job.execution_status(
) == quantum.enums.ExecutionStatus.State.SUCCESS
def test_cancel():
program = ParentProgram(
[cirq.Circuit(cirq.X(Q), cirq.measure(Q, key='m'))], None)
job = SimulatedLocalJob(job_id='test_job',
processor_id='test1',
parent_program=program,
repetitions=100,
sweeps=[])
job.cancel()
assert job.execution_status() == quantum.ExecutionStatus.State.CANCELLED
def test_run_calibration_unsupported():
program = ParentProgram([cirq.Circuit()], None)
job = SimulatedLocalJob(
job_id='test_job',
processor_id='test1',
parent_program=program,
repetitions=100,
sweeps=[{}],
)
with pytest.raises(NotImplementedError):
_ = job.calibration_results()
def run_sweep(
self,
program: cirq.AbstractCircuit,
program_id: Optional[str] = None,
job_id: Optional[str] = None,
params: cirq.Sweepable = None,
repetitions: int = 1,
program_description: Optional[str] = None,
program_labels: Optional[Dict[str, str]] = None,
job_description: Optional[str] = None,
job_labels: Optional[Dict[str, str]] = None,
) -> SimulatedLocalJob:
if program_id is None:
program_id = self._create_id(id_type='program')
if job_id is None:
job_id = self._create_id(id_type='job')
self._program_validator([program], [params], repetitions, CIRCUIT_SERIALIZER)
self._programs[program_id] = SimulatedLocalProgram(
program_id=program_id,
simulation_type=self._simulation_type,
circuits=[program],
processor=self,
engine=self.engine(),
)
job = SimulatedLocalJob(
job_id=job_id,
processor_id=self.processor_id,
parent_program=self._programs[program_id],
repetitions=repetitions,
sweeps=[params],
sampler=self._sampler,
simulation_type=self._simulation_type,
)
self._programs[program_id].add_job(job_id, job)
return job
def run_batch(
self,
programs: Sequence[cirq.AbstractCircuit],
program_id: Optional[str] = None,
job_id: Optional[str] = None,
params_list: Sequence[cirq.Sweepable] = None,
repetitions: int = 1,
program_description: Optional[str] = None,
program_labels: Optional[Dict[str, str]] = None,
job_description: Optional[str] = None,
job_labels: Optional[Dict[str, str]] = None,
) -> SimulatedLocalJob:
if program_id is None:
program_id = self._create_id(id_type='program')
if job_id is None:
job_id = self._create_id(id_type='job')
self._program_validator(programs, params_list or [{}], repetitions, CIRCUIT_SERIALIZER)
self._programs[program_id] = SimulatedLocalProgram(
program_id=program_id,
simulation_type=self._simulation_type,
circuits=programs,
engine=self.engine(),
processor=self,
)
job = SimulatedLocalJob(
job_id=job_id,
processor_id=self.processor_id,
parent_program=self._programs[program_id],
repetitions=repetitions,
sweeps=list(params_list) if params_list is not None else None,
sampler=self._sampler,
simulation_type=self._simulation_type,
)
self._programs[program_id].add_job(job_id, job)
return job
def test_run_async():
qubits = cirq.LineQubit.range(20)
c = cirq.testing.random_circuit(qubits, n_moments=20, op_density=1.0)
c.append(cirq.measure(*qubits))
program = ParentProgram([c], None)
job = SimulatedLocalJob(
job_id='test_job',
processor_id='test1',
parent_program=program,
repetitions=100,
sweeps=[{}],
simulation_type=LocalSimulationType.ASYNCHRONOUS,
)
assert job.execution_status() == quantum.ExecutionStatus.State.RUNNING
_ = job.results()
assert job.execution_status() == quantum.ExecutionStatus.State.SUCCESS
def test_delete():
program = SimulatedLocalProgram([cirq.Circuit()], None, program_id='program')
job1 = SimulatedLocalJob(
job_id='test_job1', processor_id='test1', parent_program=program, repetitions=100, sweeps=[]
)
job2 = SimulatedLocalJob(
job_id='test_job2', processor_id='test1', parent_program=program, repetitions=100, sweeps=[]
)
job3 = SimulatedLocalJob(
job_id='test_job3', processor_id='test1', parent_program=program, repetitions=100, sweeps=[]
)
program.add_job(job1.id(), job1)
program.add_job(job2.id(), job2)
program.add_job(job3.id(), job3)
assert set(program.list_jobs()) == {job1, job2, job3}
program.delete_job(job2.id())
assert set(program.list_jobs()) == {job1, job3}
program.delete(delete_jobs=True)
assert program.list_jobs() == []
def test_run_batch(simulation_type):
program = ParentProgram(
[
cirq.Circuit(
cirq.X(Q)**sympy.Symbol('t'), cirq.measure(Q, key='m')),
cirq.Circuit(
cirq.X(Q)**sympy.Symbol('x'), cirq.measure(Q, key='m2')),
],
None,
)
job = SimulatedLocalJob(
job_id='test_job',
processor_id='test1',
parent_program=program,
simulation_type=simulation_type,
repetitions=100,
sweeps=[
cirq.Points(key='t', points=[1, 0]),
cirq.Points(key='x', points=[0, 1])
],
)
if simulation_type == LocalSimulationType.ASYNCHRONOUS:
# Note: The simulation could have finished already
assert (job.execution_status() == quantum.ExecutionStatus.State.RUNNING
or job.execution_status()
== quantum.ExecutionStatus.State.SUCCESS)
else:
assert job.execution_status() == quantum.ExecutionStatus.State.READY
results = job.batched_results()
assert np.all(results[0][0].measurements['m'] == 1)
assert np.all(results[0][1].measurements['m'] == 0)
assert np.all(results[1][0].measurements['m2'] == 0)
assert np.all(results[1][1].measurements['m2'] == 1)
assert job.execution_status() == quantum.ExecutionStatus.State.SUCCESS
# Using flattened results
results = job.results()
assert np.all(results[0].measurements['m'] == 1)
assert np.all(results[1].measurements['m'] == 0)
assert np.all(results[2].measurements['m2'] == 0)
assert np.all(results[3].measurements['m2'] == 1)
for result in results:
assert result.job_id == 'test_job'
assert result.job_finished_time is not None
assert results == cirq.read_json(json_text=cirq.to_json(results))
def test_run():
program = ParentProgram(
[cirq.Circuit(cirq.X(Q), cirq.measure(Q, key='m'))], None)
job = SimulatedLocalJob(job_id='test_job',
processor_id='test1',
parent_program=program,
repetitions=100,
sweeps=[])
assert job.id() == 'test_job'
assert job.execution_status() == quantum.enums.ExecutionStatus.State.READY
results = job.results()
assert np.all(results[0].measurements['m'] == 1)
assert job.execution_status(
) == quantum.enums.ExecutionStatus.State.SUCCESS
def test_unsupported_types():
program = ParentProgram(
[cirq.Circuit(cirq.X(Q), cirq.measure(Q, key='m'))], None)
job = SimulatedLocalJob(
job_id='test_job',
processor_id='test1',
parent_program=program,
repetitions=100,
sweeps=[],
simulation_type=LocalSimulationType.ASYNCHRONOUS,
)
with pytest.raises(ValueError, match='Unsupported simulation type'):
job.results()
with pytest.raises(ValueError, match='Unsupported simulation type'):
job.batched_results()
def test_failure():
program = ParentProgram(
[cirq.Circuit(cirq.X(Q)**sympy.Symbol('t'), cirq.measure(Q, key='m'))],
None)
job = SimulatedLocalJob(
job_id='test_job',
processor_id='test1',
parent_program=program,
repetitions=100,
sweeps=[cirq.Points(key='x', points=[1, 0])],
)
try:
_ = job.results()
except ValueError:
code, message = job.failure()
assert code == '500'
assert 'Circuit contains ops whose symbols were not specified' in message
try:
_ = job.batched_results()
except ValueError:
code, message = job.failure()
assert code == '500'
assert 'Circuit contains ops whose symbols were not specified' in message
