Merge branch 'main' into qhc-783-monthly-okr-report

docs/code/transpiler.rst

@@ -1,4 +1,4 @@
-ql.transpiler
-===============
+ql.circuit_transpiler
+=========================
 
 .. automodule:: qililab.digital

docs/releases/changelog-dev.md

@@ -2,6 +2,14 @@
 
 ### New features since last release
 
+- Support GRES in %%submit_job magic method
+
+[#828](https://github.com/qilimanjaro-tech/qililab/pull/828)
+
+- Added intermediate frequency to single input lines on qm. The default is 0 (this prevents some bugs from qua-qm). Now it is possible to use the set_parameter IF and qm.set_frequency for buses with single_input.
+
+[#807](https://github.com/qilimanjaro-tech/qililab/pull/807)
+
 - A new `GetParameter` operation has been added to the Experiment class, accessible via the `.get_parameter()` method. This allows users to dynamically retrieve parameters during experiment execution, which is particularly useful when some variables do not have a value at the time of experiment definition but are provided later through external operations. The operation returns a `Variable` that can be used seamlessly within `SetParameter` and `ExecuteQProgram`.
 
   Example:
@@ -85,6 +93,71 @@
 
   [#816](https://github.com/qilimanjaro-tech/qililab/pull/816)
 
+- Added routing algorithms to `qililab` in function of the platform connectivity. This is done passing `Qibo` own `Routers` and `Placers` classes,
+  and can be called from different points of the stack.
+
+  The most common way to route, will be automatically through `qililab.execute_circuit.execute()`, or also from `qililab.platform.execute/compile()`. Another way, would be doing the transpilation/routing directly from an instance of the Transpiler, with: `qililab.digital.circuit_transpiler.transpile/route_circuit()` (with this last one, you can route with a different topology from the platform one, if desired, defaults to platform)
+
+  Example:
+
+  ```python
+  from qibo import gates
+  from qibo.models import Circuit
+  from qibo.transpiler.placer import ReverseTraversal, Trivial
+  from qibo.transpiler.router import Sabre
+  from qililab import build_platform
+  from qililab.circuit_transpiler import CircuitTranspiler
+
+  # Create circuit:
+  c = Circuit(5)
+  c.add(gates.CNOT(1, 0))
+
+  ### From execute_circuit:
+  # With defaults (ReverseTraversal placer and Sabre routing):
+  probabilities = ql.execute(c, runcard="./runcards/galadriel.yml", placer= Trivial, router = Sabre, routing_iterations: int = 10,)
+  # Changing the placer to Trivial, and changing the number of iterations:
+  probabilities = ql.execute(c, runcard="./runcards/galadriel.yml",
+
+  ### From the platform:
+  # Create platform:
+  platform = build_platform(runcard="<path_to_runcard>")
+  # With defaults (ReverseTraversal placer, Sabre routing)
+  probabilities = platform.execute(c, num_avg: 1000, repetition_duration: 1000)
+  # With non-defaults, and specifying the router with kwargs:
+  probabilities = platform.execute(c, num_avg: 1000, repetition_duration: 1000,  placer= Trivial, router = (Sabre, {"lookahead": 2}), routing_iterations: int = 20))
+  # With a router instance:
+  router = Sabre(connectivity=None, lookahead=1) # No connectivity needed, since it will be overwritten by the platform's one
+  probabilities = platform.execute(c, num_avg: 1000, repetition_duration: 1000, placer=Trivial, router=router)
+
+  ### Using the transpiler directly:
+  ### (If using the routing from this points of the stack, you can route with a different topology from the platform one)
+  # Create transpiler:
+  transpiler = CircuitTranspiler(platform)
+  # Default Transpilation (ReverseTraversal, Sabre and Platform connectivity):
+  routed_circ, final_layouts = transpiler.route_circuit([c])
+  # With Non-Default Trivial placer, specifying the kwargs, for the router, and different coupling_map:
+  routed_circ, final_layouts = transpiler.route_circuit([c], placer=Trivial, router=(Sabre, {"lookahead": 2}, coupling_map=<some_different_topology>))
+  # Or finally, Routing with a concrete Routing instance:
+  router = Sabre(connectivity=None, lookahead=1) # No connectivity needed, since it will be overwritten by the specified in the Transpiler:
+  routed_circ, final_layouts = transpiler.route_circuit([c], placer=Trivial, router=router, coupling_map=<connectivity_to_use>)
+  ```
+
+[#821](https://github.com/qilimanjaro-tech/qililab/pull/821)
+
+- Added a timeout inside quantum machines to control the `wait_for_all_values` function. The timeout is controlled through the runcard as shown in the example:
+
+  ```json
+  instruments:
+    - name: quantum_machines_cluster
+      alias: QMM
+      ...
+      timeout: 10000 # optional timeout in seconds
+      octaves:
+      ...
+  ```
+
+[#826](https://github.com/qilimanjaro-tech/qililab/pull/826)
+
 ### Improvements
 
 - Legacy linting and formatting tools such as pylint, flake8, isort, bandit, and black have been removed. These have been replaced with Ruff, a more efficient tool that handles both linting and formatting. All configuration settings have been consolidated into the `pyproject.toml` file, simplifying the project's configuration and maintenance. Integration config files like `pre-commit-config.yaml` and `.github/workflows/code_quality.yml` have been updated accordingly. Several rules from Ruff have also been implemented to improve code consistency and quality across the codebase. Additionally, the development dependencies in `dev-requirements.txt` have been updated to their latest versions, ensuring better compatibility and performance. [#813](https://github.com/qilimanjaro-tech/qililab/pull/813)
@@ -95,7 +168,7 @@
 
   Example (for Qblox)
 
-  ```
+  ```json
   buses:
   - alias: readout
     ...
@@ -160,6 +233,10 @@
 
 - Added a `save_plot=True` parameter to the `plotS21()` method of `ExperimentResults`. When enabled (default: True), the plot is automatically saved in the same directory as the experiment results. [#819](https://github.com/qilimanjaro-tech/qililab/pull/819)
 
+- Improved the transpiler, by making it more modular, and adding a `gate_cancellation()` stage before the transpilation to natives, this stage can be skipped, together with the old `optimize_transpilation()`, if the flag `optimize=False` is passed.
+
+[#823](https://github.com/qilimanjaro-tech/qililab/pull/823)
+
 ### Breaking changes
 
 - Renamed the platform's `execute_anneal_program()` method to `execute_annealing_program()` and updated its parameters. The method now expects `preparation_block` and `measurement_block`, which are strings used to retrieve blocks from the `Calibration`. These blocks are inserted before and after the annealing schedule, respectively.

requirements.txt

@@ -1,5 +1,5 @@
 pandas==1.5.3
-qibo==0.2.8
+qibo==0.2.12
 qblox-instruments==0.11.2
 qcodes==0.42.0
 qcodes_contrib_drivers==0.18.0

src/qililab/digital/__init__.py

@@ -15,21 +15,16 @@
 """
 This module contains all the decomposition and transpilation methods used within qililab.
 
-.. currentmodule:: qililab
-
 Transpilation
 ~~~~~~~~~~~~~
 
-.. autosummary::
-    :toctree: api
-
-Gate Decomposition
-~~~~~~~~~~~~~~~~~~
-
 .. currentmodule:: qililab.digital
 
 .. autosummary::
     :toctree: api
+
+    ~CircuitTranspiler
+
 """
 
 from .circuit_transpiler import CircuitTranspiler