{ "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" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Monkey patch correlation_lags\n", "if not hasattr(signal, 'correlation_lags'):\n", " def correlation_lags(in1_len, in2_len, mode='full'):\n", " r\"\"\"\n", " Calculates the lag / displacement indices array for 1D cross-correlation.\n", " Parameters\n", " ----------\n", " in1_size : int\n", " First input size.\n", " in2_size : int\n", " Second input size.\n", " mode : str {'full', 'valid', 'same'}, optional\n", " A string indicating the size of the output.\n", " See the documentation `correlate` for more information.\n", " See Also\n", " --------\n", " correlate : Compute the N-dimensional cross-correlation.\n", " Returns\n", " -------\n", " lags : array\n", " Returns an array containing cross-correlation lag/displacement indices.\n", " Indices can be indexed with the np.argmax of the correlation to return\n", " the lag/displacement.\n", " Notes\n", " -----\n", " Cross-correlation for continuous functions :math:`f` and :math:`g` is\n", " defined as:\n", " .. math::\n", " \\left ( f\\star g \\right )\\left ( \\tau \\right )\n", " \\triangleq \\int_{t_0}^{t_0 +T}\n", " \\overline{f\\left ( t \\right )}g\\left ( t+\\tau \\right )dt\n", " Where :math:`\\tau` is defined as the displacement, also known as the lag.\n", " Cross correlation for discrete functions :math:`f` and :math:`g` is\n", " defined as:\n", " .. math::\n", " \\left ( f\\star g \\right )\\left [ n \\right ]\n", " \\triangleq \\sum_{-\\infty}^{\\infty}\n", " \\overline{f\\left [ m \\right ]}g\\left [ m+n \\right ]\n", " Where :math:`n` is the lag.\n", " Examples\n", " --------\n", " Cross-correlation of a signal with its time-delayed self.\n", " >>> from scipy import signal\n", " >>> from numpy.random import default_rng\n", " >>> rng = default_rng()\n", " >>> x = rng.standard_normal(1000)\n", " >>> y = np.concatenate([rng.standard_normal(100), x])\n", " >>> correlation = signal.correlate(x, y, mode=\"full\")\n", " >>> lags = signal.correlation_lags(x.size, y.size, mode=\"full\")\n", " >>> lag = lags[np.argmax(correlation)]\n", " \"\"\"\n", "\n", " # calculate lag ranges in different modes of operation\n", " if mode == \"full\":\n", " # the output is the full discrete linear convolution\n", " # of the inputs. (Default)\n", " lags = np.arange(-in2_len + 1, in1_len)\n", " elif mode == \"same\":\n", " # the output is the same size as `in1`, centered\n", " # with respect to the 'full' output.\n", " # calculate the full output\n", " lags = np.arange(-in2_len + 1, in1_len)\n", " # determine the midpoint in the full output\n", " mid = lags.size // 2\n", " # determine lag_bound to be used with respect\n", " # to the midpoint\n", " lag_bound = in1_len // 2\n", " # calculate lag ranges for even and odd scenarios\n", " if in1_len % 2 == 0:\n", " lags = lags[(mid-lag_bound):(mid+lag_bound)]\n", " else:\n", " lags = lags[(mid-lag_bound):(mid+lag_bound)+1]\n", " elif mode == \"valid\":\n", " # the output consists only of those elements that do not\n", " # rely on the zero-padding. In 'valid' mode, either `in1` or `in2`\n", " # must be at least as large as the other in every dimension.\n", "\n", " # the lag_bound will be either negative or positive\n", " # this let's us infer how to present the lag range\n", " lag_bound = in1_len - in2_len\n", " if lag_bound >= 0:\n", " lags = np.arange(lag_bound + 1)\n", " else:\n", " lags = np.arange(lag_bound, 1)\n", " return lags\n", "\n", " signal.correlation_lags = correlation_lags" ] }, { "cell_type": "code", "execution_count": 3, "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]: 22.0\n", "Beacon difference [ns]: 8.571428571428571\n", "Beacon difference [phase]: 3.7699111843077517\n", "Impulse offsets [ns]: [ 75.4 149.6]\n", "Time difference Impulses [ns]: 74.20000000000002\n" ] } ], "source": [ "us = 1e3 # ns\n", "ns = 1/us # us\n", "\n", "\n", "band = (30, 80) # MHz\n", "samplerate = 5000 # 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.7*len(time),0.8*len(time)),\n", " ]# random offsets in interval\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": 4, "metadata": {}, "outputs": [], "source": [ "full_signals = impulses + beacons" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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 not 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": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\\Delta t = 74.20000000000002ns\n", "\\Delta A = 5.7999999999999785ns\n", "t_phi = 8.571428571428573ns\n", "B_1 = 57.14285714285714ns = 4.0T\n", "B_2 = 128.57142857142856ns = 9.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": 7, "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": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best k: -5\n", "Maximum: 2.0\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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 $A_1$, $A_2$\n", " 3. Find $B_1$, $B_2$" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# single out one period of the beacon\n", "beacon_samplerate = samplerate # MHz\n", "beacon_time = np.arange(0, 1/f_beacon, 1/beacon_samplerate)\n", "ref_beacon = sin_delay(f_beacon, beacon_time, phase=0, t_delay=0)\n", "\n", "# .. and show beacon period\n", "fig, ax = plt.subplots()\n", "ax.set_title(\"A single beacon period\")\n", "ax.set_xlabel(\"Time [ns]\")\n", "ax.set_ylabel(\"Amplitude\")\n", "ax.plot(beacon_time/ns,ref_beacon)\n", "fig.show()" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "### correlation\n", "def correlation_and_lag(sig1, sig2, mode=\"full\", normalise=False):\n", " corr = signal.correlate(sig1, sig2, mode=mode)\n", " if normalise:\n", " corr /= np.max(corr)\n", "\n", " lags = signal.correlation_lags(sig1.size, sig2.size, mode=mode)\n", " \n", " return corr, lags\n", "\n", "def find_best_lag(sig1, sig2, fix_one_short=False, fix_positive=False, subtract_means=True, **corr_kwargs):\n", " if subtract_means:\n", " sig1 -= np.mean(sig1)\n", " sig2 -= np.mean(sig2)\n", " \n", " corr, lags = correlation_and_lag(sig1, sig2, **corr_kwargs)\n", " lag_id = corr.argmax()\n", "\n", " lag = lags[lag_id]\n", " \n", " if fix_one_short:\n", " # for some reason it is always one short\n", " if lag > 0:\n", " lag += 1\n", " elif lag < 0:\n", " lag -= 1\n", "\n", " # turn negative lag into positive\n", " if fix_positive and lag < 0:\n", " lag += len(sig2)\n", " \n", " return lag, (corr, lags)\n", "\n", "def find_beacon_phase_delay(samplerate, f_beacon, reference_beacon, delayed_beacon, **lag_kwargs):\n", " \"\"\"\n", " Return phase delay of `beacon` with respect to `reference_beacon`.\n", " Note that the returned value can be off by a multiple of $2\\pi$.\n", " \n", " Parameters\n", " ==========\n", " samplerate : float\n", " Samplerate of both reference_beacon and delayed_beacon\n", " f_beacon : float\n", " Frequency of the beacons\n", " reference_beacon : ndarray\n", " The beacon to use as a reference\n", " beacon : ndarray\n", " The beacon to find the delay for\n", " \"\"\"\n", " \n", " calc_lag, _ = find_best_lag(reference_beacon, delayed_beacon, **lag_kwargs)\n", " \n", " time = calc_lag / samplerate\n", " \n", " return 2*np.pi* f_beacon * time" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### 1.1 Beacon Phase Delay ($t_\\phi$)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Beacon delays [ns] \\pm k*14.285714285714285ns: [0. 5.6]\n" ] } ], "source": [ "beacon_phase_delays = np.array([\n", " find_beacon_phase_delay(beacon_samplerate, f_beacon, ref_beacon, beacon)\n", " for beacon in beacons\n", "])\n", "\n", "beacon_time_delays = phase2time(beacon_phase_delays, f_beacon)\n", "\n", "print(\"Beacon delays [ns] \\pm k*{}ns: {}\".format(1/f_beacon/ns, beacon_time_delays/ns))" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 0.0\n", "1 2.463008640414398\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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(\"Beacon delays [ns] $\\pm$ $k*{}$\\n{} == {}\".format(1/f_beacon/ns, beacon_time_delays/ns, None))\n", "\n", "for i, _ in enumerate(beacons):\n", " l = ax.plot(time/ns, beacons[i], label=\"ch {}\".format(i), ls ='--', alpha=0.5)\n", " \n", " print(i, beacon_phase_delays[i], )\n", "\n", " if True:\n", " corrected_beacon = sin_delay(f_beacon, beacon_time, phase=beacon_phase_delays[i], t_delay=0)\n", " else:\n", " corrected_beacon = sin_delay(f_beacon, beacon_time, t_delay=beacon_time_delays[i], phase=0)\n", " \n", " ax.plot(beacon_time/ns, 2*beacon_amplitude*corrected_beacon, label='ch {} corrected'.format(i), color=l[0].get_color())\n", " \n", " # indicate start of uncorrected beacons\n", " ax.axvline(phase2time((2*np.pi+beacon_time_delays[i])%2*np.pi, f_beacon)/ns, color=l[0].get_color())\n", "\n", "ax.legend(ncol=2)\n", "ax.margins(y=0.3)\n", "if True:\n", " ax.set_xlim(time[0]/ns - 1, time[2*samplerate//f_beacon]/ns)\n", "\n", "fig.show()\n", "\n", "\n", "#ax.plot((double_signal_time) * ns, signal_2(double_signal_time + calc_shift), 'r--', label='Recovered')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### 1.2 Impulse vs beacon delays ($A_1, A_2$)\n", "\n", "Find the delay within a single beacon period" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "#def find_beacon_impulse_delay(samplerate, f_beacon, impulse, init_phase=0):\n", "def find_beacon_impulse_phase_delay(samplerate, f_beacon, reference_beacon, impulse, **lag_kwargs):\n", " \"\"\"\n", " Return phase delay of `beacon` with respect to `reference_beacon`.\n", " Note that the returned value can be off by a multiple of $2\\pi$.\n", " \n", " Parameters\n", " ==========\n", " samplerate : float\n", " Samplerate of both reference_beacon and delayed_beacon\n", " f_beacon : float\n", " Frequency of the beacons\n", " reference_beacon : ndarray\n", " The beacon to use as a reference\n", " beacon : ndarray\n", " The beacon to find the delay for\n", " \"\"\"\n", " \n", " calc_lag, _ = find_best_lag(reference_beacon, impulse, **lag_kwargs)\n", " \n", " return 2*np.pi* f_beacon * calc_lag / samplerate" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Beacon Impuls delays: $[-454.90261624 -921.11496603]$ns\n" ] } ], "source": [ "impulse_beacon_phase_delays = np.empty( len(impulses) )\n", "\n", "for i, _ in enumerate(impulses):\n", " impulse_beacon_phase_delays[i] = find_beacon_impulse_phase_delay(\n", " beacon_samplerate, f_beacon, \n", " ref_beacon, impulses[i]\n", " )\n", "\n", "print(\"Beacon Impuls delays: ${}$ns\".format(impulse_beacon_phase_delays/f_beacon/ns))" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEKCAYAAAAfGVI8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAVt0lEQVR4nO3df6zdd33f8ecLQxItUDDYk5DjEENdkhS1CRwZKqTBBEkc/rCRilqnQyQsnTVGYIOtUhCagsw/FDbRsaUlpvWASsOBVNpuO1CaEhhbh8HHIwuxK8PFUOKZKQaHaF2yZE7e++N8s3t8fa/v19fH9zj383xIRz7fz/fz+Z7P/eje8/L35ydVhSSpXc+bdgckSdNlEEhS4wwCSWqcQSBJjTMIJKlxBoEkNW7JIEiyJ8kjSR5aZH2SfCrJbJIHk7x2bN3NSb7fvW6eZMclSZPRZ4/gs8DWM6y/EdjcvXYCfwCQ5KXAHcDrgS3AHUnWnktnJUmTt2QQVNU3gBNnqLId+HyN7ANekuTlwA3AfVV1oqoeBe7jzIEiSZqC509gGxuAh8eWj3Zli5WfJslORnsTXHrppa+78sorJ9AtSWrHgQMHflpV65fTdhJBkAXK6gzlpxdW7QZ2AwwGgxoOhxPoliS1I8lfL7ftJK4aOgpsHFu+DDh2hnJJ0gVkEkEwA7yru3roDcBjVfUT4F7g+iRru5PE13dlkqQLyJKHhpJ8AXgzsC7JUUZXAr0AoKo+DXwZeBswCzwOvLtbdyLJR4H93aZ2VdWZTjpLkqZgySCoqpuWWF/AexdZtwfYs7yuSZJWgncWS1LjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIa1ysIkmxNcjjJbJLbF1j/ySQPdK/vJfn52Lqnx9bNTLLzkqRz12eqyjXAncB1jCak359kpqoOPVunqj4wVv99wLVjm3iiqq6ZXJclSZPUZ49gCzBbVUeq6ilgL7D9DPVvAr4wic5Jks6/PkGwAXh4bPloV3aaJK8ANgH3jxVfkmSYZF+Sty/SbmdXZ3j8+PGeXZckTUKfIMgCZbVI3R3APVX19FjZ5VU1AH4L+L0krzptY1W7q2pQVYP169f36JIkaVL6BMFRYOPY8mXAsUXq7mDeYaGqOtb9ewT4OqeeP5AkTVmfINgPbE6yKclFjL7sT7v6J8mrgbXAN8fK1ia5uHu/DngjcGh+W0nS9Cx51VBVnUxyG3AvsAbYU1UHk+wChlX1bCjcBOytqvHDRlcBdyV5hlHofGz8aiNJ0vTl1O/t6RsMBjUcDqfdDUl6TklyoDsfe9a8s1iSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1LheQZBka5LDSWaT3L7A+luSHE/yQPf67bF1Nyf5fve6eZKdlySduyWnqkyyBrgTuI7RRPb7k8wsMOXk3VV127y2LwXuAAZAAQe6to9OpPeSpHPWZ49gCzBbVUeq6ilgL7C95/ZvAO6rqhPdl/99wNbldVWSdD70CYINwMNjy0e7svl+PcmDSe5JsvFs2ibZmWSYZHj8+PGeXZckTUKfIMgCZfNnvP9T4Iqq+hXgL4DPnUVbqmp3VQ2qarB+/foeXZIkTUqfIDgKbBxbvgw4Nl6hqn5WVU92i58BXte3rSRpuvoEwX5gc5JNSS4CdgAz4xWSvHxscRvwV937e4Hrk6xNsha4viuTJF0glrxqqKpOJrmN0Rf4GmBPVR1MsgsYVtUM8P4k24CTwAnglq7tiSQfZRQmALuq6sR5+DkkScuUqtMO2U/VYDCo4XA47W5I0nNKkgNVNVhOW+8slqTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXG9giDJ1iSHk8wmuX2B9R9McqibvP6rSV4xtu7pJA90r5n5bSVJ07XkDGVJ1gB3AtcxmoN4f5KZqjo0Vu07wKCqHk/yHuDjwG92656oqmsm3G9J0oT02SPYAsxW1ZGqegrYC2wfr1BVX6uqx7vFfYwmqZckPQf0CYINwMNjy0e7ssXcCnxlbPmSJMMk+5K8faEGSXZ2dYbHjx/v0SVJ0qQseWgIyAJlC050nOSdwAB401jx5VV1LMkrgfuTfLeqfnDKxqp2A7thNGdxr55Lkiaizx7BUWDj2PJlwLH5lZK8FfgwsK2qnny2vKqOdf8eAb4OXHsO/ZUkTVifINgPbE6yKclFwA7glKt/klwL3MUoBB4ZK1+b5OLu/TrgjcD4SWZJ0pQteWioqk4muQ24F1gD7Kmqg0l2AcOqmgE+AbwQ+FISgB9X1TbgKuCuJM8wCp2PzbvaSJI0Zam6sA7JDwaDGg6H0+6GJD2nJDlQVYPltPXOYklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS43oFQZKtSQ4nmU1y+wLrL05yd7f+W0muGFv3oa78cJIbJtd1SdIkLBkESdYAdwI3AlcDNyW5el61W4FHq+oXgU8Cv9u1vZrRHMe/DGwFfr/bniTpAtFnj2ALMFtVR6rqKWAvsH1ene3A57r39wBvyWjy4u3A3qp6sqp+CMx225MkXSCWnLwe2AA8PLZ8FHj9YnW6ye4fA17Wle+b13bD/A9IshPY2S0+meShXr1f/dYBP512Jy4QjsUcx2KOYzHn1ctt2CcIskDZ/BnvF6vTpy1VtRvYDZBkuNwJmFcbx2KOYzHHsZjjWMxJMlxu2z6Hho4CG8eWLwOOLVYnyfOBFwMneraVJE1RnyDYD2xOsinJRYxO/s7MqzMD3Ny9fwdwf1VVV76ju6poE7AZ+PZkui5JmoQlDw11x/xvA+4F1gB7qupgkl3AsKpmgD8C/jjJLKM9gR1d24NJvggcAk4C762qp5f4yN3L/3FWHcdijmMxx7GY41jMWfZYZPQfd0lSq7yzWJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJalyfqSr3JHlkscliMvKpbl7iB5O8dmzdzUm+371uXqi9JGm6+uwRfJbRfMOLuZHR46U3M5pl7A8AkrwUuIPRbGZbgDuSrD2XzkqSJm/JIKiqbzB6tPRitgOfr5F9wEuSvBy4Abivqk5U1aPAfZw5UCRJU9BnqsqlLDSn8YYzlJ9mfM7iSy+99HVXXnnlBLolSe04cODAT6tq/XLaTiIIzmm+Yjh1zuLBYFDD4bKn3pSkJiX56+W2ncRVQ4vNS+x8xZL0HDCJIJgB3tVdPfQG4LGq+gmjqS2vT7K2O0l8fVcmSbqALHloKMkXgDcD65IcZXQl0AsAqurTwJeBtwGzwOPAu7t1J5J8FNjfbWpXVZ3ppLMkaQr6TF5/0xLrC3jvIuv2AHuW1zVJ0krwzmJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuN6BUGSrUkOJ5lNcvsC6z+Z5IHu9b0kPx9b9/TYuplJdl6SdO76TFW5BrgTuI7RhPT7k8xU1aFn61TVB8bqvw+4dmwTT1TVNZPrsiRpkvrsEWwBZqvqSFU9BewFtp+h/k3AFybROUnS+dcnCDYAD48tH+3KTpPkFcAm4P6x4kuSDJPsS/L2Rdrt7OoMjx8/3rPrkqRJ6BMEWaCsFqm7A7inqp4eK7u8qgbAbwG/l+RVp22sandVDapqsH79+h5dkiRNSp8gOApsHFu+DDi2SN0dzDssVFXHun+PAF/n1PMHkqQp6xME+4HNSTYluYjRl/1pV/8keTWwFvjmWNnaJBd379cBbwQOzW8rSZqeJa8aqqqTSW4D7gXWAHuq6mCSXcCwqp4NhZuAvVU1ftjoKuCuJM8wCp2PjV9tJEmavpz6vT19g8GghsPhtLshSc8pSQ5052PPmncWS1LjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1LheQZBka5LDSWaT3L7A+luSHE/yQPf67bF1Nyf5fve6eZKdlySduyVnKEuyBrgTuI7R/MX7k8wsMNPY3VV127y2LwXuAAaMJrw/0LV9dCK9lySdsz57BFuA2ao6UlVPAXuB7T23fwNwX1Wd6L787wO2Lq+rkqTzoU8QbAAeHls+2pXN9+tJHkxyT5KNZ9M2yc4kwyTD48eP9+y6JGkS+gRBFiibP9HxnwJXVNWvAH8BfO4s2lJVu6tqUFWD9evX9+iSJGlS+gTBUWDj2PJlwLHxClX1s6p6slv8DPC6vm0lSdPVJwj2A5uTbEpyEbADmBmvkOTlY4vbgL/q3t8LXJ9kbZK1wPVdmSTpArHkVUNVdTLJbYy+wNcAe6rqYJJdwLCqZoD3J9kGnAROALd0bU8k+SijMAHYVVUnzsPPIUlaplSddsh+qgaDQQ2Hw2l3Q5KeU5IcqKrBctp6Z7EkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXG9giDJ1iSHk8wmuX2B9R9McijJg0m+muQVY+ueTvJA95qZ31aSNF1LTlWZZA1wJ3Ado8no9yeZqapDY9W+Awyq6vEk7wE+Dvxmt+6Jqrpmwv2WJE1Inz2CLcBsVR2pqqeAvcD28QpV9bWqerxb3AdcNtluSpLOlz5BsAF4eGz5aFe2mFuBr4wtX5JkmGRfkrcv1CDJzq7O8Pjx4z26JEmalCUPDQFZoGzBGe+TvBMYAG8aK768qo4leSVwf5LvVtUPTtlY1W5gN4wmr+/Vc0nSRPTZIzgKbBxbvgw4Nr9SkrcCHwa2VdWTz5ZX1bHu3yPA14Frz6G/kqQJ6xME+4HNSTYluQjYAZxy9U+Sa4G7GIXAI2Pla5Nc3L1fB7wRGD/JLEmasiUPDVXVySS3AfcCa4A9VXUwyS5gWFUzwCeAFwJfSgLw46raBlwF3JXkGUah87F5VxtJkqYsVRfWIfnBYFDD4XDa3ZCk55QkB6pqsJy23lksSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWpcryBIsjXJ4SSzSW5fYP3FSe7u1n8ryRVj6z7UlR9OcsPkui5JmoQlgyDJGuBO4EbgauCmJFfPq3Yr8GhV/SLwSeB3u7ZXM5rj+JeBrcDvd9uTJF0g+uwRbAFmq+pIVT0F7AW2z6uzHfhc9/4e4C0ZTV68HdhbVU9W1Q+B2W57kqQLxJKT1wMbgIfHlo8Cr1+sTjfZ/WPAy7ryffPabpj/AUl2Aju7xSeTPNSr96vfOuCn0+7EBcKxmONYzHEs5rx6uQ37BEEWKJs/4/1idfq0pap2A7sBkgyXOwHzauNYzHEs5jgWcxyLOUmGy23b59DQUWDj2PJlwLHF6iR5PvBi4ETPtpKkKeoTBPuBzUk2JbmI0cnfmXl1ZoCbu/fvAO6vqurKd3RXFW0CNgPfnkzXJUmTsOShoe6Y/23AvcAaYE9VHUyyCxhW1QzwR8AfJ5lltCewo2t7MMkXgUPASeC9VfX0Eh+5e/k/zqrjWMxxLOY4FnMciznLHouM/uMuSWqVdxZLUuMMAklq3NSC4FweW7Ha9BiLDyY5lOTBJF9N8opp9HMlLDUWY/XekaSSrNpLB/uMRZLf6H43Dib5dyvdx5XS42/k8iRfS/Kd7u/kbdPo5/mWZE+SRxa71yojn+rG6cEkr+214apa8Rejk84/AF4JXAT8d+DqeXX+EfDp7v0O4O5p9PUCGYu/C/yt7v17Wh6Lrt6LgG8wullxMO1+T/H3YjPwHWBtt/y3p93vKY7FbuA93furgR9Nu9/naSz+DvBa4KFF1r8N+Aqje7jeAHyrz3antUdwLo+tWG2WHIuq+lpVPd4t7mN0P8Zq1Of3AuCjwMeB/7OSnVthfcbiHwB3VtWjAFX1yAr3caX0GYsCfqF7/2JW6f1KVfUNRldmLmY78Pka2Qe8JMnLl9rutIJgocdWzH/0xCmPrQCefWzFatNnLMbdyijxV6MlxyLJtcDGqvqzlezYFPT5vfgl4JeS/GWSfUm2rljvVlafsfgI8M4kR4EvA+9bma5dcM72+wTo94iJ8+FcHlux2vT+OZO8ExgAbzqvPZqeM45FkucxerrtLSvVoSnq83vxfEaHh97MaC/xPyd5TVX9/Dz3baX1GYubgM9W1b9M8muM7mt6TVU9c/67d0FZ1vfmtPYIzuWxFatNr8dwJHkr8GFgW1U9uUJ9W2lLjcWLgNcAX0/yI0bHQGdW6Qnjvn8j/6Gq/m+Nnu57mFEwrDZ9xuJW4IsAVfVN4BJGD6RrzbIe6zOtIDiXx1asNkuORXc45C5GIbBajwPDEmNRVY9V1bqquqKqrmB0vmRbVS37YVsXsD5/I/+e0YUEJFnH6FDRkRXt5croMxY/Bt4CkOQqRkFwfEV7eWGYAd7VXT30BuCxqvrJUo2mcmiozuGxFatNz7H4BPBC4Evd+fIfV9W2qXX6POk5Fk3oORb3AtcnOQQ8DfxOVf1ser0+P3qOxT8FPpPkA4wOhdyyGv/jmOQLjA4FruvOh9wBvACgqj7N6PzI2xjN/fI48O5e212FYyVJOgveWSxJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBoVUnysiQPdK//meR/jC3/1/PwebckOZ7kD5fZ/hNdP//ZpPsm9TWtZw1J50V3Q9U1AEk+AvxNVf2L8/yxd1fVbctpWFW/k+R/T7pD0tlwj0DNSPI33b9vTvKfknwxyfeSfCzJ30vy7STfTfKqrt76JH+SZH/3emOPz7glyb8ZW/6z7vPWJPlskoe6z/jA+ftJpbPjHoFa9avAVYweX3IE+MOq2pLkHzN6hPE/Af4V8Mmq+i9JLmf0iIOrlvl51wAbquo1AElecq4/gDQpBoFatf/Zh3El+QHw5135d+ke5Aa8Fbh6bD6kX0jyoqr6X8v4vCPAK5P8a+A/jn2eNHUGgVo1/ijvZ8aWn2Hu7+J5wK9V1RNnsd2TnHrI9RKAqno0ya8CNwDvBX4D+PvL6Lc0cZ4jkBb358D/Pwmc5JoebX4EXJPkeUk2Mppm8dnHRD+vqv4E+OeM5p2VLgjuEUiLez9wZ5IHGf2tfAP4h0u0+Uvgh4wOMT0E/LeufAPwb7tZ1gA+NPnuSsvjY6ilc5DkFmCw3MtHu218hJW5zFVakIeGpHPzBHDjudxQBrwT8F4CTY17BJLUOPcIJKlxBoEkNc4gkKTGGQSS1Lj/B5T7qtMWY+TaAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Make a figure showing the corrected beacons\n", "fig, axes = plt.subplots(len(impulses),1, sharex=True)\n", "axes[-1].set_xlabel(\"Time [us]\")\n", "ax.set_title(\"Beacon Impuls delays: ${}$ns\".format(impulse_beacon_phase_delays/f_beacon/ns))\n", "\n", "for i, beacon in enumerate(beacons):\n", " ax.set_ylabel(\"Amplitude [au]\")\n", " ax.plot(time, beacon, label=\"ch {}\".format(i))\n", "\n", "ax.plot(beacon_time, corrected_beacon, label='phase corrected (overlaps ch 0)')\n", "\n", "ax.legend()\n", "\n", "fig.show()" ] }, { "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 }