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]: [ 64. 178.]\n",
      "Time difference Impulses [ns]: 113.99999999999999\n",
      "Time difference Impulses [T]: 7.9799999999999995\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 True:\n",
    "    # freeze impulses\n",
    "    impulses_def_offsets = [\n",
    "        0.064*samplerate,\n",
    "        0.178*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",
    "    orig_imp[imp_offset] = 0.1\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 = 113.99999999999999ns\n",
      "\\Delta A = -5.428571428571415ns\n",
      "t_phi = 8.571428571428573ns\n",
      "B_1 = 57.14285714285714ns = 4.0T\n",
      "B_2 = 157.14285714285714ns = 11.0T\n",
      "kT = 100.0ns = 7.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 + t_\\phi + (kT) \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": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best k: 7\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",
    "if True:\n",
    "    # $\\Delta A$ offset\n",
    "    my_impulse = time_roll(my_impulse, samplerate, +Delta_A)\n",
    "\n",
    "best_k, (ks, maxima) = 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(\"Coherent sum of impulses with $kT$ offsets.\\nBest 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$\n",
    " 3. Find $kT$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#####  1.1 Beacon Phase Delay ($t_\\phi$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "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.1.2 Beacon Synced traces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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": [
    "fig, axes = beacon_sync_figure(\n",
    "    time, impulses, beacons,\n",
    "    delta_t = t_phi,\n",
    "    beacon_offsets = phase2time(beacon_init_phase, f_beacon) + t_phi,\n",
    "    impulse_offsets = impulses_offsets,\n",
    "    f_beacon = f_beacon,\n",
    "    show_annotations = True\n",
    ")\n",
    "axes[0].set_title(\"Beacons synchronised\")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.2 Impulse delays ($\\Delta A, kT$)\n",
    "\n",
    "###### 1.2.1 $\\Delta A$\n",
    "Find the delay within a single beacon period"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 7.]\n"
     ]
    }
   ],
   "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",
    "someB, 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",
    "someB -= someB[0]\n",
    "\n",
    "Delta_A = A[1:] - A[0]\n",
    "print(someB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 1.2.2 $kT$\n",
    "Find integer number of periods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best k: 8\n",
      "Maximum: 2.0\n"
     ]
    }
   ],
   "source": [
    "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",
    "if True:\n",
    "    # $\\Delta A$ offset\n",
    "    my_impulse = time_roll(my_impulse, samplerate, +Delta_A)\n",
    "\n",
    "best_k, (ks, maxima) = 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",
    "B = np.array([ 0, best_k])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3 Total Time delay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Δ𝐴 = [0.         5.42857143]\n",
      "B = kT = [0 8]T\n",
      "𝑡𝜙 = [0.         8.57142857]\n",
      "Δt = 0.12828571428571425\n",
      "Preset Δt = 0.11399999999999999\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": "markdown",
   "metadata": {},
   "source": [
    "##### 1.3.2 Beacon Synced and Period Alignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArkAAAEWCAYAAABi/I8SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdeVxVZf7A8c9zL/umLKKgCCqi4AZqbmmZZrtle02pLePUTE7bzK+aatrMmpqpad+stMyaabHNJksrS1MxF0RARVQQBUVBRWS99z6/P84BLshyRS4oft+v131x79m+z1m493ue85znKK01QgghhBBCdCSW9i6AEEIIIYQQrU2SXCGEEEII0eFIkiuEEEIIITocSXKFEEIIIUSHI0muEEIIIYTocCTJFUIIIYQQHY4kuUKI04pS6jGl1AdtGK9EKdW7lZc5Tyn1ZGsu08W4Pc31sbZg3vFKqd0tjFuzz06kDEKI04skuUKcIpRS2UqpMvMH/qBS6hulVFR7l0s0TWsdoLXe0V7xzYS40jxuipRSS5RS/VuyLK31LnN97K1dzlOpDC2hlFqmlPp9e5dDiNOJJLlCnFoma60DgAhgH/ByO5enQ1NKebR3GVrJs+Zx0wMoAOYd7wI60LYQQpwmJMkV4hSktS4HPgUSqocppbyVUv9SSu1SSu1TSr2hlPI1xwUrpRYppfabtcCLlFI9nOYNUUrNVUrlmeO/cBo3QymVZdYCfqWUinQap5VStyultpnzvaqUUua4WKXUz0qpw0qpA0qp/za0LkopH6XUB0qpQqXUIaXUb0qprkqpq5VS6+pN+5fqspk1lK+aNdpHlFLJSqk+TtMOMGsti8zt8aDToryUUu+b86UrpYY7zZetlLpfKZUKHFVKeSil4s2auEPm9Jc6Td9cObRSKtZ8f5FSKsOcbo9S6q9O012ilEoxY6xUSg12GpeklFpvzvdfwKfBA6MZWutS4ENgoLlci1LqAaXUdnP7f6yUCjHHxZhlv1UptQv40WmYhzlNpHlMFJnHyAynMvua2+agUioDOKOpsimlXlRK5SqlipVS65RS4xqZrn4ZeimlfjG3zVJzX3xQb9rpyvi/OKCUeshpWY8ppT4xj78jSqlNSqk4pdTflFIFZnnOc5q+k1LqHaVUvrn/nlRmswml1E1KqRXK+B88qJTaqZS60Bw3GxgHvKKMGvVXjnffCSGOnyS5QpyClFJ+wLXAaqfBzwBxQCIQC3QHHjHHWYC5QDTQEygDnH9o5wN+wAAgHPi3GWcC8DRwDUbtcQ7wn3rFuQQjgRliTne+OXwW8D0QjFGD2Fit83SgExAFhAK3m+X7CuillIp3mvZGs6zVrgceN2NkAbPNcgcCS4HFQKS5PX5wmu9Scz06m3HqJx3XAxeb4xXwtbku4cCfgQVKqX7NlaMB7wC3aa0DMRLNH83yDgXeBW4zt8GbwFfKOHHxAr4w1zsE+AS4spHlN0kpFQDcAGwwB90JTAHOxthOB4FX6812NhBP7X519hGw25z3KuAppdREc9yjQB/zdT7Gfm7KbxjHbghGIv6JUsqVZP5DYA3GdnsMmNrANGOBfsBE4JF6x9RkjG0bjLFdvsP4f+kOPIGxL6q9B9gwjqck4DzAuQnCSGArEAY8C7yjlFJa64eA5cBMs6nFTBfWSwhxorTW8pKXvE6BF5ANlACHMH5o84BB5jgFHAX6OE0/GtjZyLISgYPm+wjAAQQ3MN07GJe6qz8HAFVAjPlZA2Odxn8MPGC+fx94C+jRzHrdAqwEBjcw7nVgtvl+AEYS5m1+nge87TTtRcAW8/31wIZG4j0GLHX6nACU1dvOtzh9HgfsBSxOwz4CHmuuHE7bKNZ8vwsjkQ1qYD1n1Ru2FSPBPMvc18pp3ErgSRePm3lAuXnc7MVI6vuY4zYDE52mjTD3rwcQY5a9t9P46mEeGCcldiDQafzTwDzz/Q7gAqdxfwB2H8fxfhAY4rTPPmigDD0x/hf8nOb7oIFpeziNXwNc57TcJU7jJmP8j1nNz4Hm/J2BrkAF4Os0/fXAT+b7m4Asp3F+5rzdzM/LgN+31veBvOQlr+ZfUpMrxKllita6M+ANzAR+Vkp1A7pg/KiuMy93H8KoxewCRs2vUupNpVSOUqoY+AXobF5qjQKKtNYHG4gXiVF7C4DWugQoxKjlqrbX6X0pRiIMcB9G8r3GvMR/SyPrNB+j9uw/ymgu8axSytMc9x7wO6WUwqih+1hrXeFC7ChgeyPxGprPR9Vtc5rr9D4SyNVaO5yG5eDaNqjvSowkOEcZTTlGm8Ojgb9U7ztz/0WZsSOBPVprXS/+8fiX1rqz1rqb1vpSrXX1tokGPneKuRkjce3qNG9u/YWZIjGOmyP1ytXdaXxuvXGNUkZTlM3KaN5yCKN2P6yZ9aouQ2kz5W1q/+xzel8GHNC1N7WVmX8DMLaVJ5DvtL3exKjdPyaOU5kaOxaEEG4mSa4QpyCttV1rvRAjIRkLHMD4QR5gJjOdtdadtHGzEcBfMC7XjtRaB2HUDoKRhOYCIUqpzg2EysP4cTcmVsof47LwHhfKuFdrPUNrHYlRe/maMtum1puuSmv9uNY6ARiD0fxhmjluNVCJUZv6O+o2VWhKLsZl8pZyTijzgCillPP3ZU9c2AbHLFTr37TWl2EkRl9g1HyDUd7ZTvuus9baT2v9EZAPdDcTfef4rSEXuLBeXB+ttfO66UbmzcM4bgLrlat63nyMRL3ZMpvtb+/HaO4SbJ7IHcY4PpuSb5bBz2mYu3ocycWoyQ1z2lZBWusBLs7f2HYUQriJJLlCnIKU4TKMdoSbzVrGOcC/lVLh5jTdlVLV7SgDMZLgQ8q4sejR6mVprfOBbzGS0GCllKdSqjoJ/hC4WSmVqJTyBp4CkrXW2S6U8WpVe3PbQYwf+WO6fVJKnaOUGmTWKhdjXC53nu59jDazNq31iua3DgCLgG5KqbvNdq2BSqmRLs5bXzJGU5D7zG0zHuOydv22yU1SSnkppW5QSnXSWldhrGv1es4BbldKjTT3rb9S6mIzgVyFcUn+TmXcBHcFMKLesrVZruP1BjBbKRVtLqeLeVw1S2udi9Fs4mll3Dw4GLgVWGBO8jHwN/OY6oHRlrkxgRjruB/wUEo9AgS5UIYcYC3wmLl9R2Psm1Zn/p98DzynlApSxk17fZRSZ7u4iH1Aq/aXLIRomiS5QpxavlZKlWAkSLOB6VrrdHPc/Rg3Pa02myQsxai9BXgB8MWo8V2N0ZTB2VSM5HILRhdTdwNorX8A/g58hlFr1ge4zsWyngEkm+X9CrhLa72zgem6YfQUUYxxufxnjHaV1eZj3KTlai0u5iX0SRgJz15gG3COq/PXW1Ylxo1qF2Jsv9eAaVrrLS1Y3FQg29w/t2PcSIfWei0wAyOZP4ixH29yin+F+fkgxg2HC6sXaCaQJcCmFpTnRYx9871S6gjGsXE8JwPXY7R7zQM+Bx7VWi8xxz2O0URhJ0Zy2NT++w7jRCvTnKecxptJ1HcDRvvzQuBJ4L8YNa7uMA3wAjIw9sWnGO2YXfEicJXZ88JLbiqfEMKJqtvMSwghTi7K6AatABiqtd7W3uU52SilbsRopvK39i7LyUAZXaxt0Vo/2uzEQogOTZJcIcRJTSl1L3CJ1npCe5dFnHyUUmcARRg1xudhtHUerbXe0OSMQogOT55gI4Q4aSmlsjFuPprSzkURJ69uGM03QjH67P2jJLhCCJCaXCGEEEII0QHJjWdCCCGEEKLDcUtzhbCwMB0TE+OORQshOrCSks0ABATENzPliSsvLwfAx8eVJ8dKLFdjlZZuBcDPr1+D87R2PHeRWBJLYp061q1bd0Br3aX+cLckuTExMaxdu9YdixZCdGArVxq9V40Zk+z2WJmZmQDExcVJrFaMtWHDeACSkpa1STx3kVgSS2KdOpRSDT5RUW48E0II0WrKquxU2hzNTyiEEG4mbXKFEEK02BNPPEF0tPHkZ6012/eXsHXvEQqOlLdzyYQQpzu39K4wfPhwLc0VhBCiY9u5cyeTJ0+
      "text/plain": [
       "<Figure size 864x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = beacon_sync_figure(\n",
    "    time, impulses, beacons,\n",
    "    delta_t = (B + [0,-0])/f_beacon + t_phi,\n",
    "    beacon_offsets = phase2time(beacon_init_phase, f_beacon) + t_phi,\n",
    "    impulse_offsets = impulses_offsets,\n",
    "    f_beacon = f_beacon,\n",
    "    show_annotations = True\n",
    ")\n",
    "axes[0].set_title(\"Beacons synchronised, Period alignment\")\n",
    "fig.show()"
   ]
  }
 ],
 "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
}