Source code for qutip.qip.pulse

import numpy as np
from scipy.interpolate import CubicSpline

from qutip.qobjevo import QobjEvo
from qutip.qobj import Qobj
from qutip.qip.operations import expand_operator
from qutip.operators import identity


__all__ = ["Pulse", "Drift"]


class _EvoElement():
    """
    The class object saving the information of one evolution element.
    Each dynamic element is characterized by four variables:
    `qobj`, `targets`, `tlist` and `coeff`.

    For documentation and use instruction of the attributes, please
    refer to :class:`.Pulse`.
    """
    def __init__(self, qobj, targets, tlist=None, coeff=None):
        self.qobj = qobj
        self.targets = targets
        self.tlist = tlist
        self.coeff = coeff

    def get_qobj(self, dims):
        """
        Get the `Qobj` representation of the element. If `qobj` is None,
        a zero :class:`qutip.Qobj` with the corresponding dimension is
        returned.

        Parameters
        ----------
        dims: int or list
            Dimension of the system.
            If int, we assume it is the number of qubits in the system.
            If list, it is the dimension of the component systems.

        Returns
        -------
        qobj: :class:`qutip.Qobj`
            The operator of this element.
        """
        if isinstance(dims, (int, np.integer)):
            dims = [2] * dims
        if self.qobj is None:
            qobj = identity(dims[0]) * 0.
            targets = 0
        else:
            qobj = self.qobj
            targets = self.targets
        return expand_operator(qobj, len(dims), targets, dims)

    def _get_qobjevo_helper(self, spline_kind, dims):
        """
        Please refer to `_Evoelement.get_qobjevo` for documentation.
        """
        mat = self.get_qobj(dims)
        if self.tlist is None and self.coeff is None:
            qu = QobjEvo(mat) * 0.
        elif isinstance(self.coeff, bool):
            if self.coeff:
                if self.tlist is None:
                    qu = QobjEvo(mat, tlist=self.tlist)
                else:
                    qu = QobjEvo([mat, np.ones(len(self.tlist))],
                                 tlist=self.tlist)
            else:
                qu = QobjEvo(mat * 0., tlist=self.tlist)
        else:
            if spline_kind == "step_func":
                args = {"_step_func_coeff": True}
                if len(self.coeff) == len(self.tlist) - 1:
                    self.coeff = np.concatenate([self.coeff, [0.]])
            elif spline_kind == "cubic":
                args = {"_step_func_coeff": False}
            else:
                # The spline will follow other pulses or
                # use the default value of QobjEvo
                args = {}
            qu = QobjEvo([mat, self.coeff], tlist=self.tlist, args=args)
        return qu

    def get_qobjevo(self, spline_kind, dims):
        """
        Get the `QobjEvo` representation of the evolution element.
        If both `tlist` and `coeff` are None, treated as zero matrix.
        If ``coeff=True`` and ``tlist=None``,
        treated as time-independent operator.

        Parameters
        ----------
        spline_kind: str
            Type of the coefficient interpolation.
            "step_func" or "cubic"

            -"step_func":
            The coefficient will be treated as a step function.
            E.g. ``tlist=[0,1,2]`` and ``coeff=[3,2]``, means that the
            coefficient is 3 in t=[0,1) and 2 in t=[2,3). It requires
            ``len(coeff)=len(tlist)-1`` or ``len(coeff)=len(tlist)``, but
            in the second case the last element of `coeff` has no effect.

            -"cubic": Use cubic interpolation for the coefficient. It requires
            ``len(coeff)=len(tlist)``
        dims: int or list
            Dimension of the system.
            If int, we assume it is the number of qubits in the system.
            If list, it is the dimension of the component systems.

        Returns
        -------
        qobjevo: :class:`qutip.QobjEvo`
            The `QobjEvo` representation of the evolution element.
        """
        try:
            return self._get_qobjevo_helper(spline_kind, dims=dims)
        except Exception as err:
            print(
                "The Evolution element went wrong was\n {}".format(str(self)))
            raise(err)

    def __str__(self):
        return str({"qobj": self.qobj,
                    "targets": self.targets,
                    "tlist": self.tlist,
                    "coeff": self.coeff
                    })


