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",
    "if not True:\n",
    "    # Equal offset to beacon and \n",
    "    impulses_def_offsets = [\n",
    "        64*ns*samplerate,\n",
    "        (64*ns + (beacon_phase_offset % (2*np.pi))/(2*np.pi*f_beacon) + 6/f_beacon)*samplerate\n",
    "    ]\n",
    "    if True:\n",
    "        impulses_def_offsets = [impulses_def_offsets[0]]\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": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArkAAAEGCAYAAABhKo2JAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACKrElEQVR4nOzdd1hUV/7H8feZofcmiIKgInZFxa6JLabHVNMTd1M2vW422WQ3dTfZXzZ93fRkTUxiqmmaZmLsvSBYARugIALSpM7M+f1xh6aUQRnq9/U8PMowc+fD5c6533vuuecqrTVCCCGEEEJ0Jqa2DiCEEEIIIURLkyJXCCGEEEJ0OlLkCiGEEEKITkeKXCGEEEII0elIkSuEEEIIITodF2csNCQkREdHRztj0UIIB5WU7AHAy6t/GycRQgghnGfz5s05WutuJz7ulCI3OjqaTZs2OWPRLW7NmrEATJiwvo2TOCY5ORmA2NjYNk7iGMnrXI3l3bp1CgAjRixrxUSN60zrtz2SvM7TkbKC5HU2ydu+KKUO1ve4DFcQohOTWbCFEEJ0VVLkCtFJHS0qZ/PBPBIz8ts6ihBCCNHqpMgVohO46667iIqKqv4+u7CMg3nHsdo0j3yVhMVqa8N0QgghROtzypjcjiQ09Pq2jtAswcHBbR2hWSSvcwUHB3Pw4EGWLVtGRUUFRUVF+Pr68tT3OxnmBZFBXuzcUMj7q/dz6xl92zpuh1y/HYnkdZ6OlBUkr7NJ3o5Bad3yo/bi4+N1R7nwTIiO7oYbbuC8887jnXfe4Z///CfFfr25+cNN/Pfsp+kR4MnrSS+wMuUov9x3Jr2Cvdo6rhBCCNGilFKbtdbxJz4uwxWE6MB27NjB9u3bufLKKxk4cCCbExL5+7fb6R/mS7i/JwBPzxqMi8nEY98k4YyDWiGEEKI96vJFbmrqXFJT57Z1DIfl5uaSm5vb1jEcJnmd66GHHuKhhx5CKcXAgQOZ/8MqsgrLuHO0L08/vYeHHtpBuL8nfzmnPytTcvg24XCb5u1o61fyOldHytuRsoLkdTbJ2zF0+SI3O3s+2dnz2zqGwzrahip5nWf9+vUsXbqUhx56iOjoaJ546mm2JW3nhnFRXDRpBE88UXMTiGvHRjGiVwBPL9pJ3vGKNsvckdYvSF5n60h5O1JWkLzOJnk7hi5f5ArRUT366KO89dZbLF26lJS9+xh691tYc9P489kn3+HMbFI8d+lQCksr+efiXW2QVgghhGhdUuQK0QEtWbKE8vJyxo8fD8A7K/ex/7grrrqCypKiel8zoLsft53Zl6+2ZLA6Nac14wohhBCtTopcITqgs846i1WrVgGQcayEV39N4dwh3TleVEhQUBC5ubn885/J7NlTzHPPPVf9urumxdA7xJtHv06itMLaVvGFEEIIpzulKcSUUm9rrW9t6OcyhZgQrefJ73bw0bJETD88zcwZ09myZQuPPfYYPXr8G4ARI5bVef7KlKNc/94GXr5yOJeMiGiDxEIIIUTLafYUYkqpoAa+goHznJpWCOGwlSlHidZHcDWb+OCDD0hOTubgwYNUVNR/l7OJfUMI9HJlVUrXuwhBCCFE19HYHc+OAgcBVesxbf8+1JmhhBCOySooY/2Hz3E88RdcXFxwc3OjuLiYO++8k+hoTxYuHHPSa0wmxYSYEFan5qC1RilVz5KFEEKIjq2xMbn7gCla6961vvporXsDR1opn9OtWTOWNWvGtnUMhyUnJ5OcnOz093nrrbcIDw8nLi6OmJgYLr74Yioqmj/11Knmfeedd4iLiyMuLg6TyVT9/wceeKDZy2qO1lq/LeXz3zbgGz+LJ/7vZcLDw/H19cXNzY3HHnuM994b0eDrJseEkFVYxt6jxa2YtuOtX8nrXB0pb0fKCpLX2SRvx9BYkfsKENjAz55v+SiiPUlMTOTZZ58lISGB5ORktm/fTmJiYqu9/y233EJCQgKLFy8mMjKShIQEEhISeOmll1otQ0ew5eAxgn09ue2GqykvL2fChAl069aNsWPHEhjo2uDrJsaEALAqRWZZEEII0Tk1OFxBa/3fRn72H+fEEe1FUlISt9xyCwCpqalorYmNjW2RZV9xxRWEhYWRkJBAeno6H3/8MW+//Tbr1q1j8uTJvPfee9XP3b59O0OHDm2R9+1stNZsTjvGiF6BdO8expEjdU+wbN36YoOvjQzyIirYi1WpucyZ2NvZUYUQQohW19iYXNGF7dixgxtuuIHKykoyMjJYvHgxfn5+jb5m8uTJFBXVnaO1vLychx9+uE6BnJSUxPjx45k7dy6PP/44N910E8uWLSM4OJiwsDBef/113N3dq587ZMiQlv8FO4GU7GLyjlcwqldDJ1waNzEmhO8SDmOx2nAxy2yCQgghOpcuX+SGhl7f1hGaJTg42OnvkZ6eTmhoaPXwhA8//JBnnnmGt956i3/+858UFBTw5ZdfnvS6lStXnvTYibcRLCsrIz8/n/vuuw8AT09PbrrpJsLDwwHw8vLCzc2t+vnbt2/nrLPOaqlfrUmtsX5byqqUHEyevswY2feUXj8pJoRP1qexLaOAUVGnVig3V0davyB5na0j5e1IWUHyOpvk7Ri6fJEbE3NXW0doltbYUBMTExk0aFD198OHD+fFF1+kT58+vPfee1x++eX1vq6+nlyAF154gRkzZgBGD/HIkSMxmYyew23btnH77bcDkJGRQY8ePepc7Z+UlMT999/fYr9bUzpSQ7A6NYeYyHCG9Dm1uW7H9wlGKWM5UuTWT/I6V0fK25GyguR1NsnbMThU5CqlAoF+gEfVY1rrFc4KJdpWUlISAwcOBIxxnx988EF1kdqY+npy61v28OHDq79PTExk2LBhgFHwVv0fwGazkZKSwoABA5r7K3R6lVYb6/blcsnInqe8jEBvN4b08GdVSg73TO/XgumEEEKIttfkQDyl1M3ACuBn4Cn7v086N1brSU2dS2rq3LaO4bDc3NyThgC0tKSkJObNm8eIESMYNWoUZWVlPPPMM6e0rBPzJiUlERcXBxhDF0pLSwkMNHoRaxe8YFzwFhERUT0+tzW0xvptCQnp+RyvsDIsxHxaeSf1C2FL2jGOl1taMF3DOsr6rSJ5nasj5e1IWUHyOpvk7Rgc6cm9FxgNrNNaT1VKDcAodjuF7Oz5wMnDFtrrJPlVG6kzTz18/PHHDb73Y489xtatW3nuuef461//2uSyTsz74os1V/x7eHiwf//+6u9PXF5sbCw7d+5sdv7T0Rrr91TV3iZXpeRgUtDXV5Obm3vKeSfFhPDGsr1s2J/H1AHOv8dLe16/9ZG8ztWR8nakrCB5nU3ydgyOXFJdprUuA1BKuWutdwP9nRur7axatYoZM2bwxz/+sa2jtDvBwcG8+eab7N2716ECV7Ssm266ienTp7Ny5UpWp+YwNCIAX8+G58J1xKioQNxdTKxKlflyhRBCdC6O9ORmKKUCgG+AJUqpY8BhZ4ZqCz///DPPPfccBw4c4MEHH+TKK6/k2LFjbR3rJAUFBQDtMlt9JG/L+de//sVnn33Gtdddx1HtyzW33guceVrL9HA1Mzo6iNVS5AohhOhkmixytdaX2P/7pFLqd8Af+MmpqVrZ/v2lXHfdOZhMJnx8fHj88cd5/PHH2zpWvWw2G0D17ATtneRteRUWK2XH03n/77dySdz3p32TjokxIfzfT7vJLioj1Nej6RcIIYQQHYDSWjf9JKXMQBi1imKtdVpDz4+Pj9ebNm1qkYCt5cCBAzz77LN89dVX3H777TzwwAMEBQW1dSwhquXl5fHSSy/x0mtzces7jnWfz2VAv5gGn7916xQARoxY1uhykzIKuHDuKl65Mo6LR5z6bA1CCCFEW1BKbdZax5/4uCOzK9wNHAGWAIvtX4taPGEbi46O5u2332bz5s1kZ2fz5JNPtnUkIep46qmnOHLkCCPvfpOL7n660QK3OQb38CPAy1XG5QohhOhUHJ1dob/WukvMPVFV7ArR3rz66qscKSxj7LO/cUNMy10hazIpJvYNYXVqTrudVUQIIYRoLkcGHqYDBc4O0lb
      "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), gridspec_kw=dict(hspace=0))\n",
    "for i, ax in enumerate(axes):\n",
    "    #if i != 0:\n",
    "    #    ax.spines['top'].set_visible(False)\n",
    "    #ax.spines['right'].set_visible(False)\n",
    "    #if i != len(axes)-1:\n",
    "    #    ax.spines['bottom'].set_visible(False)\n",
    "    #ax.spines['left'].set_visible(False)\n",
    "    #ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)\n",
    "    pass\n",
    "\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], \"$\\Delta t_\\\\varphi$\", 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 True:\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",
    "if True:\n",
    "    fname = 'figures/08_beacon_sync_coherent_sum'\n",
    "\n",
    "    # Dump figure\n",
    "    fig.savefig(fname +'.pdf')\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"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1809896/665080263.py:1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  abs_beacon_time_delays_tmp = np.array([\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()\n",
    "\n",
    "if True:\n",
    "    fname = 'figures/08_beacon_sync_synchronised_outline'\n",
    "\n",
    "    # Dump figure\n",
    "    fig.savefig(fname +'.pdf')"
   ]
  },
  {
   "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": "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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 = (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()\n",
    "if True:\n",
    "    fname = 'figures/08_beacon_sync_synchronised_period_alignment'\n",
    "\n",
    "    # Dump figure\n",
    "    fig.savefig(fname +'.pdf')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}