def calibration_results(self):
"""Returns the results of a run_calibration() call.
This function will fail if any other type of results were returned
by the Engine.
"""
import cirq_google.engine.engine as engine_base
if not self._calibration_results:
result = self._wait_for_result()
result_type = result.type_url[len(engine_base.TYPE_PREFIX):]
if result_type != 'cirq.google.api.v2.FocusedCalibrationResult':
raise ValueError(
f'Did not find calibration results, instead found: {result_type}'
)
parsed_val = v2.calibration_pb2.FocusedCalibrationResult.FromString(
result.value)
cal_results = []
for layer in parsed_val.results:
metrics = calibration.Calibration(layer.metrics)
message = layer.error_message or None
token = layer.token or None
if layer.valid_until_ms > 0:
ts = datetime.datetime.fromtimestamp(layer.valid_until_ms /
1000)
else:
ts = None
cal_results.append(
CalibrationResult(layer.code, message, token, ts, metrics))
self._calibration_results = cal_results
return self._calibration_results
def get_calibration(self) -> Optional[calibration.Calibration]:
"""Returns the recorded calibration at the time when the job was run, if
one was captured, else None."""
status = self._inner_job().execution_status
if not status.calibration_name:
return None
ids = engine_client._ids_from_calibration_name(status.calibration_name)
response = self.context.client.get_calibration(*ids)
metrics = v2.metrics_pb2.MetricsSnapshot.FromString(response.data.value)
return calibration.Calibration(metrics)
def _create_perfect_calibration(
device: cirq.Device) -> calibration.Calibration:
all_metrics: calibration.ALL_METRICS = {}
if device.metadata is None:
raise ValueError(
'Devices for noiseless Virtual Engine must have qubits')
qubit_set = device.metadata.qubit_set
qubits = [cast(cirq.GridQubit, q) for q in qubit_set]
for name in METRICS_1Q:
all_metrics[name] = {(q, ): [0.0] for q in qubits}
for name in METRICS_2Q:
metric_dict: calibration.METRIC_DICT = {}
if device.metadata is not None:
for pair in device.metadata.nx_graph.edges():
qubits = [cast(cirq.GridQubit, q) for q in pair]
metric_dict[(qubits[0], qubits[1])] = [0.0]
all_metrics[name] = metric_dict
all_metrics[T1_METRIC_NAME] = {(q, ): [PERFECT_T1_VALUE] for q in qubits}
snapshot = v2.metrics_pb2.MetricsSnapshot()
snapshot.timestamp_ms = int(time.time() * 1000)
return calibration.Calibration(calibration=snapshot, metrics=all_metrics)
def test_get_programs():
program1 = NothingProgram([cirq.Circuit()], None)
job1 = NothingJob(
job_id='test3', processor_id='proc', parent_program=program1, repetitions=100, sweeps=[]
)
program1.add_job('jerb', job1)
job1.add_labels({'color': 'blue'})
program2 = NothingProgram([cirq.Circuit()], None)
job2 = NothingJob(
job_id='test4', processor_id='crop', parent_program=program2, repetitions=100, sweeps=[]
)
program2.add_job('jerb2', job2)
job2.add_labels({'color': 'red'})
processor1 = ProgramDictProcessor(programs={'prog1': program1}, processor_id='proc')
processor2 = ProgramDictProcessor(programs={'prog2': program2}, processor_id='crop')
engine = NothingEngine([processor1, processor2])
assert engine.get_program('prog1') == program1
with pytest.raises(KeyError, match='does not exist'):
engine.get_program('invalid_id')
assert set(engine.list_programs()) == {program1, program2}
assert set(engine.list_jobs()) == {job1, job2}
assert engine.list_jobs(has_labels={'color': 'blue'}) == [job1]
assert engine.list_jobs(has_labels={'color': 'red'}) == [job2]
program3 = NothingProgram([cirq.Circuit()], engine)
assert program3.engine() == engine
job3 = NothingJob(
job_id='test5', processor_id='crop', parent_program=program3, repetitions=100, sweeps=[]
)
assert job3.program() == program3
assert job3.engine() == engine
assert job3.get_processor() == processor2
assert job3.get_calibration() == calibration.Calibration()
def _to_calibration(
calibration_any: qtypes.any_pb2.Any) -> calibration.Calibration:
metrics = v2.metrics_pb2.MetricsSnapshot.FromString(calibration_any.value)
return calibration.Calibration(metrics)
def get_latest_calibration(self, timestamp: int) -> Optional[calibration.Calibration]:
return calibration.Calibration()
