Custimize the pulse-level simulation¶

import matplotlib.pyplot as plt
import numpy as np
from qutip import basis, fidelity, sigmax, sigmay, sigmaz, tensor, about
from qutip_qip.circuit import QubitCircuit
from qutip_qip.compiler import GateCompiler, Instruction, SpinChainCompiler
from qutip_qip.device import Model, ModelProcessor
from qutip_qip.noise import Noise
import qutip_qip

class MyModel(Model):
    def __init__(
        self, num_qubits, dims=None, h_x=1.0, h_z=1.0, g=0.1, t1=None, t2=None
    ):
        super().__init__(num_qubits, dims=dims)
        self.params = {
            "sz": [h_z] * num_qubits,
            "sx": [h_x] * num_qubits,
            "g": [g] * num_qubits,
            #  Will be accessed by the noise module.
            "t1": t1,
            "t2": t2,
        }
        # Control Hamiltonians
        _two_qubit_operator = tensor([sigmax(), sigmax()]) + tensor(
            [sigmay(), sigmay()]
        )
        self.controls = {}
        self.controls.update(
            {f"sx{n}": (2 * np.pi * sigmax(), n) for n in range(num_qubits)}
        )
        self.controls.update(
            {f"sz{n}": (2 * np.pi * sigmaz(), n) for n in range(num_qubits)}
        ),
        self.controls.update(
            {
                f"g{n}": (2 * np.pi * _two_qubit_operator, [n, n + 1])
                for n in range(num_qubits - 1)
            }
        ),

    def get_control(self, label):
        """
        The mandatory method. It Returns a pair of Qobj and int representing
        the control Hamiltonian and the target qubit.
        """
        return self.controls[label]

    def get_control_labels(self):
        """
        It returns all the labels of availble controls.
        """
        return self.controls.keys()

    def get_control_latex(self):
        """
        The function returns a list of dictionaries, corresponding to the latex
        representation of each control. This is used in the plotting.
        Controls in each dictionary will be plotted in a different colour.
        See examples later in this notebook.
        """
        return [
            {f"sx{n}": r"$\sigma_x^%d$" % n for n in range(num_qubits)},
            {f"sy{n}": r"$\sigma_z^%d$" % n for n in range(num_qubits)},
            {f"g{n}": r"$g_{%d}$" % (n) for n in range(num_qubits - 1)},
        ]

num_qubits = 2
processor = ModelProcessor(model=MyModel(num_qubits, h_x=1.0, h_z=1.0, g=0.1))

class MyProcessor(ModelProcessor):
    """
    Custom processor built using ModelProcessor as the base class.
    This custom processor will inherit all the methods of the base class
    such as setting up of the T1 and T2 decoherence rates in the simulations.

    In addition, it is possible to write your own functions to add control
    pulses.

    Args:
        num_qubits (int): Number of qubits in the processor.
        t1, t2 (float or list): The T1 and T2 decoherence rates for the
    """

    def __init__(self, num_qubits, h_x, h_z, g, t1=None, t2=None):
        super(MyProcessor, self).__init__(
            num_qubits, t1=t1, t2=t2
        )  # call the parent class initializer
        # The control pulse is discrete or continous.
        self.pulse_mode = "discrete"
        self.model.params.update(
            {
                # can also be different for each qubit
                "sz": [h_z] * num_qubits,
                "sx": [h_x] * num_qubits,
                "g": [g] * num_qubits,
            }
        )
        # The dimension of each controllable quantum system
        self.model.dims = [2] * num_qubits
        self.num_qubits = num_qubits
        self.set_up_ops()  # set up the available Hamiltonians

    def set_up_ops(self):
        """
        Sets up the control operators.
        """
        for m in range(self.num_qubits):
            # sigmax pulse on m-th qubit with the corresponding pulse
            self.add_control(2 * np.pi * sigmax(), m, label="sx" + str(m))
        # sz
        for m in range(self.num_qubits):
            self.add_control(2 * np.pi * sigmaz(), m, label="sz" + str(m))
        # interaction operator
        operator = tensor([sigmax(), sigmax()]) + tensor([sigmay(), sigmay()])
        for m in range(self.num_qubits - 1):
            self.add_control(2 * np.pi * operator, [m, m + 1],
                             label="g" + str(m))

