example/time-odmr.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Time-domain ODMR measurement (with APD & Time Tagger)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "![frequency-shceduling](./figure/time-scheduling.jpg)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Import necessary modules and functions firstly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from odmactor.scheduler import RamseyScheduler, RabiScheduler, RelaxationScheduler\n",
    "from odmactor.scheduler import HahnEchoScheduler, HighDecouplingScheduler\n",
    "from odmactor.utils.plotting import plot_ramsey, plot_rabi, plot_t1\n",
    "import scipy.constants as C\n",
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Ramsey detecting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**1. Set measurement parameters**\n",
    "- number of readout operation $N$ per time interval measurement point\n",
    "- delay time range for scanning modes, i.e., `[t_start, t_end, t_step]`, unit: \"ns\"\n",
    "- calibrated MW $\\pi$ pulse parameters, i.e., frequency (unit: Hz), power (unit: dBm) and time (unit: s)\n",
    "- laser initialization time $t_{init}$, signal readout pulse time $t_{sig}$, etc.\n",
    "- optional parameters: MW power $p$, if designed, the time of built-in MW $\\pi$ pulse will be regulated correspondingly\n",
    "- time bin $t$ per readout operation will be calculated dynamically when running the scheduler on scanning-time mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "t_start = 40\n",
    "t_end = 7000\n",
    "t_step = 30\n",
    "\n",
    "pi_power = 12\n",
    "pi_freq = 2.852 * C.giga\n",
    "pi_time = 310 * C.nano\n",
    "\n",
    "t_init = 5e3\n",
    "inter_init_mw = 3e3\n",
    "inter_mw_read = 200\n",
    "pre_read = 50\n",
    "t_read_sig = 800\n",
    "# t_read_ref = t_read_sig\n",
    "\n",
    "N = int(1e6 / 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**2. Construct a Ramsey Scheduler and run**\n",
    "\n",
    "Especially, the calibrated MW $\\pi$ pulse should be configured\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scheduler = RamseyScheduler(mw_ttl=1, with_ref=True, epoch_omit=5)\n",
    "scheduler.configure_mw_paras(power=pi_power, freq=pi_freq)\n",
    "scheduler.pi_pulse['freq'], scheduler.pi_pulse['power'], scheduler.pi_pulse['time'] = pi_freq, pi_power, pi_time\n",
    "scheduler.configure_odmr_seq(t_init, t_read_sig, inter_init_mw=inter_init_mw, inter_mw_read=inter_mw_read,\n",
    "                             pre_read=pre_read, N=N)\n",
    "scheduler.set_delay_times(t_start, t_end, t_step)\n",
    "scheduler.configure_tagger_counting(reader='cbm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scheduler.run_scanning()\n",
    "scheduler.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# observe detection sequence\n",
    "scheduler._gene_pseudo_detect_seq()\n",
    "fig = scheduler.sequences_figure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**3. Calculate contrast and plot figures**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "## count & contrast\n",
    "counts_sig_ref = scheduler.result  # [times, counts, counts_ref]\n",
    "contrast = [sig / ref for sig, ref in zip(counts_sig_ref[1], counts_sig_ref[2])]\n",
    "contrast_2 = [abs(sig - ref) / ref for sig, ref in zip(counts_sig_ref[1], counts_sig_ref[2])]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# plot_ramsey(counts_sig_ref[0], contrast)\n",
    "\n",
    "plt.style.use('seaborn')\n",
    "plt.plot(counts_sig_ref[0], counts_sig_ref[1], 'o-')\n",
    "plt.plot(counts_sig_ref[0], counts_sig_ref[2], 'o-')\n",
    "plt.title('Ramsey')\n",
    "plt.xlabel('Duration time (ns)')\n",
    "plt.ylabel('Count')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "plt.plot(counts_sig_ref[0][1:], contrast[1:], 'o-')\n",
    "plt.title('Ramsey')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "plt.plot(counts_sig_ref[0][1:], contrast_2[1:], 'o-')\n",
    "plt.title('Ramsey contrast')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "np.savetxt('ramsey_2.852ghz_310ns.txt', scheduler.result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Rabi oscillation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**1. Set measurement parameters**\n",
    "- number of readout operation $N$ per time interval measurement point\n",
    "- delay time range for scanning modes, i.e., `[t_start, t_end, t_step]`, unit: \"ns\"\n",
    "- laser initilization time $t_{init}$, singal readout pulse time $t_{sig}$, etc.\n",
    "- MW power $p$, MW frequency $f$\n",
    "- time bin $t$ per readout operation will be calculated dynamically when running the scheduler on scanning-time mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "t_start = 20\n",
    "t_end = 2000\n",
    "t_step = 30\n",
    "\n",
    "t_init = 3e3\n",
    "inter_init_mw = 3000\n",
    "inter_mw_read = 200\n",
    "\n",
    "t_read_sig = 800\n",
    "pre_read = 50\n",
    "\n",
    "N = int(1e6 / 4)\n",
    "\n",
    "p = 12\n",
    "f = 2.889 * C.giga"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**2. Construct a Rabi measurement Scheduler and run**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scheduler = RabiScheduler(mw_ttl=1, with_ref=True, epoch_omit=5)\n",
    "scheduler.configure_mw_paras(power=p, freq=f)\n",
    "scheduler.configure_odmr_seq(t_init, t_read_sig, pre_read=pre_read, inter_init_mw=inter_init_mw,\n",
    "                             inter_mw_read=inter_mw_read, N=N)\n",
    "scheduler.set_delay_times(t_start, t_end, t_step)\n",
    "scheduler.configure_tagger_counting(reader='cbm')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scheduler.run_scanning()\n",
    "\n",
    "scheduler.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scheduler._gene_pseudo_detect_seq()\n",
    "fig = scheduler.sequences_figure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**3. Calculate contrast and plot figures**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "## count & contrast\n",
    "counts_sig_ref = scheduler.result  # [times, counts, counts_ref]\n",
    "contrast = [sig / ref for sig, ref in zip(counts_sig_ref[1], counts_sig_ref[2])]\n",
    "contrast_2 = [abs(sig - ref) / ref for sig, ref in zip(counts_sig_ref[1], counts_sig_ref[2])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# plot_rabi(counts_sig_ref[0], counts_sig_ref[1])\n",
    "plt.style.use('seaborn')\n",
    "#plt.vlines(210, 13.6,14)\n",
    "plt.plot(counts_sig_ref[0], counts_sig_ref[1], 'o--', label='signal')\n",
    "plt.plot(counts_sig_ref[0], counts_sig_ref[2], 'o-', label='referengce')\n",
    "plt.legend()\n",
    "plt.title('Rabi Oscillation')\n",
    "plt.xlabel('MW time (ns)')\n",
    "plt.ylabel('counts')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "plt.plot(counts_sig_ref[0][1:], contrast[1:], 'o-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "plt.plot(counts_sig_ref[0][1:], contrast_2[1:], 'o-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "np.savetxt('rabi_2.889ghz_12dbm_long_7us.txt', scheduler.result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## T1 relaxometry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**1. Set measurement parameters**\n",
    "- number of readout operation $N$ per time interval measurement point\n",
    "- delay time range for scanning modes, i.e., `[t_start, t_end, t_step]`, unit: \"ns\"\n",
    "- laser initialization time $t_{init}$, signal readout pulse time $t_{sig}$, etc.\n",
    "- calibrated MW $\\pi$ pulse parameters, i.e., frequency (unit: Hz), power (unit: dBm) and time (unit: s)\n",
    "- optional parameters: MW power $p$, if designed, the time of built-in MW $\\pi$ pulse will be regulated correspondingly\n",
    "- time bin $t$ per readout operation will be calculated dynamically when running the scheduler on scanning-time mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "t_start = 1e3\n",
    "t_end = 1e6\n",
    "# t_step = 1e4\n",
    "t_length = 51\n",
    "\n",
    "pi_power = 10\n",
    "pi_freq = 2.852 * C.giga\n",
    "pi_time = 210 * C.nano\n",
    "\n",
    "t_init = 3e3\n",
    "inter_init_mw = 1e3\n",
    "t_read_sig = 800\n",
    "t_read_ref = t_read_sig\n",
    "\n",
    "N = int(1e6 / 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**2. Construct a T1 measurement scheduler and run**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scheduler = RelaxationScheduler(mw_ttl=1, ms=0, epoch_omit=5)\n",
    "scheduler.pi_pulse['freq'], scheduler.pi_pulse['power'], scheduler.pi_pulse['time'] = pi_freq, pi_power, pi_time\n",
    "scheduler.configure_odmr_seq(t_init, t_read_sig, inter_init_mw=inter_init_mw, N=N)\n",
    "scheduler.set_delay_times(t_start, t_end, length=t_length, logarithm=True)  # exponential step interval\n",
    "scheduler.configure_tagger_counting(reader='cbm')\n",
    "\n",
    "print('scheduler for detecting relaxation time of state Ms={}'.format(scheduler.ms))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scheduler.run_scanning()\n",
    "scheduler.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# observe sequence figure\n",
    "fig = scheduler.sequences_figure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**3. Calculate contrast and plot figures**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "## count & contrast\n",
    "counts_sig_ref = scheduler.result  # [times, counts, counts_ref]\n",
    "contrast = [sig / ref for sig, ref in zip(counts_sig_ref[1], counts_sig_ref[2])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "plot_t1(counts_sig_ref[0], contrast)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Hahn echo measurement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**1. Set measurement parameters**\n",
    "- number of readout operation $N$ per time interval point\n",
    "- delay time range for scanning modes, i.e., `[t_start, t_end, t_step]`, unit: \"ns\"\n",
    "- calibrated MW $\\pi$ pulse parameters, i.e., frequency (unit: Hz), power (unit: dBm) and time (unit: s)\n",
    "- laser initialization time $t_{init}$, signal readout pulse time $t_{sig}$, etc.\n",
    "- optional parameters: MW power $p$, if designed, the time of built-in MW $\\pi$ pulse will be regulated correspondingly\n",
    "- time bin $t$ per readout operation will be calculated dynamically when running the scheduler on scanning-time mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "t_start = 40\n",
    "t_end = 7000\n",
    "t_step = 30\n",
    "\n",
    "pi_power = 12\n",
    "pi_freq = 2.852 * C.giga\n",
    "pi_time = 310 * C.nano\n",
    "\n",
    "t_init = 5e3\n",
    "inter_init_mw = 3e3\n",
    "inter_mw_read = 200\n",
    "pre_read = 50\n",
    "t_read_sig = 800\n",
    "# t_read_ref = t_read_sig\n",
    "\n",
    "N = int(1e6 / 4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**2. Construct a Hahn echo measurement Scheduler and run**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scheduler = HahnEchoScheduler(mw_ttl=0, with_ref=True, epoch_omit=5)\n",
    "scheduler.configure_mw_paras(power=pi_power, freq=pi_freq)\n",
    "scheduler.pi_pulse['time'], scheduler.pi_pulse['freq'], scheduler.pi_pulse['power'] = pi_time, pi_freq, pi_power\n",
    "scheduler.configure_odmr_seq(t_init, t_read_sig, inter_init_mw, inter_mw_read, pre_read, N=N)\n",
    "scheduler.set_delay_times(t_start, t_end, t_step)\n",
    "scheduler.configure_tagger_counting(reader='cbm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scheduler.run_scanning()\n",
    "scheduler.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**3. Calculate contrast and plot figures**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "counts_sig_ref = scheduler.result  # [times, counts, counts_ref]\n",
    "contrast = [sig / ref for sig, ref in zip(counts_sig_ref[1], counts_sig_ref[2])]\n",
    "contrast_2 = [abs(sig - ref) / ref for sig, ref in zip(counts_sig_ref[1], counts_sig_ref[2])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# plot_rabi(counts_sig_ref[0], counts_sig_ref[1])\n",
    "plt.style.use('seaborn')\n",
    "#plt.vlines(210, 13.6,14)\n",
    "plt.plot(counts_sig_ref[0], counts_sig_ref[1], 'o--', label='signal')\n",
    "plt.plot(counts_sig_ref[0], counts_sig_ref[2], 'o-', label='referengce')\n",
    "plt.legend()\n",
    "plt.title('Hahn echo')\n",
    "plt.xlabel('MW time (ns)')\n",
    "plt.ylabel('counts')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "plt.plot(counts_sig_ref[0][1:], contrast[1:], 'o-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "plt.plot(counts_sig_ref[0][1:], contrast_2[1:], 'o-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## High-order dynamical decoupling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**1. Set measurement parameters**\n",
    "- number of readout operation $N$ per time interval point\n",
    "- dynamical decoupling order, i.e., $\\pi$ pulse number\n",
    "- delay time range for scanning modes, i.e., `[t_start, t_end, t_step]`, unit: \"ns\"\n",
    "- calibrated MW $\\pi$ pulse parameters, i.e., frequency (unit: Hz), power (unit: dBm) and time (unit: s)\n",
    "- laser initialization time $t_{init}$, signal readout pulse time $t_{sig}$, etc.\n",
    "- optional parameters: MW power $p$, if designed, the time of built-in MW $\\pi$ pulse will be regulated correspondingly\n",
    "- time bin $t$ per readout operation will be calculated dynamically when running the scheduler on scanning-time mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "t_start = 40\n",
    "t_end = 7000\n",
    "t_step = 30\n",
    "\n",
    "pi_power = 12\n",
    "pi_freq = 2.852 * C.giga\n",
    "pi_time = 310 * C.nano\n",
    "\n",
    "t_init = 5e3\n",
    "inter_init_mw = 3e3\n",
    "inter_mw_read = 200\n",
    "pre_read = 50\n",
    "t_read_sig = 800\n",
    "# t_read_ref = t_read_sig\n",
    "\n",
    "N = int(1e6 / 4)\n",
    "d = 8 # decoupling order\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**2. Construct a high-order dynamic decoupling measurement Scheduler and run**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scheduler = HighDecouplingScheduler(mw_ttl=0, with_ref=True, epoch_omit=5, order=d)\n",
    "scheduler.configure_mw_paras(power=pi_power, freq=pi_freq)\n",
    "scheduler.pi_pulse['time'], scheduler.pi_pulse['freq'], scheduler.pi_pulse['power'] = pi_time, pi_freq, pi_power\n",
    "scheduler.configure_odmr_seq(t_init, t_read_sig, inter_init_mw, inter_mw_read, pre_read, N=N)\n",
    "scheduler.set_delay_times(t_start, t_end, t_step)\n",
    "scheduler.configure_tagger_counting(reader='cbm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scheduler.run_scanning()\n",
    "scheduler.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**3. Calculate contrast and plot figures**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "counts_sig_ref = scheduler.result  # [times, counts, counts_ref]\n",
    "contrast = [sig / ref for sig, ref in zip(counts_sig_ref[1], counts_sig_ref[2])]\n",
    "contrast_2 = [abs(sig - ref) / ref for sig, ref in zip(counts_sig_ref[1], counts_sig_ref[2])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "plt.plot(counts_sig_ref[0], counts_sig_ref[1], 'o--', label='signal')\n",
    "plt.plot(counts_sig_ref[0], counts_sig_ref[2], 'o-', label='referengce')\n",
    "plt.legend()\n",
    "plt.title('High-order DD')\n",
    "plt.xlabel('MW time (ns)')\n",
    "plt.ylabel('counts')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}