Merge pull request #242 from BoxiLi/fix_qtrl_error

Use qutip_qtrl master branch and make tests optional

Author: BoxiLi

.github/workflows/test.yml

@@ -61,6 +61,11 @@ jobs:
       if: ${{ startsWith( matrix.qutip-version, '@') }}
       run: |
         python -m pip install 'git+https://github.com/qutip/qutip.git${{ matrix.qutip-version }}'
+        
+    - name: Install qutip-qtrl from GitHub
+      if: ${{ matrix.qutip-version == '@master' }}
+      run: |
+        python -m pip install 'git+https://github.com/qutip/qutip-qtrl.git${{ matrix.qutip-version }}'
 
     - name: Install Qiskit from PyPI
       if: ${{ matrix.qiskit-version != '' }}
@@ -69,7 +74,8 @@ jobs:
     - name: Install qutip-qip
       # Installing in-place so that coveralls can locate the source code.
       run: |
-        pip install -e .[full]
+        pip install matplotlib pytest
+        pip install -e .
     - name: Test with pytest and generate coverage report
       run: |
         pip install pytest-cov coveralls

src/qutip_qip/device/optpulseprocessor.py

@@ -5,7 +5,6 @@
 import numpy as np
 
 from qutip import Qobj, identity, tensor, mesolve
-import qutip.control.pulseoptim as cpo
 from ..circuit import QubitCircuit
 from .processor import Processor
 from ..operations import gate_sequence_product, expand_operator
@@ -195,6 +194,8 @@ def load_circuit(
                 ),
             )
 
+            import qutip.control.pulseoptim as cpo
+
             result = cpo.optimize_pulse_unitary(
                 full_drift_ham, full_ctrls_hams, U_0, U_targ, **kwargs
             )

tests/test_optpulseprocessor.py

@@ -1,21 +1,30 @@
 import os
 
-from numpy.testing import (assert_, assert_allclose,
-                           assert_equal)
+from numpy.testing import assert_, assert_allclose, assert_equal
 import numpy as np
 import pytest
 
+pytest.importorskip("qutip_qtrl")
 from qutip_qip.device import OptPulseProcessor, SpinChainModel
 from qutip_qip.circuit import QubitCircuit
 from qutip_qip.qubits import qubit_states
 import qutip
-from qutip import (fidelity, Qobj, tensor, rand_ket, basis,  sigmaz,
-                    sigmax, sigmay, identity, destroy)
+from qutip import (
+    fidelity,
+    tensor,
+    rand_ket,
+    sigmaz,
+    sigmax,
+    sigmay,
+    identity,
+)
 from qutip_qip.operations import (
-    cnot, hadamard_transform, expand_operator, gate_sequence_product)
+    cnot,
+)
 import qutip
 from packaging.version import parse as parse_version
-if parse_version(qutip.__version__) < parse_version('5.dev'):
+
+if parse_version(qutip.__version__) < parse_version("5.dev"):
     from qutip import Options as SolverOptions
 else:
     from qutip import SolverOptions
@@ -38,7 +47,8 @@ def test_simple_hadamard(self):
         test = OptPulseProcessor(N, drift=H_d)
         test.add_control(H_c, targets=0)
         tlist, coeffs = test.load_circuit(
-            qc, num_tslots=num_tslots, evo_time=evo_time, verbose=True)
+            qc, num_tslots=num_tslots, evo_time=evo_time, verbose=True
+        )
 
         # test run_state
         rho0 = qubit_states(1, [0])
@@ -51,36 +61,35 @@ def test_multi_qubits(self):
         Test for multi-qubits system.
         """
         N = 3
-        H_d = tensor([sigmaz()]*3)
+        H_d = tensor([sigmaz()] * 3)
         H_c = []
 
         # test empty ctrls
         num_tslots = 30
         evo_time = 10
         test = OptPulseProcessor(N)
         test.add_drift(H_d, [0, 1, 2])
-        test.add_control(tensor([sigmax(), sigmax()]),
-                          cyclic_permutation=True)
+        test.add_control(tensor([sigmax(), sigmax()]), cyclic_permutation=True)
         # test periodically adding ctrls
         sx = sigmax()
         iden = identity(2)
-        assert(len(test.get_control_labels()) == 3)
+        assert len(test.get_control_labels()) == 3
         test.add_control(sigmax(), cyclic_permutation=True)
         test.add_control(sigmay(), cyclic_permutation=True)
 
         # test pulse genration for cnot gate, with kwargs
         qc = [tensor([identity(2), cnot()])]
-        test.load_circuit(qc, num_tslots=num_tslots,
-                          evo_time=evo_time, min_fid_err=1.0e-6)
+        test.load_circuit(
+            qc, num_tslots=num_tslots, evo_time=evo_time, min_fid_err=1.0e-6
+        )
         rho0 = qubit_states(3, [1, 1, 1])
         rho1 = qubit_states(3, [1, 1, 0])
-        result = test.run_state(
-            rho0, options=SolverOptions(store_states=True))
-        assert_(fidelity(result.states[-1], rho1) > 1-1.0e-6)
+        result = test.run_state(rho0, options=SolverOptions(store_states=True))
+        assert_(fidelity(result.states[-1], rho1) > 1 - 1.0e-6)
 
     def test_multi_gates(self):
         N = 2
-        H_d = tensor([sigmaz()]*2)
+        H_d = tensor([sigmaz()] * 2)
         H_c = []
 
         test = OptPulseProcessor(N)
@@ -90,22 +99,23 @@ def test_multi_gates(self):
         test.add_control(tensor([sigmay(), sigmay()]))
 
         # qubits circuit with 3 gates
-        setting_args = {"SNOT": {"num_tslots": 10, "evo_time": 1},
-                        "SWAP": {"num_tslots": 30, "evo_time": 3},
-                        "CNOT": {"num_tslots": 30, "evo_time": 3}}
+        setting_args = {
+            "SNOT": {"num_tslots": 10, "evo_time": 1},
+            "SWAP": {"num_tslots": 30, "evo_time": 3},
+            "CNOT": {"num_tslots": 30, "evo_time": 3},
+        }
         qc = QubitCircuit(N)
         qc.add_gate("SNOT", 0)
         qc.add_gate("SWAP", targets=[0, 1])
-        qc.add_gate('CNOT', controls=1, targets=[0])
-        test.load_circuit(qc, setting_args=setting_args,
-                          merge_gates=False)
+        qc.add_gate("CNOT", controls=1, targets=[0])
+        test.load_circuit(qc, setting_args=setting_args, merge_gates=False)
 
         rho0 = rand_ket(4)  # use random generated ket state
         rho0.dims = [[2, 2], [1, 1]]
         U = qc.compute_unitary()
         rho1 = U * rho0
         result = test.run_state(rho0)
-        assert_(fidelity(result.states[-1], rho1) > 1-1.0e-6)
+        assert_(fidelity(result.states[-1], rho1) > 1 - 1.0e-6)
 
     def test_with_model(self):
         model = SpinChainModel(3, setup="linear")
@@ -117,7 +127,7 @@ def test_with_model(self):
             qc, merge_gates=True, num_tslots=10, evo_time=2.0
         )
 
-        if parse_version(qutip.__version__) < parse_version('5.dev'):
+        if parse_version(qutip.__version__) < parse_version("5.dev"):
             init_state = qutip.rand_ket(8, dims=[[2, 2, 2], [1, 1, 1]])
         else:
             init_state = qutip.rand_ket([2, 2, 2])