example/time-odmr-lockin.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Time-domain ODMR measurement (with Lock-in Amplifier & NI DAQ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "![frequency-shceduling](./figure/time-scheduling.jpg)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Import necessary modules and functions firstly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "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 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 = 20\n",
    "t_end = 1500\n",
    "t_step = 20\n",
    "\n",
    "pi_power = -20\n",
    "pi_freq = 44 * C.mega\n",
    "pi_time = 150 * C.nano\n",
    "\n",
    "t_init = 4e3\n",
    "inter_init_mw = 1000\n",
    "inter_mw_read = 1000\n",
    "pre_read = 0\n",
    "t_read_sig = 3000\n",
    "# t_read_ref = t_read_sig\n",
    "\n",
    "N = int(1e6)"
   ]
  },
  {
   "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=False, epoch_omit=10, use_lockin=True)\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_lockin_counting()\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)"
   ]
  },
  {
   "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",
    "if len(counts_sig_ref) == 3:\n",
    "    contrast_ramsey = [(sig - ref)  for sig, ref in zip(counts_sig_ref[1], counts_sig_ref[2])]\n",
    "else:\n",
    "    contrast_ramsey = []\n"
   ]
  },
  {
   "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-')\n",
    "if len(counts_sig_ref) == 3:\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": [
    "if len(contrast_ramsey) == 3:\n",
    "    plt.plot(counts_sig_ref[0][1:], contrast_ramsey[1:], 'o-')\n",
    "    plt.title('Ramsey')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "np.savetxt('ramsey_44mhz_150ns_2.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 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": [
    "t_start = 20\n",
    "t_end = 1500\n",
    "t_step = 25\n",
    "\n",
    "t_init = 4000\n",
    "inter_init_mw = 1000\n",
    "inter_mw_read = 1000\n",
    "\n",
    "t_read_sig = 3000\n",
    "pre_read = 0\n",
    "\n",
    "N = int(1e6)\n",
    "\n",
    "p = -20\n",
    "f = 46 * C.mega"
   ]
  },
  {
   "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=False, epoch_omit=5, use_lockin=True)\n",
    "scheduler.configure_mw_paras(power=p, freq=f)\n",
    "scheduler.configure_lockin_counting()\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",
    "\n",
    "# scheduler.asg_dwell"
   ]
  },
  {
   "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",
    "if len(counts_sig_ref) == 3:\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_rabi(counts_sig_ref[0][1:], counts_sig_ref[1][1:])\n",
    "plt.style.use('seaborn')\n",
    "#plt.vlines(210, 13.6,14)\n",
    "plt.plot(counts_sig_ref[0][1:], counts_sig_ref[1][1:], 'o', label='signal')\n",
    "if len(counts_sig_ref) == 3:\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": [
    "if contrast:\n",
    "    plt.plot(counts_sig_ref[0][1:], contrast[1:], 'o-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "np.savetxt('rabi_44.2mhz_-25dbm_sic.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 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": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "t_start = 100\n",
    "t_end = 1e6\n",
    "# t_step = 1e4\n",
    "\n",
    "pi_power = -30\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)\n",
    "\n",
    "# times = np.round(10 ** np.linspace(1, 5, 50)) * 10\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**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, use_lockin=True)\n",
    "scheduler.pi_pulse['freq'], scheduler.pi_pulse['power'], scheduler.pi_pulse['time'] = pi_freq, pi_power, pi_time\n",
    "scheduler.configure_lockin_counting()\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=51, logarithm=True) # exponential step interval\n",
    "# scheduler.set_delay_times(times=times)\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",
    "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",
    "if len(counts_sig_ref) == 3:\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": {},
   "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 = 20\n",
    "t_end = 200000\n",
    "t_step = 1000\n",
    "\n",
    "pi_power = -20\n",
    "pi_freq = 44 * C.mega\n",
    "pi_time = 150 * C.nano\n",
    "\n",
    "t_init = 10e3\n",
    "inter_init_mw = 1000\n",
    "inter_mw_read = 1000\n",
    "pre_read = 0\n",
    "t_read_sig = 5000\n",
    "# t_read_ref = t_read_sig\n",
    "\n",
    "N = int(1e6 / 2)\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=False, epoch_omit=5, use_lockin=True)\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_lockin_counting()\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)"
   ]
  },
  {
   "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",
    "if len(counts_sig_ref) == 3:\n",
    "    contrast = [sig / 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_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",
    "if len(counts_sig_ref) == 3:\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('Free precession (ns)')\n",
    "plt.ylabel('counts')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "if contrast:\n",
    "    plt.plot(counts_sig_ref[0][1:], contrast[1:], 'o-')\n",
    "    plt.title('Hahn echo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## High-order dynamical decoupling measurement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "outputs": [],
   "source": [
    "t_start = 20\n",
    "t_end = 200000\n",
    "t_step = 1000\n",
    "\n",
    "pi_power = -20\n",
    "pi_freq = 44 * C.mega\n",
    "pi_time = 150 * C.nano\n",
    "\n",
    "t_init = 10e3\n",
    "inter_init_mw = 1000\n",
    "inter_mw_read = 1000\n",
    "pre_read = 0\n",
    "t_read_sig = 5000\n",
    "# t_read_ref = t_read_sig\n",
    "\n",
    "N = int(1e6 / 2)\n",
    "\n",
    "d = 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Construct a high-order dynamical decoupling measurement Scheduler and run**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scheduler = HighDecouplingScheduler(mw_ttl=0, with_ref=False, epoch_omit=5, use_lockin=True, 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_lockin_counting()\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scheduler.run_scanning()\n",
    "scheduler.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Calculate results and plot figures**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counts_sig_ref = scheduler.result  # [times, counts, counts_ref]\n",
    "if len(counts_sig_ref) == 3:\n",
    "    contrast = [sig / ref for sig, ref in zip(counts_sig_ref[1], counts_sig_ref[2])]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(counts_sig_ref[0], counts_sig_ref[1], 'o--', label='signal')\n",
    "if len(counts_sig_ref) == 3:\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": {},
   "outputs": [],
   "source": [
    "if contrast:\n",
    "    plt.plot(counts_sig_ref[0][1:], contrast[1:], 'o-')\n",
    "    plt.title('Hahn echo')"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "bd97b8bffa4d3737e84826bc3d37be3046061822757ce35137ab82ad4c5a2016"
  },
  "kernelspec": {
   "display_name": "Python 3.8.13 ('base')",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}