Add a default optimization level to generate_preset_pass_manager

This commit adds a default value to the generate_preset_pass_manager's
optimization_level argument. If it's not specified optimization level 2
will be used. After #12148 optimization level 2 is a better fit for an
optimal tradeoff between heuristic effort and runtime that makes it
well suited as a default optimization level.

Author: mtreinish

qiskit/transpiler/preset_passmanagers/__init__.py

@@ -60,7 +60,8 @@
 import warnings
 
 from qiskit.transpiler.passmanager_config import PassManagerConfig
-from qiskit.transpiler.target import target_to_backend_properties
+from qiskit.transpiler.target import target_to_backend_properties, Target
+from qiskit.providers.backend import Backend
 from qiskit.transpiler import CouplingMap
 
 from .level0 import level_0_pass_manager
@@ -70,7 +71,7 @@
 
 
 def generate_preset_pass_manager(
-    optimization_level,
+    optimization_level=2,
     backend=None,
     target=None,
     basis_gates=None,
@@ -104,9 +105,10 @@ def generate_preset_pass_manager(
 
     Args:
         optimization_level (int): The optimization level to generate a
-            :class:`~.PassManager` for. This can be 0, 1, 2, or 3. Higher
-            levels generate more optimized circuits, at the expense of
-            longer transpilation time:
+            :class:`~.StagedPassManager` for. By default optimization level 2
+            is used if this is not specified. This can be 0, 1, 2, or 3. Higher
+            levels generate potentially more optimized circuits, at the expense
+            of longer transpilation time:
 
                 * 0: no optimization
                 * 1: light optimization
@@ -205,6 +207,16 @@ def generate_preset_pass_manager(
         ValueError: if an invalid value for ``optimization_level`` is passed in.
     """
 
+    # Handle positional arguments for target and backend. This enables the usage
+    # pattern `generate_preset_pass_manager(backend.target)` to generate a default
+    # pass manager for a given target.
+    if isinstance(optimization_level, Target):
+        target = optimization_level
+        optimization_level = 2
+    elif isinstance(optimization_level, Backend):
+        backend = optimization_level
+        optimization_level = 2
+
     if coupling_map is not None and not isinstance(coupling_map, CouplingMap):
         coupling_map = CouplingMap(coupling_map)
 

releasenotes/notes/default-level-2-generate-preset-passmanager-ec758ddc896ae2d6.yaml

@@ -0,0 +1,16 @@
+---
+features_transpiler:
+  - |
+    The ``optimization_level`` argument for the :func:`.generate_preset_pass_manager` function is
+    now optional. If it's not specified it will default to using optimization level 2. As the argument
+    is now optional, the first positional argument has been expanded to enable passing a :class:`.Target`
+    or a :class:`.BackendV2` as the first argument for more convenient construction. For example::
+
+      from qiskit.transpiler.preset_passmanager import generate_preset_pass_manager
+      from qiskit.providers.fake_provider import GenericBackendV2
+
+      backend = GenericBackendV2(100)
+
+      generate_preset_pass_manager(backend.Target)
+
+    will construct a default pass manager for the 100 qubit :class`.GenericBackendV2` instance.

test/python/transpiler/test_preset_passmanagers.py

@@ -1252,6 +1252,24 @@ def test_with_backend(self, optimization_level):
         pm = generate_preset_pass_manager(optimization_level, target)
         self.assertIsInstance(pm, PassManager)
 
+    def test_default_optimization_level(self):
+        """Test a pass manager is constructed with no optimization level."""
+        backend = GenericBackendV2(num_qubits=14, coupling_map=MELBOURNE_CMAP)
+        pm = generate_preset_pass_manager(backend=backend)
+        self.assertIsInstance(pm, PassManager)
+
+    def test_default_optimization_level_backend_first_pos_arg(self):
+        """Test a pass manager is constructed with only a positional backend."""
+        backend = GenericBackendV2(num_qubits=14, coupling_map=MELBOURNE_CMAP)
+        pm = generate_preset_pass_manager(backend)
+        self.assertIsInstance(pm, PassManager)
+
+    def test_default_optimization_level_target_first_pos_arg(self):
+        """Test a pass manager is constructed with only a positional target."""
+        backend = GenericBackendV2(num_qubits=14, coupling_map=MELBOURNE_CMAP)
+        pm = generate_preset_pass_manager(backend.target)
+        self.assertIsInstance(pm, PassManager)
+
     @data(0, 1, 2, 3)
     def test_with_no_backend(self, optimization_level):
         """Test a passmanager is constructed with no backend and optimization level."""