From c51b98b576f1777f3915c995aa32f0c26fad0431 Mon Sep 17 00:00:00 2001 From: Bjoern Ludwig Date: Fri, 8 Oct 2021 10:30:04 +0200 Subject: [PATCH] docs(Design of a digital deconvolution filter (FIR type)): introduce one more example notebook --- ...ital deconvolution filter (FIR type).ipynb | 719 ++++++++++++++++++ 1 file changed, 719 insertions(+) create mode 100644 src/PyDynamic/examples/digital_filtering/Design of a digital deconvolution filter (FIR type).ipynb diff --git a/src/PyDynamic/examples/digital_filtering/Design of a digital deconvolution filter (FIR type).ipynb b/src/PyDynamic/examples/digital_filtering/Design of a digital deconvolution filter (FIR type).ipynb new file mode 100644 index 000000000..88ead0506 --- /dev/null +++ b/src/PyDynamic/examples/digital_filtering/Design of a digital deconvolution filter (FIR type).ipynb @@ -0,0 +1,719 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a2440e75", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pathlib" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3a86db08", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy.signal as dsp\n", + "from scipy.linalg import toeplitz\n", + "from scipy.signal import lfilter, lfilter_zi\n", + "\n", + "rst = np.random.RandomState(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "215f7d02", + "metadata": {}, + "outputs": [], + "source": [ + "from PyDynamic.model_estimation.fit_filter import invLSFIR_unc\n", + "from PyDynamic.misc.SecondOrderSystem import *\n", + "from PyDynamic.misc.filterstuff import kaiser_lowpass\n", + "from PyDynamic.misc.tools import make_semiposdef, trimOrPad" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2b9a8837", + "metadata": {}, + "outputs": [], + "source": [ + "def legacy_FIRuncFilter(\n", + " y, sigma_noise, theta, Utheta=None, shift=0, blow=None, kind=\"corr\"\n", + "):\n", + " \"\"\"Uncertainty propagation for signal y and uncertain FIR filter theta\n", + "\n", + " A preceding FIR low-pass filter with coefficients `blow` can be provided optionally.\n", + "\n", + " Parameters\n", + " ----------\n", + " y : np.ndarray\n", + " filter input signal\n", + " sigma_noise : float or np.ndarray\n", + " float: standard deviation of white noise in y\n", + " 1D-array: interpretation depends on kind\n", + " theta : np.ndarray\n", + " FIR filter coefficients\n", + " Utheta : np.ndarray, optional\n", + " covariance matrix associated with theta\n", + " if the filter is fully certain, use `Utheta = None` (default) to make use of\n", + " more efficient calculations. See also the comparison given in\n", + " \n", + " shift : int, optional\n", + " time delay of filter output signal (in samples) (defaults to 0)\n", + " blow : np.ndarray, optional\n", + " optional FIR low-pass filter\n", + " kind : string\n", + " only meaningful in combination with sigma_noise a 1D numpy array\n", + " \"diag\": point-wise standard uncertainties of non-stationary white noise\n", + " \"corr\": single sided autocovariance of stationary (colored/correlated)\n", + " noise (default)\n", + "\n", + " Returns\n", + " -------\n", + " x : np.ndarray\n", + " FIR filter output signal\n", + " ux : np.ndarray\n", + " point-wise standard uncertainties associated with x\n", + "\n", + "\n", + " References\n", + " ----------\n", + "\n", + " * Elster and Link 2008 [Elster2008]_\n", + "\n", + " .. seealso:: :mod:`PyDynamic.deconvolution.fit_filter`\n", + "\n", + " \"\"\"\n", + "\n", + " Ntheta = len(theta) # FIR filter size\n", + "\n", + " # check which case of sigma_noise is necessary\n", + " if isinstance(sigma_noise, float):\n", + " sigma2 = sigma_noise ** 2\n", + "\n", + " elif isinstance(sigma_noise, np.ndarray) and len(sigma_noise.shape) == 1:\n", + " if kind == \"diag\":\n", + " sigma2 = sigma_noise ** 2\n", + " elif kind == \"corr\":\n", + " sigma2 = sigma_noise\n", + " else:\n", + " raise ValueError(\"unknown kind of sigma_noise\")\n", + "\n", + " else:\n", + " raise ValueError(\n", + " f\"FIRuncFilter: Uncertainty sigma_noise associated \"\n", + " f\"with input signal is expected to be either a float or a 1D array but \"\n", + " f\"is of shape {sigma_noise.shape}. Please check documentation for input \"\n", + " f\"parameters sigma_noise and kind for more information.\"\n", + " )\n", + "\n", + " if isinstance(\n", + " blow, np.ndarray\n", + " ): # calculate low-pass filtered signal and propagate noise\n", + "\n", + " if isinstance(sigma2, float):\n", + " Bcorr = np.correlate(blow, blow, \"full\") # len(Bcorr) == 2*Ntheta - 1\n", + " ycorr = (\n", + " sigma2 * Bcorr[len(blow) - 1 :]\n", + " ) # only the upper half of the correlation is needed\n", + "\n", + " # trim / pad to length Ntheta\n", + " ycorr = trimOrPad(ycorr, Ntheta)\n", + " Ulow = toeplitz(ycorr)\n", + "\n", + " elif isinstance(sigma2, np.ndarray):\n", + "\n", + " if kind == \"diag\":\n", + " # [Leeuw1994](Covariance matrix of ARMA errors in closed form) can be\n", + " # used, to derive this formula\n", + " # The given \"blow\" corresponds to a MA(q)-process.\n", + " # Going through the calculations of Leeuw, but assuming\n", + " # that E(vv^T) is a diagonal matrix with non-identical elements,\n", + " # the covariance matrix V becomes (see Leeuw:corollary1)\n", + " # V = N * SP * N^T + M * S * M^T\n", + " # N, M are defined as in the paper\n", + " # and SP is the covariance of input-noise prior to the observed\n", + " # time-interval (SP needs be available len(blow)-time steps into the\n", + " # past. Here it is assumed, that SP is constant with the first value\n", + " # of sigma2)\n", + "\n", + " # V needs to be extended to cover Ntheta-1 time steps more into the past\n", + " sigma2_extended = np.append(sigma2[0] * np.ones((Ntheta - 1)), sigma2)\n", + "\n", + " N = toeplitz(blow[1:][::-1], np.zeros_like(sigma2_extended)).T\n", + " M = toeplitz(\n", + " trimOrPad(blow, len(sigma2_extended)),\n", + " np.zeros_like(sigma2_extended),\n", + " )\n", + " SP = np.diag(sigma2[0] * np.ones_like(blow[1:]))\n", + " S = np.diag(sigma2_extended)\n", + "\n", + " # Ulow is to be sliced from V, see below\n", + " V = N.dot(SP).dot(N.T) + M.dot(S).dot(M.T)\n", + "\n", + " elif kind == \"corr\":\n", + "\n", + " # adjust the lengths sigma2 to fit blow and theta\n", + " # this either crops (unused) information or appends zero-information\n", + " # note1: this is the reason, why Ulow will have dimension\n", + " # (Ntheta x Ntheta) without further ado\n", + "\n", + " # calculate Bcorr\n", + " Bcorr = np.correlate(blow, blow, \"full\")\n", + "\n", + " # pad or crop length of sigma2, then reflect some part to the left and\n", + " # invert the order\n", + " # [0 1 2 3 4 5 6 7] --> [0 0 0 7 6 5 4 3 2 1 0 1 2 3]\n", + " sigma2 = trimOrPad(sigma2, len(blow) + Ntheta - 1)\n", + " sigma2_reflect = np.pad(sigma2, (len(blow) - 1, 0), mode=\"reflect\")\n", + "\n", + " ycorr = np.correlate(\n", + " sigma2_reflect, Bcorr, mode=\"valid\"\n", + " ) # used convolve in a earlier version, should make no difference as\n", + " # Bcorr is symmetric\n", + " Ulow = toeplitz(ycorr)\n", + "\n", + " xlow, _ = lfilter(blow, 1.0, y, zi=y[0] * lfilter_zi(blow, 1.0))\n", + "\n", + " else: # if blow is not provided\n", + " if isinstance(sigma2, float):\n", + " Ulow = np.eye(Ntheta) * sigma2\n", + "\n", + " elif isinstance(sigma2, np.ndarray):\n", + "\n", + " if kind == \"diag\":\n", + " # V needs to be extended to cover Ntheta time steps more into the past\n", + " sigma2_extended = np.append(sigma2[0] * np.ones((Ntheta - 1)), sigma2)\n", + "\n", + " # Ulow is to be sliced from V, see below\n", + " V = np.diag(\n", + " sigma2_extended\n", + " ) # this is not Ulow, same thing as in the case of a provided blow\n", + " # (see above)\n", + "\n", + " elif kind == \"corr\":\n", + " Ulow = toeplitz(trimOrPad(sigma2, Ntheta))\n", + "\n", + " xlow = y\n", + "\n", + " # apply FIR filter to calculate best estimate in accordance with GUM\n", + " x, _ = lfilter(theta, 1.0, xlow, zi=xlow[0] * lfilter_zi(theta, 1.0))\n", + " x = np.roll(x, -int(shift))\n", + "\n", + " # add dimension to theta, otherwise transpose won't work\n", + " if len(theta.shape) == 1:\n", + " theta = theta[:, np.newaxis]\n", + "\n", + " # NOTE: In the code below wherever `theta` or `Utheta` get used, they need to be\n", + " # flipped. This is necessary to take the time-order of both variables into\n", + " # account. (Which is descending for `theta` and `Utheta` but ascending for `Ulow`.)\n", + " #\n", + " # Further details and illustrations showing the effect of not-flipping\n", + " # can be found at https://github.com/PTB-M4D/PyDynamic/issues/183\n", + "\n", + " # handle diag-case, where Ulow needs to be sliced from V\n", + " if kind == \"diag\":\n", + " # UncCov needs to be calculated inside in its own for-loop\n", + " # V has dimension (len(sigma2) + Ntheta) * (len(sigma2) + Ntheta) --> slice a\n", + " # fitting Ulow of dimension (Ntheta x Ntheta)\n", + " UncCov = np.zeros((len(sigma2)))\n", + "\n", + " if isinstance(Utheta, np.ndarray):\n", + " for k in range(len(sigma2)):\n", + " Ulow = V[k : k + Ntheta, k : k + Ntheta]\n", + " UncCov[k] = np.squeeze(\n", + " np.flip(theta).T.dot(Ulow.dot(np.flip(theta)))\n", + " + np.abs(np.trace(Ulow.dot(np.flip(Utheta))))\n", + " ) # static part of uncertainty\n", + " else:\n", + " for k in range(len(sigma2)):\n", + " Ulow = V[k : k + Ntheta, k : k + Ntheta]\n", + " UncCov[k] = np.squeeze(\n", + " np.flip(theta).T.dot(Ulow.dot(np.flip(theta)))\n", + " ) # static part of uncertainty\n", + "\n", + " else:\n", + " if isinstance(Utheta, np.ndarray):\n", + " UncCov = np.flip(theta).T.dot(Ulow.dot(np.flip(theta))) + np.abs(\n", + " np.trace(Ulow.dot(np.flip(Utheta)))\n", + " ) # static part of uncertainty\n", + " else:\n", + " UncCov = np.flip(theta).T.dot(\n", + " Ulow.dot(np.flip(theta))\n", + " ) # static part of uncertainty\n", + "\n", + " if isinstance(Utheta, np.ndarray):\n", + " unc = np.empty_like(y)\n", + "\n", + " # use extended signal to match assumption of stationary signal prior to first\n", + " # entry\n", + " xlow_extended = np.append(np.full(Ntheta - 1, xlow[0]), xlow)\n", + "\n", + " for m in range(len(xlow)):\n", + " # extract necessary part from input signal\n", + " XL = xlow_extended[m : m + Ntheta, np.newaxis]\n", + " unc[m] = XL.T.dot(np.flip(Utheta).dot(XL)) # apply formula from paper\n", + " else:\n", + " unc = np.zeros_like(y)\n", + "\n", + " ux = np.sqrt(np.abs(UncCov + unc))\n", + " ux = np.roll(ux, -int(shift)) # correct for delay\n", + "\n", + " return x, ux.flatten() # flatten in case that we still have 2D array" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2c1ce45d", + "metadata": {}, + "outputs": [], + "source": [ + "# parameters of simulated measurement\n", + "Fs = 500e3\n", + "Ts = 1 / Fs\n", + "\n", + "# sensor/measurement system\n", + "f0 = 36e3\n", + "uf0 = 0.01 * f0\n", + "S0 = 0.4\n", + "uS0 = 0.001 * S0\n", + "delta = 0.01\n", + "udelta = 0.1 * delta\n", + "\n", + "# transform continuous system to digital filter\n", + "bc, ac = sos_phys2filter(S0, delta, f0)\n", + "b, a = dsp.bilinear(bc, ac, Fs)\n", + "\n", + "# Monte Carlo for calculation of unc. assoc. with [real(H),imag(H)]\n", + "f = np.linspace(0, 120e3, 200)\n", + "Hfc = sos_FreqResp(S0, delta, f0, f)\n", + "Hf = dsp.freqz(b, a, 2 * np.pi * f / Fs)[1]\n", + "\n", + "runs = 10000\n", + "MCS0 = S0 + rst.randn(runs) * uS0\n", + "MCd = delta + rst.randn(runs) * udelta\n", + "MCf0 = f0 + rst.randn(runs) * uf0\n", + "HMC = np.zeros((runs, len(f)), dtype=complex)\n", + "for k in range(runs):\n", + " bc_, ac_ = sos_phys2filter(MCS0[k], MCd[k], MCf0[k])\n", + " b_, a_ = dsp.bilinear(bc_, ac_, Fs)\n", + " HMC[k, :] = dsp.freqz(b_, a_, 2 * np.pi * f / Fs)[1]\n", + "\n", + "H = np.r_[np.real(Hf), np.imag(Hf)]\n", + "uAbs = np.std(np.abs(HMC), axis=0)\n", + "uPhas = np.std(np.angle(HMC), axis=0)\n", + "UH = np.cov(np.hstack((np.real(HMC), np.imag(HMC))), rowvar=0)\n", + "UH = make_semiposdef(UH)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "98d0f083", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'magnitude / au')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16, 8))\n", + "plt.errorbar(f * 1e-3, np.abs(Hf), uAbs, fmt=\".\")\n", + "plt.title(\"measured amplitude spectrum with associated uncertainties\")\n", + "plt.xlim(0, 50)\n", + "plt.xlabel(\"frequency / kHz\", fontsize=20)\n", + "plt.ylabel(\"magnitude / au\", fontsize=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "712a9be8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'phase / rad')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16, 8))\n", + "plt.errorbar(f * 1e-3, np.angle(Hf), uPhas, fmt=\".\")\n", + "plt.title(\"measured phase spectrum with associated uncertainties\")\n", + "plt.xlim(0, 50)\n", + "plt.xlabel(\"frequency / kHz\", fontsize=20)\n", + "plt.ylabel(\"phase / rad\", fontsize=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8dfceebc", + "metadata": {}, + "outputs": [], + "source": [ + "# simulate input and output signals\n", + "time = np.arange(0, 4e-3 - Ts, Ts)\n", + "# x = shocklikeGaussian(time, t0 = 2e-3, sigma = 1e-5, m0=0.8)\n", + "m0 = 0.8\n", + "sigma = 1e-5\n", + "t0 = 2e-3\n", + "x = (\n", + " -m0\n", + " * (time - t0)\n", + " / sigma\n", + " * np.exp(0.5)\n", + " * np.exp(-((time - t0) ** 2) / (2 * sigma ** 2))\n", + ")\n", + "y = dsp.lfilter(b, a, x)\n", + "noise = 1e-3\n", + "yn = y + rst.randn(np.size(y)) * noise" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6f1db74f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'signal amplitude / $m/s^2$')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16, 8))\n", + "plt.plot(time * 1e3, x, label=\"system input signal\")\n", + "plt.plot(time * 1e3, yn, label=\"measured output signal\")\n", + "plt.legend(fontsize=20)\n", + "plt.xlim(1.8, 4)\n", + "plt.ylim(-1, 1)\n", + "plt.xlabel(\"time / ms\", fontsize=20)\n", + "plt.ylabel(r\"signal amplitude / $m/s^2$\", fontsize=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "acd06d3e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Least-squares fit of an order 12 digital FIR filter to the\n", + "reciprocal of a frequency response given by 400 values\n", + "and propagation of associated uncertainties.\n", + "Final rms error = 1.545423e+01 \n", + "\n", + "\n" + ] + } + ], + "source": [ + "# Calculation of FIR deconvolution filter and its assoc. unc.\n", + "N = 12\n", + "tau = N // 2\n", + "bF, UbF = invLSFIR_unc(H, UH, N, tau, f, Fs)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5376d0e9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'FIR coefficient value')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8QAAAHpCAYAAABEAfU2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAvfklEQVR4nO3de7xldV0//tfbGbLxOpqIMmjwLURNDWxSyUy8BV6+Qv7ykqWYJlSamn7xK9oFs9SvWFrW1yBFsBQxwgHLQhRv30RxaBBEJfEGjIggjlqiwPD5/bHXwTPHc9sze5+9z6zn8/E4j73XZ33W2u89Z805+3U+a31WtdYCAAAAfXOrSRcAAAAAkyAQAwAA0EsCMQAAAL0kEAMAANBLAjEAAAC9JBADAADQS2snXcCk3eUud2n77rvvpMsAAABgDC644IJrW2t7zreu94F43333zebNmyddBgAAAGNQVV9daJ1TpgEAAOglgRgAAIBeEogBAADoJYEYAACAXhKIAQAA6CWBGAAAgF4SiAEAAOglgRgAAIBeEogBAADoJYEYAACAXpr6QFxVJ1XVN6rqM7Pa7lxV51TVF7rHO3XtVVV/VVWXVdVFVfXAyVUOAADANJv6QJzk5CSHzWl7WZIPttb2T/LBbjlJHptk/+7rqCRvXqEaAQAAWGWmPhC31j6a5Lo5zYcnOaV7fkqSI2a1v70NfCLJ+qq6+4oUCgAAwKoy9YF4AXu11q7qnn89yV7d8w1JrpjV78qubQdVdVRVba6qzddcc814KwUAAGAqrdZAfIvWWkvShtzmxNbaxtbaxj333HNMlQEAADDNVmsgvnrmVOju8Rtd+9Yk95jVb5+uDQAAAHawWgPxWUmO7J4fmeTMWe3P7GabfkiSb886tRoAAABusXbSBSylqk5NckiSu1TVlUn+OMlrk7y7qp6T5KtJntJ1f1+SxyW5LMn3kvzmihcMAADAqjD1gbi19msLrHrUPH1bkueNtyIAVpOnnnBekuS0ow+ecCUAwLRZradMAwDskqeecN4tfzABoJ8EYgAAAHpJIAYAAKCXBGIAAAB6SSAGAACglwRiAAAAekkgBgAAoJcEYgAAAHpJIAYAAKCXBGIAAAB6SSAGAACglwRiAHZbm7ZszZbLt+WTX74uD33tudm0ZeukS2JKODYASARiAHZTm7ZszbFnXJwbtt+cJNm67foce8bFgg+ODQBuIRADsFs6/uxLc/2N23dou/7G7Tn+7EsnVBHTwrEBwAyBGIDd0te2XT9UO/3h2ABghkAMwG5p7/XrhmqnPxwbAMwQiAHYLR1z6AFZt8eaHdrW7bEmxxx6wIQqYlo4NgCYsXbSBQDAOBxx0IYkyUtPvyg3bL85G9avyzGHHnBLO/3l2ABghkAMwG7riIM25NTzL0+SnHb0wROuhmni2AAgcco0AAAAPSUQAwAA0EsCMQAAAL0kEAMAANBLAjEAAAC9JBADAADQSwIxAAAAvSQQAwAA0EsCMQAAAL0kEAMAANBL1VqbdA0TtXHjxrZ58+ZJlwEAAMAYVNUFrbWN860zQgwAAEAvCcQAAAD0kkAMAABALwnEAAAA9JJADAAAQC8JxAAAAPSSQAwAAEAvCcQAAAD0kkAMAABALwnEAAAA9JJADAAAQC8JxAAAAPSSQAwAAEAvCcQAAAD0kkAMAABALwnEAAAA9JJADAAAQC8JxAAAAPSSQAwAAEAvCcQAAAD0kkAMAABALwnEAAAA9JJADAAAQC8JxAAAAPSSQAwAAEAvCcQAAAD0kkAMAABALwnEAAAA9JJADAAAQC8JxAAAAPSSQAwAAEAvCcQAAAD0kkAMAABALwnEAAAA9JJADAAAQC8JxAAAAPSSQAwAAEAvCcQAAAD0kkAMAABALwnEAAAA9JJADAAAQC8JxAAAAPSSQAwAAEAvCcQAAAD0kkAMAABALwnEAAAA9JJADAAAQC8JxAAAAPSSQAwAAEAvrZ10Abuiqr6S5LtJtie5qbW2sarunOS0JPsm+UqSp7TWvjWpGgEAAJhOu8MI8SNaawe21jZ2yy9L8sHW2v5JPtgtAwAAwA52h0A81+FJTumen5LkiMmVAgAAwLRa7YG4JXl/VV1QVUd1bXu11q7qnn89yV5zN6qqo6pqc1Vtvuaaa1aqVgAAAKbIqr6GOMkvtta2VtVdk5xTVZ+fvbK11qqqzd2otXZikhOTZOPGjT+yHgAAgN3fqh4hbq1t7R6/keQ9SR6U5OqqunuSdI/fmFyFAAAATKtVG4ir6rZVdfuZ50l+OclnkpyV5Miu25FJzpxMhQAAAEyz1XzK9F5J3lNVyeB9vLO19m9V9akk766q5yT5apKnTLBGAAAAptSqDcSttS8l+dl52r+Z5FErXxEAAACryao9ZRoAAAB2hUAMAABALwnEAAAA9JJADAAAQC8JxAAAAPSSQAwAAEAvCcQAAAD0kkAMAABALwnEAAAA9NLaYTeoqgckeXqS+yS5bWvt0V37vkkelOSc1tq3RlkkAAAAjNpQgbiq/iTJy/PDkeU2a/Wtkpya5EVJ3jSK4gAAAGBcln3KdFU9LckfJDknyYFJXjN7fWvtS0k2J3niCOsDAACAsRjmGuIXJLksyeGttYuS3DBPn88l2X8UhQEAAMA4DROI75/k7NbafEF4xteS7LVrJQEAAMD4DROIK8nNS/TZK8n3d74cAAAAWBnDBOIvJPmFhVZW1a2S/GKSS3a1KAAAABi3YQLxu5M8sKpessD6lyf56STv3OWqAAAAYMyGue3SG5M8Ocnrquop6W65VFWvT/KwJBuTfCLJiSOuEQAAAEZu2YG4tXZ9VT0iyV8m+fUka7pVL87g2uJ/SPL81tpNI68SAAAARmyYEeK01r6d5FlV9eIkP5/kJ5J8O8n5rbVrxlAfAAAAjMVQgXhGa+26JGePuBYAAABYMcNMqgUAAAC7jWWPEFfVScvs2lprz9nJegAAAGBFDHPK9LOWWN+SVPcoEAMAADDVhgnE+y3Qvj6DCbb+MMnHk7xsF2sCAACAsRvmtktfXWDVV5N8uqrOTnJRkg8keesIagMAAICxGdmkWq21K5K8N8kLR7VPAAAAGJdRzzJ9dZL9R7xPAAAAGLmRBeKqWpPkkUm+Pap9AgAAwLgMc9ulX1pkH/dI8ptJDkzyll0vCwAAAMZrmFmmP5zBLZUWUkk+muSYXSkIAAAAVsIwgfhPMn8gvjnJt5Kc31o7fyRVAQAAwJgNc9ul48ZYBwAAAKyoUc8yDQAAAKuCQAwAAEAvLXjKdFV9aSf32VprP7WT2wIAAMCKWOwa4ltl8VmlF1I7WQsAAACsmAUDcWtt3xWsAwAAAFaUa4gBAADoJYEYAACAXlr2fYhnVNWtk/x8kg1Jbj1fn9ba23exLgAAABiroQJxVT07yeuS3GmhLhlMxCUQAwAAMNWWfcp0VR2W5C1JrkryvzIIv2cmeUWSc7rlf0zy7NGXCQAAAKM1zDXEL0nyzSS/0Fp7Q9d2YWvtta21w5I8N8mTknxxxDUCAADAyA0TiB+Y5L2tte/Ot31r7a1J/j2DEWMAAACYasME4ttmcLr0jO8nucOcPpuTPHhXiwIAAIBxGyYQfz3JnrOWr0pywJw+d0yyZleLAgAAgHEbJhBfkh0D8MeSPKqqHpYkVXW/JE/p+gEAAMBUGyYQ/2uSh1bV3t3y65JsT/LhqromyaeT3D7Jn462RAAAABi9YQLxCUk2JLk2SVprn03yqAyC8rVJ3p/ksa219426SAAAABi1tcvt2Fq7McnVc9o+keQJoy4KYFhPPeG8JMlpRx884UoAAFgtlj1CXFXrx1gHAABMjaeecN4tf2wFdl/DnDJ9VVWdVlWPq6phtgMAAICpM0yw/UqSJyd5b5KtVXV8Vd1/LFUBDGHTlq3Zcvm2fPLL1+Whrz03m7ZsnXRJAKxifq9Afyw7ELfW7pPkwUn+NskeSV6S5MKquqCqXlBVdxlTjQAL2rRla4494+LcsP3mJMnWbdfn2DMu9uEFgJ3i9wr0y1CnPrfWPtVae16Su2cwWvwvSe6f5I0ZjBpvqqojRl0kwEKOP/vSXH/j9h3arr9xe44/+9IJVQTAaub3CvTLTl0L3Fq7sbX2T621J2ZwK6YXJ/lMkicmOX2E9QEs6mvbrh+qHQAW4/cK9MsoJse6NsklST6X5MYkNYJ9AizL3uvXDdUOAIvxewX6ZacDcVXdu6pek+TyJP+W5OlJvprkj0ZUG8CSjjn0gKzbY80Obev2WJNjDj1gQhUBsJr5vQL9snaYzlV1pyS/luTIJBszGA3+TpK3Jjm5tfbxkVcIsIgjDtqQJHnp6Rflhu03Z8P6dTnm0ANuaQeAYfi9Av2y7EBcVf+U5HFJfixJS/KBJCcneU9r7ftjqQ5gGY44aENOPf/yJMlpRx884WoAWO38XoH+GGaE+FeSXJrklCR/31oz9zwAALslQRj6YZhAfHBr7ZNjqwQAAABW0LIDsTAMTDN/yQcAYFijuO0SAAAArDoCMQAAAL0kEAMAANBLAjEAAAC9JBADAADQS8sOxFV1z6q6wxJ9bl9V99z1sgAAAGC8hhkh/nKSFy7R5wVdPwAAAJhqwwTi6r4AAABg1Rv1NcR3S/LfI94nAAAAjNzaxVZW1TPnNB04T1uSrElyzyS/keTiEdUGAAAAY7NoIE5ycpLWPW9JDu++5po5lfp7SV45ksoAAABgjJYKxL/ZPVaSk5JsSnLmPP22J/lmkvNaa9tGVRwAAACMy6KBuLV2yszzqjoyyabW2tvHXhUAAACM2VIjxLdorT1inIUAAADASlp2IIZJ27Rla44/+9J8bdv12Xv9uhxz6AE54qANky4LAICe8Hl09zNUIK6qhyc5JsmDktwp89+2qbXWJhq0q+qwJH+ZwezXb2mtvXaS9ews/+F+aNOWrTn2jItz/Y3bkyRbt12fY88YTGje138TAABWjs+jP2p3yCvLDq5V9fgMJtVak+TyJJcmuWk8Ze28qlqT5G+SPCbJlUk+VVVntdY+O9nKhuM/3I6OP/vSW/4tZlx/4/Ycf/alvfz3AABgZfk8uqPdJa8MM5J7XJIbkzy+tfb+8ZQzEg9Kcllr7UtJUlXvyuBWUasqEPsPt6Ovbbt+qHYAABgln0d3tLvklflOeV7I/ZKcNuVhOEk2JLli1vKVXdstquqoqtpcVZuvueaaFS1uufyH29He69cN1Q4AAKPk8+iOdpe8Mkwg/q8k142rkJXUWjuxtbaxtbZxzz33nHQ58/IfbkfHHHpA1u2xZoe2dXusyTGHHjChigAA6BOfR3e0u+SVYQLxB5McPK5CRmhrknvMWt6na1tV/Ifb0REHbchrnnT/bFi/LpVkw/p1ec2T7r+qTscAAGD18nl0R7tLXqnW2vI6Vv1kkvOTvCnJn7XlbrjCqmptkv9M8qgMgvCnkjy9tXbJfP03btzYNm/evIIVLt/uMGsbAACwe1oteaWqLmitbZx33RCB+KQk+yZ5eJKvJrkwybZ5urbW2nN2ptBRqarHJXljBjNin9Ra+7OF+k5zIAYAAGDXLBaIh5ll+lmznu/bfc2nJZloIG6tvS/J+yZZA4zTpi1b89LTL8oN22/Ohin+axwAsLqtlhFA2FnDBOL9xlYFsGwz93y7YfvNSVbvPd8AgOm2u9xnFhaz7EDcWvvqOAsBlmd3uecbADDdfOagD4aZZRqYArvLPd8AgOnmMwd9MHQgrqr/WVXvqqpPV9Vls9rvU1UvrSp/LoIx2l3u+QYATDefOeiDZQfiGjglyaYkT07yU9nxuuJvJXl1kt8YZYHAjnaXe74BANPNZw76YJgR4t9N8owkb0ty5ySvn72ytfb1JP+e5PEjqw74EW4KDwCsBJ856INhZpl+TpJPJ3lua61V1Xw3MP5CkkNHUhmwoCMO2uCXEQAwdj5zsLsbZoT4gCQfaq3NF4RnfCPJnrtWEgAAAIzfMIH4piQ/vkSfDUn+a+fLAQAAgJUxTCD+bJJDqqrmW1lVP57kkUm2jKIwAAAAGKdhAvHfJ7l3kjdU1Q7bVdWaJH+RZO8kJ4+sOgAAABiTYSbVOiHJE5O8IIPbLn03Sarq9CQPySAMn9lae8eoiwQAAIBRW/YIcWtte5InJPmTJLdOcq8kleRJSW6T5FUZBGUAAACYesOMEKe1dlOS46rqlRkE4p9I8u0kn+8CMwAAAKwKQwXiGd2tly4dcS0AAACwYoaZVAsAAAB2GwuOEFfVuUlakiNba1d2y8vRWmuPGkl1AAAAMCaLnTJ9SAaB+Dazlpej7UI9AAAAsCIWDMSttVsttgwAAACrmZALAABALwnEAAAA9NKyA3FV/XZVfbGq9l5g/YZu/XNGVx4AAACMxzAjxE9PclVr7WvzrWytbU1yZZLfGEVhAAAAME7DBOIDknx6iT4XJbn3zpcDAAAAK2OYQHzHJNuW6POdJHfa6WoAAABghQwTiK9K8oAl+jwgyTU7Xw4AAACsjGEC8YeSHFZVvzjfyqp6WJLHJvngKAoDAACAcRomEP+fJDck+UBV/UVV/XJV/Uz3+IYk5yT5QdcPAAAAptra5XZsrV1aVU9J8s4kL0rywlmrK4Prh5/eWvvcSCsEAACAMVh2IE6S1tq/VNX/SPKsJA9Osj6DibY+keSU1to3R1wfAAAAjMVQgThJutD752OoBQAAAFbMMNcQAwAAwG5jwRHiqvql7un5rbXvz1peUmvto7tcGQAAAIzRYqdMfzhJS3KfJP85a3k51uxSVQAAADBmiwXiP8kgAF87ZxkAAABWvQUDcWvtuMWWAQAAYDVbcFKtqrquqo6ZtfxHw1xHDAAAANNssVmm1ydZN2v5uCSHjLEWAAAAWDGLBeKrk+yzUoUAAADASlpsUq1PJHlGVW1PclXXdkhVLbXP1lp71SiKAwAAgHFZLBAfk+ReSY6e1XZIlj5tuiURiAEAAJhqi80yfVlV3T/Jfkk2ZHAf4pOTnLIilQEAAMAYLTZCnNbazUm+mOSL3anSX2mtfWQlCgMAAIBxWuy2S/9RVUfNavrNJJvGXhEAAACsgMVmmT4wyd1mLZ+U5IhxFgMAAAArZbFA/M0kd5m1vOT00gAAALBaLHYN8YUZ3HZpa35426UDq+qZS+20tfb2EdQGAAAAY7NYIH5ZkvcleU0Gt1JKksO7r4VU11cgBgAAYKotdtulC6rqp5M8KIPbLp2c5MzuCwAAAFa1pW679N0kH0ySqjo5yYWtNfchBgAAYNVbNBDPsV+SbWOqAwAAAFbUsgNxa+2rM8+r6rZJ7pXkdq21j42jMAAAABinxW679COqap+q+qck30qyOcmHZq37xar6bFUdMtIKAQAAYAyWHYir6u5JPpnBLNP/nOS87Hhv4k8muWuSp46yQACG99QTzstTTzhv0mUAAEy1YUaI/ziDwPuY1tqTkpwze2Vr7cYkH0vy0NGVBwAAAOMxTCB+XJKzWmsfWqTP5Un23rWSAABYac4sAfpomEC8V5IvLNHnxiS33flyAAAAYGUME4ivS3KPJfrcK8nXd74cAAAAWBnDBOJ/T/LEqrrbfCurav8kh2XWzNMAAAAwrYYJxMcn+fEkH6mqxya5TTK4J3G3/N4kNyf585FXCQAAACO2drkdW2ufrKqjk7w5g9suzfhO93hTkme31i4ZYX0AAAAwFsOMEKe1dlKS+yX5qyTnJ/likv9I8n+TPKC19o6RVwjAUDZt2Zotl2/LJ798XR762nOzacvWSZcETDk/N4C+WvYI8YzW2heS/P4YagFgF23asjXHnnFxbth+c5Jk67brc+wZFydJjjhowyRLA6aUnxtAnw01QgzAdDv+7Etz/Y3bd2i7/sbtOf7sSydUETDt/NwA+mzoEeKqekiS30pyUJL1Sb6d5IIkb2utfXyk1QEwlK9tu36odgA/N4A+G2qEuKr+NIPbLz07g0C8X5IDkzwnyceq6tWjLhCA5dt7/bqh2gH83AD6bNmBuKqenOTlSS7PYIT4fyRZ1z3+Vtf+v6vqKWOoE4BlOObQA7JujzU7tK3bY02OOfSACVUETDs/N4A+G+aU6d9LcnWSn2+tXTur/StJTqqqs5J8Jsnzkrx7ZBUCsGwzE+C89PSLcsP2m7Nh/bocc+gBJsYBFuTnBtBnwwTin03y9jlh+BattWur6h+TPHMklQGwU444aENOPf/yJMlpRx884WqA1cDPDaCvhrmGeG2S7y3R53vZiYm6AAAAYKUNE4i/mOQJVTXvNl3747p+AAAAMNWGCcTvTHKfJGdW1f6zV1TVTyU5Pcl9u34AAAAw1YY5vfkvkhyW5PFJHltVX0tyVZK7JdmQQbj+f10/AAAAmGrLHiFurd2Q5DFJXpHky0n2SfLzSe7RLb8iyaO6fgAAADDVhpoAq7V2Y5LXJHlNVd0uyR2TfLu19l/jKA4AgJVhdmmgj3Z6RuguBAvCAAAArErLDsRV9XMZXD98Qmvt6nnW3y3JUUnOaq1dOLIKARiakR4AgKUNM8v0S5L8VpJvLLD+6iTPSfLiXS0KAAAAxm2YQHxwkg+11tp8K7v2c5M8dBSFLaaqjquqrVV1Yff1uFnrjq2qy6rq0qo6dNy1AAAAsDoNcw3x3ZJcuUSfryW5+86XM5Q3tNZeP7uhqu6b5GlJfibJ3kk+UFX3aq1tX6GaAAAAWCWGGSH+XpI9l+izZ5If7Hw5u+zwJO9qrf2gtfblJJcledAE6wEAAGBKDROIL0xyeHe7pR9RVXfIIJBeuOtlLcvzq+qiqjqpqu7UtW1IcsWsPld2bQAAALCDYQLxiRmMAJ9TVQ+YvaKqfjbJ+5Pcpeu3y6rqA1X1mXm+Dk/y5iQ/leTAJFcl+fMh931UVW2uqs3XXHPNKMoFAABglVn2NcSttdOq6rFJnplkS1VdnWRrBiOweyWpJG9vrZ06isJaa49eTr+q+rsk/9wtbk1yj1mr9+na5u77xHTBfePGjfNOEgYAAMDubZgR4rTWnpXkt5N8NoNJtn6ue7wkyVHd+rGrqtkTd/1Kks90z89K8rSqunVV7Zdk/yTnr0RNAAAArC7DzDKd5Iejq1V1myTrk2xrrX1v1IUt4XVVdWCSluQrSY7uarukqt6dQWC/KcnzzDANAADAfIYOxDO6ELzSQXjmtZ+xyLo/S/JnK1gOAAAAq9BQp0wDAADA7kIgBgAAoJcEYgAAAHpJIAYAAKCXBGIAAAB6SSAGAACgl0YaiKvqzlV1/Cj3CQAAAOMwkkBcVberqj9O8qUkLx7FPgEAAGCclgzEVfVTVfXWqrqoqi6oqjdW1V1mrX9+BkH4j5LskeQN4ysXAAAARmPtYiur6ieTfDLJnZJU13xgkkdW1UOTvDvJLye5IcnfJHl1a+3rY6sWAAAARmTRQJzk5UnunOR9SU7u2n4rgxD84SQHJTk9yUtaa1eMp0QAAAAYvaUC8SOTXNJae8JMQ1WdkeQzGYwU/2Vr7ffHVx4AAACMx1LXEO+T5NzZDa21m5Oc0y2+fhxFAQAAwLgtFYhvneSb87RflyStta0jrwgAAABWwEjvQwwAAACrxVLXECfJIVX1I21JUlV/mB/OPj2jtdZeteulAQAAwPgsKxB3X/N55aznLYNw3JIIxAAAAEy1pQLxK5dYDwAAAKvSooG4tSYQAwAAsFsyqRYAAAC9JBADAADQS4ueMl1Vf7QT+zTLNAAAAFNvqUm1jssPZ49eilmmAQAAWDXMMg0AAEAvmWUaAACAXjKpFgAAAL20aCCuqmdW1QNWqhgAAABYKUuNEJ+c5IjZDVV1ZFWdO66CAAAAYCXszCnT+yZ5+IjrAAAAgBXlGmIAAAB6SSAGAACglwRiAAAAemk5gbiNvQoAAABYYWuX0ee4qjpubmNVbV+gf2utLWe/AAAAMDHLCa415D6H7Q8AAAArbtFA3FpzjTEAAAC7JYEXAACAXhKIAQAA6CWBGAAAgF4SiAEAAOglgRgAAIBeEogBAADoJYEYAACAXhKIAQAA6CWBGAAAgF4SiAEAAOglgRgAAIBeEogBAADoJYEYAACAXhKIAQAA6CWBGAAAgF4SiAEAAOglgRgAAIBeEogBAADoJYEYAACAXhKIAQAA6CWBGAAAgF4SiAEAAOglgRgAAIBeEogBAADoJYEYAACAXhKIAQAA6CWBGAAAgF4SiAEAAOglgRgAAIBeEogBAADoJYEYAACAXhKIAQAA6CWBGAAAgF4SiAEAAOglgRgAAIBeEogBAADoJYEYAACAXhKIAQAA6CWBGAAAgF4SiAEAAOglgRgAAIBeEogBAADoJYEYAACAXpraQFxVT66qS6rq5qraOGfdsVV1WVVdWlWHzmo/rGu7rKpetvJVAwAAsFpMbSBO8pkkT0ry0dmNVXXfJE9L8jNJDkvyf6tqTVWtSfI3SR6b5L5Jfq3rCwAAAD9i7aQLWEhr7XNJUlVzVx2e5F2ttR8k+XJVXZbkQd26y1prX+q2e1fX97MrUzEAAACryTSPEC9kQ5IrZi1f2bUt1A4AAAA/YqIjxFX1gSR3m2fVK1prZ47xdY9KclSS3POe9xzXywAAADDFJhqIW2uP3onNtia5x6zlfbq2LNI+93VPTHJikmzcuLHtRA0AAACscqvxlOmzkjytqm5dVfsl2T/J+Uk+lWT/qtqvqn4sg4m3zppgnQAAAEyxqZ1Uq6p+JcmbkuyZ5F+q6sLW2qGttUuq6t0ZTJZ1U5Lntda2d9s8P8nZSdYkOam1dsmEygcAAGDKVWv9PmN448aNbfPmzZMuAwAAgDGoqgtaaxvnW7caT5kGAACAXSYQAwAA0EsCMQAAAL0kEAMAANBLAjEAAAC9JBADAADQSwIxAAAAvSQQAwAA0EsCMQAAAL0kEAMAANBLAjEA9MhTTzgvTz3hvEmXAQBTQSAGAACglwRiAAAAekkgBgAAoJcEYgAAAHpJIAYAAKCXBGIAAAB6SSAGAACglwRiAAAAekkgBgAAoJcEYgAAAHpJIAYAAKCXBGIAAAB6SSAGgJ7YtGVrtly+LZ/88nV56GvPzaYtWyddEgBMlEAMAD2wacvWHHvGxblh+81Jkq3brs+xZ1wsFAPQawIxAPTA8Wdfmutv3L5D2/U3bs/xZ186oYoAYPIEYgDoga9tu36odgDoA4EYAHpg7/XrhmoHgD4QiAGgB4459ICs22PNDm3r9liTYw49YEIVAcDkrZ10AQDA+B1x0IYkyUtPvyg3bL85G9avyzGHHnBLOwD0kUAMAD1xxEEbcur5lydJTjv64AlXAwCT55RpAAAAekkgBgAAoJcEYgAAAHpJIAYAAKCXBGIAAAB6SSAGAACglwRiAAAAekkgBgAAoJcEYgAAAHpJIAYAAKCXBGIAAAB6SSAGAACgl9ZOugAAYOWcdvTBky4BAKaGEWIAAAB6SSAGAACglwRiAAAAekkgBgAAoJcEYgAAAHpJIAYAAKCXBGIAAAB6SSAGAACglwRiAAAAekkgBgAAoJcEYgAAAHpJIAYAAKCXBGIAAAB6SSAGAACglwRiAAAAekkgBgAAoJcEYgAAAHpJIAYAAKCXBGIAAAB6qVprk65hoqrqmiRfnXQdS7hLkmsnXQRTybHBYhwfLMSxwUIcGyzEscFipv34+MnW2p7zreh9IF4Nqmpza23jpOtg+jg2WIzjg4U4NliIY4OFODZYzGo+PpwyDQAAQC8JxAAAAPSSQLw6nDjpAphajg0W4/hgIY4NFuLYYCGODRazao8P1xADAADQS0aIAQAA6CWBeMpV1WFVdWlVXVZVL5t0PUyHqrpHVX2oqj5bVZdU1QsnXRPTparWVNWWqvrnSdfC9Kiq9VV1elV9vqo+V1UHT7ompkdV/X73O+UzVXVqVf34pGtiMqrqpKr6RlV9ZlbbnavqnKr6Qvd4p0nWyGQscGwc3/1euaiq3lNV6ydY4tAE4ilWVWuS/E2Sxya5b5Jfq6r7TrYqpsRNSV7SWrtvkockeZ5jgzlemORzky6CqfOXSf6ttXbvJD8bxwidqtqQ5AVJNrbW7pdkTZKnTbYqJujkJIfNaXtZkg+21vZP8sFumf45OT96bJyT5H6ttQck+c8kx650UbtCIJ5uD0pyWWvtS621G5K8K8nhE66JKdBau6q19h/d8+9m8KF2w2SrYlpU1T5JHp/kLZOuhelRVXdM8ktJ3pokrbUbWmvbJloU02ZtknVVtTbJbZJ8bcL1MCGttY8muW5O8+FJTumen5LkiJWsiekw37HRWnt/a+2mbvETSfZZ8cJ2gUA83TYkuWLW8pURepijqvZNclCST064FKbHG5O8NMnNE66D6bJfkmuSvK07nf4tVXXbSRfFdGitbU3y+iSXJ7kqybdba++fbFVMmb1aa1d1z7+eZK9JFsPUenaSf510EcMQiGEVq6rbJfmnJC9qrX1n0vUweVX1hCTfaK1dMOlamDprkzwwyZtbawcl+e845ZFOdz3o4Rn84WTvJLetqt+YbFVMqza4TY1b1bCDqnpFBpf1vWPStQxDIJ5uW5PcY9byPl0bpKr2yCAMv6O1dsak62FqPDTJE6vqKxlcZvHIqvqHyZbElLgyyZWttZmzSU7PICBDkjw6yZdba9e01m5MckaSX5hwTUyXq6vq7knSPX5jwvUwRarqWUmekOTX2yq7r69APN0+lWT/qtqvqn4sg8ktzppwTUyBqqoMrgP8XGvtLyZdD9OjtXZsa22f1tq+GfzMOLe1ZpSHtNa+nuSKqjqga3pUks9OsCSmy+VJHlJVt+l+xzwqJl1jR2clObJ7fmSSMydYC1Okqg7L4FKtJ7bWvjfpeoYlEE+x7uL05yc5O4NfSu9urV0y2aqYEg9N8owMRv8u7L4eN+migKn3e0neUVUXJTkwyasnWw7Tojtz4PQk/5Hk4gw+I5440aKYmKo6Ncl5SQ6oqiur6jlJXpvkMVX1hQzOKHjtJGtkMhY4Nv46ye2TnNN9Jv3biRY5pFplI9oAAAAwEkaIAQAA6CWBGAAAgF4SiAEAAOglgRgAAIBeEogBAADoJYEYAKZEVW2sqnOq6tqqalV14ax1+1fVe6rq6926bV37cd3yIbvwuq2qPryL5a+Yqtq3q/nkMb/Oyd3r7DvO1wFgcgRiAMauCxWLfT1rVt+ZgHfcnH0cN89236+qy6rqxNUeWqrqDkn+JcmDkrwrySuT/G23bk2STUkel+Sfu3Wr/h6gVfWsud9/AFhJayddAAC98soF2i8cYh8fSfLh7vlPJHlkkucm+dWqenBr7Qs7Xd1kPSjJXZO8orX26jnr9kty3yR/11o7as66v84gQF++C699nyTf24XtV9rWDGr+9qQLAWB1E4gBWDGtteNGsJsPz95PVd0qyXszGD19eZLfHMFrTMLe3ePXhlnXWrs2ybW78sKttc/vyvYrrbV2Y5JVVTMA08kp0wCsaq21m5Oc3C3+/LDbV9VTq+qDVXVddwr2V6rq1KraOKffravqZVV1cVV9r6q+U1Ufq6qnLLLvB1fV6d11vzdU1RVVdUJV7T2rz75V1ZKc0jW9bfap5N26j3Tr/njWuuO67Re8hriq7l1VJ3Xv6QdV9Y2u5t+Z02/ea4iram1V/W5VfaJ7v9+rqi1V9fzuDxGz+95yXW/3/F3dtdDfr6rNVfWEOf0/nORt87znJa/ZXega4tnX/FbV0d336vtVdXV3Wv0dF9jfo7t/l//ujoNNVXXvJWpY8nvb9dvU1fSCefbxqm7dWxd7LQDGxwgxALuTG5fbsaoqg0B2ZAYjrGckuSbJPkkekeTSJJu7vj+W5OwkD89gZPJvktwmya8mOa2qDmytvXzO/p+d5MQkP0hyVpIrkuyf5LeS/M+qekhr7fIk2zI4lfzAJIcnOTM/PIX8wm7dvl2ds08Xn3lc6P09Psk/Jrl1kn9LcmqS9Ul+NslLk7x5ie33yGDk/dDu3+KdSb7f/du8KcmDkzxjnk1/Msn5Sb6U5O+T3DnJU5OcWVWPbq19qOt3cvfe577ndO274nVd3e9N8v6u5ucm+ekMTrG/RVX9apLTktzQPV6V5BeTnJfkovl2PsT3NkmenWRLktdV1cdaa1u6fTwqgzMaPpvk93bx/QKwkwRiAFbM3ImyOl9prZ28C/tck+Q53eL/G2LT52YQMj+V5DGttVuuR+32eddZfV+SQRj+1yRPbK3d1PV7ZQbh79iq+ufW2se79ntlMCHWV5I8vLW2dda+H5VBSPvLJL/SWtuW5LhuYqnDk2ya8+9xYTf6e2TmnC6+kKq6SwYBdm2SR7bWPjJn/T5L7SPJKzIIlX+d5EWtte3dtmsyCIPPrqrTW2tnztnukCTHtdZuuV68qt6ZQSg/JsmHkqS1dvLgbxLzvudd9ZAk958JpVW1Nsm5SR5RVQ9qrZ3ftd8uyQlJbk7ysNba5lk1vyHJi+bueJjvbfc+r6uqX8vgjxmnVdUDk9w2yT9kEKif0lpbTddvA+xWBGIAVtIfz9P2kfzwlOflOGRWsL5zksckuXcGI22vGmI/M6NyR88Ow0nShb+rZjU9O0lL8uKZMNz1+0ZVvSrJWzIYHfx4t+p3kuyR5IWzA1O3zQer6qwMRhJv31r77hA1L9eRSe6Q5K/mhuGuhisX27g7Hfr3knw9ye/PhOFu2+1V9ZIMrtX+9QxGd2f7apI/nfN6Z1fV5RlMHLYS/mTWCG1aazdV1duSPKyr4fxu1eEZHENvnx2GO8dl8B7nnmY99Pe2tfbxqvrDJK/JIIDvmeRuSZ7bWrtkl98tADtNIAZgxbTWagS7eXj3NduFSQ6ZG2wXUlW3TXK/JFfPnMK6SN/bZ3Cq7dYFJp86t3s8aFbbwTO1VtV81zXfNcmaJPdKcsFyah7SQ7rHf93J7e+VQVD8QpI/6EZy57o+g5me57pwdoCe5Yr88N9l3OaG25nXT5I7zWp7YPc43x8Nvl2D+0DPPdZ29nv7fzI4dfvp3fKprbW3LPQGAFgZAjEAq80rW2vHdaOYG5L8ryQvSPLuqnpsN8nWUtZ3j1sX69SZGSG8aoH1M+3rZ7X9RPd4zBL7vt0yXn9nrO8el/P+5jNT//6Zf1R/xnz1b1ug701Zuck856thZmR/zay2me/t1Qvs5+vztO3U97a11qrqjCS/3DW9cYntAVgBZpkGYFVqrd3cWruitfbCJKdnEDSev8zNt3WPG5bRd2bU+W4LrL/7nH6zn9+xtVaLfP3IyOSIbOsel/P+5jNT/3uWqH+/XS91ombe514LrJ/ve75T39uq2j/J65N8K4Nrlt9SVT8+ijcBwM4TiAHYHbwkgwmK/qiq7rBU59bafyf5TJK9quqgJfp+N8kXk2zoQs1cj+ge/2NW2ye6x4ctVcuYzLz+Y3dy+89nEKof0s02PS4zp1avWbTX+Mx8z+aeFp3uFk0HzrPN0N/bqrp1BjNY3zaDGbdfk+T+MUoMMHECMQCrXjeB0t9lcDrrS5a52V91jyfMvT9tVd2qqu4+q+mkJJXk+G6W5Zl+d0nyh7P6zPjrDG4B9YZuVuIdVNWPVdU4w/IpSb6T5Heq6pfmef1FZ5nuJg57Uwaj339VVevm2cfdq+q+u1jnN7vHe+7ifnbWmRmM2D695tx3OoNJtea7b/HOfG9fn8E15q9rrZ2TwWno/57k6Kp68q69BQB2hWuIAdhdvDqD2y/9flW9qbV27RL935LBKN8zknyhqs7M4D7Ee2dwr9qTMghFySDQPDaDWYk/XVXvy+A+xE/OYBKl17XWbrnlU2vt8929ak9KcklV/VuS/8xgduJ7dq97TQazY49ca+3aqnp6BqeSf6iq/jWDe+reIckDktwjyVKnO78qg3sW/3YGsyafm8E1yXfN4Nrih2Zwa6bP7kKp5yX5XpIXVdVP5IfX7L5puROk7YrW2n9V1VEZjN5+rKpm34f4fkk+muSX5mwz1Pe2qn4lg1P5P5nkD7p9bO9uxXRhBqdOX9Ba+9KY3y4A8zBCDMBuobV2VZI3J7l9kmOX0b+11p6Z5DeSfC7JU5K8OIPTZz+W5KxZfW/I4PZOr+iafi+DWxt9IcnTW2v/e579/0OSn0vyjgxC6PO71/rpDILq7+7M+1yu1tq/JNnYvf5BGUw+9uQMbh/1mmVsf2OSI5I8M8mlSZ6Qwej7YRl8fvjDbt+7UuO3kvx/GYTqZ2UQwl+VHWeCHqvW2ukZvKcLMjgGfjvJdRnMJv3lBbZZ1ve2qu6Z5K0ZXHf8tDm37Loig9t53SHJu6rqx8bw9gBYQrXWJl0DAAAArDgjxAAAAPSSQAwAAEAvCcQAAAD0kkAMAABALwnEAAAA9JJADAAAQC8JxAAAAPSSQAwAAEAvCcQAAAD0kkAMAABAL/3/N4pWR1zSkwoAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16, 8))\n", + "plt.errorbar(range(N + 1), bF, np.sqrt(np.diag(UbF)), fmt=\"o\")\n", + "plt.xlabel(\"FIR coefficient index\", fontsize=20)\n", + "plt.ylabel(\"FIR coefficient value\", fontsize=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "dbfe0c57", + "metadata": {}, + "outputs": [], + "source": [ + "fcut = f0 + 10e3\n", + "low_order = 100\n", + "blow, lshift = kaiser_lowpass(low_order, fcut, Fs)\n", + "shift = tau + lshift" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "654bb06d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16, 10))\n", + "HbF = (\n", + " dsp.freqz(bF, 1, 2 * np.pi * f / Fs)[1] * dsp.freqz(blow, 1, 2 * np.pi * f / Fs)[1]\n", + ")\n", + "plt.semilogy(f * 1e-3, np.abs(Hf), label=\"measured frequency response\")\n", + "plt.semilogy(f * 1e-3, np.abs(HbF), label=\"inverse filter\")\n", + "plt.semilogy(f * 1e-3, np.abs(Hf * HbF), label=\"compensation result\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "db3ec711", + "metadata": {}, + "outputs": [], + "source": [ + "xhat, Uxhat = legacy_FIRuncFilter(yn, noise, bF, UbF, shift, blow)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "562090fe", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1.0, 1.0)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16, 8))\n", + "plt.plot(time * 1e3, x, label=\"input signal\")\n", + "plt.plot(time * 1e3, yn, label=\"output signal\")\n", + "plt.plot(time * 1e3, xhat, label=\"estimate of input\")\n", + "plt.legend(fontsize=20)\n", + "plt.xlabel(\"time / ms\", fontsize=22)\n", + "plt.ylabel(\"signal amplitude / au\", fontsize=22)\n", + "plt.tick_params(which=\"both\", labelsize=16)\n", + "plt.xlim(1.9, 2.4)\n", + "plt.ylim(-1, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ba4632f0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.9, 2.4)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16, 10))\n", + "plt.plot(time * 1e3, Uxhat)\n", + "plt.xlabel(\"time / ms\", fontsize=22)\n", + "plt.ylabel(\"signal uncertainty / au\", fontsize=22)\n", + "plt.subplots_adjust(left=0.15, right=0.95)\n", + "plt.tick_params(which=\"both\", labelsize=16)\n", + "plt.xlim(1.9, 2.4)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.9 (PyDynamic)", + "language": "python", + "name": "pydynamic-py39" + }, + "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.6" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file