Add QVM helper extract_gate_times_ns_from_device (#7350)

* Add QVM helper `extract_gate_times_ns_from_device`

Gate times are necessary for noisy quantum virtual machine simulations.
Provide adapter to fetch them from GridDeviceMetadata (which are supplied
for known QVMs) rather than from user-provided value or hard-coded default.

Prerequisite for QVM update, b/395705720

* Fix missing line and fill in coverage

* Nit - rename `gtype` --> `gate_type`

* Use separate unit test for GridDevice without duration data

Author: pavoljuhas

cirq-google/cirq_google/engine/virtual_engine_factory.py

@@ -13,22 +13,28 @@
 # limitations under the License.
 
 """Functions to instantiate SimulatedLocalEngines to simulate various Google Devices."""
+
+from __future__ import annotations
+
 import json
 import pathlib
 import time
-from typing import cast, List, Optional, Type, Union
+from typing import cast, Dict, List, Optional, Type, TYPE_CHECKING, Union
 
 import google.protobuf.text_format as text_format
 
 import cirq
-from cirq.sim.simulator import SimulatesSamples
 from cirq_google.api import v2
 from cirq_google.devices import grid_device
 from cirq_google.devices.google_noise_properties import NoiseModelFromGoogleNoiseProperties
 from cirq_google.engine import calibration, engine_validator, simulated_local_processor, util
 from cirq_google.engine.calibration_to_noise_properties import noise_properties_from_calibration
 from cirq_google.engine.simulated_local_engine import SimulatedLocalEngine
 from cirq_google.engine.simulated_local_processor import SimulatedLocalProcessor
+from cirq_google.ops import fsim_gate_family
+
+if TYPE_CHECKING:
+    import cirq_google
 
 MOST_RECENT_TEMPLATES = {
     'rainbow': 'rainbow_2021_12_10_device_spec_for_grid_device.proto.txt',
@@ -303,8 +309,8 @@ def create_device_spec_from_processor_id(processor_id: str) -> v2.device_pb2.Dev
     return _create_device_spec_from_template(template_name)
 
 
-def create_device_from_processor_id(processor_id: str) -> cirq.Device:
-    """Generates a `cirq.Device` for a given processor ID.
+def create_device_from_processor_id(processor_id: str) -> grid_device.GridDevice:
+    """Generates a `cirq_google.GridDevice` for a given processor ID.
 
     Args:
         processor_id: name of the processor to simulate.
@@ -385,7 +391,7 @@ def create_noiseless_virtual_engine_from_latest_templates() -> SimulatedLocalEng
 
 
 def create_default_noisy_quantum_virtual_machine(
-    processor_id: str, simulator_class: Optional[Type[SimulatesSamples]] = None, **kwargs
+    processor_id: str, simulator_class: Optional[Type[cirq.SimulatesSamples]] = None, **kwargs
 ) -> SimulatedLocalEngine:
     """Creates a virtual engine with a noisy simulator based on a processor id.
 
@@ -425,3 +431,40 @@ def create_default_noisy_quantum_virtual_machine(
     )
 
     return SimulatedLocalEngine([simulated_processor])
+
+
+def extract_gate_times_ns_from_device(
+    device: cirq_google.GridDevice,
+) -> Dict[Type[cirq.Gate], float]:
+    """Extract a dictionary of gate durations in nanoseconds from GridDevice object.
+
+    The durations are obtained from `GridDevice.metadata` field which is
+    provided for devices obtained with `create_device_from_processor_id`.
+
+    Args:
+        device: Object representing Google devices with a grid qubit layout.
+
+    Returns:
+        A dictionary of gate durations versus supported gate types.  Returns an
+        empty dictionary when `device.metadata` do not provide gate durations.
+    """
+    gate_times_ns: Dict[Type[cirq.Gate], float] = {}
+    if not device.metadata.gate_durations:
+        return gate_times_ns
+    gate_type: Type[cirq.Gate]  # pragma: no cover
+    for gate_family, duration in device.metadata.gate_durations.items():
+        if isinstance(gate_family, fsim_gate_family.FSimGateFamily):
+            for g in gate_family.gates_to_accept:
+                gate_type = g if isinstance(g, type) else type(g)
+                gate_times_ns[gate_type] = duration.total_nanos()
+            continue
+        # ordinary GateFamily here
+        gate_type = (
+            gate_family.gate if isinstance(gate_family.gate, type) else type(gate_family.gate)
+        )
+        gate_times_ns[gate_type] = duration.total_nanos()
+    # cirq.IdentityGate can leak from FSimGateFamily.  Exclude to default to zero duration.
+    _ = gate_times_ns.pop(cirq.IdentityGate, None)
+    # cirq.WaitGate has variable duration and should not be included here.
+    _ = gate_times_ns.pop(cirq.WaitGate, None)
+    return gate_times_ns

cirq-google/cirq_google/engine/virtual_engine_factory_test.py

@@ -208,3 +208,20 @@ def test_create_default_noisy_quantum_virtual_machine():
         expected = factory.create_device_spec_from_processor_id(processor_id)
         assert device_specification is not None
         assert device_specification == expected
+
+
+def test_extract_gate_times_ns_from_device():
+    device = factory.create_device_from_processor_id('rainbow')
+    gate_times_ns = factory.extract_gate_times_ns_from_device(device)
+    assert gate_times_ns[cirq.MeasurementGate] == 4_000_000
+    assert gate_times_ns[cg.SycamoreGate] == 12
+    assert cirq.IdentityGate not in gate_times_ns
+    assert cirq.WaitGate not in gate_times_ns
+
+
+def test_extract_gate_times_ns_from_device_without_durations():
+    metadata_without_durations = cirq.GridDeviceMetadata(
+        qubit_pairs=[tuple(cirq.GridQubit.rect(2, 1))], gateset=cirq.Gateset(cirq.XPowGate)
+    )
+    device_without_durations = cg.GridDevice(metadata_without_durations)
+    assert factory.extract_gate_times_ns_from_device(device_without_durations) == {}