def rz_compiler(gate, args):
    """
    Compiles the RZ gate to an instruction for a pulse.

    Args:
        gate (qutip_qip.circuit.Gate): A qutip Gate object.
        args:(dict): A dictionary for compilation arguments e.g.
                     hardware parameters.

    Returns:
        Instruction (qutip_qip.compiler.instruction.Instruction):
        An instruction to implement a gate containing the control
        pulses.
    """
    tlist = np.array([1.0])
    coeff = np.array([0.0, 0.25])
    # instruction is an object that includes the pulse coefficient
    # and time sequence
    pulse_info = [("sz0", coeff)]
    return [Instruction(gate, tlist, pulse_info)]

class MyCompiler(GateCompiler):  # compiler class
    def __init__(self, num_qubits, params):
        super(MyCompiler, self).__init__(num_qubits, params=params)
        # pass our compiler function as a compiler for X gate.
        self.gate_compiler["X"] = self.single_qubit_compiler
        self.gate_compiler["Y"] = self.single_qubit_compiler
        self.args.update({"params": params})

    def single_qubit_compiler(self, gate, args):
        """
        Compiler for the X and Y gate.
        """
        targets = gate.targets
        if gate.name == "Z":
            pulse_prefix = "sz"
            pulse_strength = args["params"]["sz"][targets[0]]
        elif gate.name == "X":
            pulse_prefix = "sx"
            pulse_strength = args["params"]["sx"][targets[0]]
        coeff, tlist = self.generate_pulse_shape(
            "hann",  # Scipy Hann window
            100,  # 100 sampling point
            maximum=pulse_strength,
            area=(np.pi / 2)
            / (
                2 * np.pi
            ),  # 1/2 becuase we use sigmax as the operator instead of sigmax/2
        )
        pulse_info = [(pulse_prefix + str(targets[0]), coeff)]
        return [Instruction(gate, tlist, pulse_info)]

def mygate_compiler(gate, args):
    targets = gate.targets  # target qubit

    theta = gate.arg_value
    coeff1 = np.concatenate([np.linspace(0, 10, 50),
                             np.linspace(10, 0, 50), [0]]) / 50
    coeff2 = np.concatenate([np.linspace(0, 10, 50),
                             np.linspace(10, 0, 50), [0]]) / 50
    #  save the information in a tuple (pulse_name, coeff)
    pulse_info = [
        ("sx" + str(targets[0]), theta * coeff1),
        ("sx" + str(targets[1]), theta * coeff2),
    ]
    tlist = np.linspace(0, 1, len(coeff1))
    return [Instruction(gate, tlist, pulse_info)]

class Extral_decay(Noise):
    def __init__(self, arg):
        self.arg = arg
        pass

    def get_noisy_dynamics(self, dims, pulses, systematic_noise):
        pass

circuit = QubitCircuit(2)
circuit.add_gate("X", targets=1)
circuit.add_gate("X", targets=0)

class ZZ_crosstalk(Noise):
    def __init__(self, strength):
        self.strength = strength

    def get_noisy_dynamics(self, dims, pulses, systematic_noise):
        zz_operator = tensor([sigmaz(), sigmaz()])
        for i in range(len(dims) - 1):
            systematic_noise.add_control_noise(
                self.strength * zz_operator, targets=[i, i + 1],
                tlist=None, coeff=True
            )  # constant, always 1


crosstalk_noise = ZZ_crosstalk(strength=1.0)

class Extral_decay_2(Noise):
    def __init__(self, ratio):
        self.ratio = ratio

    def get_noisy_dynamics(self, dims, pulses, systematic_noise):
        from qutip import destroy

        op = destroy(2)
        for pulse in pulses:  # iterate for all pulses
            if (
                "sx" in pulse.label and pulse.coeff is not None
            ):  # if it is a sigma-x pulse and is not empty
                pulse.add_lindblad_noise(
                    op,
                    targets=pulse.targets,
                    tlist=pulse.tlist,
                    coeff=self.ratio * pulse.coeff,
                )
                # One can also use add_control_noise here
                # to add addtional hamiltonian as noise (see next example).


extral_decay = Extral_decay_2(0.3)