[docs]class Pulse(): """ Representation of a control pulse and the pulse dependent noise. The pulse is characterized by the ideal control pulse, the coherent noise and the lindblad noise. The later two are lists of noisy evolution dynamics. Each dynamic element is characterized by four variables: `qobj`, `targets`, `tlist` and `coeff`. See examples for different construction behavior. Parameters ---------- qobj: :class:'qutip.Qobj' The Hamiltonian of the ideal pulse. targets: list target qubits of the ideal pulse (or subquantum system of other dimensions). tlist: array-like, optional `tlist` of the ideal pulse. A list of time at which the time-dependent coefficients are applied. `tlist` does not have to be equidistant, but must have the same length or one element shorter compared to `coeff`. See documentation for the parameter `spline_kind`. coeff: array-like or bool, optional Time-dependent coefficients of the ideal control pulse. If an array, the length must be the same or one element longer compared to `tlist`. See documentation for the parameter `spline_kind`. If a bool, the coefficient is a constant 1 or 0. spline_kind: str, optional Type of the coefficient interpolation: "step_func" or "cubic". -"step_func": The coefficient will be treated as a step function. E.g. ``tlist=[0,1,2]`` and ``coeff=[3,2]``, means that the coefficient is 3 in t=[0,1) and 2 in t=[2,3). It requires ``len(coeff)=len(tlist)-1`` or ``len(coeff)=len(tlist)``, but in the second case the last element of `coeff` has no effect. -"cubic": Use cubic interpolation for the coefficient. It requires ``len(coeff)=len(tlist)`` label: str The label (name) of the pulse. Attributes ---------- ideal_pulse: :class:`._EvoElement` The ideal dynamic of the control pulse. coherent_noise: list of :class:`._EvoElement` The coherent noise caused by the control pulse. Each dynamic element is still characterized by a time-dependent Hamiltonian. lindblad_noise: list of :class:`._EvoElement` The dissipative noise of the control pulse. Each dynamic element will be treated as a (time-dependent) lindblad operator in the master equation. spline_kind: str See parameter `spline_kind`. label: str See parameter `label`. Examples -------- Create a pulse that is turned off >>> Pulse(sigmaz(), 0) # doctest: +SKIP >>> Pulse(sigmaz(), 0, None, None) # doctest: +SKIP Create a time dependent pulse >>> tlist = np.array([0., 1., 2., 4.]) # doctest: +SKIP >>> coeff = np.array([0.5, 1.2, 0.8]) # doctest: +SKIP >>> spline_kind = "step_func" # doctest: +SKIP >>> Pulse(sigmaz(), 0, tlist=tlist, coeff=coeff, spline_kind="step_func") # doctest: +SKIP Create a time independent pulse >>> Pulse(sigmaz(), 0, coeff=True) # doctest: +SKIP Create a constant pulse with time range >>> Pulse(sigmaz(), 0, tlist=tlist, coeff=True) # doctest: +SKIP Create an dummy Pulse (H=0) >>> Pulse(None, None) # doctest: +SKIP """ def __init__(self, qobj, targets, tlist=None, coeff=None, spline_kind=None, label=""): self.spline_kind = spline_kind self.ideal_pulse = _EvoElement(qobj, targets, tlist, coeff) self.coherent_noise = [] self.lindblad_noise = [] self.label = label @property def qobj(self): """ See parameter `qobj`. """ return self.ideal_pulse.qobj @qobj.setter def qobj(self, x): self.ideal_pulse.qobj = x @property def targets(self): """ See parameter `targets`. """ return self.ideal_pulse.targets @targets.setter def targets(self, x): self.ideal_pulse.targets = x @property def tlist(self): """ See parameter `tlist` """ return self.ideal_pulse.tlist @tlist.setter def tlist(self, x): self.ideal_pulse.tlist = x @property def coeff(self): """ See parameter `coeff`. """ return self.ideal_pulse.coeff @coeff.setter def coeff(self, x): self.ideal_pulse.coeff = x
[docs] def add_coherent_noise(self, qobj, targets, tlist=None, coeff=None): """ Add a new (time-dependent) Hamiltonian to the coherent noise. Parameters ---------- qobj: :class:'qutip.Qobj' The Hamiltonian of the pulse. targets: list target qubits of the pulse (or subquantum system of other dimensions). tlist: array-like, optional A list of time at which the time-dependent coefficients are applied. `tlist` does not have to be equidistant, but must have the same length or one element shorter compared to `coeff`. See documentation for the parameter `spline_kind` of :class:`.Pulse`. coeff: array-like or bool, optional Time-dependent coefficients of the pulse noise. If an array, the length must be the same or one element longer compared to `tlist`. See documentation for the parameter `spline_kind` of :class:`.Pulse`. If a bool, the coefficient is a constant 1 or 0. """ self.coherent_noise.append(_EvoElement(qobj, targets, tlist, coeff))
def add_control_noise(self, qobj, targets, tlist=None, coeff=None): self.add_coherent_noise(qobj, targets, tlist=tlist, coeff=coeff)
[docs] def add_lindblad_noise(self, qobj, targets, tlist=None, coeff=None): """ Add a new (time-dependent) lindblad noise to the coherent noise. Parameters ---------- qobj: :class:'qutip.Qobj' The collapse operator of the lindblad noise. targets: list target qubits of the collapse operator (or subquantum system of other dimensions). tlist: array-like, optional A list of time at which the time-dependent coefficients are applied. `tlist` does not have to be equidistant, but must have the same length or one element shorter compared to `coeff`. See documentation for the parameter `spline_kind` of :class:`.Pulse`. coeff: array-like or bool, optional Time-dependent coefficients of the pulse noise. If an array, the length must be the same or one element longer compared to `tlist`. See documentation for the parameter `spline_kind` of :class:`.Pulse`. If a bool, the coefficient is a constant 1 or 0. """ self.lindblad_noise.append(_EvoElement(qobj, targets, tlist, coeff))
[docs] def get_ideal_qobj(self, dims): """ Get the Hamiltonian of the ideal pulse. Parameters ---------- dims: int or list Dimension of the system. If int, we assume it is the number of qubits in the system. If list, it is the dimension of the component systems. Returns ------- qobj: :class:`qutip.Qobj` The Hamiltonian of the ideal pulse. """ return self.ideal_pulse.get_qobj(dims)
[docs] def get_ideal_qobjevo(self, dims): """ Get a `QobjEvo` representation of the ideal evolution. Parameters ---------- dims: int or list Dimension of the system. If int, we assume it is the number of qubits in the system. If list, it is the dimension of the component systems. Returns ------- ideal_evo: :class:`qutip.QobjEvo` A `QobjEvo` representing the ideal evolution. """ return self.ideal_pulse.get_qobjevo(self.spline_kind, dims)
[docs] def get_noisy_qobjevo(self, dims): """ Get the :obj:`.QobjEvo` representation of the noisy evolution. The result can be used directly as input for the qutip solvers. Parameters ---------- dims: int or list Dimension of the system. If int, we assume it is the number of qubits in the system. If list, it is the dimension of the component systems. Returns ------- noisy_evo: :class:`qutip.QobjEvo` A ``QobjEvo`` representing the ideal evolution and coherent noise. c_ops: list of :class:`qutip.QobjEvo` A list of (time-dependent) lindbald operators. """ ideal_qu = self.get_ideal_qobjevo(dims) noise_qu_list = [noise.get_qobjevo(self.spline_kind, dims) for noise in self.coherent_noise] qu = _merge_qobjevo([ideal_qu] + noise_qu_list) c_ops = [noise.get_qobjevo(self.spline_kind, dims) for noise in self.lindblad_noise] full_tlist = self.get_full_tlist() qu = _merge_qobjevo([qu], full_tlist) for i, c_op in enumerate(c_ops): c_ops[i] = _merge_qobjevo([c_op], full_tlist) return qu, c_ops
[docs] def get_full_tlist(self, tol=1.0e-10): """ Return the full tlist of the pulses and noise. It means that if different ``tlist`` are present, they will be merged to one with all time points stored in a sorted array. Returns ------- full_tlist: array-like 1d The full time sequence for the noisy evolution. """ # TODO add test all_tlists = [] all_tlists.append(self.ideal_pulse.tlist) for pulse in self.coherent_noise: all_tlists.append(pulse.tlist) for c_op in self.lindblad_noise: all_tlists.append(c_op.tlist) all_tlists = [tlist for tlist in all_tlists if tlist is not None] if not all_tlists: return None full_tlist = np.unique(np.sort(np.hstack(all_tlists))) full_tlist = np.concatenate( (full_tlist[:1], full_tlist[1:][np.diff(full_tlist) > tol])) return full_tlist
[docs] def print_info(self): """ Print the information of the pulse, including the ideal dynamics, the coherent noise and the lindblad noise. """ print("-----------------------------------" "-----------------------------------") if self.label is not None: print("Pulse label:", self.label) print("The pulse contains: {} coherent noise elements and {} " "Lindblad noise elements.".format( len(self.coherent_noise), len(self.lindblad_noise))) print() print("Ideal pulse:") print(self.ideal_pulse) if self.coherent_noise: print() print("Coherent noise:") for ele in self.coherent_noise: print(ele) if self.lindblad_noise: print() print("Lindblad noise:") for ele in self.lindblad_noise: print(ele) print("-----------------------------------" "-----------------------------------")
class Drift(): """ The time independent drift Hamiltonian. Usually its the intrinsic evolution of the quantum system that can not be tuned. Parameters ---------- qobj: :class:`qutip.Qobj` or list of :class:`qutip.Qobj`, optional The drift Hamiltonians. Attributes ---------- qobj: list of :class:`qutip.Qobj` A list of the the drift Hamiltonians. """ def __init__(self, qobj=None): if qobj is None: self.drift_hamiltonians = [] elif isinstance(qobj, list): self.drift_hamiltonians = qobj else: self.drift_hamiltonians = [qobj] def add_drift(self, qobj, targets): """ Add a Hamiltonian to the drift. Parameters ---------- qobj: :class:'qutip.Qobj' The collapse operator of the lindblad noise. targets: list target qubits of the collapse operator (or subquantum system of other dimensions). """ self.drift_hamiltonians.append(_EvoElement(qobj, targets)) def get_ideal_qobjevo(self, dims): """ Get the QobjEvo representation of the drift Hamiltonian. Parameters ---------- dims: int or list Dimension of the system. If int, we assume it is the number of qubits in the system. If list, it is the dimension of the component systems. Returns ------- ideal_evo: :class:`qutip.QobjEvo` A `QobjEvo` representing the drift evolution. """ if not self.drift_hamiltonians: self.drift_hamiltonians = [_EvoElement(None, None)] qu_list = [QobjEvo(evo.get_qobj(dims)) for evo in self.drift_hamiltonians] return _merge_qobjevo(qu_list) def get_noisy_qobjevo(self, dims): """ Same as the `get_ideal_qobjevo` method. There is no additional noise for the drift evolution. Returns ------- noisy_evo: :class:`qutip.QobjEvo` A `QobjEvo` representing the ideal evolution and coherent noise. c_ops: list of :class:`qutip.QobjEvo` Always an empty list for Drift """ return self.get_ideal_qobjevo(dims), [] def _find_common_tlist(qobjevo_list, tol=1.0e-10): """ Find the common `tlist` of a list of :class:`qutip.QobjEvo`. """ all_tlists = [qu.tlist for qu in qobjevo_list if isinstance(qu, QobjEvo) and qu.tlist is not None] if not all_tlists: return None full_tlist = np.unique(np.sort(np.hstack(all_tlists))) full_tlist = np.concatenate( (full_tlist[:1], full_tlist[1:][np.diff(full_tlist) > tol])) return full_tlist ######################################################################## # These functions are moved here from qutip.qip.device.processor.py ######################################################################## def _merge_qobjevo(qobjevo_list, full_tlist=None): """ Combine a list of `:class:qutip.QobjEvo` into one, different tlist will be merged. """ # TODO This method can be eventually integrated into QobjEvo, for # which a more thorough test is required # no qobjevo if not qobjevo_list: raise ValueError("qobjevo_list is empty.") if full_tlist is None: full_tlist = _find_common_tlist(qobjevo_list) spline_types_num = set() args = {} for qu in qobjevo_list: if isinstance(qu, QobjEvo): try: spline_types_num.add(qu.args["_step_func_coeff"]) except Exception: pass args.update(qu.args) if len(spline_types_num) > 1: raise ValueError("Cannot merge Qobjevo with different spline kinds.") for i, qobjevo in enumerate(qobjevo_list): if isinstance(qobjevo, Qobj): qobjevo_list[i] = QobjEvo(qobjevo) qobjevo = qobjevo_list[i] for j, ele in enumerate(qobjevo.ops): if isinstance(ele.coeff, np.ndarray): new_coeff = _fill_coeff( ele.coeff, qobjevo.tlist, full_tlist, args) qobjevo_list[i].ops[j].coeff = new_coeff qobjevo_list[i].tlist = full_tlist qobjevo = sum(qobjevo_list) return qobjevo def _fill_coeff(old_coeffs, old_tlist, full_tlist, args=None, tol=1.0e-10): """ Make a step function coefficients compatible with a longer `tlist` by filling the empty slot with the nearest left value. The returned `coeff` always have the same size as the `tlist`. If `step_func`, the last element is 0. """ if args is None: args = {} if "_step_func_coeff" in args and args["_step_func_coeff"]: if len(old_coeffs) == len(old_tlist) - 1: old_coeffs = np.concatenate([old_coeffs, [0]]) new_n = len(full_tlist) old_ind = 0 # index for old coeffs and tlist new_coeff = np.zeros(new_n) for new_ind in range(new_n): t = full_tlist[new_ind] if old_tlist[0] - t > tol: new_coeff[new_ind] = 0. continue if t - old_tlist[-1] > tol: new_coeff[new_ind] = 0. continue # tol is required because of the floating-point error if old_tlist[old_ind+1] <= t + tol: old_ind += 1 new_coeff[new_ind] = old_coeffs[old_ind] else: sp = CubicSpline(old_tlist, old_coeffs) new_coeff = sp(full_tlist) new_coeff *= (full_tlist <= old_tlist[-1]) new_coeff *= (full_tlist >= old_tlist[0]) return new_coeff