m-thesis-introduction/simulations/08_beacon_sync.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Beacon Sync\n",
    "\n",
    "Synchronise two delta peaks, by using an intermediate beacon that was sent out together with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.signal as signal\n",
    "\n",
    "import os\n",
    "import sys\n",
    "# Append parent directory to import path so lib can be found\n",
    "sys.path.append(os.path.dirname(os.path.abspath(os.getcwd())))\n",
    "from lib.util import *\n",
    "from lib.plotting import *\n",
    "from lib.timing import *\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beacon period [ns]: 14.285714285714285\n",
      "Beacon initial [ns]: 4.4\n",
      "Beacon initial [phase]: 1.9352210746113125\n",
      "Beacon initial [idx]: 2.2\n",
      "Beacon difference [ns]: 8.571428571428571\n",
      "Beacon difference [phase]: 3.7699111843077517\n",
      "Impulse offsets [ns]: [ 76. 164.]\n",
      "Time difference Impulses [ns]: 88.0\n",
      "Time difference Impulses [T]: 6.160000000000001\n"
     ]
    }
   ],
   "source": [
    "us = 1e3 # ns\n",
    "ns = 1/us # us\n",
    "\n",
    "\n",
    "band = (30, 80) # MHz\n",
    "samplerate = 500 # MHz\n",
    "timelength = 0.2 # us\n",
    "\n",
    "time = np.arange(0, timelength, 1/samplerate)\n",
    "\n",
    "# generate beacons\n",
    "if True: # in-band\n",
    "    f_beacon = 70 # MHz\n",
    "else: # under band\n",
    "    f_beacon = 20 # MHz\n",
    "\n",
    "beacon_amplitude = 0.1\n",
    "beacon_init_phase = time2phase(4.4*ns, f_beacon)\n",
    "beacon_phase_offset = 1.2*np.pi\n",
    "\n",
    "beacons = np.array([\n",
    "    beacon_amplitude * sin_delay(f_beacon, time, t_delay=0, phase=-beacon_init_phase),\n",
    "    beacon_amplitude * sin_delay(f_beacon, time, t_delay=0, phase=-beacon_init_phase-beacon_phase_offset)\n",
    "])\n",
    "\n",
    "\n",
    "# generate impulses\n",
    "impulses = []\n",
    "impulses_offsets = []\n",
    "impulses_def_offsets = [\n",
    "                        (0.3*len(time),0.4*len(time)),\n",
    "                        (0.5*len(time),0.9*len(time)),\n",
    "                       ]# random offsets in interval\n",
    "if not True:\n",
    "    # freeze impulses\n",
    "    impulses_def_offsets = [\n",
    "        0.072*samplerate,\n",
    "        0.168*samplerate        \n",
    "    ]\n",
    "    \n",
    "for i in range(2):\n",
    "    offset = None\n",
    "    if impulses_def_offsets:\n",
    "        if len(impulses_def_offsets) == 1:\n",
    "            offset = impulses_def_offsets[0]\n",
    "        else:\n",
    "            offset = impulses_def_offsets[i]\n",
    "    orig_imp, imp_offset = deltapeak(timelength, samplerate, offset=offset, peaklength=1)\n",
    "\n",
    "    ## Bandpass it\n",
    "    imp, _ = fft_bandpass(orig_imp, band, samplerate)\n",
    "    imp /= np.max(imp)\n",
    "    \n",
    "    impulses.append(imp)\n",
    "    impulses_offsets.append(imp_offset/samplerate)\n",
    "\n",
    "impulses = np.array(impulses)\n",
    "impulses_offsets = np.array(impulses_offsets)\n",
    "print(\"Beacon period [ns]:\", 1/f_beacon/ns)\n",
    "print(\"Beacon initial [ns]:\", phase2time(beacon_init_phase, f_beacon) /ns)\n",
    "print(\"Beacon initial [phase]:\", beacon_init_phase)\n",
    "print(\"Beacon initial [idx]:\", phase2time(beacon_init_phase, f_beacon)*samplerate)\n",
    "print(\"Beacon difference [ns]:\", phase2time(beacon_phase_offset, f_beacon)/ns)\n",
    "print(\"Beacon difference [phase]:\", beacon_phase_offset)\n",
    "print(\"Impulse offsets [ns]:\", impulses_offsets[:,0]/ns)\n",
    "print(\"Time difference Impulses [ns]: {}\".format( (impulses_offsets[1,0]-impulses_offsets[0,0])/ns ))\n",
    "print(\"Time difference Impulses [T]: {}\".format( (impulses_offsets[1,0]-impulses_offsets[0,0])*f_beacon ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_signals = impulses + beacons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 864x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Make a figure showing two signals with a beacon per signal\n",
    "colors = ['y','g']\n",
    "multiplier_name = ['m','n']\n",
    "\n",
    "\n",
    "fig, axes = plt.subplots(3,1, sharex=True, figsize=(12,4))\n",
    "axes[-1].set_xlabel(\"Time [ns]\")\n",
    "axes[-1].set_yticks([],[])\n",
    "for i in range(0, 2):\n",
    "    axes[i].set_yticks([],[])\n",
    "    axes[i].set_ylabel(\"Antenna {:d}\".format(i+1))\n",
    "    axes[i].plot(time/ns, impulses[i])\n",
    "    axes[i].plot(time/ns, beacons[i], marker='.')\n",
    "    if not True:\n",
    "        axes[i].plot(time/ns, full_signals[i])\n",
    "\n",
    "\n",
    "# indicate timing of pulses\n",
    "for i, impulse_offset in enumerate(impulses_offsets):\n",
    "    kwargs = dict(color=colors[i])\n",
    "    [ax.axvline(impulse_offset/ns, **kwargs) for ax in (axes[i], axes[-1])]\n",
    "\n",
    "\n",
    "# indicate timing of the beacons\n",
    "# and annotate ticks and impulse widths\n",
    "tmp_beacon_phases = beacon_init_phase + np.arange(0,2)*beacon_phase_offset\n",
    "if True: # mod phases\n",
    "    tmp_beacon_phases %= 2*np.pi\n",
    "tmp_beacon_offsets = phase2time(tmp_beacon_phases, f_beacon)\n",
    "\n",
    "\n",
    "A = np.empty(2)\n",
    "B = np.empty(2)\n",
    "for i in range(0,2):\n",
    "    kwargs = dict(color=colors[i], ls=(0, (3,2)))\n",
    "    tick_kwargs = dict(color='k', alpha=0.2)\n",
    "\n",
    "    # indicate every period of the beacon\n",
    "    beacon_ticks =  tmp_beacon_offsets[i] + [(n)*1/f_beacon for n in range(1+int((time[-1] - time[0]) * f_beacon))]\n",
    "\n",
    "    [axes[i].axvline(tick/ns, **{**kwargs, **tick_kwargs}) for tick in beacon_ticks]\n",
    "\n",
    "    # reference period in beacon\n",
    "    [ax.axvline(tmp_beacon_offsets[i]/ns, **kwargs) for ax in (axes[i], axes[-1])]\n",
    "\n",
    "    # annotate width between impulse and closest beacon tick\n",
    "    # and closest beacon tick and reference tick\n",
    "    closest_beacon_tick_id = np.argmin(np.abs(beacon_ticks-impulses_offsets[i]))\n",
    "    if closest_beacon_tick_id != 0 and beacon_ticks[closest_beacon_tick_id] > impulses_offsets[i]:\n",
    "        closest_beacon_tick_id -= 1\n",
    "    closest_beacon_tick = beacon_ticks[closest_beacon_tick_id]\n",
    "\n",
    "    annotate_width(axes[i], f\"$A_{i+1}$\", closest_beacon_tick/ns, impulses_offsets[i]/ns, 0.7)\n",
    "    annotate_width(axes[i], f\"$B_{i+1}={multiplier_name[i]}T$\", closest_beacon_tick/ns, tmp_beacon_offsets[i]/ns, 0.4)\n",
    "\n",
    "    A[i] = closest_beacon_tick - impulses_offsets[i]\n",
    "    B[i] = closest_beacon_tick - tmp_beacon_offsets[i]\n",
    "\n",
    "# annotate width between beacon reference periods\n",
    "annotate_width(axes[-1], \"$t_\\phi$\", tmp_beacon_offsets[0]/ns, tmp_beacon_offsets[-1]/ns, 0.4)\n",
    "\n",
    "# annotate width between pulses\n",
    "annotate_width(axes[-1], \"$\\Delta t$\", impulses_offsets[0]/ns, impulses_offsets[-1]/ns, 0.4)\n",
    "\n",
    "\n",
    "fig.show()\n",
    "if False:\n",
    "    fname = 'figures/08_beacon_sync_timing_outline'\n",
    "\n",
    "    # Dump figure\n",
    "    fig.savefig(fname +'.pdf')\n",
    "    \n",
    "    # Dump information into accompanying file\n",
    "    with open(fname + '.dat', 'w+') as fp:\n",
    "        fp.write(\"f_beacon = {}MHz\\n\".format(f_beacon))\n",
    "        fp.write(\"samplerate = {}\\n\".format(samplerate))\n",
    "        fp.write(\"band = {}MHz\\n\".format(band))\n",
    "        fp.write(\"timelength = {}us\\n\".format(timelength))\n",
    "        \n",
    "        fp.write(\"-\"*8 + \"\\n\")\n",
    "        fp.write(\"\\Delta t = {}ns\\n\".format( (impulses_offsets[1][0] - impulses_offsets[0][0])/ns ))\n",
    "        fp.write(\"t_phi = {}ns\\n\".format( (tmp_beacon_offsets[1]-tmp_beacon_offsets[0])/ns ))\n",
    "        fp.write(\"\\Delta A = {}ns\\n\".format( (A[1] - A[0])/ns ))\n",
    "        fp.write(\"kT = {}ns = {}T\\n\".format( (B[1]-B[0])/ns, (B[1]-B[0])*f_beacon ))\n",
    "        \n",
    "        fp.write(\"-\"*8 + \"\\n\")\n",
    "        fp.write(\"A_1 = {}ns\\n\".format( (A[0])/ns ))\n",
    "        fp.write(\"A_2 = {}ns\\n\".format( (A[1])/ns ))\n",
    "        fp.write(\"B_1 = {}ns = {}T\\n\".format( (B[0])/ns, (B[0]*f_beacon) ))\n",
    "        fp.write(\"B_2 = {}ns = {}T\\n\".format( (B[1])/ns, (B[1]*f_beacon) ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\Delta t = 88.0ns\n",
      "\\Delta A = -8.000000000000007ns\n",
      "t_phi = 8.571428571428573ns\n",
      "B_1 = 71.42857142857142ns = 5.0T\n",
      "B_2 = 142.85714285714283ns = 10.0T\n",
      "kT = 71.42857142857142ns = 5.0T\n"
     ]
    }
   ],
   "source": [
    "t_phi = (tmp_beacon_offsets[1]-tmp_beacon_offsets[0])\n",
    "Delta_A = (A[1] - A[0])\n",
    "\n",
    "print(\"\\Delta t = {}ns\".format( (impulses_offsets[1][0] - impulses_offsets[0][0])/ns ))\n",
    "print(\"\\Delta A = {}ns\".format( Delta_A/ns ))\n",
    "print(\"t_phi = {}ns\".format( t_phi/ns ))\n",
    "print(\"B_1 = {}ns = {}T\".format( (B[0])/ns, (B[0]*f_beacon) ))\n",
    "print(\"B_2 = {}ns = {}T\".format( (B[1])/ns, (B[1]*f_beacon) ))\n",
    "print(\"kT = {}ns = {}T\".format( (B[1]-B[0])/ns, (B[1]-B[0])*f_beacon ))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "\\Delta t = (A_2 + B_2) - (A_1 + B_1) + t_\\phi\\\\\n",
    "\\quad         = (A_2 - A_1) + (B_2 - B_1) + t_\\phi\\\\\n",
    "\\quad         = (A_2 - A_1) + (nT - mT) + t_\\phi\\\\\n",
    "\\quad         = \\Delta A + (kT) + t_\\phi\n",
    "$\n",
    "\n",
    ", where $\\Delta A < T$ and $k \\in \\mathbb{Z}$ and $t_\\phi$ is minimisable by synchronising the beacons.\n",
    "\n",
    "Then $\\Delta t$ can be determined by iteratively summing the signals, changing $k$, and finding the $k$ belonging to the maximum of the sums."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_beacon_integer_period_sum(samplerate, f_beacon, ref_impulse, impulse, k_step=1):\n",
    "    max_k = int( len(ref_impulse)*f_beacon/samplerate )\n",
    "    ks = np.arange(-max_k/2, max_k/2, step=k_step)\n",
    "    \n",
    "    maxima = np.empty(len(ks))\n",
    "    \n",
    "    best_i = 0\n",
    "    \n",
    "    for i,k in enumerate(ks, 0):\n",
    "        augmented_impulse = time_roll(impulse, samplerate, k/f_beacon)\n",
    "        \n",
    "        maxima[i] = max(ref_impulse + augmented_impulse)\n",
    "        \n",
    "        if maxima[i] > maxima[best_i]:\n",
    "            best_i = i\n",
    "        \n",
    "    return ks[best_i], (ks, maxima)\n",
    "\n",
    "def find_beacon_integer_period(samplerate, f_beacon, ref_impulse, impulse, k_step=1):\n",
    "    return find_beacon_integer_period_sum(samplerate, f_beacon, ref_impulse, impulse, k_step=k_step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best k: -5\n",
      "Maximum: 2.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Make figure showing the sums depending on k\n",
    "ref_impulse = impulses[0]\n",
    "my_impulse = impulses[1]\n",
    "\n",
    "# remove 'already determined' offsets\n",
    "if True:\n",
    "    # $t_\\phi$ offset\n",
    "    my_impulse = time_roll(my_impulse, samplerate, -t_phi)\n",
    "\n",
    "    # $\\Delta A$ offset\n",
    "    my_impulse = time_roll(my_impulse, samplerate, +Delta_A)\n",
    "\n",
    "best_k, (ks, maxima) = find_beacon_integer_period(samplerate, f_beacon, ref_impulse, my_impulse)\n",
    "print(\"Best k: {:0g}\".format(best_k))\n",
    "print(\"Maximum: {}\".format(maxima[np.where(ks == best_k)][0]))\n",
    "\n",
    "\n",
    "# Make figure\n",
    "fig, axes = plt.subplots(1, 1, sharex=True,figsize=(12,4))\n",
    "if not hasattr(axes, 'ndim'):\n",
    "    axes = [axes]\n",
    "\n",
    "axes[0].set_title(\"Sum of impulses with $kT$ offsets. Best offset: ${:.0f}*T$\".format(best_k))\n",
    "axes[-1].set_xlabel(\"Time [ns]\")\n",
    "\n",
    "if not True:\n",
    "    i=0\n",
    "    axes[i].set_ylabel(\"Reference\")\n",
    "    axes[i].plot(time/ns, ref_impulse, label=\"reference\")\n",
    "    axes[i].plot(time/ns, my_impulse, label='impulse')\n",
    "    axes[i].legend()\n",
    "\n",
    "axes[-1].set_ylabel(\"Coherence Sum\")\n",
    "\n",
    "best_maximum = np.max(maxima)\n",
    "axes[-1].axhline(best_maximum, alpha=0.7)\n",
    "\n",
    "for i, k in enumerate(ks, 0):\n",
    "        sample_offset = int(k*1/f_beacon*samplerate)\n",
    "        augmented_impulses = np.roll(my_impulse, sample_offset)\n",
    "        \n",
    "        summed_impulse = ref_impulse + augmented_impulses\n",
    "        if True or k%2 == 1:\n",
    "            axes[-1].plot(time/ns, summed_impulse, label='k={:.0f}'.format(k),\n",
    "                         alpha=0.1 + 0.9*1/(1+2*abs(best_maximum-maxima[i]))\n",
    "                        )\n",
    "    \n",
    "axes[-1].legend()\n",
    "fig.show()\n",
    "\n",
    "del ref_impulse\n",
    "del my_impulse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Solve it\n",
    "\n",
    " 1. Find $t_\\phi$\n",
    " 2. Find $\\Delta A$, and $kT$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#####  1.1 Beacon Phase Delay ($t_\\phi$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beacon delays [ns] \\pm k*14.285714285714285ns: [0.         8.57142857]\n"
     ]
    }
   ],
   "source": [
    "abs_beacon_time_delays_tmp = np.array([\n",
    "    beacon_time_delay(samplerate, beacons[0], beacon)\n",
    "        for beacon in beacons\n",
    "])\n",
    "\n",
    "\n",
    "abs_beacon_time_delays = abs_beacon_time_delays_tmp[:,0]\n",
    "t_phi = np.array(abs_beacon_time_delays % (1/f_beacon), dtype=np.float64)\n",
    "beacon_time_delays_err = abs_beacon_time_delays_tmp[:,1]\n",
    "\n",
    "print(\"Beacon delays [ns] \\pm k*{}ns: {}\".format(1/f_beacon/ns, t_phi/ns))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEsCAYAAADtt+XCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy9eZhU1bmo/35VPY/0CDTN0Mw00M3UTArIoGhUFHA2KvEmmsF4cnOTE5Mccz2eJNf4y4kmeuKQqFHjgEHFGWdlRkDmsZu5gYaeoOepav3+WNVYNNVdQ9cI632e9VTV3muv9e3aVfvba61vEKUUBoPBYDB4iyXUAhgMBoMhMjEKxGAwGAw+YRSIwWAwGHzCKBCDwWAw+IRRIAaDwWDwCaNADAaDweATRoEYDAaDwSeMAjEYDAaDTxgFYvAIEfmHiPzWw7oHRWROoGVy6k+JSL2I/K6b7XwmIk0istJfsnVo/4iIjA1E2wZDKDAKJEA4bqKNIlInItUi8p6I9A21XOcxhUqpX3enAaXULOD7fpLnLEQkDegN7HJTb5GIXNLJvntEZIOINIvIP7poY4hDEf6zk/2xIvKMiBwSkVoR2SQiV3SoM0BE3nf8dstE5HERiXLa/4WjjzpH2eO0r65DsYnIY96ch6tz6K7cXckcyXKHEqNAAsvVSqkk9I3jBPCYm/qGCEJEHhCRBzysPhooUUo1ddLW3SIy/5uPcpfT53aOAb8FnnXT1/8A67vYHwUcAWYAqcD9wGsiMsCpzl+Bk+jf7hhH3R92aOcepVSSowxr3+i0LQnoCTQC//LyPFydgz/kdilzJMsdSowCCQKOm8YSIL99m4jkiMjrIlIuIgdE5F6nffeJyD7H08pO5xuJiPQVkTccx1WKyONO+0Y4nlZOicgOEZnntO+giPxMRLaKyGkRWSwicZ3JLCJjReRrhwyLgTinfZ3K7qKdrs7l5yLyeof6j4nIo473vxCRo45j94jI7C6/aA/P1dd2u0kBsN3Rf4KIvOy4jkmO/c8Cg4CfAL8H7MBbzg0opd5QSi0FKjvrRERuAk4Bn3ZWRylVr5R6QCl1UCllV0q9CxwAxjtVywNeU0o1KaXKgGXASO9OGYDr0DfGFZ6eR2fnYOQOP4wCCQIikgDcCKx1fLYA7wBbgD7AbOAnIjLXccg+YBr6aeU/gX+KSG8RsQLvAoeAAY5jX3W0Ge1o8yMgG/gx8JKIOD+t3ABcjv6xFgCLOpE3BlgKvAiko5/CFnooe0dcnotj3z+By0Wkh6PtKMf39KJD7nuAIqVUMjAXONhJH65wea5+aNdXCoBtIpIHrAT2AAuVUnVOdZTTq83ps0eISArwIPB/vDyuJzAU2OG0+c/ATQ5l1we4An1Tc+b/iUiFiKySTqbdgDuAF5SHUVu9OQcf5fZE5kiWO7gopUwJQEHflOrQTyRt6OHvaMe+ScDhDvV/CTzXSVubgWuAKUA5EOWizjSgDLA4bXsFeMBJnm877XsYeLKT/qY75BWnbavRw3e3sjv6mtPVuTh9/gD4nuP9VcBOx/vB6CfAOUC0m+9aAYM79O/yXN21i1Y0K7vo613HNT0FNDlK++d3uzhuDfAk+snzGhf77wYWOPqf6fh8bSdt/Rb4h4vtfwZ+4Xj/APBPD36n0cAnwFMdto8ANjp+uwr4R4ffwyQgGYhF32xrgUEd2uiHVoR5np6Hp+fgi9yeyBzJcoeimBFIYLlWKdUDfeHvAb4UkV5AfyDHMdV0SkROAb9Cz7siIreLyGanfaOATKAvcEgp1eairxzgiFLK7rTtEHqU0E6Z0/sGIAnX5ABHlePX69QW7mTvSBfn0s7zwLcd77+NHvWglCpBT+c8AJwUkVdFJKcTeV3h8ly7265S6iqlVA/HdX0IeKj9s1LqKlfHiIigz3s+WpG91bGOUuoppdQb33xUTyk9XeIRIjIGrRQf8eIYC/r7bkH/Pp23fwi8ASSir1ca8AcnedcppWqVUs1KqeeBVcC3OnRxO1oZH/DnOfgqt4cyR7LcQccokCCglLI5bg424GL0gtoBpxtPD6VUslLqWyLSH/gb+geW4bhRbQfEcVw/cbKGceIY0NfxY2ynH3DUB5GPA30cNz7ntuhK9o6NuDmXdpYCBSIyCj0Ceal9h1LqZaXUxWilpXC6gXWHQLXbBXmO1znA/xGRCV3I9g+l1Bc+9HEJelrzsIiUAT8DForI164qO67tM2jFv1Ap1eq0Ox39sPK446ZVCTxH1zctxdnXFfSN+Hl/noOf5XYlcyTLHXSMAgkCorkG/VSxC/gKqHEs5saLiFVERolIEfoJRKGnqhCR76CfXnEcdxx4SEQSRSRORC5y7FsH1AP/LiLRjnnSq3GskXjJGvRQ+l4RiRKRBcBEJxk6k70jXZ0LcJaBwcvAV0qpw466w0RklojEoqeJGtEKuFv4s12lF0Yf8KBqAbBVKbUNuAt402kdyGMc1yIOsAJWx/Vvf5h4Gr0IP8ZRngTeQ6/xuOIJ9LTJ1UqpRucdSqkK9FTbDxx99kBPnWxxyNFDROa29y8it6KnPT90knUqevTrbMXk7jw8OQef5PZE5kiWO2SEeg7tfC3oefhG9DpILfrJ+1an/TnoNYoyoBq9wD7Hse93QBVQAfwJ+BL4rmNfP/RTe6Vj/1+c2hzpqHsa2AnM7yDPHKfPD9DFHDkwAdjkkH2xo/zWnewd++rqXJzqX4xWNN9x2laAVla1juPfBXI6kdXVGojLc3XXLu7XQD5wXFNX5YNOjrkfeKLD53VAnJe/qQcc5+pcHuii7j87yP0rx/v2kVdTB/mdf59jgC8c17cCfUPNduzLQpuq1qLXftYCl3bo/yngxe6ch4tz8FluT2SOZLlDVdoXaQyGkCEi/YDdQC+lVI0PxzcBzWhlen835PgYmIweCQXDtNdgiGiMAjGEFMeazZ+AFKXUnaGWx2AweI6rxViDISiISCLaQ/8Q2mfDYDBEEGYEYjAYDAafMFZYBoPBYPAJo0AMBoPB4BNGgRgMBoPBJ4wCMRgMBoNPGAViMBgMBp8wCsRwXiB+SmtrCH8kwKmHDZ5jFIghYIhO2jQmiF2eSWsrIuki8qZDqRwSkVuCKIfPiJtUsi7qBzS1rKPeWWlaJcSpZVUAUw8bvMMoEENAEJFMdCyfLnOAB5D/QYfN7gncCjwhImGf4Q3PUsl2JJCpZeHcNK2hTi1rCBOMAjH4HREZjL7BWIBK0al3gxb1wOHhvhC4XylVp5RaCbwN3BYsGbpBoFKbep2iFVynaVUhTi1rCB+MAjH4HaWTNv0MWOJ4ksxQrpNgnYOIvCtOyao6lHc9FGEoYFNK7XXatoUIyDGNZ6lkO+L31LLgeZpWCaPUsobgYhSIIVAUotPXnoWIfNHVQcop45+L4jLjnwuS0CHtnTmNTgsa7nyJVnQ1QCmwAR2+vzN+AQxE57B4GnhHRAY5V3BEO56Bd0mSAP4LeEYpdaSzCiISjU4C9rxSareH5+FW5m7KbQgSRoEYAsUYHAmI2hGRdHSug0BTB6R02JaCzqkQtogHqWQ7ogKQWtYhi9s0rRJmqWUNwccoEIPfcdxARuE0AhGRu9Hz2BNF5Mkujv3AhRVOe/nAQxH2AlEiMsRpWyFnT7GEI76kku2IP1LLgps0rSJhmVrWEGSMAjEEgnhHsQCIyFhgJvB34MfoHOiprg5USl3hbIXToVzh6hgXbdSjn34fFJ369yLgGvTTctii3KSS7YgELrUsuE/TGrLUsobwwSgQg99x3MCfBHaKSCmwAP0EOgY9KmlDZxAMJD9EK7GT6PS7P1BKnRmBOEY6vwqwDL6wAJ0bpRwoQX9X/7t9Zwe5o9FmuOXoqcEfA9cqpZz9Ku4A3lBKuZq++w+0iex9wLcd7/8DQCnVoJQqay/oacEmpVS5iPQH7kZfzzKnEeKtHpyHJzK7k9sQJph8IIaAIyKPoC1w7kPfMB5QSl3n5z78ktbWEP6IST0cNhgFYgg4IlKInsvuh14H+b5S6nhopTIYDN3FKBBDUBCR0cBdSqkfh1oWg8H
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Make a figure showing the corrected beacons\n",
    "fig, ax = plt.subplots(1,1, sharex=True)\n",
    "ax.set_xlabel(\"Time [ns]\")\n",
    "ax.set_ylabel(\"Amplitude [au]\")\n",
    "ax.set_title(\n",
    "    \"Beacon delays [ns] $\\pm$ $k*{}$\\n$t_{{\\phi}}$ = {}\"\n",
    "    .format(1/f_beacon/ns, t_phi/ns)\n",
    ")\n",
    "\n",
    "for i, _ in enumerate(beacons):\n",
    "    l = ax.plot(\n",
    "                time/ns, beacons[i],\n",
    "                label=\"ch {}\".format(i), \n",
    "                ls ='--', \n",
    "                alpha=0.5\n",
    "    )\n",
    "    \n",
    "    # indicate start of uncorrected beacons\n",
    "    ax.axvline(\n",
    "        t_phi[i]/ns,\n",
    "        color=l[0].get_color(),\n",
    "        ls = '--'\n",
    "    )\n",
    "    \n",
    "    ax.plot(\n",
    "            (time-t_phi[i])/ns,\n",
    "            beacons[i],\n",
    "            label='ch {} corrected'.format(i),\n",
    "            color=l[0].get_color(),\n",
    "            ls=(5*i+2, (20, 20))\n",
    "    )\n",
    "    \n",
    "ax.legend(ncol=2)\n",
    "ax.margins(y=0.3)\n",
    "if True:\n",
    "    ax.set_xlim(time[0]/ns - 10, time[2*samplerate//f_beacon]/ns)\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.2 Impulse delays ($\\Delta A, kT$)\n",
    "\n",
    "Find the delay within a single beacon period"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "impulse_max_time = np.argmax(impulses, axis=1) /samplerate\n",
    "impulse_time_in_periods = np.array((impulse_max_time - t_phi)*f_beacon)\n",
    "B, A = np.divmod(impulse_time_in_periods, 1)\n",
    "\n",
    "# subtract the reference beacon's value to obtain time differences\n",
    "A -= A[0]\n",
    "B -= B[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3 Total Time delay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Δ𝐴 = [0. 8.]\n",
      "B = kT = [0. 5.]T\n",
      "𝑡𝜙 = [0.         8.57142857]\n",
      "Δt = 0.08800000000000001\n",
      "Preset Δt = 0.08800000000000001\n"
     ]
    }
   ],
   "source": [
    "print(\"Δ𝐴 = {}\".format(A /f_beacon/ns))\n",
    "print(\"B = kT = {}T\".format(B))\n",
    "print(\"𝑡𝜙 = {}\".format(t_phi/ns))\n",
    "\n",
    "\n",
    "delta_t = A/f_beacon + B/f_beacon + t_phi\n",
    "\n",
    "print(\"Δt = {}\".format(delta_t[1]))\n",
    "\n",
    "print(\"Preset Δt = {}\".format(impulses_offsets[1,0]-impulses_offsets[0,0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}