{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Custimize the pulse-level simulation\n",
    "Author: Boxi Li (etamin1201@gmail.com)\n",
    "\n",
    "In this note, we demonstrate examples of customizing  the pulse-level simulator in qutip-qip.The notebook is divided into three parts:\n",
    "1. Customizing the Hamiltonian model\n",
    "2. Customizing the compiler\n",
    "3. Customizing the noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import numpy as np\n",
    "\n",
    "from qutip import sigmax, sigmay, sigmaz, tensor, fidelity\n",
    "from qutip import basis\n",
    "\n",
    "from qutip_qip.pulse import Pulse\n",
    "from qutip_qip.device import ModelProcessor, Model\n",
    "from qutip_qip.circuit import QubitCircuit\n",
    "from qutip_qip.compiler import GateCompiler, Instruction, SpinChainCompiler\n",
    "from qutip_qip.noise import Noise\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Customizing the Hamiltonian model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start from the customization of the Hamiltonian model, which is represented by a class instance of `Model`.A minimal requirement for a processor model is specifying the hardware parameters and the control Hamiltonians of the physical system. The former will be provided to the compiler for computing the pulse strength. The latter will be accessed by the `Processor` class via the method `get_control`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyModel(Model):\n",
    "    def __init__(self, num_qubits, dims=None, h_x=1., h_z=1., g=0.1, t1=None, t2=None):\n",
    "        super().__init__(num_qubits, dims=dims)\n",
    "        self.params = {\n",
    "            \"sz\": [h_z] * num_qubits,\n",
    "            \"sx\": [h_x] * num_qubits,\n",
    "            \"g\": [g] * num_qubits,\n",
    "            \"t1\": t1, #  Will be accessed by the noise module.\n",
    "            \"t2\": t2,\n",
    "        }\n",
    "        # Control Hamiltonians\n",
    "        _two_qubit_operator = tensor([sigmax(), sigmax()]) + tensor([sigmay(), sigmay()])\n",
    "        self.controls = {}\n",
    "        self.controls.update(\n",
    "            {f\"sx{n}\": (2 * np.pi * sigmax(), n) for n in range(num_qubits)})\n",
    "        self.controls.update(\n",
    "            {f\"sz{n}\": (2 * np.pi * sigmaz(), n) for n in range(num_qubits)}),\n",
    "        self.controls.update(\n",
    "            {f\"g{n}\": (2 * np.pi * _two_qubit_operator, [n, n+1]) for n in range(num_qubits - 1)}),\n",
    "        \n",
    "    def get_control(self, label):\n",
    "        \"\"\"\n",
    "        The mandatory method. It Returns a pair of Qobj and int representing the control Hamiltonian and the target qubit.\n",
    "        \"\"\"\n",
    "        return self.controls[label]\n",
    "\n",
    "    def get_control_labels(self):\n",
    "        \"\"\"\n",
    "        It returns all the labels of availble controls.\n",
    "        \"\"\"\n",
    "        return self.controls.keys()\n",
    "\n",
    "    def get_control_latex(self):\n",
    "        \"\"\"\n",
    "        The function returns a list of dictionaries, corresponding to the latex representation of each control.\n",
    "        This is used in the plotting. Controls in each dictionary will be plotted in a different colour.\n",
    "        See examples later in this notebook.\n",
    "        \"\"\"\n",
    "        return ([\n",
    "            {f\"sx{n}\": r\"$\\sigma_x^%d$\" % n for n in range(num_qubits)},\n",
    "            {f\"sy{n}\": r\"$\\sigma_z^%d$\" % n for n in range(num_qubits)},\n",
    "            {f\"g{n}\": r\"$g_{%d}$\" % (n) for n in range(num_qubits - 1)}])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a quantum system of $n$ qubits arranged in a chain (same as the [spin chain model](https://qutip-qip.readthedocs.io/en/stable/apidoc/qutip_qip.device.html?highlight=spinchain#qutip_qip.device.SpinChainModel)), where we have control over three Hamiltonian: $\\sigma_x$, $\\sigma_z$ on each qubit, and neighbouring-qubits interaction $\\sigma_x\\sigma_x+\\sigma_y\\sigma_y$:\n",
    "\n",
    "$$\n",
    "H = \\sum_{j=0}^{n-1} c_{1,j}(t) \\cdot h_x^{j}\\sigma_x^{j} + \\sum_{j=0}^{n-1} c_{2,j}(t) \\cdot h_z^{j}\\sigma_z^{j}\n",
    "+ \\sum_{j=0}^{n-2} c_{3,j}(t)\\cdot g^{j}(\\sigma_x^{j}\\sigma_x^{j+1}+\\sigma_y^{j}\\sigma_y^{j+1})\n",
    "$$\n",
    "\n",
    "where $h_x$, $h_z$, $g$ are the hardware parameters and $c_{i,j}(t)$ are the time-dependent control pulse coefficients. This Hamiltonian is the same as the one for the linear spin chain model in QuTiP. In general, the hardware parameters will not be identical for each qubit, but here, for simplicity, we represent them by three numbers: $h_x$, $h_z$ and $g$.\n",
    "\n",
    "To simulate a custom quantum device, we provide the model to `ModelProcessor`, which is used for simulators based on a concrete physics model (in contrast to optimal control for arbitrary Hamiltonians). In this way, we inherit the necessary methods from `ModelProcessor` used in the simulation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_qubits = 2\n",
    "processor = ModelProcessor(model=MyModel(num_qubits, h_x=1.0, h_z=1.0, g=0.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In `set_up_ops`, we define the control Hamiltonians of the quantum system and use them to initialize the control pulses. We can get the map between the pulse labels and the pulse location with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['sx0', 'sx1', 'sz0', 'sz1', 'g0'])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "processor.get_control_labels()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or access a control Hamiltonian by its label:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
       " Qobj data =\n",
       " [[0.         6.28318531]\n",
       "  [6.28318531 0.        ]],\n",
       " 0)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sx0 = processor.get_control(\"sx0\")\n",
    "sx0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In qutip-qip 0.1 version, the model is directly defined in the `Processor`. This can still be achieved in version 0.2 as shown in the following cell. This is equivalent to the definition above. An instance of `Model` is automatically created and saved in the processor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyProcessor(ModelProcessor):\n",
    "    \"\"\"\n",
    "    Custom processor built using ModelProcessor as the base class.\n",
    "    This custom processor will inherit all the methods of the base class\n",
    "    such as setting up of the T1 and T2 decoherence rates in the simulations.\n",
    "\n",
    "    In addition, it is possible to write your own functions to add control pulses.\n",
    "\n",
    "    Args:\n",
    "        num_qubits (int): Number of qubits in the processor.\n",
    "        t1, t2 (float or list): The T1 and T2 decoherence rates for the\n",
    "    \"\"\"\n",
    "    def __init__(self, num_qubits, h_x, h_z, g, t1=None, t2=None):\n",
    "        super(MyProcessor, self).__init__(num_qubits, t1=t1, t2=t2)  # call the parent class initializer\n",
    "        self.pulse_mode = \"discrete\"  # The control pulse is discrete or continous.\n",
    "        self.model.params.update({\"sz\": [h_z] * num_qubits,  # can also be different for each qubit\n",
    "                       \"sx\": [h_x] * num_qubits,\n",
    "                       \"g\": [g] * num_qubits})\n",
    "        self.model.dims = [2] * num_qubits  # The dimension of each controllable quantum system, here num_qubits qubits.\n",
    "        self.num_qubits = num_qubits\n",
    "        self.set_up_ops()  # set up the available Hamiltonians\n",
    "\n",
    "    def set_up_ops(self):\n",
    "        \"\"\"\n",
    "        Sets up the control operators.\n",
    "        \"\"\"\n",
    "        for m in range(self.num_qubits):\n",
    "            # sigmax pulse on m-th qubit with the corresponding pulse \n",
    "            self.add_control(2 * np.pi * sigmax(), m, label=\"sx\" + str(m))\n",
    "        # sz\n",
    "        for m in range(self.num_qubits):\n",
    "            self.add_control(2 * np.pi * sigmaz(), m, label=\"sz\" + str(m))\n",
    "        # interaction operator\n",
    "        operator = tensor([sigmax(), sigmax()]) + tensor([sigmay(), sigmay()])\n",
    "        for m in range(self.num_qubits - 1):\n",
    "            self.add_control(2 * np.pi * operator, [m, m+1], label=\"g\" + str(m))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load and compile the circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "We first define a quantum circuit. Here we use a two-qubit circuit with two X  gates. Acting on a $|00\\rangle$ state, this results in a $|11\\rangle$ state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<qutip_qip.circuit.QubitCircuit at 0x22d94eaab20>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit = QubitCircuit(num_qubits)\n",
    "circuit.add_gate(\"X\", targets=1)\n",
    "circuit.add_gate(\"X\", targets=0)\n",
    "circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For circuit plotting, see [this notebook](quantum-gates.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To convert a quantum circuit into the Hamiltonian model, we need a compiler. The custom definition of a compiler will be discussed in details in the next section. Because we used the Hamiltonian model of the spin chain, we here simply \"borrow\" the compiler of the spin chain model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[2, 2], [1, 1]], shape = (4, 1), type = ket\\begin{equation*}\\left(\\begin{array}{*{11}c}3.450\\times10^{-07}\\\\1.624\\times10^{-08}j\\\\1.624\\times10^{-08}j\\\\-1.000\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[2, 2], [1, 1]], shape = (4, 1), type = ket\n",
       "Qobj data =\n",
       "[[ 3.44966416e-07+0.00000000e+00j]\n",
       " [ 0.00000000e+00+1.62381269e-08j]\n",
       " [ 0.00000000e+00+1.62381269e-08j]\n",
       " [-1.00000000e+00+0.00000000e+00j]]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "processor = ModelProcessor(model=MyModel(num_qubits, h_x=1.0, h_z=1.0, g=0.1))\n",
    "processor.native_gates = [\"ISWAP\", \"RX\", \"RZ\"]\n",
    "\n",
    "# processor.num_qubits, processor.params access directly the information in the model.\n",
    "compiler = SpinChainCompiler(processor.num_qubits, processor.params)\n",
    "\n",
    "processor.load_circuit(circuit, compiler=compiler)\n",
    "result = processor.run_state(init_state = basis([2,2], [0,0]))\n",
    "result.states[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The compiled pulse coefficients are now saved in the processor and can be accessed by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.]\n",
      "[0.   0.25]\n"
     ]
    }
   ],
   "source": [
    "sx1_pulse = processor.find_pulse(\"sx1\")\n",
    "print(sx1_pulse.coeff)\n",
    "print(sx1_pulse.tlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a rectangular pulse that starts from time 0 and ends at time 0.25.\n",
    "\n",
    "#### Note\n",
    "\n",
    "For discrete pulse, the time sequence is one element shorter than the pulse coefficient because we need to specify the start and the end of the pulse. If two sequences are of the same length, the last element of `coeff` will be neglected. Later, we will see continuous pulse where `coeff` and `tlist` have the same length.\n",
    "\n",
    "To give an intuitive illustration of the control pulses, we give each pulse a latex label by defining a method `get_operators_labels` and then plot the compiled pulses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "processor.plot_pulses()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Customizing the compiler\n",
    "\n",
    "How the quantum gates are implemented on hardware varies on different quantum systems. Even on the same physical platform, different implementation will yield different performance. The simplest way of implementation is to define a rectangular pulse like the one above. However, in reality, the control signal will have a continuous shape. In the following, we show how to customize the compiler with a gaussian pulse.\n",
    "\n",
    "A typical gate compiler function looks like the one in the following cell, with the form ``XX_compiler(self, gate, args)``. It takes two arguments, `gate` and `args`: `gate` is the quantum gate to be compiled and `args` is a dictionary for additional parameters, for instance, parameters we defined in `Processor.params`.\n",
    "\n",
    "For each gate, the function returns the input gate, the time sequence and the pulse coefficients in an `Instruction` object.\n",
    "\n",
    "Below is an example of a rectangular pulse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rz_compiler(gate, args):\n",
    "    \"\"\"\n",
    "    Compiles the RZ gate to an instruction for a pulse.\n",
    "\n",
    "    Args:\n",
    "        gate (qutip_qip.circuit.Gate): A qutip Gate object.\n",
    "        args:(dict): A dictionary for compilation arguments e.g. hardware parameters.\n",
    "\n",
    "    Returns:\n",
    "        Instruction (qutip_qip.compiler.instruction.Instruction): An instruction to implement\n",
    "                                                                  a gate containing the control\n",
    "                                                                  pulses.\n",
    "    \"\"\"\n",
    "    tlist = np.array([1.])\n",
    "    coeff = np.array([0., 0.25])\n",
    "    # instruction is an object that includes the pulse coefficient and time sequence\n",
    "    pulse_info = [(\"sz0\", coeff)]\n",
    "    return [Instruction(gate, tlist, pulse_info)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we replace it with a continuous pulse. In particular, we define a `single_qubit_compiler` method. For RX and RY gate, it reads the maximal driving strength from the parameters and computes the corresponding time sequence and pulse amplitude.\n",
    "\n",
    "For simplicity, we make use of the [`generate_pulse_shape` method](https://qutip-qip.readthedocs.io/en/stable/apidoc/qutip_qip.compiler.html?highlight=generate_pulse_shape#qutip_qip.compiler.GateCompiler.generate_pulse_shape), which is defined in the parent class `GateCompiler` and is available  in all subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyCompiler(GateCompiler):  # compiler class\n",
    "    def __init__(self, num_qubits, params):\n",
    "        super(MyCompiler, self).__init__(num_qubits, params=params)\n",
    "        # pass our compiler function as a compiler for X gate.\n",
    "        self.gate_compiler[\"X\"] = self.single_qubit_compiler\n",
    "        self.gate_compiler[\"Y\"] = self.single_qubit_compiler\n",
    "        self.args.update({\"params\": params})\n",
    "\n",
    "    def single_qubit_compiler(self, gate, args):\n",
    "        \"\"\"\n",
    "        Compiler for the X and Y gate.\n",
    "        \"\"\"\n",
    "        targets = gate.targets\n",
    "        if gate.name == \"Z\":\n",
    "            pulse_prefix = \"sz\"\n",
    "            pulse_strength = args[\"params\"][\"sz\"][targets[0]]\n",
    "        elif gate.name == \"X\":\n",
    "            pulse_prefix = \"sx\"\n",
    "            pulse_strength = args[\"params\"][\"sx\"][targets[0]]\n",
    "        coeff, tlist= self.generate_pulse_shape(\n",
    "                \"hann\",  # Scipy Hann window\n",
    "                100,  # 100 sampling point\n",
    "                maximum=pulse_strength,\n",
    "                area= (np.pi/2) / (2*np.pi),  # 1/2 becuase we use sigmax as the operator instead of sigmax/2\n",
    "            )\n",
    "        sign = np.sign(pulse_strength)\n",
    "        pulse_info = [(pulse_prefix + str(targets[0]), coeff)]\n",
    "        return [Instruction(gate, tlist, pulse_info)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The attribute `pulse_mode` can be set to `\"discrete\"` or `\"continuous\"`. For continuous pulse, QuTiP solvers will use cubic spline interpolation. To minimize the boundary effect, it is recommended that the continuous pulse goes smoothly to 0 at the beginning and the end. We can see the advantage of the scheduling when we introduce a T1 decoherence and compare the fidelity of the final state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fidelity without scheduling: 0.9982136886930341\n"
     ]
    }
   ],
   "source": [
    "gauss_compiler = MyCompiler(processor.num_qubits, processor.params)\n",
    "processor = ModelProcessor(model=MyModel(num_qubits, h_x=1.0, h_z=1.0, g=0.1, t1=300))\n",
    "processor.pulse_mode = \"continuous\"\n",
    "tlist, coeff = processor.load_circuit(circuit, compiler=gauss_compiler, schedule_mode = False);\n",
    "print\n",
    "result = processor.run_state(init_state = basis([2,2], [0,0]))\n",
    "print(\"fidelity without scheduling:\", fidelity(result.states[-1], basis([2,2],[1,1])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "processor.plot_pulses(use_control_latex=False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also turn on the scheduler to schedule the circuit for a shorter execution time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fidelity with scheduling: 0.9990450021201522\n"
     ]
    }
   ],
   "source": [
    "processor = ModelProcessor(model=MyModel(num_qubits, h_x=1.0, h_z=1.0, g=0.1, t1=300))\n",
    "tlist, coeffs = processor.load_circuit(circuit, schedule_mode = \"ASAP\", compiler=gauss_compiler);\n",
    "processor.pulse_mode = \"continuous\"\n",
    "result = processor.run_state(init_state = basis([2,2], [0,0]))\n",
    "print(\"fidelity with scheduling:\", fidelity(result.states[-1], basis([2,2],[1,1])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAGoCAYAAABbkkSYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABCFElEQVR4nO3dR5Bd153n+d997j7/0nuQAEHQADQgAEqUSmLJlBzlKFGkZjO7mphNV+9mMb3pXvQsZjqmOyo6ZtHTm4roiFFJlJcolTxVciUSAAGCBAlDEkR6n8/f+645s7gvk6DIor3AS/P9RLx4iSSQvEgAmfnNc+75W8YYAQAAAADev0SvLwAAAAAAdgsCCwAAAABiQmABAAAAQEwILAAAAACICYEFAAAAADFJXYe3ybGEAAAAAHY7681eyQoWAAAAAMSEwAIAAACAmBBYAAAAABATAgsAAAAAYkJgAQAAAEBMCCwAAAAAiAmBBQAAAAAxuR5zsAAA6DljXhvLaFlvOqoEAIDYEVgAgBvGD0KttzyttzpabXRUbXtquL4aTvRcd3zVXV8Nx49e7/pyvECuF8r1Q7l+oE4QyvNDdfxQXmhkjJEx//qUe0tSKmkpnUxEz4mE0qmEMsmE0klLdjqpkp1S0U4pb6dUtJMqZFIqdF9XsFPqz6fVl89ooJDZejmTYhMIAOCNrGu/wxeT2N8gAGD7Msao1vY1X2troeposeZooepqoeZoteFqpdHRasPVequjuuO/5SeJZMJSqvtIJiwlLEuJhKWEpehl65qXE9HK1LVrU29Yp7KsrQAL//JZRqGRwtAoCI0CY7Ze9ruPt5LPJFXJpTVYzGiklNVo2dZoOdt92N3XZTVYyCiRYAUNAHahN/3gTmABAN6SMUYrjY6urrU0s97S1dWWrq61NL3W0my1raWaK9cP3/DrsqlopSiViFaPNleMXls9in6cSkQrS5tBtV0Y81pseYGRF4TXPF77cScw8oPNFbY3vh+SCUvDRVv7BnLaN5DXvv68pvqjl6f6cxorZ5VKshoGADsQgQUAeHObEfXSckOXlxp6ebmpq2tNXVltaWatJecvwiGXTshOJZVJJZRNJWSnk7JTie4jKTud2FaxdKOExqjjvxZbrh+o44dyvDDa6uiHanvB635NMmFprJzVweGCbhkubj3fMlzQWDnL/WMAsH0RWACw14Wh0cx6W5eX67q81NBLS01dXIperjv+1s9LJSzl0lEo5dLJ6JGJnrPppJJseXvPQmPkeIEcL4otxwvU7gRqe4FaneB1WxOz6YQODBV060hJB4cLun20pDvGy7ppIM+fAQD0HoEFAHtJq+PrwkJd5+dremG+pudna3pxof66FRQ7FQVUwU4qn0mp0D3gwU4lWDnpAWOMXD9UqxOo1fHV6gRqdqIIa3Ve/+d222hRd46XdcdYWXeMl3THWFkDhUwPrx4A9hwCCwB2q41WR2dnqnputqrzczU9N1vV1bXW1gfkdNJSIROdilfMplTIJFWwU0pz78+OEYRGzc7rT1hsdYLX3fc1VMzonqk+3TNV0T1TFd092afhkt3DqwaAXY3AAoDdwPECPT9X1Znpqs5Or+uZ6Q1Nr7W3/ns+E61CFbOprePHs2lWpHYjY4w6Qdg96j7YCq+G+9p2z5GSraP7oui6e6pPd09WWOkCgHgQWACw0xhjdGW1pZNX1nT66oaeubqui4t1bd6mk0snVbRTKudSKmfTKmdTnEgH+UGoeneuWM3x1HB8Na/ZYnjTQF737x/Q8Zv7dfzmfh0aKXKUPAC8ewQWAGx3XhDq/FxNT19Z08kra/rzK2tab3mSpEwyoWI2pXK2G1O5lOxUssdXjJ3CD0LVHF91x1O17anm+FvbCwt2Usdu6teJm6PoOnpTn4p2qsdXDADbHoEFANtN0/V16tV1nbyypqeurOnM1Y2tI9HzmaTK2bT68mn15dLKZ5Js80NsjDFqe4Gq7W5wtX3Vu1sLE5Z053hZHz44qAduGdT9BwZUzqZ7fMUAsO0QWADQa44X6JmrG/rTSyv6/eVVnZ3ZUBAaWZJK2ZTKuSim+nJp2WlWp3Bj+UGoquNpo+Vpo+2p1vYUmii4Do+X9eFbh/TALQM6sZ/gAgARWABw4/lBqGdnq/rTS6v6w+UVnbyyrk4QbgVVfz6j/kJalWyae6ew7QShUbXtaaPV0fpfBNeRiYo+fHBQf3XrkD5wYEBZviEAYO8hsADgets8lOK3F5b0zxeX9S+vrG3NLyrZKfXl01FU5Qkq7Dz/WnBlkgl94MCAHrxtSB89NKw7xkpsZwWwFxBYAHA9NF1ff3ppVb+9uKzfXFjSzHp0ZHohk1RfN6b68xllUgQVdpcgNNpodbTa7Gi95W0dDz9YyOjB24b14G1D+sitw8ziArBbEVgAEAdjjF5cqOu3F5f15ItLOvnquvzQKJWw1JdPa7CQ0UAho3yGU9iwtzheoLVmR2utKLg63QNb7hwr6RN3jugTd4zq6L4+JTkSHsDuQGABwHvV6vj6/aUV/eqFJf36wpKW666kaNtffyGjwUJGfbk0s4SALmOM6q6vtWa0wlVteTKS+nJpffyOEX3ijhE9eNuwKjkOywCwYxFYAPBuLNYc/eqFJf3yhUX9/tKKOkGodNJSfz6ztUrFjf3AO+MFodaaHa00XK01PXWCUAlLOnHzgP7mcBRcB4eL3LsFYCchsADgrRhj9MJ8Xb98YVG/OL+gc7M1SdE8qoFCRsNFW335tBJ8AQi8L8YYVdu+VpuuVpsd1Z3o3q2p/pw+dXhUnzkypvv3D7CVEMB2R2ABwF/yglD/8vKqfnF+UT8/v6iFqiNJquTSGipkNFS0VbAZ8AtcT44XaKXR0WrT1XrTU2CM+nJpffpIFFt/desQq8UAtiMCCwCk6Iu5319a0U+fm9fPzy+q7vhKJiz159MaLtoaLGZkp/hiDugFPwy12uhoueFqrdmRFxhl0wl9/PYRffauMX38jhGGHAPYLggsAHtXq+PrtxeW9ZNz8/rVi0tqdQKlk5YGC7ZGSrYGChm2IwHbTGiM1ptRbK00OnL9UKmEpQ8dHNRn7xrTpw6PaqSU7fVlAti7CCwAe0vd8fTrF5f0k3PzevLCslw/VCaV0FAho5GSrf5ChvupgB1i876tKLZctTqBLEn3HxjQF+8Z12fvGmfeFoAbjcACsPtV255+cX5RPzk3r99dWo62F6USGixGK1UcUgHsfMYYNTuBlmqOlhsdNVxfCUv6wP4BfeHeCX32rjENFYktANcdgQVgd2p1fP3yhSX96MycfnNxSX5glEsnNVSMVqoquTSHVAC7WMP1tVRztNRw1XQDJSzpgVsG9YV7JvSZI6MaJLYAXB8EFoDdw/EC/fbisn50dk6/PL8oxw+VTSc0UrQ1Us6qnE0RVcAeY4xR0w20WHe0XHfV7ESx9aGDg/riPRP6zJEx9Rcyvb5MALsHgQVgZ/OCUH+4vKIfnZ3TPz23oGYnUCaV0HDR1mjZVh8rVQC6jDHRylbd3YqtZMLSg4eG9PB9k/rU4VHlM6leXyaAnY3AArDzBKHRU6+s6UfPzumJZ+dVbXtKJy0NdaOqP89BFQDe2mZsLdZcLdVdtb1A2VRCnzkypofvm9RHDg0pnUz0+jIB7DwEFoCdwRijF+br+t4zM/r+mTkt112lEpYGixmNlrIaLGSU4Eh1AO+BMUYbbU8LNUcrdVedIBpq/MV7J/TloxM6fnM/K+EA3ikCC8D2Nl9t6wdn5vSdUzO6tNRQwpIGChmNlbMaKtrMqQIQq9AYrTY6Wqg5Wm12FIRGE31ZPXx0Ug/fN6nbRku9vkQA2xuBBWD7qTuefvrcgr57elZ/fnlVRlIll9ZY2dZIKatMim07AK4/Pwi13HC1WHO11uzISLp9tKivHJvSl+6d0ERfrteXCGD7IbAAbA9eEOp3l5b13dOz+vnzi+oEofKZpEbLWY2VbW48B9BTrh9qqe5oseaq2vZkKTqJ8JFjU/rsXWMq2HyMAiCJwALQS8YYnZ2p6vvPzOoHZ2a13vKUSSY0XLI1XuFYdQDbU6vja6HmarHmqNUJlE0n9Pm7x/XIsSk9cMsg94MCexuBBeDGm91o67unZvSd0zO6stpS0ooOqxgrZzVY5ARAADuDMUbVtqf5qqPlhisvMBot2/ra8Sl99diUDg4Xe32JAG48AgvAjeF4gX72/IK+dXJaf7wc3VfVn09rtJzVSMnmOGQAO1oQGi03XC1Una37te6dquhrJ/bpi/eMqy/PMGNgjyCwAFw/xhg9O1PV4yen9f0zc2q4vnLppMbKtsYrOeUyyV5fIgDEzvUDLVRdLdQcNVxfqYSlT945oq8d36eP3T7MN5SA3Y3AAhC/1Yar7z0zq398elqXlxpKWpaGShlNVHLqz6e5rwrAnrA5zHi+6mip7sr1Q/Xl0nr4vkl97fiU7pqs9PoSAcSPwAIQDz8I9eSFZX3z6Wn9+sKSgtConE1pvJLTaJktgAD2ttAYrTU7mq86Wmm4Co10x1hJX79/nx4+Oqn+AlsIgV2CwALw/lxarOtbJ6f1nVMzWmt5yqQSW1sAixxbDABv4AWhFmqOFqqOak60hfBTh0f12P379OChYQaoAzsbgQXg3as5nn58dl7feOqqzs1WZUkaLEZbADkFEADeubrja77a1mLNVScINVy09eiJKT16Yp8ODBV6fXkA3j0CC8A7E4ZG//Lyqr51clo/eW5BHT9UwU5qvJzTWCUrO8UWQAB4r0JjtNJwNbfx2imEx2/u19fv36fP3z3OIGNg5yCwALy1mfWWvn1qRt98elrzVUephKXRcpZBwABwnbheoPnuFsJmd5DxF++Z0KMn9un+/f183AW2NwILwBs5XqB/em5B33x6Wv/y8mszqyYqOQ2XbO4PAIAbIBpkHG0hXKq78kOjmwby+vr9+/TVY5Mar+R6fYkA3ojAAhAxxujsTFXfevqqfnBmTs1OEM2sqkSrVbk0M6sAoFeC0Gip7miu6mij5SlhSR+5dUhfv/8m/c3hEdkpPkYD2wSBBex1y3VX339mVt946qpeXmkqmbA0XMxonJlVALAttTrRbK3Fmqu2F6icTemrx6aYrQVsDwQWsBd5QajfvLikbz49rScvLisIjSq57syqkq0UM6sAYNszxmit1dHchqPVRkeBMbpzrKTHmK0F9BKBBewlFxfrevzktL59akbrLU92KqHRclYTlSwnVAHADrY1W6vmqNb2lU5Gs7UePcFsLeAGI7CA3a7a9vSjs3P65tPT0cwqSxoq2BqvZJlZBQC7UN3xNF91tFR35fqhRkq2vnac2VrADUJgAbtRGBr98aVVPX5yWj99bkGdIFTRTmm8ktVYOasMM6sAYNcLjdFK3dV8LdpCaCSduLlfjzFbC7ieCCxgN5lea+nxUzN6/GQ0syqdtDRSirYAlphZBQB71uZsrcWaq4brK5dO6gv3jOux+/fpxM3M1gJiRGABO127E+ifnp/vzqxakyQNFDIar2Q1XGRmFQDgNdFsrWgL4XLDlRcY3TyY12Mn9umRY1Maq2R7fYnATkdgATuRMUanr27o26em9cPuzKp8JqmxcjSzKsvMKgDA2/DDUMt1Vws1R2vNaLbWg4eG9dj9+/TJO5mtBbxHBBawkyzWHH3n9IwePzmjV1aaSiUsDRVtTfRl1ZdjZhUA4L35y9lalVxaX7lvUo+emNKRCWZrAe8CgQVsd64f6Jfnl/T4yWn986VlhUbqy6c1Xs5qhJlVAIAYGWO01uxovupopTtb6/B4WY+dmNKXma0FvBMEFrAdGWP0/FxNj5+c1vfPzKna9pRLJzVajo5Xz2c4+QkAcH1tztZarLmqtj2lk5Y+fWRMjx6f0keZrQX8awgsYDtZbbj6/pk5fevpaV1YrCtpWRoqRgdWDBQybAEEAPRE3fE0V3W03J2tNVruztY6vk/7ma0FXIvAAnrNC0I9eWFZj5+c1q9eXFIQGlVyaY2VbY2Ws0qzBRAAsE2EodFyIzoYY3O21gf2D+jRE1N6iNlagERgAb1zcbGux09O67unZ7Xa7MhOJbpbAHMq8gkKALDNOV6ghZqjhZqjphsol0nqi/eM67ET+3Sc2VrYuwgs4EZab3b042fn9K2TMzo3W1XCkgaLtsbLWQ0WM0rwyQgAsMNsztba3ELoh0b7B/N65NiUHr5vUvsG8r2+ROBGIrCA6831A/3mxSV99/Ssfv3ikvzQqJRNaayc1Vg5q0yKLYAAgN3BD0Mt1aIthOstT5L0gQMDeuTYpD5397jK2XSPrxC47ggs4HqIBgGv67unZ/Wjs3OqOb6y6YRGirbGKlmV+AQDANjl2p1oC+FS3VHDDZRJJfTpw6N65NiUPnpoiDEj2K0ILCBOr6429b1nZvWd0zOaXmsrlbA0WMxovJxVf4EtgACAvccYo5rja6HqaKnhquOHGihk9PDRSX312KSOTJS5Xwu7CYEFvF/Vlqcfn5vTd07N6PTVDUnSQD6jsYqt4SKDgAEA2BQao9VGR/M1R6sNV6GRDo0U9dVjU3r4vgmNV3K9vkTg/SKwgPei44d68sKSvnt6Rr96cUleYFSyUxop2xorZ5VNJ3t9iQAAbGteEGqx5mqx7mij5cmS9KGDg3rk2JQ+e9cYR75jpyKwgHcqDI3+/Mqafnh2Tk88G91XZacSGil176uyU2xxAADgPWh1oi2Ei3VXrU6gbCqhTx0e1ZeOTurB24Zkp/jGJXYMAgt4K8YYnZut6odn5vTDs3Naqrtb91WNlbMa4L4qAABis3nk+0LN1UrDleuHKmVTeuiucX3p6IQeuGVQyQSfd7GtEVjAm7m81NAPz87pB2dm9epqSwlLGihkNFrOarho88EdAIDrLDRGa82OFmuOVpsdeYHRUDGjL947oS/dO6Gj+/rYOYLtiMACNs1ttPWjs3P6/plZvTBflxRF1UjJ1kjJVprDKgAA6IkgNFppuFqsu1uHY0z15/TloxP60r2Tun2s1OtLBDYRWNjbluqOfvbcgn5wdk4nr6xLkiq5tEZKtkZLtmwOqwAAYFvxg1BLdVdLdVdrzY6MopMIH75vUl+8Z0I3DeZ7fYnY2wgs7D2LNUc/PTevJ87N6+SVdRlJRTsVRVXZVj7DqUUAAOwErh9qqe5oqeZqo+1Jkg6Pl/X5e8b10N3jOjBU6PEVYg8isLA3zFfb+um5BT1xbl6nX42iqpRNaagYbf8rchQsAAA7WtsLtFRztdxwVe3G1u2jpa3YunWk2OMrxB5BYGH3mt1ob61UPdMdAFy+JqqYrwEAwO7keIGW6tFJhOutKLYOjRT10N3j+vw94zo0UuSADFwvBBZ2l1dWmvr58wv6ybl5nZ2pSoqiarhoa4TtfwAA7DmOF2i54Wq5/lps3TJU0OfvGddnjozpyESZ2EKcCCzsbGFodHZmQz8/v6ifPb+gl5ebkrpR1T39j6gCAACS5PqBluuulusdrbeiAzLGK1l9+vCoPnV4TB+8ZYBTg/F+EVjYeVw/0B9fWtXPn1/UL88vaLnRkWVJ/fmMhgoZDZVs5Tj9DwAAvIWOH2qlEd2ztdHy5IdGRTulT9wxok8dHtXHbh9WKZvu9WVi5yGwsDNUW55+c2FJP3t+QU9eXFa7EyidtNSfz2i4aGuwmOE7TgAA4D0Jwmio8XIjOvrd9UOlEpY+dHBQnz48qk/eOaqJvlyvLxM7A4GF7ckYoxcX6vrNhSX95sUlnXp1XaGRsumEBgsZDRVtDeQzSiTYMw0AAOJjjFG17Wm50dFa01XDDSRJhyfK+uQdI/rY7cM6uq9fSb4GwZsjsLB91B1Pf7i8qicvLOnXLy5pqe5Kiu6nGuhGVTmb4kZUAABwwzRdX8sNV6vNjqotT0ZSOZfSX982oo/fPqwHbxvWUNHu9WVi+yCw0DvGGF1eanRXqZb11JU1BaHZ2vo3WIgeNvdTAQCAbcALQq01O1ptdLTe7sjxQlmSjkxW9Inu6ta9U32sbu1tBBZurOW6qz++tKLfX1rR7y6taKHmSIqG/g7kMxosZlTJpZVglQoAAGxjxhjVXV+rjY7Wmh1V29HqViWX1kcPDekjtw7pr24d0r6BfK8vFTcWgYXrq+n6euqVNf3+8op+d2lZFxcbkqRMKqG+XFoD3VWqLKtUAABgB/OCUKvd1a1qu6O2F0qSpvpz+uihKLY+fHBIA4VMj68U1xmBhXg5XqBnZ6r600ur+v3lZZ2+uqEgNEpalir5tPrzUVSVbO6lAgAAu5MxRq1OoLVmNG9ro+3JC6Ivh+8cK+kj3eA6sX9ARZt5nbsMgYX3p+n6On11XU+9sqY/v7ymZ6bXtz6AVHIp9eUyGihE2/7YjwwAAPai0BjVHX8ruKptT6GREpZ0eKKiBw4M6AMHBnT//gH1s8K10xFYeHeqLU9PX1nTU1fW9OeXV3VutqrQSJYllbPprajqy6eZSwUAAPAmgtBoo93RRstTte2p1vYVdL/+PjRS1AdviWLrgwcGNVbJ9vhq8S4RWPjXBaHRxcW6nrm6oTPT6zr16rpeXm7KKPqOSyWXViWXVl8+rUo2rRRBBQAA8K6FoVHN8bTR8rTR9lRzXttSONmX0/Gb+3XfTX06uq9PhyfKslPcu76NXf/Asizr/5iamvp36+vrajQasb1dxG+57urM9IaeuboeRdXMhtqdaLienUqoaKe2gqqcZcsfAADA9RAao4brbwVXw/HV9qKvydJJS4cnyrpvXxRd9+3r176BHPe2bx83JLAemJub+9OhQ4cIrG3CGKOFmqPnZmt6braq5+eqOjdb1WItGuybsKRSNq1SN6jKuZRy6ST/cAEAAHrE8QLVHE/Vtq+646nu+PLD6Gv2vlxad09VdNdkRUcmyjoyUdHNA3kl+GZ4L7y3wLIsqyDpW5KmJCUl/SdJ/07Sl4wxFyzL+oakXxtj/nv3l5hisUhg9YAfhLqy2tKFhbqem6vq+dkoptZbnqTob0DRTqlgJ1XKplXOplRidQoAAGBbC41R0/VVbfuqOZ6arq+G66vbXMpnkluxtfl8cKTA9sLr702/iH4nZ0V+VtKcMebzkmRZVkXSnKR/sCzr7yX1XxNXuAGC0OjqWksXF+u6uFDXxaWGLizU9MpKc2sPb8KKYqpopzQ8aqucTatop4gpAACAHSZhWdGOo2xaUk5SdC9Xo+Or4fiqO74uLTb0zNWNrZWuhCXdPFjQ7aMlHRot6tBoSbeNFnVgiPC63t7JCtZtkn4u6ZuSfmyM+V339f+vpEck3WuMmbnml7CCFQNjjFabHb262tQrK63uc1MvLTX00kpTHT/c+rmFTFK5TFKFTLQ6VbBTKmZSLBUDAADsIZszuequr6brq+kGanuBmq6/dQrdteF1YLig/YN53TxY0P7BgkZKNl8/vjvv/R4sy7IGJD0k6X+R9CtJ/1HSbyXtl/SQMebcNT+dwHqH2p1Ac9W25jaix/RaW1e6IXVltammG2z9XEvR8q+dTqpob8ZUFFSpBCf6AQAA4M2FoVGzE6jZuTa8fLU6wdY2Qyk66OymgbwODBW0f6igmwbymurPaaIvp/FKtruChmu853uwJiStGWMcy7K+IOlvJf1O0u2S/oek/yLpQ8YYr/tL9nxg+UGotWZHyw1XK42OVuqulhuuFqqO5jbamt1oa3a9rY2297pfZ0nK20llU0nl0tGqVL77yKaTSnDwBAAAAGISGiPXC9XyArU7vtqdQC0vkOuHarnB1ryuTUU7pfFKVpPd6JqoZDVSzmq4aGuoaGuolNFgwVYmtWe++f+eA+szig62CCV5kv6NpH+Q9AFjTN2yrP8sqW6M+feWZf1fk5OT/9vc3JwmJib0t3/7t/oP/+E/xPmbuCHC0MjxA7U70bKq4wVquoGqbe91j5rjqbb545anpbqrlYarjZb3psPA0klLuXRS6WRC2XRC2VS0IvXaywkiCgAAAD1njJHrh3K8QI4fyvUCOV4oxw/U8UO53cebKWVTGiraGi7ZGixkuidVRzNVy9mUyrloDFA5l1I5m1auu5iQS0fPO+jMgL05aHij1dH/+j9OKTRGfmAUXPMchK89XL/7l6Zb7e9EwpIyqYTSiYQSCUvppCU7lVAmmVAm1X10X7ZTiT06nLe3/0B62as75kPDddDr7xNYe/S93/P3+958t0vq8d+5Xv+59/Z/3zO9HmeyV9/vEp/be+XN/s4Hodn62nnz2fUDudeEmBcYeUGojh9uHcDxdjYXJex0Uvl0Up+9a0z/+0N3xv1bisN7PkVwR7NkyUjdVSNLCctSKmEpkXjtOWlFYZTLvFbOmy/n0kllM9EfbiUflffmw04lev4BFgAAANgJHC9Q3fFftwus5vhyOsHW7jHHC7d2kG0+Jvtzvb70d2XXr2ABAAAAwHXwpiste3HPGgAAAABcFwQWAAAAAMSEwAIAAACAmBBYAAAAABATAgsAAAAAYkJgAQAAAEBMCCwAAAAAiAmBBQAAAAAxIbAAAAAAICYEFgAAAADEhMACAAAAgJgQWAAAAAAQEwILAAAAAGJCYAEAAABATAgsAAAAAIgJgQUAAAAAMSGwAAAAACAmBBYAAAAAxITAAgAAAICYEFgAAAAAEBMCCwAAAABiQmABAAAAQEwILAAAAACICYEFAAAAADEhsAAAAAAgJgQWAAAAAMSEwAIAAACAmBBYAAAAABATAgsAAAAAYkJgAQAAAEBMCCwAAAAAiAmBBQAAAAAxIbAAAAAAICYEFgAAAADEhMACAAAAgJgQWAAAAAAQEwILAAAAAGJCYAEAAABATAgsAAAAAIgJgQUAAAAAMSGwAAAAACAmBBYAAAAAxITAAgAAAICYEFgAAAAAEBMCCwAAAABiQmABAAAAQEwILAAAAACICYEFAAAAADEhsAAAAAAgJgQWAAAAAMSEwAIAAACAmBBYAAAAABATAgsAAAAAYkJgAQAAAEBMCCwAAAAAiAmBBQAAAAAxIbAAAAAAICYEFgAAAADEhMACAAAAgJgQWAAAAAAQEwILAAAAAGJCYAEAAABATAgsAAAAAIgJgQUAAAAAMSGwAAAAACAmBBYAAAAAxITAAgAAAICYEFgAAAAAEBMCCwAAAABiQmABAAAAQEwILAAAAACICYEFAAAAADEhsAAAAAAgJgQWAAAAAMSEwAIAAACAmBBYAAAAABATAgsAAAAAYkJgAQAAAEBMCCwAAAAAiAmBBQAAAAAxIbAAAAAAICYEFgAAAADEhMACAAAAgJgQWAAAAAAQEwILAAAAAGJCYAEAAABATAgsAAAAAIgJgQUAAAAAMSGwAAAAACAmBBYAAAAAxITAAgAAAICYEFgAAAAAEBMCCwAAAABiQmABAAAAQEwILAAAAACICYEFAAAAADEhsAAAAAAgJgQWAAAAAMSEwAIAAACAmBBYAAAAABATAgsAAAAAYkJgAQAAAEBMCCwAAAAAiAmBBQAAAAAxIbAAAAAAICYEFgAAAADEhMACAAAAgJgQWAAAAAAQEwILAAAAAGKS6vUFAAD2HmOMmp1A1banhuOr4XqqO74art/9sa+646vp+nL9UB0/lOsH6gTRy4732utCE729cOuNbz5FLyQTljLJhNLJhDKpxOte3nwu2knlMykV7ZQKdkoFO6lCJnq5aKfUl0+rv5BRIZOUZVk9eZ8BAHYGAgsAEAtjjNaaHS3UHC3WHC1UXa02XK02O1rrPla6P95odeQF5m3fZiphKZmwlLAsWZa2ni1Jic3Xv8mvs655wWwGmJFCE2WXMVGAme7r/MDID9/+etJJS+VcWgP5jAYK0aO/kNFQ0dZo2dZYOavRclYjZVuDBVvJBDEGAHuNZczbf0J5l2J/gwCA3nO8QLMbbV1da2m6+5ivOt1HW8t1902jKZ20lE4mlNpcSdpcOUpaSnVfn0paSiUSSias6MfdsLqRq0XGGAVhFFpB+PqXvSDsPqKXO92XN/+b64dveHsJSxosRtE10ZfVVH9eU/057evPa2ogp6n+vIo23+cEgB3sTT9JEVgAgC0N19dLSw29vNLQ1dUopl5dberVtZaW6+7rfm4yYSnbjSU7nZCdSiqbSshOJWSnk7K72/ESe2AVJzSmu2Xxta2L7ut+HMrxgjesklVyaU3153TzYF4Hhgq6ZaioW4YLumW4qEou3aPfDQDgHSKwAADRSs1yw9XlpYZeWm7qpaWGLi3WdXGp8YaIynVDKZdOKptJKpfuPjJRPHE/0jtnjJEXGLW9QI4XdJ9Dtb1Arh+o5Qav+wTan0/r4HBRt45E0XVwuKjbRkua6s/xfgeA7YHAAoC9xvECXVys64X5ms7P1XR+vqYX5utquP7Wz0klLOUz0SEPhe5hD4VMUtl0knuIbqDQGLU7gVqdQK2O330OugH22hbEQiap28dKunO8rDvGy7pzrKTbxkoqZ1nxAoAbjMACgN1srdnRudnqVkw9N1fVlZWmNnelpRJW91S86IS8vB2FlJ1iJWq784JQTTdQs/PaKYvNjv+6e97GK1kdnijr7smK7pmq6K7JikZK2R5eNQDsegQWAOwWrY6v52ZrOju9obMzG3rm6oZmN9pb/z2XTqqQSaqYjY4ZL2VTyqU5Ynw3McbI9cPoaPvuo+kGr1udHCnZOrqvT/dMVXT3VJ/unqxooJDp4VUDwK5CYAHAThSGRheX6jr96obOTm/o9PS6XlpqbK1M5dJJlbIplbMplbJplbIppZPMkd+r/DBUw/FVc3zVHU/1bnhtmujL6vjNAzp+U5+O3zygO8dLSvH3BQDeCwILAHYCxwt0dnpDJ19d19NX1nTyyvrWqkQmmVApG61IVXJplbJp2Sm+OMZb84NQ9W501ZxoqHPbi6Irm0ro6L4+ndg/oOM39+u+m/rUl2eVCwDeAQILALajtWZHp15d18kra/rzK2t6bra6dZx30U6pnEupL5dWJZdmmx9i43iBqm1PG21PtXYUXZufwG8ZKuiBg4N64JZBPXBgQCNl7uUCgDdBYAHAdlBte3rqlTX98aUV/eHyii4uNiRFg2lL2fRWTPXl02z1ww0ThEY1x4uiq+Wp5nhbh2jsH8zrw7cO6UO3DOqDtwxweAYARAgsAOiFVsfXySvr+uNLq/rD5WU9P1dTaKJBvZVcSv25jPry0XY/jkXHdhEao4bja73lab3VUbXtba2sHhgq6MPdFa4PHxzUYNHu8dUCQE8QWABwIwSh0ZnpDf3zxWX94fKKzkxvyA+NEpZUzqbVn0+rv5BRJZtWgqDCDvFacHW0/hcrXIfHy/rr24f10UNDOn5zv+xUssdXCwA3BIEFANfLYs3Rby8u67cXlvXPl5ZVd3xZksq5aMtffyGtvlyGFSrsGqExqju+1podrTU7qjqejIkOzXjg4KAePDSsB28b0sHhIvcNAtitCCwAiIvrBzp1ZV2/vbis31xY2rqPKptOqD+f0WAho4FChnuosGf4Qaj1lqe1ZkfrrY6aneiUwtGSrY/dPqKP3zGsjxwaVtFO9fhKASA2BBYAvB/z1bZ++cKSnrywpD9cXpHjhUpYUiWX1mAho8GCrYLNKX+AJLU7gdZana3g8gKjVMLSBw8M6JN3juoTd4xo/1Ch15cJAO8HgQUA74YxRs/P1fSL84v6xflFnZ+vSZLymeTWKlV/Ia1UglUq4K2Exqja9rTS6Git6arRHXy8fzCvv7lzVJ+4c0T37x9gxRfATkNgAcDbcbxAf3p5Vb/sRtVS3ZUk9eXSGipmNFS0lc+wSgW8H+1OoJWGq5VmRxutjkIjFTJJ/fXtw/qbO0f1yTtGVcmne32ZAPB2CCwAeDOrDVe/fnFJv3xhUb+9uCzHC5VKWOrPZ7aiKpPiO+vA9eCHodabnlYartZaHTleqGTC0gMHBvTZu8b0qcNjGqswdwvAtkRgAcCmhaqjf3puXj95bkEnr6wpNNEBFYMFW0PFjPrznPgH3GjGGNUcX8t1VysNd+ugjHunKvrMXWP6zJExHRwu9vgqAWALgQVgb5tea+mnz83riXPzOjtdlSQV7ZSGihkNl2yV7BRb/4BtpOlGsbXccFVzfEnSLUMFfe7uKLbunqzwbxZALxFYAPael5Yb+qfnFvTEs/Nbh1SUsykNFW2NlGwVODIa2BEcL9iKrY2WJyNprJzVF+4Z1+fvGdfRfX3EFoAbjcACsPsZY3Rhsa6fnlvQT87N69JSNJ+qkktruBtVuUyyx1cJ4P3o+KFWGq6W6q7Wu4dkjFey+uK9E/r83eO6Z4qVLQA3BIEFYPd6ebmhHz87r++fmdXLy01JUl8+rZGireGSrWyaqAJ2Iy+IYmuxFh2SYYw00RfF1hfuntBdk2ViC8D1QmAB2F1m1lt64tl5/eDM3Nb2v758WqMlW8OlrGxO/gP2FC8ItVx//crWVH9ua2XryASxBSBWBBaAnW+p7ugnz87rB2fn9MzVDUnRPVWj5axGWKkC0HVtbK01OzKSbhrI6+GjE/ryfZOcRgggDgQWgJ1pvdnRPz2/oB+emdOfX1lVaKSSndJI2dZoKcs9VQDeUscPtdxwtdTdRihJRybK+sp9k/rivRMaLTNnC8B7QmAB2DnanUA/P7+g7z0zq99dWlEQGhUySQ2XbI2Wsypy+h+A98D1Ai3WXS3WHNUcX5akD94yqK/eN6nP3DWmSi7d60sEsHMQWAC2tyA0+peXV/Xd0zP6ybkFtb1AufRmVDGnCkC8mq6vxZqjxbqrVidQOmnpE3eM6OGjk/r4HSNsOQbwdggsANvTiws1fe/0rL73zKyW6q5SCUvDJVtj5az682miCsB1ZYxRzYlia6nuyvVDFTJJPXT3uB6+b1IP3DKoZIKPQwDegMACsH0sVB398Oysvn1qRhcXG0pY0kA+o7FKVkNFmy9mAPREaIzWW54Wq45Wmq68wGi4ZOurxyb1tWNTOjRa6vUlAtg+CCwAvdVwff3suQV95/SM/vTSqoyiAcCj3cMqMhyrDmAbCUKjlYarhZqj1UZ0EuGRibK+dnxKX7p3QoNFu9eXCKC3CCwAN14QGv3u0rK+d3pWP3t+QY4fKp9JaqRka7ySVT7DYRUAtr+OH2qh5mwdjpFMWPr47cP62vEpffyOEdkp7tcC9iACC8CN8/JyQ98+NaPHT81oue4qk0x076uyVclxXxWAnavh+JrvxpbrhypnU/ry0Ul99dikju7r4+MbsHcQWACur4br6yfPzuubJ6d16tV1WZIGChlNdO+rSnBfFYBdJDRG682O5quOVpodBaHR/sG8Hj2xT1+5b1ITfbleXyKA64vAAhA/Y4yeemVNj5+a1o+fnZfjhSrYSY2XsxqrZNk2A2BP8INQi/Xofq2NlidL0ocODuqRY1P63N1jbIcGdicCC0B85qttfefUjL759LSm19tKJSyNlGxN9OVUzjKvCsDe1e4EW1sIW51ont8X7x3XYyf26fjN/Xx8BHYPAgvA++N4gX5xflHffHpaf7i8IiOpL5/WRCWrkVKWo9UB4BrGGG20Pc1XHS3XXfmh0c2DeX39/n165NiURsvZXl8igPeHwALw7hlj9PxcTd98elrff2ZWdddXNp3QWDmriUpOuQxbAAHg7fhhqKWaq/nuFsKEJT14aFhfv3+fPnnnKGMqgJ2JwALwzq02XH3/zJz+8amrurQUDQIeLtkar+Q0kOcUQAB4r1odX/NVRws1R44XqpJL66vHJvXo8X06PFHu9eUBeOcILABvzQ9C/fOlZf3jU9P61YtLCkKjcjal8UpWo+Ws0km+wwoAcTHGaHXzFMKGq9BIh8fL+p8+sE9fundCfflMry8RwFsjsAC8uctLDT1+alrfPjmj1WZHmVRCYyVb4305FW1OvgKA680LQi1UHc3XHNUdX6mkpc8eGdOjJ/bpI7cOcY8rsD0RWABeU3c8PfHsvL7x9LTOTm/IkjRYzGiiktNgMaMEWwABoCfqjqe5qqOlmqtOEGq0ZOvRE/v0teNT2j9U6PXlAXgNgQXsdWFo9OdX1vT4yWk9cW5erh+qkElqvJLTWMVmZhUAbCNhaLTccDVfdbTW7MhIun9/v75+/016iNlawHZAYAF71exGNLPqH5+e1txGd2ZV2dZEhZlVALATOF6ghZqjhaqjZne21pfundCjJ6aYrQX0DoEF7CWOF+hnzy/oW09P648vrcpI6s+nNVHJabhks58fAHYgY4yq7WgL4eZsrf2DeX39/pv01WOTzNYCbiwCC9jtjDF6dqaqx09O63tnZtV0o+9yjpWj49WZWQUAu8ebzdb62G3DevQEs7WAG4TAAnarlYar7z8zq28+Pa1LSw0lLUvDpYzGKzn1M7MKAHa9VsfvHozhqO2F6sun9ZX7JvXYiX26c5zZWsB1QmABu4kXhHrywrIeP/nazKpKLq2xclajZZuZVQCwB73ZbK27Jsp67P59+vK9k6rk072+RGA3IbCA3eDSYl2Pn5rRt0/NaK3ZkZ1KaLSc1Xgly8wqAMCWjh9qseZooeao5vjKJBP69JFRPXZin/6K2VpAHAgsYKeqOZ5+dHZO33p6WmdnqkpY0mAh2gLIzCoAwNvZmq1Vd9XxQ42Ws3rsxJS+dnxKNw8yWwt4jwgsYCcJQ6M/vLSib5+c0U+fX1DHD1W0UxqvZDVWznLzMgDgXbt2ttZqsyNJ+uCBAT12Yp8+x2wt4N0isICd4NXVpr59akaPn5zRQs1RJpnQcMnWRCWrEjOrAAAxcbxAC1VHC3VHTTdQIZPUF++d0KMn9unYTX18vgHeHoEFbFdN19dPzs3rWyen9fSVdUmbWwCzGioyswoAcP0YY7TR9jR/zWytA0MFff3+ffrqfZMaYbYW8K8hsIDtxBijp15Z0+OnZvTEs/Nqe4EKdlJjpazGKlll08ysAgDcWH4QaqnuaqHmaH1zttbtI3rsxJQ+cQeztYC/QGAB28HcRlvfOTWjb52a1vRaW+mkpeGirfFKVpUcM6sAANtDq+NrbiM6GKPtBerLp/XIsSk9emJKd4wxWwsQgQX0juMF+tnzC3r85Iz+cHlFRlJ/Pq3xSlYjpSxbAAEA21ZojNb+crbWZEVfPzGlLzFbC3sbgQXcSMYYnZne0LdPzegHZ+bUcH3lM0mNlmyNV3LKZdgCCADYWTp+qIXubK264yudtPTZI2P66vEpffTWIaUYco+9hcACboTptZa+/8ysvnN6RldWW0omLA0Xo5lV/Xm2AAIAdj5jjOqur/nuFsJOEGqwkNFX7pvUV45N6vB4mc932AsILOB6qTmefvLsvL5zembrFMD+fFpj5axGSjbf0QMA7FphaLTS7Gih2tZqs6PQSLeNFvXIsSk9fN+kRjmFELsXgQXEyQtC/fPFZX339Kx+fn5BXmBUtFMaLdkarWSV4xRAAMAe4wWhFmuOFmuuNtrRKYQfPjikR45P6jNHGGSMXYfAAt4vY4zOzVb13dOz+sGZWa23PNmpaBDweJlBwAAAbGp1fM1Xoy2ErU6gXDqpz909pq/eN6UPHRzkgCfsBgQW8F7NbbT1ve59VS8vN5VMWBosZDRWzmqwmFGCqAIA4E1tDjJeqDpabrjyAqORkq2vHJvUI8emdNtoqdeXCLxXBBbwbmy0Ovrpcwv6wZlZ/fnlta2j1Ue791Wlua8KAIB3JQiNVhrRIOPVZkfGSIfHy/ry0Ql98d4JTfTlen2JwLtBYAFvp9Xx9Yvzi/rh2Tn99sKy/NCoYCc1UspqvJzlaHUAAGKyeeT7Ut1Vte1Jku7f368vHZ3UQ3eNabBo9/gKgbdFYAFvpuNHh1X88Oycfn5+QY4XKpdOarhka7Rsq2RzXxUAANdTq+NrseZqqe6q4fpKWNJHDw3ry0cn9OkjYyraHI6BbYnAAjYFodGfX1nVj87O6Yln51VzfNmphIaKUVT15ZhXBQDAjWaMUcONYmu5ER2OkUkl9Mk7RvTloxP62O0jynJKL7YPAgt7mzFGZ2eq+tHZOf3gzKxWGh2lk9FhFaPlrAYKHFYBAMB2YYxRte1rsRYdjuH6oQp2Up89Mq4vH53Qhw8OMmcSvUZgYe8JQ6Nnpjf003PzeuLcvOarjhKWtqJqqGhzTCwAANtcaIzWWx0t1lytdE8irOTS+txdY3ro7nF96OAgh0+hFwgs7A1haHT66rqeODevn5yb12LNVcKSBgoZjZRsDRU5ARAAgJ0qCI1Wmx0t1R2tNjryQ6NyNqXPHBnTQ/eM668ODimT4vM8bggCC7tXEBqdvLKmnz63oCfOzWu57iqZsDSQT2u4lNVwMcM2AgAAdpkgNFprdrRUd7XajFa2inZKnz4yqofuGtdHbxuSneKeLVw3BBZ2Fy8I9fQrUVT99Ll5rTQ6UVRtrlQViCoAAPaKMDRaa3Vjq9FRJwiVzyT16cOj+tzd4/rr24Y5IANxI7Cw8zVdX7+9uKxfnF/Ur15YVM3xt6JqtGRrsJhRKkFUAQCwl4XGaL27srXS7Kjjh8qmEnrwtmF96vCoPnnnqAYKmV5fJnY+Ags701Ld0S/PL+kX5xf0+8sr8gKjTCqhgXxGwyVbg4UMB1UAAIA3FR2Q4Wm57mqt2VHbC5SwpOM39+vTh8f0qcOj2j9U6PVlYmcisLBzXF5q6OfnF/Tz5xd1ZnpDklTIJDVQiKKqkktzpDoAAHhXjDGqu/5WbNUcX5J063BRnz4yqk8dHtW9U31K8I1bvDMEFrYv1w/01Ctr+s2Ly/r1i4u6stqSJFVyaQ0WMhou2irYSYb/AgCA2LQ7gZYb0dHvG21PxkiDxYw+fXhUH7t9RH9165CKdqrXl4nti8DC9jKz3tKTF5b15IUl/eHyqtpeoKRlqS+f1lAxo6Gizc2oAADghvCCUCuNjlYa0eqWHxqlEpbu3z+gj98xrI/fPqJbR4p8sxfXIrDQWx0/1MlX1/TkhWX95sUlXVpqSJLymaT68xkNFTPqz3M/FQAA6K3QGG20PK02O1pvdVTvbiUcr2T18TtG9PHbR/Thg4MqsLq11xFYuLGMMXp5pak/XF7R7y+t6PeXV9TqRDeW9uUzGixEj3yGrX8AAGD7crxAq82OVrtbCb3AKJ209IEDA3rw0LD+6tYhHR4vc+/W3kNg4fpbqjv64+VV/f7yin53aVmLNVdStErVl0trqGirP59mPhUAANiRXre61eyo7karW5VcWh+5dUgfvnVQH7l1SDcN5PkG8u5HYCF+dcfT01fW9PtLq/rdpeWtbX92KqFKLq3+fEYDhbRyaVapAADA7uN6gdZantabHW20PbW9QJI0Ucnqo4eG9eFbB/Xhg0MaLtk9vlJcBwQW3r+1ZkdPX1nTU6+s6c8vr+r8fE2hkZIJS5VcWgP5tPoLGZXsFEEFAAD2FGOMWp1Aa62O1pueNtodeUH0pfHB4YI+eMugPnhgQPfvH9BEX67HV4sYEFh49xZrjv78ypqeemVVf355bWuFKpmwVM6m1JdLqy+fUSWX5nAKAACAaxhjVHN8rbc62mh5qjneVnBN9uX0wVsGtoLrwFCBb07vPAQW3poXhHpxvq5nptd15uqGnr6ypun1tiQpnbRUzqbVl0+rL5dWOZvmRk4AAIB3YXPQ8UbL2wou1w8lSYOFjD5wYEDHburXfTf16a7JCuNqtr/rH1iWZR2/6667TrbbbT300EP6+7//e0p8G1uoOnrm6rqemd7Q6VfX9exsVZ3uP/JsOqGSnVJfPqO+fFpFO6UEf5YAAACx2dxSuNH2tNHqqOb4anWie7iSCUt3jpV03039OrqvT/fd1Mcq1/ZzQwLrqT/96U/3f/CDH9RDDz2kf/tv/60+97nPxfb28d4YY7RYc/XcbFXPz9X03FxVZ6c3tFSPTvhLWFI5l1bJTqmSS6uSS8tOJfgHDAAAcIO5fqha21PV8VRv+6q7r20rLGdTOrovWt26a7KiIxNlTivsrfcWWJZlFSR9S9KUpKSk/yTp30n6kjHmgmVZ35D0a0k/lvQbY8ztkvSNb3xDTz75pP7bf/tv8f0W8LbC0Ghmva3n5qpbQXVutqq1Zmfr5xTtlAp2UpVseius2O4HAACw/Rhj1OwEqrY91dqe6q6vhutr80v4gp3UkYkotu6aqOjIZFm3DhcZiXNjvOkX0O9k/PRnJc0ZYz4vSZZlVSTNSfoHy7L+XlK/Mea/W5Z1QtKMpNslaWpqSrOzs7FcOd7IGKP5qqOLi3VdWmzo4mJdFxbqurTU2DoeNGFtxlRKt40WVbJTKmZTSiX4BwcAALATWJalop1S0U5psnvyYBAaNV1fdddX3fF1caGu06+uyw+j6konLR0cLur2sZJuGy3p0EhRh0ZLumkgz6FkN8A7Caxzkv5vy7L+T0k/Nsb8TtIvLMt6VNL/I+ne63mBe53jBbq61tKVlaaurDb18nJTFxbrurhYV9MNtn5eNp1QLp3SYDGjop1SqRtW/CMCAADYXZIJS+VctBNp0+ZKV8OJwmu57urqWks/ODO39XMyqYQODhd0+2hJh0ZLOjBU0M2Ded08WFDRfidZgHfibd+TxpiLlmUdk/SQpP9oWdavJP1HSXdKaknqV7RyNatoG6EkaWZmRpOTk9floncTY4yqbU+zG21Nr7X16mpTV1ajoHplpanFmvO6YxntVEL5TFL9uYym+pIqdL+jkWYZGAAAYM+6dqVr7JrX+0GoZidQ0/XV7Phaqrl6dbWl718TXlJ0iuH+oYL2Dxa0fzCvm4cKunkgr6n+nAYKGe7zehfeyT1YE5LWjDGOZVlfkPS3kn6naCvg/5D0XyR9yBjj/eUhF3/3d3+nhx566Hr/HratMDTaaHtaabharrtaqDqa22hrrtrW7Iaj2fWW5jacrS19m+xUQrlMUtlUUvlMUrlMUvl09ExIAQAA4P3yg1BtL1CrE6jtBWp3nx0vfMPXpplUQmPlrKb6cxqv5DTRl9VEX07jlaxGy1kNFW0NFDJ7cefUez7k4jOKDrYIJXmS/o2kf5D0AWNM3bKs/yypboz595ZlnThy5MjT7XZbn/vc5/Rf/+t/3TW1G4RGdcdTtf3ao9b2X/fjlYarlYarpZqr5YartWZHQfjG9282nZCdSiqTTCibTiibTiqbip6JKAAAAPRSEJqt6HK8QI4fyvECdfxQnSBUuxO8YfBtwpL68mkNFW0Nl2wNFe2t8No8pbqcS6ucTV3zclqZ1I7+undvDhquO57+/peXFBijIPyLxzWv6/hRrW8VfCdQywvkXPMX660kLCmbjuIolbCUSSVkpxLKJBPKdJ/tbljtwboHAADALhGa6GtnxwvkdqOrc82zHxh5QSjXD7cO3vjX2KmEcunk1kJDNp1QPpPqni+QlJ1O6oEDA/qfP7T/xvzm3p33fIrgjub6of6/p64qmbCUtKzoOWEp0X05kZASlhUFUCqKoXIurZGSLfualaVsOqFSNhq4W8pGj+jltErZ1DuaG2W9+Z/BnrNLFjV3vO3w59DrFe5t8C7YFrbF3wX+NLbJnwMkbYt3RK//TWyHv4/bwXZ4N/T6c+X71fa6B284nurXPrv+1rHzjhfI9aJg24y2phtovenJ8QKNl7O9/m28K7t+BQsAAAAAroM3rd8dvekRAAAAALYTAgsAAAAAYkJgAQAAAEBMCCwAAAAAiAmBBQAAAAAxIbAAAAAAICYEFgAAAADEhMACAAAAgJgQWAAAAAAQEwILAAAAAGJCYAEAAABATAgsAAAAAIgJgQUAAAAAMSGwAAAAACAmBBYAAAAAxITAAgAAAICYEFgAAAAAEBMCCwAAAABiQmABAAAAQEwILAAAAACICYEFAAAAADEhsAAAAAAgJgQWAAAAAMSEwAIAAACAmBBYAAAAABATAgsAAAAAYkJgAQAAAEBMCCwAAAAAiAmBBQAAAAAxIbAAAAAAICYEFgAAAADEhMACAAAAgJgQWAAAAAAQEwILAAAAAGJCYAEAAABATAgsAAAAAIgJgQUAAAAAMSGwAAAAACAmBBYAAAAAxITAAgAAAICYEFgAAAAAEBMCCwAAAABiQmABAAAAQEwILAAAAACICYEFAAAAADEhsAAAAAAgJgQWAAAAAMSEwAIAAACAmBBYAAAAABATAgsAAAAAYkJgAQAAAEBMCCwAAAAAiAmBBQAAAAAxIbAAAAAAICYEFgAAAADEhMACAAAAgJgQWAAAAAAQEwILAAAAAGJCYAEAAABATAgsAAAAAIgJgQUAAAAAMSGwAAAAACAmBBYAAAAAxITAAgAAAICYEFgAAAAAEBMCCwAAAABiQmABAAAAQEwILAAAAACICYEFAAAAADEhsAAAAAAgJgQWAAAAAMSEwAIAAACAmBBYAAAAABATAgsAAAAAYkJgAQAAAEBMCCwAAAAAiAmBBQAAAAAxIbAAAAAAICYEFgAAAADEhMACAAAAgJgQWAAAAAAQEwILAAAAAGJCYAEAAABATAgsAAAAAIgJgQUAAAAAMSGwAAAAACAmBBYAAAAAxITAAgAAAICYEFgAAAAAEBMCCwAAAABiQmABAAAAQEwILAAAAACICYEFAAAAADEhsAAAAAAgJgQWAAAAAMSEwAIAAACAmBBYAAAAABATAgsAAAAAYkJgAQAAAEBMCCwAAAAAiAmBBQAAAAAxSV2Ht2ldh7cJAAAAANseK1gAAAAAEBMCCwAAAABiQmABAAAAQEwILAAAAACICYEFAAAAADEhsAAAAAAgJv8/9I1tuhDrJR8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "processor.plot_pulses(use_control_latex=False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define your own gate\n",
    "The number of predefined gates in qutip is limited, hence you are encouraged to define your own gate. Here we show how to define a parametrized gate. First, you will need to define a gate function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\Miniconda3\\envs\\notebook\\lib\\site-packages\\qutip_qip\\operations\\gates.py:463: UserWarning: Unknown gate MYGATE\n",
      "  warnings.warn(\"Unknown gate %s\" % name)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<qutip_qip.circuit.QubitCircuit at 0x22d94e84640>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def mygate(theta = None):\n",
    "    # We just call the Molmer Sorensen gate as an example.\n",
    "    # If you do not want to run the circuit at the gate matrix level (circuit.run), no need for this function,\n",
    "    # otherwise you will need to define this python function that returns the Qobj of the gate.)\n",
    "    from qutip_qip.operations import molmer_sorensen\n",
    "    return molmer_sorensen(theta, 2, targets=[0, 1])\n",
    "circuit = QubitCircuit(2)\n",
    "circuit.user_gates = {\"MYGATE\": mygate}  # no need for this if you don't use circuit.run\n",
    "circuit.add_gate(\"X\", targets=1)\n",
    "circuit.add_gate(\"MYGATE\", targets=[0,1], arg_value=3*np.pi/2)\n",
    "circuit.add_gate(\"X\", targets=0)\n",
    "circuit\n",
    "# You may see a warning because MYGATE is not found in defined LaTeX gate names, just ignore it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[2, 2], [1, 1]], shape = (4, 1), type = ket\\begin{equation*}\\left(\\begin{array}{*{11}c}-0.707j\\\\0.0\\\\0.0\\\\-0.707\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[2, 2], [1, 1]], shape = (4, 1), type = ket\n",
       "Qobj data =\n",
       "[[ 0.        -0.70710678j]\n",
       " [ 0.        +0.j        ]\n",
       " [ 0.        +0.j        ]\n",
       " [-0.70710678+0.j        ]]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit.run(basis([2,2],[0,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to define a compiler function for it. Since compiling a real MS gate is rather complicated, we here just use a dummy triangular pulse. The goal is to show how to get access to the parameter `theta` during the compiling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mygate_compiler(gate, args):\n",
    "    targets = gate.targets  # target qubit\n",
    "    parameters = args[\"params\"]\n",
    "    \n",
    "    theta = gate.arg_value\n",
    "    coeff1 = np.concatenate([np.linspace(0,10,50), np.linspace(10,0,50), [0]]) / 50\n",
    "    coeff2 = np.concatenate([np.linspace(0,10,50), np.linspace(10,0,50), [0]]) / 50\n",
    "    pulse_info = [(\"sx\" + str(targets[0]), theta * coeff1),\n",
    "                  (\"sx\" + str(targets[1]), theta * coeff2)\n",
    "                 ]  #  save the information in a tuple (pulse_name, coeff)\n",
    "    tlist = np.linspace(0, 1, len(coeff1))\n",
    "    return [Instruction(gate, tlist, pulse_info)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAGoCAYAAABbkkSYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA1E0lEQVR4nO3deZSdd33n+c9z971UpSqpFsnaZUlVAkIM7jjdBJLQsRNCcsiwJs0cDodMM92TPp2ZDjB0GJYkkKQzZ2Y6QDod5kw3WZqEnoR2gMB0ggFDE2OMbam02FosqTbVfvfteZ7f/HGXqpKEVZZ+papb9/06x0tJj8qPFte9n+f3+35+jjFGAAAAAIC7F9jsGwAAAACA7YKABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEtCFj8XdYQAAAAAuoVzq29kBQsAAAAALCFgAQAAAIAlNrcIAgAAAB2rUvc0sVTWtaWSppcrWi7XlCu7KlTr8nypMRHjKBUNKhUNKxMPaagnpqGeuEZ649qZjMhxbrlrDF2EgAUAAICuU6y6eurqkk5NZjU+mdOzk8u6tli+6bqAI4WDgcawTTM7uZ6R699cP7AjEdaJoYxODGU0OpLRgwd2anhHfGN/IthyHGOsdVNQcgEA2BCVuqfzM3mdmc7p2mJJNdeXkbQ7E9XwjriO7Err0EBSoSA73wHcmu8bPTOxrG8+P69vPj+n719dboekRCSoZCSkVCykeDioeDigWDiocDCggKNbrkr5xsj1jKqup0rdV7nuqVB1Vay6KtY8ec3Pvac3rn94uF//6MiAXnv/gJJR1je2kVsuVxKwAABbylKxpjPTOY1PZXVmKqdTk1ldni+q9bDYkRQMNF7TVj9BjgQd3T+Y0dhI4+nxieEeHR9KKxHhzQzQrXzf6KmrS/riqWl98dlpzearkqRMLKTeRES9ybAysbDClh/O+MaoWHW1VKprqVRTtlxX3TOKBAN6zdEBPTI2qNeP7lYmFrb638U9R8ACAGwdxhhNLJU1PpXTmamsxqdzOj2Z1fVctX1NPBxUMhpUKhpSOhZSOhpWLBxoP012vcZT42LVU75aV6HqqVh1VXV9SY1XvgP9SY2O9Gh0ONP8q0d9ychm/JQB3CNTy2X9xZMT+k/fvarpbEVBR+pNRrQrHVN/KmI9UN2Ob4yy5bpm81XNF6qq1H1FQwE9Mjaot7xqr/7BgZ0KBJjd6kAELADA5qi5vi7MFtorU61QVah6khqvUMloqD04no6FlIqGFAm99DdBxhhVXV/5iqt8pd7YslPzVKp57Wt2paM62QxdJ5qha09vnOF0oIP5vtFjz83qP3z7ir7x3JyMpL5kWEOZuPpTkS2zhdgYo1zF1XS2otl8RXXPaE9vXO/8kX1666vuU0+cVa0OQsACAGy8fKWus9P59ha/01NZXZgtqO41XiZCAacZpkLtIJWKhtrb/jZK3WuFrkYjWLHmqVBx2y9e6VioEbiGmqtdIxkdGkjd8yfdAF6aSt3TF56e1L/7+iVdmi8qFg5oMBPTcE9c8Uhws2/vRXm+0Vy+qslsWculumLhgN76wF6960cPaH9/crNvD7dHwAIA2GOM0fVcVWemGw1crS1+E0srLVzRUEDJaEjpaGN4PB0NKREJbpmVIs83KlRXha5qY0i9NdsVCTo6ujutsVWrXccGMwypA1tAvlLXf/xvV/SZxy9rsVhTOhbSfb0J7cpEFdgiX2NeinylrquLZc3mKzJGesPLhvQrP3FER3anN/vW8IMRsAAAd8bzjS7PF5pb+3Iab65MLZfq7WuSkeDaMBULKRIMbJkwtV6+MSo1V7fyVbfdCrZ6rmt/f7I9z9Wa7dqZim7ujQNdolh19f98+wX9u69fVK7iamcyovv6EupNhDvu682tVF1P1xbLmlwuy/ONHhkb1K/85BEdG8xs9q3hZgQsAMDtlWuezs3kmvNSOY1PZnVuJt8OGAFHSkVDjTDVXJVKRUNbZr5hI6yZ66q6KlTqN811DaSjOjmc0ehIT+MMnOEe7e1jrguwpVzz9NnvvKBPfe2ilst19aciOtCf3LZNfDXX17WlkiaWynJ9o58+Oahf+6ljbB3cWghYAIC1Fou19qxUa1XqhVWV6JHgjfNSYSWjwY7cfrMRWnNdjW2GzbmuqqvWS2sqGlpTpDE6nNHhXcx1AS+F7xv956cm9DtfOa+5fFV9yYgO9ie7pgyi7vm6utgIWkbSLz14n37lJ46war41ELAAoFutVKK3iica81KtM2GklUr0dDSkdCysVDS0phId6+P5jfNv8s3Zrta/tw4dDbfmuoZ7NNo8s+v4EHNdwK18+8K8PvrXZ3RuJq9MPKTDAyn1JrrzmIWq6+nyfFFTyxXFI0H9j689pHf/w4NbvshjmyNgAUA3qHuNSvTWvNTpZqgqVF1JjVeDxha/lUr0dCzEqsoGMs25rny7UOPmua59OxOrzutq/LOfJ9ToUhdm8/rNL57V187PKR4O6uBAUrvTUR74qDGDdnGuoLlCTQPpqP71zxzXG18+zK/N5iBgAcB2U6i6OtealZrK6vRUTs9fz//ASvR0c3ZqoyvRcXs3z3W5KtbcNXNd/alI87yulRbD+/oSvJHCtlWouvq//vZ5febxywo40r6+hPb0JviadQvLpZqeny0oV3H1wL5effTnxnRimCKMe4yABQCdbDZfaa9KnZnK6dRkVtcWS+0vvo1K9KDS0fCWrETH+qyd62qErtVzXclIUKPDPc25rsZq15HdzHWhsxlj9MVT0/roo2c0m69quCemQwOpOzpsvJsYYzSVrejSXFF139cvPnif/pd/fL92dOk2yk1AwAKATuD7RlcWS2vLJyazWijW2tckI0ElIqH29r5UNKRoiHmp7epWc12rz+sKBx0d2ZXW2EimHb6OD2WUYq4LHeDiXEEf+qvT+tbFBaVjId2/O901BRa21D1fl+aKmlwuKxMP69cevl9ve9V9rPxtPAIWAGw1VdfT89cLa8onzkzlVK43tom1K9EjK2dLpaLMS2HtXFfjzK7GQcmr57ru60tobE+rNr4RvgbSzHVhayjVXP3+313QH37jkhxHOtCf1J4dHG1wN/IVV8/N5rVcquvEcEa/+fNj+qH7ejf7trYzAhYAbKZsua6zq+alxiezujBXbLfLhQKOUqsr0WMhpSIhBXgCiXVqzXW1thfmbzHXtTPZnOtqrXYNNea6+HOGe8UYo6+eua7/7QvjmslVNJiJ6fCulKJsB7TCGKPr+aouzhVUqft6ywN79L6Hj1HrvjEIWABwLxhjNJOraHyydVhvVqcnc5pcLreviYUDK6tSzUAVDzMvhY1R924OXYWK237hTkSC7RWuE0ONMo0ju1OKhqh/hl1XFor60BfG9fXn5pSKhnR0d/fWrm801/N1eaGkiaWSUtGQfu3hY3r7q9k2aBkBCwBs83yjy/NrK9HHJ3NaLtfb1ySjQSUjKy1+qViIN67YdJ5vVKytCl03zHWFAo4O70qtaTA8PpRhNgZ3pFL39OnHLupTj12QMc3tgL1xDi2/BwpVV8/PFrRYrGl0OKPfYNugTQQsALgblbqnczP5lXmpyazOzeTbMy+tealUdGVlKhUNKcS8FDqEMUblundTdXyl7revGdkRXynTGMpodCSjwUyM1Vf8QH937ro+9IVxTSyVtTsT1ZGBlKJhHjLdS61tg5fmiirXPb3tVXv1aw8fU1+S1cO7RMACgPVaKtba2/taleiX54tqPtxXOHjDvFQ0rGQ0yNNYbEtV12sWaTRWu0o1r31wtST1xMMaG85odGSlUONAf5KHC13u2mJJH/4v4/rbc7NKRYM6sivNG/pN1tg2WNTEUlmpaEjve+QYbYN3h4AFADcyxmhiqdwMUzmdmcrq1GRW13PV9jXxcFDJaLAZpsJKR0OKhalER3dzPV+Fqqd8td5e6SpUPHnN9xWRUED3705rbGTlzK5jg2klIlTHb3eVuqc/+PpFfeqxi/J9o/07E9rbl+AB1Bayetvg2EhGv/HzJ/WKvTs2+7Y6EQELQHere74uzhXa5ROnJxurU/nmk3hHUjIaah/W26pE56BLYH38VnV8pd5e8SpWPdW8ler4/f3JRuhqrnSdGM6on3azbeO/nrmuDz+6sh3w8EBKMbYDbkmrtw1W6p7e9uq9+lc/xbbBl8huwHIcJynpU5Jqkh4zxvzxnd8bANhVrLo6N5Nrl0+cmszquet51b3G17xguxI9qNSqMMU2CcCuVnV8vr3FsK5SzVtTHT+QjmqsGbaoju9MVxdK+vCj4/q7c7NKRUM6sivFG/UO0do2eG2prEyMQ4pfIusB659IWjbGPOo4zueMMW+5m7sDgDs1l6/eNC91daHUXlaPhgLNLX7hdotfIsK8FLCZ6l4jdLXq44u1xr+33pYkIsE1ByRTHb81FaquPv1Y47BgY6T9O5Pa20c7YCdavW3w5EiPfuPnx/Rytg3ejvWA9QFJXzbGPO04zp8aY95+N3cHALfj+0ZXF0s3han5Qq19TSISvOl8qWiIeSmgE7Sq4wvN6vhCrVEfv3rluVEdv/bMLqrj7z3X8/W5J6/p9776nBaLNQ1mojrEdsCOZ4zR9VxVl+Yb2wbf+qq9+p//8f0aSLON9we484DlOM7LJf1bSf2SjjU/2QuS/idjzF87jvOfjDFvtXevALpdzfX13PW8zkzn2pXoZ6Zz7W1FjqRULHTT+VJhWsuAbWV91fGx5lzXSqHGUA/V8RvlsfOz+s0vntXzswX1JsI6PJBShpC7rbier8vzRV1bLisWCuo9rzmoX37NQaWilNTc4M4CluM4MUlPS3qnMeYJx3E+Jikm6cOSfl9SRdLjzGABuFO5Sl1np3LtJr/Tk1ldmC2sOfB0zflSzWDF/nCge623Ov7Eqtmug1TH35Wnri7p975yXt+6uKBkJKiDA0kNpKIE2W2sVHN1ca6o2XxVvYmw/sVPHNE7HtxH+dOKOw5Yb5D0DmPMO5ofv1nSw8aYd99wKS2CAF6UMUaz+arGp7Ian8xpvNnkN7FUbl/TmJda2d6XjoUUDwd5AQdwW67vq1DxVKjWm3NdjRC2ujr+2O60Rkcyze2FPTo2mFaSp/Iv6tREVr/3/53XY+fnFA0FdF9fQnt6mbPqJtlyXZfmC1os1jWyI65/+fqj+rlXDLNr5C4C1vub1328+fHHJU0YYz55w6UELABtnm90eb64Zl7q9GRWS6V6+5pkJNgOU62VKQbYAdi0Uh3vqlCpq1D1VKi5qrlrq+NHb2gxZOZEeubasj75tQv66pnrigQD2tsX157euEKBrn9T3ZWMMVos1nRpvqhcxdXIjpje+9rDevMDe7r5tfuOA9Z7JP24MebtjuMclfSopIeMMQs3XErAArpUpe7p/Ey+HabGJ3M6O51TpfkGJuBIqWhozcpUKhpiqw6ATXFjdXyhWR1fXF0dn4pqdKR5VldztmtfF1TH+77RY8/N6g++fklPXF5UOOhoT29C9/XG+ZoNSY3/fxaKNV1ZKGm5XNdAOqr/4TUH9dZX7VU61nWzeHccsFKS/kzSAUnzkn7VGPOU4zgDkn5H0q9L+mitVntXONx1v6hA11ku1XTmhnmpi3MFNcelFA46K6tSzTCVjIbYSgJgy6t7/g1zXY1/v1V1/Ilm8Do6uD2q44tVV48+M6V//83LujhXUDwc1J7euIZ7YgQr3JIxRkulul5YKGqpVFc8EtRbfniP3vnQfh0aSG327d0rdmvaJclxnI+o0Sr4bmNM/o4/EYAtxxijqWxF45PZxmG9041K9JlspX1NPBxUIhJst/ilY2HFwlSiA9g+bqyOb53XtaY6fiDVnutqbTHsSXTGQ+dTE1n96RNX9YWnJ1WqecrEQtrTm9DuTJQHY1i3XLmua0tlzeYr8o30o4d26s0P7NVPjQ4qHun8BxAvwvo5WClJn5YUMMb8otgiCHQs1/N1ab64Uj4x1djql6usNHKloiElm2EqFWsc2EuLEIButLo6vlBtrHKVqp7K9ZUthsM7Yhob7lmZ6xrOaHiLVMdfmM3ri8/O6NFnp3RhtqBQwNFAOqrhnrh64qEtcY/oTFXX19RyWTO5iko1T4lIUD9zckhvfMWwHjywczu+b7AXsBzHCUn6Q0kfkfQWSd81xnztrm4PwD1RqLo6N51bOV9qKqvzM/k1T2NXh6l0LKxUlEp0ALidquurUKm3txi2QlhLTzzcnOnKNFe8enRoYOOr4yt1T0++sKRvXpjT352d1fOzBUlSbyKsXemodmditMHBKmOMlst1TWcrmstX5fpGyWhQr7t/l15/YrceOtS/XYpk7G8RvAErWMAWs1Ss6dRkVqcmsxqfyur0ZE5XF0vt74+GAkpGgkrFQkpFw0rHQkpEgmwLAQBLXN9XseopX2lUx5eaoctrDq5GggHdP5jW6PDKbNexwcwdV8cbYzSxVNbp5tf+ZyaW9d0XllRzfQWcRsgbSEW1Kx1VNLytt25hi/D8RvvgfKGqxWKtXYC1f2dCDx7YqQf29+rYYEaHd6U6cTthdwWs67mKnr62/AO///Y/7Re/4HY//naf/vY/fqP/+3f323U393/bH7vBP7e7/K2/B783d/ffL9c8PTuR1VNXl9acL5WMBpWIrG3xi4aYlwKAe21NdXy1rmK1cUhy9Ybq+BPN0HV0V1rhUEC+MarWPRWrnoo1V8Wqp1JzJmwmW9GVhZKuLBTbbYitBteeeFh9yYh2JMJUrGNTGWOUq7haLtW0XK4rV3ZV81b+3I/0xnVoIKXBTEy7MlH1p6JKx0I6Nth4+LAFdVfA+pvT0/qnf/zUZt8GsCl2JiPatzOhA/1J7d+Z1L6dCSUiHKTZKci8Lw2/Xi+Nc+v3A9hkxhgtlmq6ulDS1cWSJpbKmlwua3pVsdCtBBwpFg6qNxHRzlRE/amo9uyIa19/Qnt3JBS+lzMv/NF6SfjlajxsmMlWNLlc1tRyWZNLZc0VasqW61ou1doNxe997SG97+Fjm3uzt9ZdAStbrmtiqfSi19zuReZ2L9q3/f67/fwv/t3reFOx0f/923z+2/74F/uxd3fvt3P739uN+7k1fvzG/d6EggH1JSMv/gkAAB0hW6rr0nxBvjGSHMXDQaWiISWiQSUjIZpbsW15vtFSqaZi1VUiEtqqM1vdFbAAAAAAYAPdMmCxERcAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgCQELAAAAACwhYAEAAACAJQQsAAAAALCEgAUAAAAAlhCwAAAAAMASAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsIWABAAAAgCUELAAAAACwhIAFAAAAAJYQsAAAAADAEgIWAAAAAFhCwAIAAAAASwhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgCQELAAAAACwhYAEAAACAJQQsAAAAALCEgAUAAAAAlhCwAAAAAMASAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsCW32DaBzeb7RbL6iiaWyZrIV5Sp15cquSjVXvjGSpIDjKBUNKR0La0cirKGemEZ2xNWfiioQcDb5ZwAAAADYRcDCulTqnp6+tqzTk1mdmc7p1ERWl+eLcn1zy+ud5t/Mrb9bkVBA9+9Oa3Q4oxPDGZ0c6dHJkR6FgiyqAgAAoHM55ge9A37prH0ibD7fN3pmYlmPPz+vb12Y1/euLqnuNX6LY6GAktGQUtGQYuGg4uGAouGgwgFHoWBAAUdynMbqlDFGnm/k+kZ1z1fV9VWueyrXPBWqroo1TzXXlyTFw0E9eLBPP3qoX685OqCju1PtzwMAhaqrc9M5nZnOKV9xFQ46SkXDOjiQ1JFdKe1MRTf7FgEA3eWWb1QJWGjzfKPvXVnSl05N60unpjWbr0qS0rGQehNh9SYiSsfCiobsrTIZY1R1fWXLdS2V6lou11SsepKkfTsT+pmTQ3pkbEhjIxnCFtBFZnMVjU/ndGaqsWJ+ajKrqeXyi77QDKSjOjnSo7GRHo0NZzQ60qPhnhhfOwAAG4WAhVu7ulDSnz95TX/+5DXN5qsKBhz1JcIaSMe0MxlRxGKgWo9K3dN8oaa5QkVLxbqMpAP9Sb3tVXv1plfu0UCap9TAduH7RpcXijozldP4VE6nJpd1ZiqnpVK9fU08HFAqGlY6FlI61lg9j4QC8o1R3TMqNVfD8xVXxZqrQsVtvyD1xMM6OdKj0ZGMRod7dGIoowP9SQWZAQUA3D0CFlZ4vtFXx2f02e9c0bcvLsiR1JeMaKgnpp2piEKBrTELVfd8zearmslWtFyuKxhw9BPHdum/f2i/Hjq0kyfTQAep1D2dn8nrzHRO41NZPTuR1XMzeVWa24QdR0pGGiEqHQ0p1fznS53N9HyjQtVVvlJXvuKqUG381RoZjYUCOj6c0ejwSui6fzCtWDho+6cMANjeCFiQilVXf/HkNf3R45c1sVRWIhLUYCamoZ7Yln9zUay6mspWdD1XUdX1dXR3Su/5Rwf1xlcMKxra2vcOdJulYk1nmlv8xqeyemYiqysLxXbICQUaDaOtEJWOhZSMhhTYoIcmvjEqVt124MpXXRWrbnu2NOBIhwZSGhvpaZTvDDUKeHYkIhtyPwCAbYGA1c0WClV95vHL+ux3rihfcdUTD+u+vrgGUtGOWwXyfKPruYquLZVVqLramYrovT92SL/44D7FIwQt4F4yxmhiqazxqUb5xOnJrE5PZtsznJIUDQXWrEilY2HFwoFN/9pjjFGl7jdWuprhq1TzVK577WuGemJrQhdzXQCAVQhY3WipWNO//+Yl/d/fuqxK3ddAOqp9fQn1xMObfWt3zRijpVJdLyyUtFSqqTcR1ntfe0i/9A/2KRHhBALAtrrn68JsoRGmWvNS07l2MY0jKREJtoNUKhZWujkv1Ulqrq98ta5CxW3OdTVaT1sysZBGh3s0NtJY5Rod7tHB/iTHTABA9yFgdZNsua7PfPOS/ujxyyrVPO1OR3WgP6lkdHsGj+VSTZcXilos1tWbCOufve6w/smP7GPrIHCH8pW6zs3kNd48++7ZiawuzBbaZ98FHUfJaFDpWLh5mHijfGK7lkfcONfVCl1e89ejdbbf2EhPM3RldGwwzcMeANjeCFjdoOb6+ux3ruj/+K/PKV9xtasZrFLbNFjdaLlUbwatmoZ3xPS+h4/pZ182rMA2fdMH3C1jjGbz1fas1OmpnE5PZDWxXG5fEwkGlGqFqebqVCIS7Pptcr4xKjXbCwvNbYbFqqea1yjtCDjSvp1JnVwVuk4MZTivCwC2DwLWdmaM0d+cntFvfemsri2V1ZcM6/BASulY528FvBMLxZouzhWUr7gaHc7ogz9zXA8d6t/s2wI2lecbXZ4vtlv8Tk9mNT6V0/KaSvTgmuKJVDSkaGjz56U6hTFGFddvbi9shK5SzVOptjLXtSsdbc91NUJXj/b2xfk1BoDOQ8Darp66uqSP/fUZff/qslLRkA4PJNWXjHT9i7UxRjO5ii7Pl1Sue3rd/QP60M+O6kB/crNvDdhwlbqnczP59srUqYmszl/Pq+qurK4kI6FV81J3VomO9al7vvKVVothXcVqY4th64UzFQ21V7la1fFHdqcU5vcDALYyAtZ2M1+o6hNfPqvPf29S0VBAB/qTGuqJbVjNcafyfKOJpZKuLJZkjPSe1xzUP3/d4W07j4bus1is6cxUTmemsxqfzOnZyaxeWCiq9eU9HHRWzpdqrkptZCU61sfzm9Xxq+rji1W3PecWDjo6siutsdYhycMZHR/KdM2WbwDoAASs7cL1fP3J31/V737lvEo1V3t7E9q/M8GT59uoup4uzBY1k6toVzqqf/2GE/rZlw11/UofOsdKJXq22eLXmJmaW1WJHgsHGudLNevQ09HQlqhEx/qY1lxX1W1sM2yudrVWHiXpvr5Ee66rteq1Kx3bxLsGgK5FwNoOvndlUR/8y9M6N5NXXyKso7vTrMS8RMulup6fzStXcfXq/X36yM+N6vhQZrNvC1ij5rYq0Rstfqcmsjo7nVOxtqoSPRpsbO+LhtsrU51WiY7bM8ao6vrNFsPWeV1u+8+CJPUlIzrZOq+ruc1wX1+Cgh8A2FgErE42X6jqt798Tn/xvQnFwgEdHkhpV7rzDgneKowxmspWdGm+KNfz9c4f2a9/+fqj2+J8MHSefKWus9P59srUsxNZXZxbVYkecJSKBttBKt3c4rddK9GxPq7nr2wvrLgq1hrbDJt/bBQPB3ViOKOxVaHryO4Ux1cAgD0ErE7k+UZ/+vdX9Nt/c17Fmqv7ehPa359QKMBTahvqnq+Lc0VNLZfVm4zof/3p43rTD43w1Bcbwhij67lqe1ZqfCqnZyeXNbVcaV8TCTW2+K0unqASHevl+0bFWnOlq7nNsLBqrisYcHR4IKnRkR6NDjdWvI4PZXi4BAB3hoDVaZ66uqQP/uVpnZ3OqTcR1v1sB9ww+Updz10vaLlc1w/v69XHfm5MJ4bZNog716hEL2h8KqczU7mVSvTySiV6IhJcG6ZiIUWCzEvBLmOMynWvXaSRb652Veorc10jO+LtMo3WNsPBTIw/iwDw4ghYnWKxWNMnvnxWf/4k2wHvJWOMppvbButsG8RLUK55OjeTa54v1Tio96ZK9BtWpVJUomOTVV2vWaSxMtdVqK7Mde2IhzU6ktHY8MpByQf6U2xNBYAVBKytzveNPvfkNX38y2dVqLja05vQAdoB77m65+vSXFGTbBvELSwUqjoznVs5X2oypysLxfbcSzjotMNUo3girGQ0SCU6OoLrNcs0Vm0vXD3XFQ0FdGwwrbGRnvZc1/2704pHmOsC0JUIWFvZ6cmsPviXp/TMRFa9zXZAzjrZXPlKXc/PFrRUYttgNzLG6OpiqXm+VGOL3+nJnOYKK5Xo8XBQyWaTXzoWVopKdGxDvjHNg5Hrq87r8lTzVlZo9/cnG9XxQytndvUlI5t85wCw4QhYW1G2XNf//tXz+ux3rigcDOjQQJJ971tIa9vg5fmiamwb3LZqrq/nrufbK1OnJxvV6KVVlejJaEipaLAdpNKxkMKsLqNLGWNUqfvNla668s3QVa6vbDHcnY5qdKRnTYvhnt44r28AthMC1lZijNFfPT2p3/jrs1os1jSyI66DA0nesG1Rdc/XpfmiJpfYNtjpcpV6Y1WquTJ16oZK9FDAaYapEJXowEtU9/z2WV2Fal3FWmPOq/UGIRUNtUs0Wqtdh3elOL8NQKeyG7Acxzko6YOSeowx/50IWOt2ejKrjzw6ru++sKSeeFhHd6eUibEi0glWbxt8YF+vPsq2wS3LGKOZXEXjk7nmylRWz05m11SiR5uV6O0wFQspHqYSHbDJ842K1ZUyjcYWw5Xq+HDQ0ZFdaY02izRODPfo+FBaaV4XAWx9G7OC5TjO5wlY6zObr+jffOW8/uLJCUVCAR3oT2q4h+2AnYZtg1uP6/m6PF9sVKJPr1SiZ1dVoicjwUb5RGylzY8DV4HNYYxRqea1yzTyzdDVat6UpL29cZ3cs3aui0ZdAFsMAWuzVOqePvP4ZX3yaxdUqXva0xvX/p1sB+x0N7YNfuCRY/qFV+5h2+AGK9VcnZvJN1v8GmHq/Ex+zcD92kr0sFLRIG2cwBZnjFHN9deudNUas10tfYmwRlc1GJ4YyuhAf5ItvAA2y50HLMdxXi7p30rql3Ss+ck+Zoz5EAHrB/N9oy+dntZvfemsppYrGkhFdXhXUokI7YDbyepDio8NpvX+R47px44O8JTVgvlCtT0rNd5s8buyuFKJHgkG2i1+jYN6w0pEqEQHthPX829a6VpdHR8LB3RsMKOxkYxODDUOSr5/MK1YmBVqABvuzgKW4zgxSU9Leqcx5gnHcT4mKSbpE5J+U9LrJf2RMea3rN5uBzPG6OvPzel3v3Je41M5pWMhHR5IUVm7jRljdD1X1eWFoko1Tw8e6NMHfvq4XrF3x2bfWkfw/WYleqvFbyqr05NZzRdq7WvaleixcPuMqWiISnSgGzWq41dWulp/1b3Ge5qAIx0cSGlseGV74YmhjHp5HQZg1x0HrDdIeocx5h3Nj98s6WFjzLtvuJQVLElPXF7U737lnL77wpISkaD270xQu95FfGM0uVzW1YWSKq6vh8cG9auvP6qju9ObfWtbRtX19Pz1wkqL32RWZ2+oRE81m/saB/VSiQ7g9laq45vndVVclepe+2uLJA1mYhodWdleODqcoToewN2444D1/uZ1H29+/HFJE8aYT95wadcGLGOMvnVhQZ967IK+fXFBsXBA+/oSGt4RZ6tSl3I9X1eXyrq2WJLrG/3U6G7989cd0ck9PZt9a/dUtlxvB6kzUzmdmlzWxbmivBsq0VsrUqlYSMkIlegA7Km5vgpVV/nmeV2lqqdCdaU6Ph0LaXSo0V7YqpA/vCvFQx0A63HHAes9kn7cGPN2x3GOSnpU0kPGmIUbLu26gOX5Rl8dn9EnH7uo05NZxcIB7dmR0J7eOG8QIalRhHFtsaTJ5Ypqnq/XHOnXP3vdYb36QN+2emLaalYcb58vldWpiaymsiuV6LFwQMlIq3iCSnQAm8fzTTN0Nc/raoau1dXxR3e3quMbWwyPD2WUijJDDWCNOw5YKUl/JumApHlJv2qMecpxnAFJvyPp1yV9tFarvSsc7o6a6myprs8/NaH/+N9e0JWFkpLRoPb2NrYCEqxwK67na2K5rImlsqqur+ODab3rRw/oja8Y7rhBbLd56PL4VLbd5HdTJXo0pGQkuKoSPawoB4kC2MJWV8evPq9rdXX8fX0JnWy2GJ4Yzmh0KKNdmdgm3jWATWa/pt1xnI+o0Sr4bmNM/o4/UQcwxuiZiaz+9O+v6AtPT6nq+uqJh7W3N865HFg3z28cfju5XFa+4qonHtZbHtijX/jhPTo2uPUOLC5WW5Xo2eb5Urk1lejBgKNkNKhUpHVQb1jJaFChAGEKQOczxqja3mLY+KtUX1sdvzMZaax0jTTmuk4MZ3RgZ5IjO4DuYDdgNVe2Pi0pYIz5RW3TLYIXZgv6L89M6a++P6mriyWFAo52paPa0xvnlHncMWOMlkt1XVsqa6FYlW+k40Np/cIr9+gNLxvWYM+9fyI6l6826tCbK1OnJ7O6slBq/48dCQWUigSVioWUioaVjoWoRAfQlVrV8atXulZXx8fDQR0bSmtsuHVmV0ZHd1MdD2xD9gKW4zghSX8o6SOS3iLpu8aYr93V7W0RNdfXk1cW9fXzc/rbc7O6MFuQJPUlI9qdjmpXOsqBpbCq5vq6nq/oeq7a3mY3NpzRT57YrZ88vlsnhjJWn4T6vtELC8VmmMq1w9RCcaUSPREJ3jQvRSU6APxgvm9UrDVXulaFrtXV8Yd3pTTaKtNornbtSFAdD3Qw+1sEb9CRK1gLhaqemVjW01eX9f1ry/relSWVap4CjrQjHtHOVCNYRXnqhHugWHU1V6hqoVjTcqkRttKxkF61r1cPHOjTD9/Xq/sH0+t+Qa65vp67ntepyazGp7Ian8rp3HRe5Xpje0vAaVairwpTKSrRAcAKY4zKda99SHJjtctrfw2WpKGemMZWbS8cHc5oZAfV8UCH6K6AtVSs6cJcQdW6r6rb+GK2UKhpLl/V9VxFl+aLujhb0HJzxcCR2jMkO5MR9SbCrFRhU9VcXwvFqpZL9fYT0ZadyYiO7k5rf39CA+mYBtJRDaQiCgYCWirWdGoyq2cmlnV2Otd+ehoOOivnSzVXpZKREHMCAHCP1dzGeV2F1lxXs1yjJRMLtdsLR4czun8wrb5kREHHUc3zVfeMaq6vuuer5vny/S31Fgywbncmpr19ic2+jVvproD15VPTeu+fPHXTtwccKRMPa2cyqoF0pDlPldDe3jirVNjSClVXVxdLms1VNJOrajZX0WKxpnzFvel/vng4qJEdMe3pa/zZ3tObUH8qwhNRANiiqq6n6WxFU0tlTSyXdT1X1eRSuV0qBHSzf/pjh/T+R45t9m3cSncFrLl8Vedn8oqGA4qGAoqFg82VqQhP7LGtuJ6vxWJNs/mqjJEy8ZD29ib4cw4AHc71fF2eL+r52YKy5bp8YxQOBhQJBhr/DAUUDjocEYNtb09vQgf6k5t9G7fSXQELAAAAADbQLQMWQ0YAAAAAYAkBCwAAAAAsIWABAAAAgCUELAAAAACwhIAFAAAAAJYQsAAAAADAEgIWAAAAAFhCwAIAAAAASwhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgCQELAAAAACwhYAEAAACAJQQsAAAAALCEgAUAAAAAlhCwAAAAAMASAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsIWABAAAAgCUELAAAAACwhIAFAAAAAJYQsAAAAADAEgIWAAAAAFhCwAIAAAAASwhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgCQELAAAAACwhYAEAAACAJQQsAAAAALCEgAUAAAAAlhCwAAAAAMASAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsIWABAAAAgCUELAAAAACwhIAFAAAAAJYQsAAAAADAEgIWAAAAAFhCwAIAAAAASwhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgSehOf6DjOElJn5JUk/SYMcbaTQEAAABAJ7rjgCXpTZI+b4x51HGcz9m6IQAAAADoVHezRXCPpGvNf/cs3AsAAAAAdLR1BSzHcV7uOM43HMc54ziO7ziOkfTLaoSsdX8eAAAAANjOnNvNTjmOE5P0tKR3GmOecBznY5Jikj4s6fclVSQ9boz54429VQAAAADYMpxbfeN6ZrB+UtJTxpgnmh8/K+lhY0xR0rtWXUfAAgAAANDV1rO1b0zSqVUfv1LSUxtzOwAAAADQudazgrUg6cclyXGco2q0Bz60kTcFAAAAAJ1oPQHrzyS90XGc05LmJb3dGLPgOM59ahRdHJAkzsECAAAA0O1uW3Lxoj/YcQ5I+oik9xpjCtbuCgAAAAC2tluWXNxxvbrjOPvVaBJ8b7PwAgAAAAC62t2cX/UlSYuSPuA4Tp+l+wEAAACAjnVXWwRvwBAWAAAAgG5hd4sgAAAAAGCt9bQIdqYvv1+aOXX76wAAAABsXYMnpUc+sdl3sW6sYAEAAACAJcxgAQAAAMBLxwwWAAAAAGwkAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsIWABAAAAgCUELAAAAACwhIAFAAAAAJYQsAAAAADAEgIWAAAAAFhCwAIAAAAASwhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgCQELAAAAACwhYAEAAACAJQQsAAAAALCEgAUAAAAAlhCwAAAAAMASAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsIWABAAAAgCUELAAAAACwhIAFAAAAAJYQsAAAAADAEgIWAAAAAFhCwAIAAAAASwhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgCQELAAAAACwhYAEAAACAJQQsAAAAALCEgAUAAAAAlhCwAAAAAMASAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsIWABAAAAgCUELAAAAACwhIAFAAAAAJYQsAAAAADAEgIWAAAAAFhCwAIAAAAASwhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwJI7DliO4xx0HOczjuN83uYNAQAAAECnuuOAZYy5ZIx5t82bAQAAAIBOxhZBAAAAALBkXQHLcZyXO47zDcdxzjiO4zuOYxzH+ehG3xwAAAAAdJLQ7S5wHCcm6XOS3mmMecJxnI9Jikn6Px3H+QNJP+Q4zgeMMRt8qwAAAACwtTm3C0aO47xB0juMMe9ofvxmSQ/fYv6KhAUAAACgWzi3+sb1bBEck3Rq1cevlPSUjTsCAAAAgO3ktlsEJS1I+nFJchznqKQ3SXpoI28KAAAAADrRegLWn0l6o+M4pyXNS3q7MWbBcZz7JP2ypAOSxAwWAAAAgG532xmsF/3BjnNA0kckvdcYU7B2VwAAAACwtd3xDNatP5vj7Jf0YTXCVfFOPw8AAAAAbBd3c9DwlyQtSvqA4zh9lu4HAAAAADrWXW0RvAFDWAAAAAC6hd0tggAAAACAtdbTItiZvvx+aebU7a8DAAAAsHUNnpQe+cRm38W6sYIFAAAAAJYwgwUAAAAALx0zWAAAAACwkQhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgCQELAAAAACwhYAEAAACAJQQsAAAAALCEgAUAAAAAlhCwAAAAAMASAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsIWABAAAAgCUELAAAAACwhIAFAAAAAJYQsAAAAADAEgIWAAAAAFhCwAIAAAAASwhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgCQELAAAAACwhYAEAAACAJQQsAAAAALCEgAUAAAAAlhCwAAAAAMASAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsIWABAAAAgCUELAAAAACwhIAFAAAAAJYQsAAAAADAEgIWAAAAAFhCwAIAAAAASwhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgCQELAAAAACwhYAEAAACAJQQsAAAAALCEgAUAAAAAlhCwAAAAAMASAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsIWABAAAAgCUELAAAAACwhIAFAAAAAJYQsAAAAADAknUFLMdxjjuO8w3HcZ51HOdfOY5zYaNvDAAAAAA6zW0DluM4IUl/IulfGGNeJumgpNMbfWMAAAAA0GlC67jmTZKeMcZ8v/nxGUmzjuMkJX1KUk3SY8aYDbpFAAAAAOgM69ki+DJJT6/6eKz58Zskfd4Y8x5Jb7R+ZwAAAADQYdYTsBYkHZUkx3FeIemXJD0jaY+ka81rvI24OQAAAADoJOsJWJ+V9IDjOKckvVvSC8aYS5Im1AhZ6/08AAAAALCtrScYVYwxDxpjTkq6Kukvm9/+/0r6BcdxPi3p0Y26QQAAAADoFM7tyikcx/l1SW+TVJf0LUm/aoyp3uJSWi4AAAAAdAvnlt9osf1vSwWs337it3Vu8dxm3wYAAACAu3Cs75je9+r3bfZt3MotAxazUwAAAABgybZdwQIAAACADcQKFgAAAABsJAIWAAAAAFhCwAIAAAAASwhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgCQELAAAAACwhYAEAAACAJQQsAAAAALCEgAUAAAAAlhCwAAAAAMASAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsIWABAAAAgCUELAAAAACwhIAFAAAAAJYQsAAAAADAEgIWAAAAAFhCwAIAAAAASwhYAAAAAGAJAQsAAAAALCFgAQAAAIAlBCwAAAAAsISABQAAAACWELAAAAAAwBICFgAAAABYQsACAAAAAEsIWAAAAABgCQELAAAAACwhYAEAAACAJQQsAAAAALAkZPFzORY/FwAAAAB0HFawAAAAAMASAhYAAAAAWELAAgAAAABLCFgAAAAAYAkBCwAAAAAsIWABAAAAgCX/PxZ69F/wiRZVAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x432 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gauss_compiler = MyCompiler(processor.num_qubits, processor.params)\n",
    "processor = ModelProcessor(model=MyModel(num_qubits, h_x=1.0, h_z=1.0, g=0.1, t1=300))\n",
    "gauss_compiler.gate_compiler[\"MYGATE\"] = mygate_compiler\n",
    "processor.pulse_mode = \"continuous\"\n",
    "tlist, coeff = processor.load_circuit(circuit, compiler=gauss_compiler)\n",
    "processor.plot_pulses()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Customizing the noise\n",
    "Apart from pre-defined noise such as T1, T2 noise and random noise in the control pulse amplitude (see this [notebook](qip-noisy-device-simulator.ipynb), one can also define custom noise. Here we will see two examples of customizing noise, one systematic (pulse-independent) noise and one pulse-dependent noise. \n",
    "\n",
    "To understand how noise is processed, we briefly introduced the data structure of the simulation framework. The control elements are stored as a list of `Pulse` objects in the Processor. In each Pulse contains the idea pulse, the control noise part and the decoherence part. For systematic noise, it is saved under the `Pulse` representation labelled `\"system\"`, which represents the intrinsic dynamics of the quantum system. For pulse-dependent noise, we will add them to their corresponding control `Pulse`. \n",
    "\n",
    "The definition of noise is realized by a subclass of `UserNoise`, including two methods: \n",
    "- the initialization method containing the property of the noise, such as frequency or amplitude.\n",
    "- the method `get_noisy_dynamics` that takes all the control pulse `pulses`, a dummy `Pulse` object representing systematic noise and the dimension of the system (here two qubits `[2,2]`).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Extral_decay(Noise):\n",
    "    def __init__(self, arg):\n",
    "        self.arg = arg\n",
    "        pass\n",
    "\n",
    "    def get_noisy_dynamics(self, dims, pulses, systematic_noise):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Systematic noise\n",
    "\n",
    "We first show an example of systematic noise. Here, we introduce a ZZ crosstalk noise between neighbouring qubits with a constant strength. It is done in three steps:\n",
    "\n",
    "- Define the noise class.\n",
    "- Initialize the noise object with given coupling strength.\n",
    "- Define the Processor as usual and add the noise to the processor.\n",
    "\n",
    "In the following example, we check the fidelity of the same circuit of two X gates, but now with this additional noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "circuit = QubitCircuit(2)\n",
    "circuit.add_gate(\"X\", targets=1)\n",
    "circuit.add_gate(\"X\", targets=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qutip import sigmaz\n",
    "from qutip_qip.operations import expand_operator\n",
    "from qutip_qip.pulse import Pulse\n",
    "from qutip_qip.noise import Noise\n",
    "\n",
    "class ZZ_crosstalk(Noise):\n",
    "    def __init__(self, strength):\n",
    "        self.strength = strength\n",
    "\n",
    "    def get_noisy_dynamics(self, dims, pulses, systematic_noise):\n",
    "        zz_operator = tensor([sigmaz(), sigmaz()])\n",
    "        for i in range(len(dims)-1):\n",
    "            systematic_noise.add_control_noise(\n",
    "                self.strength * zz_operator, targets=[i,i+1], tlist=None, coeff=True)  # constant, always 1\n",
    "\n",
    "crosstalk_noise = ZZ_crosstalk(strength=1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final fidelity with ZZ crosstalk: 0.9899565784438967\n"
     ]
    }
   ],
   "source": [
    "processor = ModelProcessor(model=MyModel(num_qubits, h_x=1.0, h_z=1.0, g=0.1))\n",
    "processor.add_noise(crosstalk_noise)  # The noise is added to the processor\n",
    "gauss_compiler = MyCompiler(processor.num_qubits, processor.params)\n",
    "tlist, coeff = processor.load_circuit(circuit, compiler=gauss_compiler);\n",
    "\n",
    "result = processor.run_state(init_state = basis([2,2], [0,0]))\n",
    "print(\"Final fidelity with ZZ crosstalk:\", fidelity(result.states[-1],basis([2,2],[1,1])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pulse dependent noise\n",
    "In this second example, we demonstrate how to add an additional amplitude damping channel on the qubits. The amplitude of this decay is linearly dependent on the control pulse \"sx\", i.e. whenever the pulse \"sx\" is turned on, the decoherence is also turned on. The corresponding annihilation operator has a coefficient proportional to the control pulse amplitude. This noise can be added on top of the default T1, T2 noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qutip_qip.pulse import Pulse\n",
    "class Extral_decay(Noise):\n",
    "    def __init__(self, ratio):\n",
    "        self.ratio = ratio\n",
    "\n",
    "    def get_noisy_dynamics(self, dims, pulses, systematic_noise):\n",
    "        from qutip import destroy\n",
    "        op = destroy(2)\n",
    "        for pulse in pulses:   # iterate for all pulses\n",
    "            if \"sx\" in pulse.label and pulse.coeff is not None:   # if it is a sigma-x pulse and is not empty\n",
    "                pulse.add_lindblad_noise(op, targets=pulse.targets, tlist=pulse.tlist, coeff=self.ratio * pulse.coeff)\n",
    "                # One can also use add_control_noise here to add addtional hamiltonian as noise (see next example).\n",
    "\n",
    "extral_decay = Extral_decay(0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final fidelity with pulse dependent decoherence: 0.9939250019133458\n"
     ]
    }
   ],
   "source": [
    "processor = ModelProcessor(model=MyModel(num_qubits, h_x=1.0, h_z=1.0, g=0.1))\n",
    "processor.add_noise(extral_decay)\n",
    "gauss_compiler = MyCompiler(processor.num_qubits, processor.params)\n",
    "tlist, coeff = processor.load_circuit(circuit, compiler=gauss_compiler);\n",
    "\n",
    "result = processor.run_state(init_state = basis([2,2], [0,0]))\n",
    "print(\"Final fidelity with pulse dependent decoherence:\", fidelity(result.states[-1],basis([2,2],[1,1])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2.0\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table><tr><th>Software</th><th>Version</th></tr><tr><td>QuTiP</td><td>4.6.3</td></tr><tr><td>Numpy</td><td>1.22.2</td></tr><tr><td>SciPy</td><td>1.8.0</td></tr><tr><td>matplotlib</td><td>3.5.1</td></tr><tr><td>Cython</td><td>0.29.27</td></tr><tr><td>Number of CPUs</td><td>12</td></tr><tr><td>BLAS Info</td><td>OPENBLAS</td></tr><tr><td>IPython</td><td>8.0.1</td></tr><tr><td>Python</td><td>3.9.0 | packaged by conda-forge | (default, Nov 26 2020, 07:53:15) [MSC v.1916 64 bit (AMD64)]</td></tr><tr><td>OS</td><td>nt [win32]</td></tr><tr><td colspan='2'>Sat Feb 12 23:26:05 2022 W. Europe Standard Time</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import qutip_qip\n",
    "print(qutip_qip.version.version)\n",
    "from qutip.ipynbtools import version_table\n",
    "version_table()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}