Fix AerBackend issues caused by upgrading BackendV2

qiskit_aer/backends/aer_simulator.py

@@ -518,6 +518,7 @@ class AerSimulator(AerBackend):
                 "continue_loop",
                 "reset",
                 "switch_case",
+                "barrier",
             ]
         ),
         "density_matrix": sorted(
@@ -542,6 +543,7 @@ class AerSimulator(AerBackend):
                 "continue_loop",
                 "reset",
                 "switch_case",
+                "barrier",
             ]
         ),
         "matrix_product_state": sorted(
@@ -568,6 +570,7 @@ class AerSimulator(AerBackend):
                 "continue_loop",
                 "reset",
                 "switch_case",
+                "barrier",
             ]
         ),
         "stabilizer": sorted(
@@ -591,6 +594,7 @@ class AerSimulator(AerBackend):
                 "continue_loop",
                 "reset",
                 "switch_case",
+                "barrier",
             ]
         ),
         "extended_stabilizer": sorted(
@@ -600,6 +604,7 @@ class AerSimulator(AerBackend):
                 "roerror",
                 "save_statevector",
                 "reset",
+                "barrier",
             ]
         ),
         "unitary": sorted(
@@ -608,6 +613,7 @@ class AerSimulator(AerBackend):
                 "save_unitary",
                 "set_unitary",
                 "reset",
+                "barrier",
             ]
         ),
         "superop": sorted(
@@ -620,6 +626,7 @@ class AerSimulator(AerBackend):
                 "save_superop",
                 "set_superop",
                 "reset",
+                "barrier",
             ]
         ),
         "tensor_network": sorted(
@@ -643,6 +650,7 @@ class AerSimulator(AerBackend):
                 "set_density_matrix",
                 "reset",
                 "switch_case",
+                "barrier",
             ]
         ),
     }
@@ -695,7 +703,9 @@ class AerSimulator(AerBackend):
 
     _AVAILABLE_DEVICES = None
 
-    def __init__(self, configuration=None, properties=None, provider=None, **backend_options):
+    def __init__(
+        self, configuration=None, properties=None, provider=None, target=None, **backend_options
+    ):
         self._controller = aer_controller_execute()
 
         # Update available methods and devices for class
