diff --git a/lib/util.py b/lib/util.py index 7cfd841..6f9c7f3 100644 --- a/lib/util.py +++ b/lib/util.py @@ -47,13 +47,20 @@ def time2phase(time, frequency=1): def phase2time(phase, frequency=1): return phase/(2*np.pi*frequency) -def time_roll(a, samplerate, time_shift, *roll_args, int_func=lambda x: np.rint(x).astype(int), **roll_kwargs): +def phase_modulo(phase, low=np.pi): + """ + Modulo phase such that it falls within the + interval $[-low, 2\pi - low)$. + """ + return (phase + low) % (2*np.pi) - low + +def time_roll(a, samplerate, time_shift, sample_shift=0, int_func=lambda x: np.rint(x).astype(int), **roll_kwargs): """ Like np.roll, but use samplerate and time_shift to approximate the offset to roll. """ - shift = int_func(time_shift*samplerate) - return np.roll(a, shift, *roll_args, **roll_kwargs) + shift = int_func(time_shift*samplerate + sample_shift) + return np.roll(a, shift, **roll_kwargs) ### signal generation def fft_bandpass(signal, band, samplerate): diff --git a/simulations/08_find_beacon_phase_delay.ipynb b/simulations/08_find_beacon_phase_delay.ipynb new file mode 100644 index 0000000..613fcfa --- /dev/null +++ b/simulations/08_find_beacon_phase_delay.ipynb @@ -0,0 +1,468 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Find Sine delay in Beacon" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import signal\n", + "\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", + "\n", + "\n", + "# monkey patch correlation_lags into signal if it does not exist\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": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def lag_gridsearch(grid, sample_rate, reference, signal_data):\n", + " \"\"\"\n", + " Return the best time shift found when doing a grid search.\n", + " \n", + " Parameters\n", + " ----------\n", + " lag_grid - ndarray\n", + " The array specifying the grid that is to be searched.\n", + " sample_rate - float\n", + " Sample rate of signal_data to transform index to time.\n", + " signal_data - ndarray\n", + " The real signal to find the time shift for.\n", + " reference - ndarray\n", + " Real signal to use as reference to obtain lag.\n", + " \n", + " Returns\n", + " -------\n", + " lag : ndarray\n", + " The best time shift obtained\n", + " err : tuple\n", + " Difference to the previous and next time shift from lag, resp.\n", + " \"\"\"\n", + "\n", + " assert signal_data.shape >= reference.shape, str(signal_data.shape) + \" \" + str(reference.shape)\n", + " \n", + " corrs = grid_correlate(grid, reference, signal_data)\n", + " \n", + " idx = np.argmax(corrs)\n", + "\n", + " lag = grid[idx]/sample_rate\n", + " \n", + " err_min = (grid[idx-1]-grid[idx])/(2*sample_rate)\n", + " err_plus = (grid[idx+1]-grid[idx])/(2*sample_rate)\n", + "\n", + " return lag, np.array([err_min, err_plus])\n", + " \n", + "\n", + "def grid_correlate(grid, reference, x):\n", + " \"\"\"\n", + " Determine correlation between x and reference using grid as \n", + " the lags to be used for the correlation.\n", + " \n", + " Parameters\n", + " ----------\n", + " grid - ndarray\n", + " The array specifying the grid that is to be searched.\n", + " x - ndarray\n", + " The real signal to find the time shift for.\n", + " reference - ndarray\n", + " Real signal to use as reference to obtain lag.\n", + " \n", + " Returns\n", + " -------\n", + " corrs - ndarray\n", + " The correlations along grid.\n", + " \"\"\"\n", + " grid = np.asarray(grid)\n", + " x = np.asarray(x)\n", + " reference = np.asarray(reference)\n", + "\n", + " assert x.shape >= reference.shape, str(signal_data.shape) + \" \" + str(reference.shape)\n", + " \n", + " reference = np.pad(reference, (0,len(x)-len(reference)), 'constant', constant_values=0)\n", + " \n", + " ref_conj = np.conjugate(reference)\n", + " \n", + " corrs = np.array([np.dot(np.roll(ref_conj, lag), x) for lag in grid], dtype=np.float64)\n", + " \n", + " return corrs\n", + "\n", + "def correlation_grid(grid_size=None, in1_len=None, in2_len = None, end = None, start=None, mode='full'):\n", + " \"\"\"\n", + " Abuse correlation_lags to determine the endpoints of the grid.\n", + " \"\"\"\n", + " \n", + " if in1_len is not None or in2_len is not None:\n", + " if in2_len is None:\n", + " in2_len = in1_len\n", + " elif in1_len is None:\n", + " in1_len = in2_len\n", + "\n", + " lags = signal.correlation_lags(in1_len, in2_len, mode=mode)\n", + "\n", + " max_lag = max(lags)\n", + " min_lag = min(lags)\n", + " else:\n", + " max_lag = np.inf\n", + " min_lag = -np.inf\n", + "\n", + " if end is None:\n", + " end = max_lag\n", + " elif end > max_lag:\n", + " raise ValueError(\"Grid end is too high\")\n", + "\n", + " if start is None:\n", + " start = min_lag\n", + " elif start < min_lag:\n", + " raise ValueError(\"Grid start is too low\")\n", + " \n", + " if grid_size is None:\n", + " grid_size = end - start\n", + "\n", + " return np.linspace(start, end, grid_size, dtype=int, endpoint=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def beacon_time_delay(samplerate, ref_beacon, beacon):\n", + " grid = correlation_grid(in1_len=len(ref_beacon), in2_len=len(beacon), mode='full')\n", + " time_lag, errs = lag_gridsearch(grid, samplerate, ref_beacon, beacon)\n", + "\n", + " return time_lag, errs\n", + "\n", + "def beacon_phase_delay(samplerate, f_beacon, ref_beacon, beacon):\n", + " time_delay, errs = beacon_time_delay(samplerate, ref_beacon, beacon)\n", + "\n", + " phase = time2phase(time_delay, f_beacon)\n", + " phase_err = time2phase(errs, f_beacon)\n", + " \n", + " return phase, phase_err" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "us = 1e3 # ns\n", + "ns = 1/us # us\n", + "\n", + "samplerate = 500 # MHz\n", + "timelength = 0.2 # us\n", + "\n", + "\n", + "beacon_time = np.arange(0, timelength, 1/samplerate)\n", + "f_beacon = 100 # MHz\n", + "\n", + "\n", + "beacon_init_phase = phase2time(42/ns, f_beacon)\n", + "beacon_phase_offset = 1.2*np.pi\n", + "\n", + "beacons = np.array([\n", + " sin_delay(f_beacon, beacon_time, phase=-beacon_init_phase),\n", + " sin_delay(f_beacon, beacon_time, phase=-beacon_init_phase-beacon_phase_offset)\n", + "])\n", + "\n", + "ref_time = np.arange(0, 1/f_beacon, 1/samplerate)\n", + "ref_beacon = sin_delay(f_beacon, ref_time, t_delay=0, phase=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reference Delay" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cheat Time Delay [ns]: 6.387242824454661 \\pm [0. 0.]\n", + "Calculated Time Delay [ns]: 5.999999999999994 \\pm [-1. 1.]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "show_originals = True\n", + "\n", + "\n", + "fig, axes = plt.subplots(3,1, sharex=True, figsize=(16,4))\n", + "axes[0].set_title(\"Determine phase delay for one beacon\")\n", + "axes[-1].set_xlabel(\"Time [ns]\")\n", + "\n", + "## Originals\n", + "i=0\n", + "axes[i].set_ylabel(\"Originals\")\n", + "axes[i].plot(beacon_time/ns, \n", + " np.pad(ref_beacon, (0,len(beacons[0])-len(ref_beacon)), 'constant', constant_values=0), \n", + " label=\"Reference\",\n", + " color='g')\n", + "axes[i].plot(beacon_time/ns, \n", + " beacons[0], \n", + " label=\"Beacon 0\",\n", + " color='r'\n", + " )\n", + "axes[i].legend(loc='center right')\n", + "\n", + "for i in range(1, 3): \n", + " if i == 1:\n", + " label = \"Cheat\"\n", + " time_delay = phase2time(phase_modulo(beacon_init_phase,0), f_beacon)\n", + " time_delay_err = np.array([0,0])\n", + "\n", + " \n", + " ## Calculated\n", + " else:\n", + " label = \"Calculated\"\n", + " phase_delay, phase_err = beacon_phase_delay(samplerate, f_beacon, ref_beacon, beacons[0])\n", + " time_delay = phase2time(phase_modulo(phase_delay, 0), f_beacon)\n", + " time_delay_err = phase2time(phase_err, f_beacon)\n", + " \n", + " axes[i].set_ylabel(label)\n", + " print(\"{} Time Delay [ns]: {} \\pm {}\".format(label, time_delay/ns, time_delay_err/ns))\n", + "\n", + " ### Show original\n", + " if show_originals:\n", + " axes[i].plot(beacon_time/ns, \n", + " beacons[0],\n", + " color='r', alpha=0.4\n", + " )\n", + "\n", + " axes[i].axvline(time_delay/ns)\n", + " axes[i].plot(beacon_time/ns,\n", + " sin_delay(f_beacon, beacon_time, t_delay=time_delay),\n", + " ls = (4, (10, 4)),\n", + " label='sin')\n", + " axes[i].plot(ref_time/ns,\n", + " time_roll(ref_beacon, samplerate, time_delay, sample_shift=0),\n", + " ls = (6, (10, 4)),\n", + " label='roll')\n", + " axes[i].legend(loc='center right')\n", + "\n", + "\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Determine delay between 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": [ + "abs_time_delay, time_delay_err = beacon_time_delay(samplerate, beacons[0], beacons[1])\n", + "time_delay = abs_time_delay % (1/f_beacon)\n", + "\n", + "\n", + "fig, axes = plt.subplots(2, sharex=True, figsize=(16,4))\n", + "axes[-1].set_xlabel(\"Time [ns]\")\n", + "axes[0].set_title(\"Time Delay between two Beacons[ns]: {} \\pm {}\".format(time_delay/ns, time_delay_err/ns))\n", + "\n", + "\n", + "## Originals\n", + "i=0\n", + "axes[i].set_ylabel(\"Originals\")\n", + "axes[i].plot(beacon_time/ns, \n", + " beacons[0], \n", + " label=\"Beacon 0\",\n", + " color='g')\n", + "axes[i].plot(beacon_time/ns, \n", + " beacons[1], \n", + " label=\"Beacon 1\",\n", + " color='r'\n", + " )\n", + "axes[i].axvline(0, color='g', alpha=0.3)\n", + "axes[i].axvline(time_delay/ns, color='r', alpha=0.3)\n", + "\n", + "## Correct Beacon 1\n", + "i=1\n", + "axes[i].set_ylabel(\"Corrected Beacon 1\")\n", + "axes[i].plot(beacon_time/ns, \n", + " beacons[0], \n", + " #label=\"Beacon 0\",\n", + " color='g',\n", + " )\n", + "axes[i].plot(beacon_time/ns,\n", + " time_roll(beacons[1], samplerate, -time_delay, sample_shift=0),\n", + " ls = (6, (10, 4)),\n", + " color='orange',\n", + " label='Corrected Beacon 1'\n", + " )\n", + "\n", + "# put legend between plots\n", + "lines_labels = [ax.get_legend_handles_labels() for ax in fig.axes]\n", + "lines, labels = [sum(lol, []) for lol in zip(*lines_labels)]\n", + "\n", + "fig.subplots_adjust(hspace=0.3)\n", + "fig.legend(lines, labels ,loc='right', ncol=3, bbox_to_anchor=(0.55, 0.51))\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 +}