@@ -717,7 +727,11 @@ def __init__(self, configuration=None, properties=None, provider=None, **backend
         self._cached_basis_gates = self._BASIS_GATES["automatic"]
 
         super().__init__(
-            configuration, properties=properties, provider=provider, backend_options=backend_options
+            configuration,
+            properties=properties,
+            provider=provider,
+            target=target,
+            backend_options=backend_options,
         )
 
     @classmethod
@@ -812,6 +826,11 @@ def _name(self):
     def from_backend(cls, backend, **options):
         """Initialize simulator from backend."""
         if isinstance(backend, BackendV2):
+            if backend.description is None:
+                description = "created by AerSimulator.from_backend"
+            else:
+                description = backend.description
+
             configuration = QasmBackendConfiguration(
                 backend_name=f"'aer_simulator({backend.name})",
                 backend_version=backend.backend_version,
@@ -826,9 +845,10 @@ def from_backend(cls, backend, **options):
                 max_shots=int(1e6),
                 coupling_map=list(backend.coupling_map.get_edges()),
                 max_experiments=backend.max_circuits,
-                description=backend.description,
+                description=description,
             )
             properties = target_to_backend_properties(backend.target)
+            target = backend.target
         elif isinstance(backend, BackendV1):
             # Get configuration and properties from backend
             configuration = copy.copy(backend.configuration())
@@ -837,6 +857,8 @@ def from_backend(cls, backend, **options):
             # Customize configuration name
             name = configuration.backend_name
             configuration.backend_name = f"aer_simulator({name})"
+
+            target = None
         else:
             raise TypeError(
                 "The backend argument requires a BackendV2 or BackendV1 object, "
@@ -853,7 +875,7 @@ def from_backend(cls, backend, **options):
                 options["noise_model"] = noise_model
 
         # Initialize simulator
-        sim = cls(configuration=configuration, properties=properties, **options)
+        sim = cls(configuration=configuration, properties=properties, target=target, **options)
         return sim
 
     def available_methods(self):

qiskit_aer/backends/aerbackend.py

@@ -29,6 +29,7 @@
 from qiskit.pulse import Schedule, ScheduleBlock
 from qiskit.qobj import QasmQobj, PulseQobj
 from qiskit.result import Result
+from qiskit.transpiler import CouplingMap
 from ..aererror import AerError
 from ..jobs import AerJob, AerJobSet, split_qobj
 from ..noise.noise_model import NoiseModel, QuantumErrorLocation
@@ -48,7 +49,7 @@ class AerBackend(Backend, ABC):
     """Aer Backend class."""
 
     def __init__(
-        self, configuration, properties=None, defaults=None, backend_options=None, provider=None
+        self, configuration, properties=None, provider=None, target=None, backend_options=None
     ):
         """Aer class for backends.
 
@@ -59,8 +60,8 @@ def __init__(
         Args:
             configuration (BackendConfiguration): backend configuration.
             properties (BackendProperties or None): Optional, backend properties.
-            defaults (PulseDefaults or None): Optional, backend pulse defaults.
             provider (Provider): Optional, provider responsible for this backend.
+            target (Target):  initial target for backend
             backend_options (dict or None): Optional set custom backend options.
 
         Raises:
@@ -76,22 +77,24 @@ def __init__(
             backend_version=configuration.backend_version,
         )
 
-        # Initialize backend properties and pulse defaults.
+        # Initialize backend properties
         self._properties = properties
-        self._defaults = defaults
         self._configuration = configuration
 
-        # Custom option values for config, properties, and defaults
+        # Custom option values for config, properties
         self._options_configuration = {}
-        self._options_defaults = {}
         self._options_properties = {}
-        self._target = None
+        self._target = target
         self._mapping = NAME_MAPPING
 
         # Set options from backend_options dictionary
         if backend_options is not None:
             self.set_options(**backend_options)
 
+        # build coupling map
+        if self.configuration().coupling_map is not None:
+            self._coupling_map = CouplingMap(self.configuration().coupling_map)
+
     def _convert_circuit_binds(self, circuit, binds, idx_map):
         parameterizations = []
 
@@ -330,18 +333,6 @@ def properties(self):
             setattr(properties, key, val)
         return properties
 
-    def defaults(self):
-        """Return the simulator backend pulse defaults.
-
-        Returns:
-            PulseDefaults: The backend pulse defaults or ``None`` if the
-                           backend does not support pulse.
-        """
-        defaults = copy.copy(self._defaults)
-        for key, val in self._options_defaults.items():
-            setattr(defaults, key, val)
-        return defaults
-
     @property
     def max_circuits(self):
         if hasattr(self.configuration(), "max_experiments"):
@@ -351,17 +342,16 @@ def max_circuits(self):
 
     @property
     def target(self):
-        self._target = convert_to_target(
-            self.configuration(), self.properties(), self.defaults(), self._mapping
-        )
-        return self._target
+        if self._target is not None:
+            return self._target
+
+        return convert_to_target(self.configuration(), self.properties(), None, NAME_MAPPING)
 
     def clear_options(self):
         """Reset the simulator options to default values."""
         self._options = self._default_options()
         self._options_configuration = {}
         self._options_properties = {}
-        self._options_defaults = {}
 
     def status(self):
         """Return backend status.
@@ -702,8 +692,6 @@ def set_option(self, key, value):
             self._set_configuration_option(key, value)
         elif hasattr(self._properties, key):
             self._set_properties_option(key, value)
-        elif hasattr(self._defaults, key):
-            self._set_defaults_option(key, value)
         else:
             if not hasattr(self._options, key):
                 raise AerError(f"Invalid option {key}")
@@ -735,15 +723,15 @@ def _set_properties_option(self, key, value):
         elif key in self._options_properties:
             self._options_properties.pop(key)
 
-    def _set_defaults_option(self, key, value):
-        """Special handling for setting backend defaults options."""
-        if value is not None:
-            self._options_defaults[key] = value
-        elif key in self._options_defaults:
-            self._options_defaults.pop(key)
-
     def __repr__(self):
         """String representation of an AerBackend."""
         name = self.__class__.__name__
         display = f"'{self.name}'"
         return f"{name}({display})"
+
+    def get_translation_stage_plugin(self):
+        """use custom translation method to avoid gate exchange"""
+        if self._target is None:
+            return "aer_backend_plugin"
+        else:
+            return None