diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..a61a6f2 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,12 @@ +repos: + - repo: https://github.com/psf/black + rev: 24.10.0 + hooks: + - id: black + language_version: python3 + + - repo: https://github.com/pre-commit/mirrors-isort + rev: v5.9.3 + hooks: + - id: isort + language_version: python3 \ No newline at end of file diff --git a/README.md b/README.md index cc34a9f..9a7f996 100644 --- a/README.md +++ b/README.md @@ -23,17 +23,26 @@ mag, phase, freq = sqil.extract_h5_data(path, ['mag_dB', 'phase', 'ro_freq']) ## Development -Install poetry if you haven't already (`pip install poetry`) and then run the following +1. Install poetry if you haven't already +```bash +$ pip install poetry +``` +2. Install the required packages using poetry ```bash $ poetry install +``` + +3. Install the pre-commit hooks. This will automatically format your code before committing +```bash $ poetry run pre-commit install ``` -Start the virtual environment +4. Start the virtual environment ```bash $ poetry shell ``` + To exit the virtual environment just use `exit` #### Test your changes @@ -44,13 +53,17 @@ $ pip install -e . --user **Anaconda** If you want to install in a specific anaconda environment + - from your poetry shell build the package + ```bash $ poetry run build ``` + - open an anaconda shell - activate the desired environemnt - pip install the wheel file (.whl) in the dist folder of the sqil-core project + ```bash $ pip install PATH_TO_SQIL_CORE_FOLDER/dist/SQIL_CORE-VERSION.whl ``` diff --git a/poetry.lock b/poetry.lock index 00402b9..e79d1ce 100644 --- a/poetry.lock +++ b/poetry.lock @@ -533,17 +533,20 @@ files = [ [[package]] name = "isort" -version = "5.13.2" +version = "5.9.3" description = "A Python utility / library to sort Python imports." optional = false -python-versions = ">=3.8.0" +python-versions = ">=3.6.1,<4.0" files = [ - {file = "isort-5.13.2-py3-none-any.whl", hash = "sha256:8ca5e72a8d85860d5a3fa69b8745237f2939afe12dbf656afbcb47fe72d947a6"}, - {file = "isort-5.13.2.tar.gz", hash = "sha256:48fdfcb9face5d58a4f6dde2e72a1fb8dcaf8ab26f95ab49fab84c2ddefb0109"}, + {file = "isort-5.9.3-py3-none-any.whl", hash = "sha256:e17d6e2b81095c9db0a03a8025a957f334d6ea30b26f9ec70805411e5c7c81f2"}, + {file = "isort-5.9.3.tar.gz", hash = "sha256:9c2ea1e62d871267b78307fe511c0838ba0da28698c5732d54e2790bf3ba9899"}, ] [package.extras] -colors = ["colorama (>=0.4.6)"] +colors = ["colorama (>=0.4.3,<0.5.0)"] +pipfile-deprecated-finder = ["pipreqs", "requirementslib"] +plugins = ["setuptools"] +requirements-deprecated-finder = ["pip-api", "pipreqs"] [[package]] name = "jinja2" @@ -1859,4 +1862,4 @@ watchmedo = ["PyYAML (>=3.10)"] [metadata] lock-version = "2.0" python-versions = "^3.10" -content-hash = "2f82f0e04fe5054d38372289fc6de591400b6a468bd41d85baff53bc5b057722" +content-hash = "987f1ea77443462dc4db8b10d21c53155cc59bfbc37decd8808912055cb5c991" diff --git a/pyproject.toml b/pyproject.toml index edbbb3e..5a7574e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -17,11 +17,11 @@ scipy = "^1.14.1" h5py = "^3.12.1" matplotlib = "^3.9.3" seaborn = "^0.13.2" +isort = "5.9.3" [tool.poetry.group.dev.dependencies] black = "^24.10.0" -isort = "^5.13.2" pre-commit = "^4.0.1" mkdocs = "^1.6.1" mkdocs-material = "^9.5.48" diff --git a/sketching/kit.ipynb b/sketching/kit.ipynb new file mode 100644 index 0000000..2c8af1b --- /dev/null +++ b/sketching/kit.ipynb @@ -0,0 +1,671 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy.optimize as spopt\n", + "from scipy.constants import hbar" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import sqil_core as sqil\n", + "\n", + "# Deep\n", + "deep = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00075-cavity_check_2024-12-12T171954'\n", + "# Tiny\n", + "tiny = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00032-cavity_check_2024-12-12T144742'\n", + "# Good\n", + "good = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00077-cavity_check_2024-12-12T172355'\n", + "# Bad\n", + "bad = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00062-cavity_check_2024-12-12T160601'\n", + "# Very bad\n", + "very_bad = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00053-cavity_check_2024-12-12T155026'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calibration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cable delay" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import scipy.optimize as spopt\n", + "from scipy import stats\n", + "\n", + "def get_delay(f_data,z_data,delay=None,ignoreslope=True,guess=True):\n", + " '''\n", + " ignoreslope option not used here\n", + " retrieves the cable delay assuming the ideal resonance has a circular shape\n", + " modifies the cable delay until the shape Im(S21) vs Re(S21) is circular\n", + " see \"do_calibration\"\n", + " '''\n", + " maxval = np.max(np.absolute(z_data))\n", + " z_data = z_data/maxval\n", + " A1, A2, A3, A4, fr, Ql = fit_skewed_lorentzian(f_data,z_data)\n", + " if ignoreslope==True:\n", + " A2 = 0\n", + " else:\n", + " z_data = (np.sqrt(np.absolute(z_data)**2-A2*(f_data-fr))) * np.exp(np.angle(z_data)*1j) #usually not necessary\n", + " if delay==None:\n", + " if guess==True:\n", + " delay = guess_delay(f_data,z_data)\n", + " else:\n", + " delay=0.\n", + " delay = fit_delay(f_data,z_data,delay,maxiter=200)\n", + " params = [A1, A2, A3, A4, fr, Ql]\n", + " return delay, params\n", + "\n", + "def fit_skewed_lorentzian(f_data, z_data):\n", + " amplitude = np.absolute(z_data)\n", + " amplitude_sqr = amplitude**2\n", + " A1a = np.minimum(amplitude_sqr[0],amplitude_sqr[-1])\n", + " A3a = -np.max(amplitude_sqr)\n", + " fra = f_data[np.argmin(amplitude_sqr)]\n", + " def residuals(p,x,y):\n", + " A2, A4, Ql = p\n", + " err = y -(A1a+A2*(x-fra)+(A3a+A4*(x-fra))/(1.+4.*Ql**2*((x-fra)/fra)**2))\n", + " return err\n", + " p0 = [0., 0., 1e3]\n", + " p_final = spopt.leastsq(residuals,p0,args=(np.array(f_data),np.array(amplitude_sqr)))\n", + " A2a, A4a, Qla = p_final[0]\n", + "\n", + " def residuals2(p,x,y):\n", + " A1, A2, A3, A4, fr, Ql = p\n", + " err = y -(A1+A2*(x-fr)+(A3+A4*(x-fr))/(1.+4.*Ql**2*((x-fr)/fr)**2))\n", + " return err\n", + " p0 = [A1a, A2a , A3a, A4a, fra, Qla]\n", + " p_final = spopt.leastsq(residuals2,p0,args=(np.array(f_data),np.array(amplitude_sqr)))\n", + " #A1, A2, A3, A4, fr, Ql = p_final[0]\n", + " #print(p_final[0][5])\n", + " return p_final[0]\n", + "\n", + "\n", + "def guess_delay(f_data,z_data):\n", + " phase2 = np.unwrap(np.angle(z_data))\n", + " gradient, intercept, r_value, p_value, std_err = stats.linregress(f_data,phase2)\n", + " return gradient*(-1.)/(np.pi*2.)\n", + "\n", + "\n", + "def fit_delay(f_data,z_data,delay=0.,maxiter=0):\n", + " def residuals(p,x,y):\n", + " phasedelay = p\n", + " z_data_temp = y*np.exp(1j*(2.*np.pi*phasedelay*x))\n", + " xc,yc,r0 = fit_circle(z_data_temp)\n", + " err = np.sqrt((z_data_temp.real-xc)**2+(z_data_temp.imag-yc)**2)-r0\n", + " return err\n", + " p_final = spopt.leastsq(residuals,delay,args=(f_data,z_data),maxfev=maxiter,ftol=1e-12,xtol=1e-12)\n", + " return p_final[0][0]\n", + "\n", + "\n", + "def fit_circle(z_data, refine_results=False):\n", + " def calc_moments(z_data):\n", + " xi = z_data.real\n", + " xi_sqr = xi*xi\n", + " yi = z_data.imag\n", + " yi_sqr = yi*yi\n", + " zi = xi_sqr+yi_sqr\n", + " Nd = float(len(xi))\n", + " xi_sum = xi.sum()\n", + " yi_sum = yi.sum()\n", + " zi_sum = zi.sum()\n", + " xiyi_sum = (xi*yi).sum()\n", + " xizi_sum = (xi*zi).sum()\n", + " yizi_sum = (yi*zi).sum()\n", + " return np.array([ [(zi*zi).sum(), xizi_sum, yizi_sum, zi_sum], \\\n", + " [xizi_sum, xi_sqr.sum(), xiyi_sum, xi_sum], \\\n", + " [yizi_sum, xiyi_sum, yi_sqr.sum(), yi_sum], \\\n", + " [zi_sum, xi_sum, yi_sum, Nd] ])\n", + "\n", + " M = calc_moments(z_data)\n", + "\n", + " a0 = ((M[2][0]*M[3][2]-M[2][2]*M[3][0])*M[1][1]-M[1][2]*M[2][0]*M[3][1]-M[1][0]*M[2][1]*M[3][2]+M[1][0]*M[2][2]*M[3][1]+M[1][2]*M[2][1]*M[3][0])*M[0][3]+(M[0][2]*M[2][3]*M[3][0]-M[0][2]*M[2][0]*M[3][3]+M[0][0]*M[2][2]*M[3][3]-M[0][0]*M[2][3]*M[3][2])*M[1][1]+(M[0][1]*M[1][3]*M[3][0]-M[0][1]*M[1][0]*M[3][3]-M[0][0]*M[1][3]*M[3][1])*M[2][2]+(-M[0][1]*M[1][2]*M[2][3]-M[0][2]*M[1][3]*M[2][1])*M[3][0]+((M[2][3]*M[3][1]-M[2][1]*M[3][3])*M[1][2]+M[2][1]*M[3][2]*M[1][3])*M[0][0]+(M[1][0]*M[2][3]*M[3][2]+M[2][0]*(M[1][2]*M[3][3]-M[1][3]*M[3][2]))*M[0][1]+((M[2][1]*M[3][3]-M[2][3]*M[3][1])*M[1][0]+M[1][3]*M[2][0]*M[3][1])*M[0][2]\n", + " a1 = (((M[3][0]-2.*M[2][2])*M[1][1]-M[1][0]*M[3][1]+M[2][2]*M[3][0]+2.*M[1][2]*M[2][1]-M[2][0]*M[3][2])*M[0][3]+(2.*M[2][0]*M[3][2]-M[0][0]*M[3][3]-2.*M[2][2]*M[3][0]+2.*M[0][2]*M[2][3])*M[1][1]+(-M[0][0]*M[3][3]+2.*M[0][1]*M[1][3]+2.*M[1][0]*M[3][1])*M[2][2]+(-M[0][1]*M[1][3]+2.*M[1][2]*M[2][1]-M[0][2]*M[2][3])*M[3][0]+(M[1][3]*M[3][1]+M[2][3]*M[3][2])*M[0][0]+(M[1][0]*M[3][3]-2.*M[1][2]*M[2][3])*M[0][1]+(M[2][0]*M[3][3]-2.*M[1][3]*M[2][1])*M[0][2]-2.*M[1][2]*M[2][0]*M[3][1]-2.*M[1][0]*M[2][1]*M[3][2])\n", + " a2 = ((2.*M[1][1]-M[3][0]+2.*M[2][2])*M[0][3]+(2.*M[3][0]-4.*M[2][2])*M[1][1]-2.*M[2][0]*M[3][2]+2.*M[2][2]*M[3][0]+M[0][0]*M[3][3]+4.*M[1][2]*M[2][1]-2.*M[0][1]*M[1][3]-2.*M[1][0]*M[3][1]-2.*M[0][2]*M[2][3])\n", + " a3 = (-2.*M[3][0]+4.*M[1][1]+4.*M[2][2]-2.*M[0][3])\n", + " a4 = -4.\n", + "\n", + " def func(x):\n", + " return a0+a1*x+a2*x*x+a3*x*x*x+a4*x*x*x*x\n", + "\n", + " def d_func(x):\n", + " return a1+2*a2*x+3*a3*x*x+4*a4*x*x*x\n", + "\n", + " x0 = spopt.fsolve(func, 0., fprime=d_func)\n", + "\n", + " def solve_eq_sys(val,M):\n", + " #prepare\n", + " M[3][0] = M[3][0]+2*val\n", + " M[0][3] = M[0][3]+2*val\n", + " M[1][1] = M[1][1]-val\n", + " M[2][2] = M[2][2]-val\n", + " return np.linalg.svd(M)\n", + "\n", + " U,s,Vt = solve_eq_sys(x0[0],M)\n", + "\n", + " A_vec = Vt[np.argmin(s),:]\n", + "\n", + " xc = -A_vec[1]/(2.*A_vec[0])\n", + " yc = -A_vec[2]/(2.*A_vec[0])\n", + " # the term *sqrt term corrects for the constraint, because it may be altered due to numerical inaccuracies during calculation\n", + " r0 = 1./(2.*np.absolute(A_vec[0]))*np.sqrt(A_vec[1]*A_vec[1]+A_vec[2]*A_vec[2]-4.*A_vec[0]*A_vec[3])\n", + " if refine_results:\n", + " print(\"agebraic r0: \" + str(r0))\n", + " xc,yc,r0 = fit_circle_iter(z_data, xc, yc, r0)\n", + " r0 = fit_circle_iter_radialweight(z_data, xc, yc, r0)\n", + " print(\"iterative r0: \" + str(r0))\n", + " return xc, yc, r0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Phase fit" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "def phase_fit(f_data,z_data,theta0, Ql, fr):\n", + " phase = np.angle(z_data)\n", + " def residuals_1(p,x,y,Ql):\n", + " theta0, fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_2(p,x,y,theta0):\n", + " Ql, fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_3(p,x,y,theta0,Ql):\n", + " fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_4(p,x,y,theta0,fr):\n", + " Ql = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_5(p,x,y):\n", + " theta0, Ql, fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " p0 = [theta0, fr]\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_1(a,b,c,Ql),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " theta0, fr = p_final[0]\n", + " p0 = [Ql, fr]\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_2(a,b,c,theta0),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " Ql, fr = p_final[0]\n", + " p0 = fr\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_3(a,b,c,theta0,Ql),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " fr = float(p_final[0])\n", + " p0 = Ql\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_4(a,b,c,theta0,fr),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " Ql = float(p_final[0])\n", + " p0 = [theta0, Ql, fr]\n", + " p_final = spopt.leastsq(residuals_5,p0,args=(f_data,phase))\n", + " return p_final[0]\n", + "\n", + "def dist(x):\n", + " np.absolute(x,x)\n", + " c = (x > np.pi).astype(int)\n", + " return x+c*(-2.*x+2.*np.pi)\n", + "\n", + "def periodic_boundary(x,bound):\n", + " return np.fmod(x,bound)-np.trunc(x/bound)*bound\n", + "\n", + "def center(z_data,zc):\n", + " return z_data-zc" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "# Calibration\n", + "def do_calibration(f_data,z_data,ignoreslope=True,guessdelay=True):\n", + " '''\n", + " performs an automated calibration and tries to determine the prefactors a, alpha, delay\n", + " fr, Ql, and a possible slope are extra information, which can be used as start parameters for subsequent fits\n", + " see also \"do_normalization\"\n", + " the calibration procedure works for transmission line resonators as well\n", + " '''\n", + " delay, params = get_delay(f_data,z_data,ignoreslope=ignoreslope,guess=guessdelay)\n", + " z_data = (z_data-params[1]*(f_data-params[4]))*np.exp(2.*1j*np.pi*delay*f_data)\n", + " xc, yc, r0 = fit_circle(z_data)\n", + " zc = xc + 1j*yc\n", + " fitparams = phase_fit(f_data,center(z_data,zc),0.,np.absolute(params[5]),params[4])\n", + " theta, Ql, fr = fitparams\n", + " beta = periodic_boundary(theta+np.pi,np.pi)\n", + " offrespoint = complex((xc+r0*np.cos(beta)),(yc+r0*np.sin(beta)))\n", + " alpha = np.angle(offrespoint)\n", + " a = np.absolute(offrespoint)\n", + " print('After calibration')\n", + " print(f'delay {delay}\\nQ_tot {Ql}\\na {a}\\nalpha {alpha}')\n", + " return delay, a, alpha, fr, Ql, params[1], params[4]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Normalization" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "def do_normalization(f_data,z_data,delay,amp_norm,alpha,A2,frcal):\n", + " '''\n", + " transforming resonator into canonical position\n", + " '''\n", + " return (np.sqrt(np.absolute(z_data)**2-A2*(f_data-frcal)))/amp_norm*np.exp(1j*(-alpha+2.*np.pi*delay*f_data))*np.exp(1j*np.angle(z_data))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Circle fit S11" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "def circlefit(f_data,z_data,fr=None,Ql=None,refine_results=False,calc_errors=True):\n", + " '''\n", + " S11 version of the circlefit\n", + " '''\n", + "\n", + " if fr==None: fr=f_data[np.argmin(np.absolute(z_data))]\n", + " if Ql==None: Ql=1e6\n", + " xc, yc, r0 = fit_circle(z_data,refine_results=refine_results)\n", + " phi0 = -np.arcsin(yc/r0)\n", + " theta0 = periodic_boundary(phi0+np.pi,np.pi)\n", + " z_data_corr = center(z_data,complex(xc,yc))\n", + " theta0, Ql, fr = phase_fit(f_data,z_data_corr,theta0,Ql,fr)\n", + " #print(\"Ql from phasefit is: \" + str(Ql))\n", + " Qi = Ql/(1.-r0)\n", + " Qc = 1./(1./Ql-1./Qi)\n", + "\n", + " results = {\"Qi\":Qi,\"Qc\":Qc,\"Ql\":Ql,\"fr\":fr,\"theta0\":theta0}\n", + "\n", + " #calculation of the error\n", + " p = [fr,Qc,Ql]\n", + " #chi_square, errors = rt.get_errors(rt.residuals_notch_ideal,f_data,z_data,p)\n", + " if calc_errors==True:\n", + " chi_square, cov = get_cov_fast_directrefl(f_data,z_data,p)\n", + " #chi_square, cov = rt.get_cov(rt.residuals_notch_ideal,f_data,z_data,p)\n", + "\n", + " if cov is not None:\n", + " errors = np.sqrt(np.diagonal(cov))\n", + " fr_err,Qc_err,Ql_err = errors\n", + " #calc Qi with error prop (sum the squares of the variances and covariaces)\n", + " dQl = 1./((1./Ql-1./Qc)**2*Ql**2)\n", + " dQc = - 1./((1./Ql-1./Qc)**2*Qc**2)\n", + " Qi_err = np.sqrt((dQl**2*cov[2][2]) + (dQc**2*cov[1][1])+(2*dQl*dQc*cov[2][1])) #with correlations\n", + " errors = {\"Ql_err\":Ql_err, \"Qc_err\":Qc_err, \"fr_err\":fr_err,\"chi_square\":chi_square,\"Qi_err\":Qi_err}\n", + " results.update( errors )\n", + " else:\n", + " print(\"WARNING: Error calculation failed!\")\n", + " else:\n", + " #just calc chisquared:\n", + " fun2 = lambda x: residuals_notch_ideal(x,f_data,z_data)**2\n", + " chi_square = 1./float(len(f_data)-len(p)) * (fun2(p)).sum()\n", + " errors = {\"chi_square\":chi_square}\n", + " results.update(errors)\n", + "\n", + " return results\n", + "\n", + "\n", + "def get_cov_fast_directrefl(xdata,ydata,fitparams): #enhanced by analytical derivatives\n", + " #derivatives of notch_ideal model with respect to parameters\n", + " def dS21_dQl(p,f):\n", + " fr,Qc,Ql = p\n", + " return 2.*fr**2/( Qc*(2j*Ql*fr-2j*Ql*f+fr)**2 )\n", + "\n", + " def dS21_dQc(p,f):\n", + " fr,Qc,Ql = p\n", + " return 2.*Ql*fr/(2j*Qc**2*(f-fr)*Ql-Qc**2*fr)\n", + "\n", + " def dS21_dfr(p,f):\n", + " fr,Qc,Ql = p\n", + " return - 4j*Ql**2*f/(Qc*(2j*Ql*fr-2j*Ql*f+fr)**2)\n", + "\n", + " u = residuals_directrefl(fitparams,xdata,ydata)\n", + " chi = np.absolute(u)\n", + " u = u/chi # unit vector pointing in the correct direction for the derivative\n", + "\n", + " aa = dS21_dfr(fitparams,xdata)\n", + " bb = dS21_dQc(fitparams,xdata)\n", + " cc = dS21_dQl(fitparams,xdata)\n", + "\n", + " Jt = np.array([aa.real*u.real+aa.imag*u.imag, bb.real*u.real+bb.imag*u.imag\\\n", + " , cc.real*u.real+cc.imag*u.imag ])\n", + " A = np.dot(Jt,np.transpose(Jt))\n", + " chisqr = 1./float(len(xdata)-len(fitparams)) * (chi**2).sum()\n", + " try:\n", + " cov = np.linalg.inv(A)*chisqr\n", + " except:\n", + " cov = None\n", + " return chisqr, cov\n", + "\n", + "def residuals_directrefl(p,x,y):\n", + " fr,Qc,Ql = p\n", + " #if fr == 0: print(p)\n", + " err = y - ( 2.*Ql/Qc - 1. + 2j*Ql*(fr-x)/fr ) / ( 1. - 2j*Ql*(fr-x)/fr )\n", + " #if np.isinf((np.complex(1,2*Ql*(x-fr)/float(fr))).imag):\n", + " # print(np.complex(1,2*Ql*(x-fr)/float(fr)))\n", + " # print(\"x: \" + str(x))\n", + " # print(\"Ql: \" +str(Ql))\n", + " #print(\"fr: \" +str(fr))\n", + " return err\n", + "\n", + "def residuals_notch_ideal(p,x,y):\n", + " fr,absQc,Ql,phi0 = p\n", + " #if fr == 0: print(p)\n", + " err = np.absolute( y - ( ( 1. - (Ql/float(absQc)*np.exp(1j*phi0))/(1+2j*Ql*(x-fr)/float(fr)) ) ) )\n", + " #if np.isinf((np.complex(1,2*Ql*(x-fr)/float(fr))).imag):\n", + " # print(np.complex(1,2*Ql*(x-fr)/float(fr)))\n", + " # print(\"x: \" + str(x))\n", + " # print(\"Ql: \" +str(Ql))\n", + " #print(\"fr: \" +str(fr))\n", + " return err" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reflection" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "def S11_directrefl(f,fr=10e9,Ql=900,Qc=1000.,a=1.,alpha=0.,delay=.0):\n", + " '''\n", + " full model for notch type resonances\n", + " '''\n", + " return a*np.exp(complex(0,alpha))*np.exp(-2j*np.pi*f*delay) * ( 2.*Ql/Qc - 1. + 2j*Ql*(fr-f)/fr ) / ( 1. - 2j*Ql*(fr-f)/fr )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fit" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7741150756.532712 2729.3073358696624 9671.745796645659\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\duina\\AppData\\Local\\Temp\\ipykernel_27304\\2105727276.py:66: RuntimeWarning: Number of calls to function has reached maxfev = 200.\n", + " p_final = spopt.leastsq(residuals,delay,args=(f_data,z_data),maxfev=maxiter,ftol=1e-12,xtol=1e-12)\n", + "C:\\Users\\duina\\AppData\\Local\\Temp\\ipykernel_27304\\2511080271.py:31: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " fr = float(p_final[0])\n", + "C:\\Users\\duina\\AppData\\Local\\Temp\\ipykernel_27304\\2511080271.py:34: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " Ql = float(p_final[0])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mag, phase, freq = sqil.extract_h5_data(good, ['mag', 'phase', 'frequency'])\n", + "mag, phase, freq = mag[0,:], phase[0,:], freq[0,:]\n", + "\n", + "linmag = 10 ** (mag / 20)\n", + "phase = np.unwrap(phase)\n", + "data = linmag * np.exp(1j * phase)\n", + "\n", + "delay, amp_norm, alpha, fr, Ql, A2, frcal = do_calibration(freq, data, ignoreslope=True, guessdelay=True)\n", + "z_data = do_normalization(freq,data,delay,amp_norm,alpha,A2,frcal)\n", + "fitresults = circlefit(freq, z_data, fr,Ql,refine_results=False,calc_errors=True)\n", + "z_data_sim = A2*(freq-frcal)+S11_directrefl(freq,fr=fitresults[\"fr\"],Ql=fitresults[\"Ql\"],Qc=fitresults[\"Qc\"],a=amp_norm,alpha=alpha,delay=delay)\n", + "\n", + "import matplotlib.pyplot as plt\n", + "plt.figure()\n", + "plt.plot(freq, np.abs(data), '.')\n", + "plt.plot(freq, np.abs(z_data_sim), 'red')\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, np.angle(data), '.')\n", + "plt.plot(freq, np.angle(z_data_sim), 'red')\n", + "\n", + "print(fitresults[\"fr\"],fitresults[\"Ql\"],fitresults[\"Qc\"])\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modified" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "def circlefit(f_data,z_data,fr=None,Ql=None,refine_results=False,calc_errors=True):\n", + " '''\n", + " S11 version of the circlefit\n", + " '''\n", + "\n", + " if fr==None: fr=f_data[np.argmin(np.absolute(z_data))]\n", + " if Ql==None: Ql=1e6\n", + " xc, yc, r0 = fit_circle(z_data,refine_results=refine_results)\n", + " phi0 = -np.arcsin(yc/r0)\n", + " theta0 = periodic_boundary(phi0+np.pi,np.pi)\n", + " z_data_corr = center(z_data,complex(xc,yc))\n", + " theta0, Ql, fr = phase_fit(f_data,z_data_corr,theta0,Ql,fr)\n", + " #print(\"Ql from phasefit is: \" + str(Ql))\n", + " # Qi = Ql/(1.-r0)\n", + " # Qc = 1./(1./Ql-1./Qi)\n", + " Qc=Ql/(r0*np.exp(-1j*phi0))\n", + " Qi=1/(1/Ql-1/np.real(Qc))\n", + "\n", + " results = {\"Qi\":Qi,\"Qc\":Qc,\"Ql\":Ql,\"fr\":fr,\"theta0\":theta0, \"phi0\":phi0}\n", + "\n", + " #calculation of the error\n", + " p = [fr,Qc,Ql]\n", + " #chi_square, errors = rt.get_errors(rt.residuals_notch_ideal,f_data,z_data,p)\n", + " if calc_errors==True:\n", + " chi_square, cov = get_cov_fast_directrefl(f_data,z_data,p)\n", + " #chi_square, cov = rt.get_cov(rt.residuals_notch_ideal,f_data,z_data,p)\n", + "\n", + " if cov is not None:\n", + " errors = np.sqrt(np.diagonal(cov))\n", + " fr_err,Qc_err,Ql_err = errors\n", + " #calc Qi with error prop (sum the squares of the variances and covariaces)\n", + " dQl = 1./((1./Ql-1./Qc)**2*Ql**2)\n", + " dQc = - 1./((1./Ql-1./Qc)**2*Qc**2)\n", + " Qi_err = np.sqrt((dQl**2*cov[2][2]) + (dQc**2*cov[1][1])+(2*dQl*dQc*cov[2][1])) #with correlations\n", + " errors = {\"Ql_err\":Ql_err, \"Qc_err\":Qc_err, \"fr_err\":fr_err,\"chi_square\":chi_square,\"Qi_err\":Qi_err}\n", + " results.update( errors )\n", + " else:\n", + " print(\"WARNING: Error calculation failed!\")\n", + " #else:\n", + " # #just calc chisquared:\n", + " # fun2 = lambda x: residuals_notch_ideal(x,f_data,z_data)**2\n", + " # chi_square = 1./float(len(f_data)-len(p)) * (fun2(p)).sum()\n", + " # errors = {\"chi_square\":chi_square}\n", + " # results.update(errors)\n", + "\n", + " return results\n", + "\n", + "def S11_directrefl(f,fr=10e9,Ql=900,Qc=1000.,a=1.,alpha=0.,delay=.0, phi=0):\n", + " '''\n", + " full model for notch type resonances\n", + " '''\n", + "\n", + " return a*np.exp(complex(0,alpha))*np.exp(-2j*np.pi*f*delay) * ( 1-2*Ql/np.abs(Qc)*np.exp(1j*phi)/(1+2j*Ql*(f/fr-1)) )" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7741150756.532712 2729.3073358696624 (9671.304590676658+92.38110894313314j)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\duina\\AppData\\Local\\Temp\\ipykernel_27304\\2105727276.py:66: RuntimeWarning: Number of calls to function has reached maxfev = 200.\n", + " p_final = spopt.leastsq(residuals,delay,args=(f_data,z_data),maxfev=maxiter,ftol=1e-12,xtol=1e-12)\n", + "C:\\Users\\duina\\AppData\\Local\\Temp\\ipykernel_27304\\2511080271.py:31: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " fr = float(p_final[0])\n", + "C:\\Users\\duina\\AppData\\Local\\Temp\\ipykernel_27304\\2511080271.py:34: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " Ql = float(p_final[0])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mag, phase, freq = sqil.extract_h5_data(good, ['mag', 'phase', 'frequency'])\n", + "mag, phase, freq = mag[0,:], phase[0,:], freq[0,:]\n", + "\n", + "linmag = 10 ** (mag / 20)\n", + "phase = np.unwrap(phase)\n", + "data = linmag * np.exp(1j * phase)\n", + "\n", + "delay, amp_norm, alpha, fr, Ql, A2, frcal = do_calibration(freq, data, ignoreslope=True, guessdelay=True)\n", + "z_data = do_normalization(freq,data,delay,amp_norm,alpha,A2,frcal)\n", + "fitresults = circlefit(freq, z_data, fr,Ql,refine_results=False,calc_errors=False)\n", + "z_data_sim = A2*(freq-frcal)+S11_directrefl(freq,fr=fitresults[\"fr\"],Ql=fitresults[\"Ql\"],Qc=fitresults[\"Qc\"],a=amp_norm,alpha=alpha,delay=delay, phi=fitresults[\"phi0\"])\n", + "\n", + "\n", + "import matplotlib.pyplot as plt\n", + "plt.figure()\n", + "plt.plot(freq, np.abs(data), '.')\n", + "plt.plot(freq, np.abs(z_data_sim), 'red')\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, np.angle(data), '.')\n", + "plt.plot(freq, np.angle(z_data_sim), 'red')\n", + "\n", + "print(fitresults[\"fr\"],fitresults[\"Ql\"],fitresults[\"Qc\"])\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/sketching/resonator.py b/sketching/resonator.py new file mode 100644 index 0000000..77c3f7b --- /dev/null +++ b/sketching/resonator.py @@ -0,0 +1,76 @@ +import matplotlib.pyplot as plt +import numpy as np +import scipy.optimize as spopt +from scipy import stats +from scipy.linalg import norm +from scipy.optimize import curve_fit, minimize, newton +from tabulate import tabulate + +import sqil_core as sqil + + +def guess_from_lorentzian(freq, z_data): + y = np.abs(z_data) ** 2 + params, cov = fit_skewed_lorentzian(freq, y) + (A1, A2, A3, A4, fr, Q_tot) = params + return fr, Q_tot, [A1, A2, A3, A4] + + +# Read the data +[dBmag], [phase], [freq] = sqil.extract_h5_data(bad, ["mag", "phase", "frequency"]) +linmag = 10 ** (dBmag / 20) +phase = shift_phase(np.unwrap(phase)) +data = linmag * np.exp(1j * phase) + +data_history = [] +data_history.append(data) + +fr = None +Q_tot = None + +# Guess fr and Q_tot from the lorentzian fit of the magnitude +if not skip_lorentzian_guess: + fr, Q_tot = guess_from_lorentzian(freq, data) + # If the estimate Q_tot is < 0 ignore it + if Q_tot < 0: + Q_tot = None + +# Estimate a rough cable delay from the first points of the phase data +[c, tau] = estimate_linear_background(freq, phase, 0.1) +tau /= 2 * np.pi +# Remove cable delay from phase +phase1 = shift_phase(phase - 2 * np.pi * tau * (freq - freq[0])) +data1 = linmag * np.exp(1j * phase1) +data_history.append(data1) + +# Move the circle to the center +xc, yc, r0 = fit_circle_algebraic(data1) +data3 = data1 - xc - 1j * yc +phase3 = np.unwrap(np.angle(data3)) +data_history.append(data3) + +# Perform the phase vs frequency fit +theta0, Q_tot, fr = fit_phase_vs_freq_taketo(freq, phase3, Q_tot=Q_tot, f_r=fr) + +# Find the off-resonant point => find a and alpha +p_offres = (xc + 1j * yc) + r0 * np.exp(1j * (theta0 + np.pi)) +a = np.abs(p_offres) +alpha = np.angle(p_offres) +# Adjust the data +linmag5 = linmag / a +phase5 = phase1 - alpha +data5 = linmag5 * np.exp(1j * phase5) +data_history.append(data5) + +# Find the impedence mismatch +xc, yc, r0 = fit_circle_algebraic(data5) +phi0 = -np.arcsin(yc / r0) +# Calculate Q_ext and Q_int +Q_ext = Q_tot / (r06 * np.exp(-1j * phi0)) # REFLECTION ONLY +Q_int = 1 / (1 / Q_tot - 1 / np.real(Q_ext)) + +# Calculate the final fit +fit = S11_reflection(freq, a, alpha, tau, Q_tot, Q_ext, fr, phi0) + +# Get a global phase factor +theta0 = phase[0] - np.unwrap(np.angle(fit))[0] diff --git a/sketching/takethree.ipynb b/sketching/takethree.ipynb new file mode 100644 index 0000000..f2a3ca7 --- /dev/null +++ b/sketching/takethree.ipynb @@ -0,0 +1,1328 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import sqil_core as sqil\n", + "from scipy.optimize import curve_fit, minimize, newton\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import scipy.optimize as spopt\n", + "from scipy import stats\n", + "from scipy.linalg import norm\n", + "\n", + "from tabulate import tabulate" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Deep\n", + "deep = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00075-cavity_check_2024-12-12T171954'\n", + "# Tiny\n", + "tiny = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00032-cavity_check_2024-12-12T144742'\n", + "# Good\n", + "good = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00077-cavity_check_2024-12-12T172355'\n", + "# Bad\n", + "bad = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00062-cavity_check_2024-12-12T160601'\n", + "# Very bad\n", + "very_bad = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00053-cavity_check_2024-12-12T155026'\n", + "# Hanger\n", + "hanger = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00082-cavity_check_2024-12-12T174140'\n", + "# NiNi P2 reflection\n", + "p2_refl = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00077-cavity_check_2024-12-12T172355'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "My helpers" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def estimate_linear_background(x: np.ndarray, data: np.ndarray, points_cut = 0.1) -> list:\n", + " is1D = len(data.shape) == 1\n", + " points = data.shape[0] if is1D else data.shape[1]\n", + " cut = int(points * points_cut)\n", + "\n", + " # Consider just the cut points\n", + " x_data = x[0:cut] if is1D else x[0:cut,:]\n", + " X = np.vstack([np.ones_like(x_data), x_data]).T\n", + " y_data = data[0:cut] if is1D else data[0:cut,:]\n", + "\n", + " # Linear fit\n", + " coefficients, residuals, _, _ = np.linalg.lstsq(\n", + " X, y_data if is1D else y_data.T, rcond=None)\n", + "\n", + " return coefficients\n", + "\n", + "\n", + "def compute_global_2pi_shift(phase, phase_tmp, make_integer = True):\n", + " \"\"\"Compute the single global 2pi shift n that best aligns `phase` with `phase_tmp`.\"\"\"\n", + " delta_phase = phase - phase_tmp\n", + " n = np.mean(delta_phase) / (2 * np.pi)\n", + " return int(np.round(n)) if make_integer else n\n", + "\n", + "\n", + "def print_fit_result(names, params, errors):\n", + " headers = ['Param', 'Fitted value', '% Error']\n", + " data = [\n", + " [names[i], params[i], np.round(errors[i],2)] for i in range(len(params))\n", + " ]\n", + " table = tabulate(data, headers=headers, tablefmt='github')\n", + " print(table)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Reviewed Taketo functions" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def shift_phase(phase):\n", + " \"\"\"\n", + " Shifts the (unwrapped) phase data so that the first phase value\n", + " lies within the range (-pi, pi].\n", + "\n", + " Parameters:\n", + " phase (array-like): Unwrapped phase data.\n", + "\n", + " Returns:\n", + " array-like: Phase data shifted to the range (-pi, pi].\n", + " \"\"\"\n", + " # Calculate how many 2*pi shifts are required to bring phase[0] into (-pi, pi]\n", + " n = np.round(phase[0] / (2 * np.pi))\n", + "\n", + " # Shift the entire phase array\n", + " return phase - 2 * n * np.pi\n", + "\n", + "def fit_phase_vs_freq_taketo(freq, phase, theta_0 = None, Q_tot = None, f_r = None):\n", + " if theta_0 is None:\n", + " theta_0 = np.mean(phase)\n", + " if Q_tot is None:\n", + " Q_tot = 0.01\n", + " if f_r is None:\n", + " f_r = np.mean(freq) #freq[np.argmin(np.abs(phase - np.mean(phase)))]\n", + "\n", + " def objective(x):\n", + " theta_0, Q_tot, f_r = x\n", + " model = theta_0 + 2 * np.arctan(2 * Q_tot * (1 - freq / f_r))\n", + " residuals = phase - model\n", + " return np.square(residuals).sum()\n", + "\n", + " res = minimize(\n", + " fun=objective,\n", + " x0=[theta_0, Q_tot, f_r],\n", + " method=\"Nelder-Mead\",\n", + " options={\n", + " \"maxiter\": 3000000,\n", + " \"disp\": True\n", + " }\n", + " )\n", + "\n", + " theta_0, Q_tot, f_r = res.x\n", + " return theta_0, Q_tot, f_r\n", + "\n", + "def S11_reflection(freq, a, alpha, tau, Q_tot, Q_ext, f_r, phi):\n", + " env = a * np.exp(1j * alpha) * np.exp(2j * np.pi * (freq - freq[0]) * tau)\n", + " resonator = 1 - (2 * Q_tot / np.abs(Q_ext)) * np.exp(1j * phi) / (1 + 2j * Q_tot * (freq / f_r - 1))\n", + " return env * resonator\n", + "\n", + "def S21_hanger(freq, a, alpha, tau, Q_tot, Q_ext, f_r, phi):\n", + " Deltaf = freq-freq[0]\n", + " env = a*(- 1.1303416225502072e-09 * Deltaf) * np.exp(1j * alpha) * np.exp(2j * np.pi * Deltaf * tau)\n", + " resonator = 1 - (Q_tot / np.abs(Q_ext)) * np.exp(1j * phi) / (1 + 2j * Q_tot * (freq / f_r - 1))\n", + " return env * resonator\n", + "\n", + "def S11_reflection_mesh(freq, a, alpha, tau, Q_tot, Q_ext, f_r, phi):\n", + " \"\"\"\n", + " Vectorized S11 reflection function.\n", + "\n", + " Parameters\n", + " ----------\n", + " freq : array, shape (N,)\n", + " Frequency points.\n", + " a, alpha, tau, Q_tot, Q_ext, f_r, phi : scalar or array\n", + " Parameters of the S11 model.\n", + "\n", + " Returns\n", + " -------\n", + " S11 : array\n", + " Complex reflection coefficient. Shape is (M1, M2, ..., N) where M1, M2, ... are the broadcasted shapes of the parameters.\n", + " \"\"\"\n", + " # Ensure freq is at least 2D for broadcasting (1, N)\n", + " freq = np.atleast_1d(freq) # (N,)\n", + "\n", + " # Ensure all parameters are at least 1D arrays for broadcasting\n", + " a = np.atleast_1d(a) # (M1,)\n", + " alpha = np.atleast_1d(alpha) # (M2,)\n", + " tau = np.atleast_1d(tau) # (M3,)\n", + " Q_tot = np.atleast_1d(Q_tot) # (M4,)\n", + " Q_ext = np.atleast_1d(Q_ext) # (M5,)\n", + " f_r = np.atleast_1d(f_r) # (M6,)\n", + " phi = np.atleast_1d(phi) # (M7,)\n", + "\n", + " # Reshape frequency to (1, 1, ..., 1, N) for proper broadcasting\n", + " freq = freq[np.newaxis, ...] # This makes sure freq has shape (1, 1, ..., N)\n", + "\n", + " # Calculate the envelope part\n", + " env = a[..., np.newaxis] * np.exp(1j * alpha[..., np.newaxis]) * np.exp(2j * np.pi * (freq - freq[..., 0:1]) * tau[..., np.newaxis])\n", + "\n", + " # Calculate the resonator part\n", + " resonator = 1 - (2 * Q_tot[..., np.newaxis] / np.abs(Q_ext[..., np.newaxis])) * np.exp(1j * phi[..., np.newaxis]) / (1 + 2j * Q_tot[..., np.newaxis] * (freq / f_r[..., np.newaxis] - 1))\n", + "\n", + " return env * resonator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From KIT" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def get_delay(f_data,z_data,delay=None,ignoreslope=True,guess=True):\n", + " '''\n", + " ignoreslope option not used here\n", + " retrieves the cable delay assuming the ideal resonance has a circular shape\n", + " modifies the cable delay until the shape Im(S21) vs Re(S21) is circular\n", + " see \"do_calibration\"\n", + " '''\n", + " maxval = np.max(np.absolute(z_data))\n", + " z_data = z_data/maxval\n", + " A1, A2, A3, A4, fr, Ql = fit_skewed_lorentzian(f_data,z_data)\n", + " if ignoreslope==True:\n", + " A2 = 0\n", + " else:\n", + " z_data = (np.sqrt(np.absolute(z_data)**2-A2*(f_data-fr))) * np.exp(np.angle(z_data)*1j) #usually not necessary\n", + " if delay==None:\n", + " if guess==True:\n", + " delay = guess_delay(f_data,z_data)\n", + " else:\n", + " delay=0.\n", + " delay = fit_delay(f_data,z_data,delay,maxiter=200)\n", + " params = [A1, A2, A3, A4, fr, Ql]\n", + " return delay, params\n", + "\n", + "def fit_skewed_lorentzian(f_data, z_data):\n", + " amplitude = np.absolute(z_data)\n", + " amplitude_sqr = amplitude**2\n", + " A1a = np.minimum(amplitude_sqr[0],amplitude_sqr[-1])\n", + " A3a = -np.max(amplitude_sqr)\n", + " fra = f_data[np.argmin(amplitude_sqr)]\n", + " def residuals(p,x,y):\n", + " A2, A4, Ql = p\n", + " err = y -(A1a+A2*(x-fra)+(A3a+A4*(x-fra))/(1.+4.*Ql**2*((x-fra)/fra)**2))\n", + " return err\n", + " p0 = [0., 0., 1e3]\n", + " p_final = spopt.leastsq(residuals,p0,args=(np.array(f_data),np.array(amplitude_sqr)))\n", + " A2a, A4a, Qla = p_final[0]\n", + "\n", + " def residuals2(p,x,y):\n", + " A1, A2, A3, A4, fr, Ql = p\n", + " err = y -(A1+A2*(x-fr)+(A3+A4*(x-fr))/(1.+4.*Ql**2*((x-fr)/fr)**2))\n", + " return err\n", + " p0 = [A1a, A2a , A3a, A4a, fra, Qla]\n", + " p_final = spopt.leastsq(residuals2,p0,args=(np.array(f_data),np.array(amplitude_sqr)))\n", + " #A1, A2, A3, A4, fr, Ql = p_final[0]\n", + " #print(p_final[0][5])\n", + " return p_final[0]\n", + "\n", + "\n", + "def guess_delay(f_data,z_data):\n", + " phase2 = np.unwrap(np.angle(z_data))\n", + " gradient, intercept, r_value, p_value, std_err = stats.linregress(f_data,phase2)\n", + " return gradient*(-1.)/(np.pi*2.)\n", + "\n", + "\n", + "def fit_delay(f_data,z_data,delay=0.,maxiter=0):\n", + " def residuals(p,x,y):\n", + " phasedelay = p\n", + " z_data_temp = y*np.exp(1j*(2.*np.pi*phasedelay*x))\n", + " xc,yc,r0 = fit_circle_algebraic(z_data_temp)\n", + " err = np.sqrt((z_data_temp.real-xc)**2+(z_data_temp.imag-yc)**2)-r0\n", + " return err\n", + " p_final = spopt.leastsq(residuals,delay,args=(f_data,z_data),maxfev=maxiter,ftol=1e-12,xtol=1e-12)\n", + " return p_final[0][0]\n", + "\n", + "def fit_circle_algebraic(z_data):\n", + " def calc_moments(z_data):\n", + " xi = z_data.real\n", + " xi_sqr = xi*xi\n", + " yi = z_data.imag\n", + " yi_sqr = yi*yi\n", + " zi = xi_sqr+yi_sqr\n", + " Nd = float(len(xi))\n", + " xi_sum = xi.sum()\n", + " yi_sum = yi.sum()\n", + " zi_sum = zi.sum()\n", + " xiyi_sum = (xi*yi).sum()\n", + " xizi_sum = (xi*zi).sum()\n", + " yizi_sum = (yi*zi).sum()\n", + " return np.array([ [(zi*zi).sum(), xizi_sum, yizi_sum, zi_sum], \\\n", + " [xizi_sum, xi_sqr.sum(), xiyi_sum, xi_sum], \\\n", + " [yizi_sum, xiyi_sum, yi_sqr.sum(), yi_sum], \\\n", + " [zi_sum, xi_sum, yi_sum, Nd] ])\n", + "\n", + " M = calc_moments(z_data)\n", + "\n", + " a0 = ((M[2][0]*M[3][2]-M[2][2]*M[3][0])*M[1][1]-M[1][2]*M[2][0]*M[3][1]-M[1][0]*M[2][1]*M[3][2]+M[1][0]*M[2][2]*M[3][1]+M[1][2]*M[2][1]*M[3][0])*M[0][3]+(M[0][2]*M[2][3]*M[3][0]-M[0][2]*M[2][0]*M[3][3]+M[0][0]*M[2][2]*M[3][3]-M[0][0]*M[2][3]*M[3][2])*M[1][1]+(M[0][1]*M[1][3]*M[3][0]-M[0][1]*M[1][0]*M[3][3]-M[0][0]*M[1][3]*M[3][1])*M[2][2]+(-M[0][1]*M[1][2]*M[2][3]-M[0][2]*M[1][3]*M[2][1])*M[3][0]+((M[2][3]*M[3][1]-M[2][1]*M[3][3])*M[1][2]+M[2][1]*M[3][2]*M[1][3])*M[0][0]+(M[1][0]*M[2][3]*M[3][2]+M[2][0]*(M[1][2]*M[3][3]-M[1][3]*M[3][2]))*M[0][1]+((M[2][1]*M[3][3]-M[2][3]*M[3][1])*M[1][0]+M[1][3]*M[2][0]*M[3][1])*M[0][2]\n", + " a1 = (((M[3][0]-2.*M[2][2])*M[1][1]-M[1][0]*M[3][1]+M[2][2]*M[3][0]+2.*M[1][2]*M[2][1]-M[2][0]*M[3][2])*M[0][3]+(2.*M[2][0]*M[3][2]-M[0][0]*M[3][3]-2.*M[2][2]*M[3][0]+2.*M[0][2]*M[2][3])*M[1][1]+(-M[0][0]*M[3][3]+2.*M[0][1]*M[1][3]+2.*M[1][0]*M[3][1])*M[2][2]+(-M[0][1]*M[1][3]+2.*M[1][2]*M[2][1]-M[0][2]*M[2][3])*M[3][0]+(M[1][3]*M[3][1]+M[2][3]*M[3][2])*M[0][0]+(M[1][0]*M[3][3]-2.*M[1][2]*M[2][3])*M[0][1]+(M[2][0]*M[3][3]-2.*M[1][3]*M[2][1])*M[0][2]-2.*M[1][2]*M[2][0]*M[3][1]-2.*M[1][0]*M[2][1]*M[3][2])\n", + " a2 = ((2.*M[1][1]-M[3][0]+2.*M[2][2])*M[0][3]+(2.*M[3][0]-4.*M[2][2])*M[1][1]-2.*M[2][0]*M[3][2]+2.*M[2][2]*M[3][0]+M[0][0]*M[3][3]+4.*M[1][2]*M[2][1]-2.*M[0][1]*M[1][3]-2.*M[1][0]*M[3][1]-2.*M[0][2]*M[2][3])\n", + " a3 = (-2.*M[3][0]+4.*M[1][1]+4.*M[2][2]-2.*M[0][3])\n", + " a4 = -4.\n", + "\n", + " def func(x):\n", + " return a0+a1*x+a2*x*x+a3*x*x*x+a4*x*x*x*x\n", + "\n", + " def d_func(x):\n", + " return a1+2*a2*x+3*a3*x*x+4*a4*x*x*x\n", + "\n", + " x0 = spopt.fsolve(func, 0., fprime=d_func)\n", + "\n", + " def solve_eq_sys(val,M):\n", + " #prepare\n", + " M[3][0] = M[3][0]+2*val\n", + " M[0][3] = M[0][3]+2*val\n", + " M[1][1] = M[1][1]-val\n", + " M[2][2] = M[2][2]-val\n", + " return np.linalg.svd(M)\n", + "\n", + " U,s,Vt = solve_eq_sys(x0[0],M)\n", + "\n", + " A_vec = Vt[np.argmin(s),:]\n", + "\n", + " xc = -A_vec[1]/(2.*A_vec[0])\n", + " yc = -A_vec[2]/(2.*A_vec[0])\n", + " # the term *sqrt term corrects for the constraint, because it may be altered due to numerical inaccuracies during calculation\n", + " r0 = 1./(2.*np.absolute(A_vec[0]))*np.sqrt(A_vec[1]*A_vec[1]+A_vec[2]*A_vec[2]-4.*A_vec[0]*A_vec[3])\n", + "\n", + " print(f'Circle fit: xc = {xc}, yc = {yc}, r0 = {r0}')\n", + " return xc, yc, r0\n", + "\n", + "\n", + "\n", + "#############################\n", + "def phase_fit_kit(f_data,z_data,theta0, Ql, fr):\n", + " phase = np.unwrap(np.angle(z_data)) # ADDED UNWRAPPING\n", + " def residuals_1(p,x,y,Ql):\n", + " theta0, fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_2(p,x,y,theta0):\n", + " Ql, fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_3(p,x,y,theta0,Ql):\n", + " fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_4(p,x,y,theta0,fr):\n", + " Ql = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_5(p,x,y):\n", + " theta0, Ql, fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " p0 = [theta0, fr]\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_1(a,b,c,Ql),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " theta0, fr = p_final[0]\n", + " p0 = [Ql, fr]\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_2(a,b,c,theta0),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " Ql, fr = p_final[0]\n", + " p0 = fr\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_3(a,b,c,theta0,Ql),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " fr = float(p_final[0])\n", + " p0 = Ql\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_4(a,b,c,theta0,fr),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " Ql = float(p_final[0])\n", + " p0 = [theta0, Ql, fr]\n", + " p_final = spopt.leastsq(residuals_5,p0,args=(f_data,phase))\n", + " return p_final[0]\n", + "\n", + "def dist(x):\n", + " np.absolute(x,x)\n", + " c = (x > np.pi).astype(int)\n", + " return x+c*(-2.*x+2.*np.pi)\n", + "\n", + "def periodic_boundary(x,bound):\n", + " return np.fmod(x,bound)-np.trunc(x/bound)*bound\n", + "\n", + "def center(z_data,zc):\n", + " return z_data-zc\n", + "\n", + "\n", + "\n", + "def fit_skewed_lorentzian(x, y):\n", + " A1a = np.minimum(y[0], y[-1])\n", + " A3a = -np.max(y)\n", + " fra = x[np.argmin(y)]\n", + "\n", + " # First fit to get initial estimates for the more complex fit\n", + " def residuals(p, x, y):\n", + " A2, A4, Ql = p\n", + " err = y - (A1a + A2 * (x - fra) + (A3a + A4 * (x - fra)) / (1. + 4. * Ql**2 * ((x - fra) / fra)**2))\n", + " return err\n", + " p0 = [0., 0., 1e3]\n", + " p_final, _ = spopt.leastsq(residuals, p0, args=(np.array(x), np.array(y)))\n", + " A2a, A4a, Qla = p_final\n", + "\n", + " # Full parameter fit\n", + " def residuals2(p, x, y):\n", + " A1, A2, A3, A4, fr, Ql = p\n", + " err = y - (A1 + A2 * (x - fr) + (A3 + A4 * (x - fr)) / (1. + 4. * Ql**2 * ((x - fr) / fr)**2))\n", + " return err\n", + " p0 = [A1a, A2a, A3a, A4a, fra, Qla]\n", + " popt, pcov, infodict, errmsg, ier = spopt.leastsq(residuals2, p0, args=(np.array(x), np.array(y)), full_output=True)\n", + " # Since Q_tot is always present as a square it may turn out negative\n", + " popt[-1] = np.abs(popt[-1])\n", + "\n", + " # Calculate percentage errors\n", + " std_errs = compute_standard_errors(x, popt, pcov, infodict['fvec'])\n", + " perc_errs = std_errs / np.abs(popt) * 100\n", + "\n", + " return popt, perc_errs\n", + "\n", + "def compute_standard_errors(x, popt, pcov, residuals):\n", + " # Calculate reduced chi-squared\n", + " dof = len(x) - len(popt) # degrees of freedom (N - p)\n", + " chi2_red = np.sum(residuals**2) / dof\n", + " # Rescale the covariance matrix\n", + " pcov = pcov * chi2_red\n", + " # Calculate standard errors for each parameter\n", + " standard_errors = np.sqrt(np.diag(pcov))\n", + " return standard_errors\n", + "\n", + "def skewed_lorenzian(f, A1, A2, A3, A4, fr, Q_tot):\n", + " return A1 + A2 * (f-fr) + (A3 + A4 * (f-fr)) / (1 + (2*Q_tot*(f/fr-1))**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "[dBmag], [phase], [freq] = sqil.extract_h5_data(bad, ['mag', 'phase', 'frequency'])\n", + "linmag = 10**(dBmag/20)\n", + "phase = shift_phase(np.unwrap(phase))\n", + "data = linmag * np.exp(1j*phase)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-9.472994697559244 1.2767180323576412e-09\n", + "| Param | Fitted value | % Error |\n", + "|---------|----------------|-----------|\n", + "| A1 | 0.150029 | 0.02 |\n", + "| A2 | 7.75537e-10 | 0.07 |\n", + "| A3 | 0.0382418 | 0.82 |\n", + "| A4 | -1.63455e-07 | 0.23 |\n", + "| fr | 7.74147e+09 | 0 |\n", + "| Q_tot | 2237.43 | 0.15 |\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGvCAYAAAB4u44CAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbldJREFUeJzt3Xl8VNX9//HXnZuFsCQsgRCQJeCCC4sCIoqIyKZ1QVtFtKLUUrXyrcrPDdsKrqh1wVor1q2ugFbEDVkMBEQREGVTQMCwTwJBmEAIycy95/fHJEOGJJBAlknyfj4ePmrunLm55zpN3jnnc861jDEGERERkQjmqe4LEBERETkaBRYRERGJeAosIiIiEvEUWERERCTiKbCIiIhIxFNgERERkYinwCIiIiIRT4FFREREIl5UdV9ARXBdlx07dtCoUSMsy6ruyxEREZEyMMawb98+WrVqhcdz5DGUWhFYduzYQZs2bar7MkREROQYbN26lRNOOOGIbWpFYGnUqBEQ7HB8fHyp7fx+P7Nnz2bQoEFER0dX1eVFlLp+D9T/ut1/0D2o6/0H3YNI6n92djZt2rQJ/R4/kloRWAqngeLj448aWOrXr098fHy1/0eqLnX9Hqj/dbv/oHtQ1/sPugeR2P+ylHOo6FZEREQingKLiIiIRDwFFhEREYl4CiwiIiIS8RRYREREJOIpsIiIiEjEU2ARERGRiKfAIiIiIhFPgUVEREQingKLiIiIRDwFFhGJCF5fLt9szMLry63uSxGRCFQrniUkIjXb1KVbGDttFa4BjwUTrurMsJ5tq/uyRCSCaIRFRKqV15cbCisAroEHpq3WSIuIhFFgEZFq9cbCdFwD7awMOlrbAXCMYVPWgWq+MhGJJJoSEpFq4/Xl8spX6cSTw/zYMewzcZyb9wL7qU/7xPrVfXkiEkE0wiIi1SY9KwcDXGkvBKCRlcvpnk0ALPh5V/VdmIhEHAUWEak2KYkN8Fhwvmdl6NjpVjoG1bGISDgFFhGpNskJcTxyxRm0s3aGjp1RMMKiOhYRKUqBRUSq1Z6cg7QtEliSrV8BsC1LdSwiEqLAIiLVxuvL5b0vFxNr+UPHGnEAjwWPX3UGyQlx1Xh1IhJJtEpIRKpNelYOba3MsGPxHOCf157JpV1bVdNViUgk0giLiFSblMQGJBOcAvKapgDEWzmc2bZxNV6ViEQiBRYRqTbJCXGc0zwfgPVuawAakUt8Pbs6L0tEItAxBZYXX3yR9u3bU69ePXr16sWSJUtKbTtt2jR69OhB48aNadCgAd26dePtt98Oa2OM4cEHHyQ5OZm4uDgGDBjA+vXrj+XSRKSGSWQPAG6zkwDwWIb92Xur8YpEJBKVO7BMnTqVMWPGMG7cOL7//nu6du3K4MGD2blzZ4ntmzZtyl//+lcWLVrEypUrGTlyJCNHjmTWrFmhNk899RT//Oc/mTRpEosXL6ZBgwYMHjyYgwcPHnvPRCTiTV26hQO/Brfj/2pXffJMNAAHsn+tzssSkQhU7sDy7LPPMmrUKEaOHMlpp53GpEmTqF+/Pq+//nqJ7fv168eVV17JqaeeSseOHbnjjjvo0qULCxcGd7Y0xjBx4kT+9re/ccUVV9ClSxfeeustduzYwfTp04+rcyISuQofetjC2gtApmlCNsFlzJmZGdV4ZSISicq1Sig/P59ly5YxduzY0DGPx8OAAQNYtGjRUd9vjGHu3LmsW7eOJ598EoD09HQyMjIYMGBAqF1CQgK9evVi0aJFXHvttcXOk5eXR15eXujr7OxsAPx+P36/v1j7QoWvHalNbVfX74H6Hzn935CRjWugOXsB2Gkak23q09zy8c/Pl7Epqj1Xdz+hwr9vJN2D6lDX+w+6B5HU//JcQ7kCS1ZWFo7jkJSUFHY8KSmJtWvXlvo+n89H69atycvLw7Zt/v3vfzNw4EAAMjIyQuc4/JyFrx1uwoQJPPTQQ8WOz549m/r1j77R1Jw5c47aprar6/dA/a/+/u/NAws7NMKyk8Zk0wCAhtYB/jr9R/xbVtI4tnK+fyTcg+pU1/sPugeR0P8DB8q+m3WV7MPSqFEjli9fzv79+0lNTWXMmDF06NCBfv36HdP5xo4dy5gxY0JfZ2dn06ZNGwYNGkR8fHyp7/P7/cyZM4eBAwcSHR19TN+7pqvr90D9j6z+Wy1+pmFasFZtt0lgnwluFNeIAxgsOnY7h14pTSv0e0baPahqdb3/oHsQSf0vnCEpi3IFlsTERGzbJjMzfKOnzMxMWrZsWer7PB4PJ554IgDdunVjzZo1TJgwgX79+oXel5mZSXJyctg5u3XrVuL5YmNjiY0t/mdXdHR0mW5+WdvVZnX9Hqj/kdH/i9oHryHfRJFjxZFHDAD1rHxsy6JjUnylXWek3IPqUtf7D7oHkdD/8nz/chXdxsTE0L17d1JTU0PHXNclNTWV3r17l/k8ruuGalBSUlJo2bJl2Dmzs7NZvHhxuc4pIjXPvl+9AOy1EphwVRcOEvzhVc/ya2t+EQlT7imhMWPGcOONN9KjRw/OPvtsJk6cSE5ODiNHjgRgxIgRtG7dmgkTJgDBepMePXrQsWNH8vLymDFjBm+//TYvvfQSAJZlceedd/Loo49y0kknkZKSwt///ndatWrF0KFDK66nIhJxdnq30wnYZycwrGdbFn+VANlwfkoj+vdsW92XJyIRpNyBZdiwYezatYsHH3yQjIwMunXrxsyZM0NFs1u2bMHjOTRwk5OTw5///Ge2bdtGXFwcnTp14p133mHYsGGhNvfeey85OTn86U9/Yu/evfTp04eZM2dSr169CuiiiESiqUu3sOTrFfSNge35Dfhu6RY6xARHVOqRX81XJyKR5piKbkePHs3o0aNLfC0tLS3s60cffZRHH330iOezLIuHH36Yhx9++FguR0RqmMI9WG72BAvudhPPA9NW82brYA0LgbwjvFtE6iI9S0hEqlx6Vg6ugWbWPgB2m3gcYzhogn9DWYHc6rw8EYlACiwiUuVSEhvgsaAZPgB+NfHYlkVMveA+SpajKSERCafAIiJVLjkhjglXdaZp4QgL8Tx+1RnUiwtuHOdxNCUkIuEUWESkWgzr2ZbW0fsBGHpeF4b1bAtRwUJ7j6MHn4pIOAUWEak28W5wSqhFyzYAeKKDq4RsjbCIyGEUWESkWhhjaGyCgSUvpgkAVkxwhCXKVWARkXAKLCJSLd75ag31rWAwGfbuBqYu3YInOhhYbFdFtyISToFFRKqc15fLf75YAkCeiWafqccD01ZzwA1uzR+lwCIih1FgEZEql56VQxOCm8ZlEQ9YOMbg89sARBtNCYlIOAUWEalyKYkNSLSCgeVX0wgA27JIbBwPQLTRCIuIhFNgEZEql5wQx4B2wR8/u00CtmXx+FVn0LRxAgAxGmERkcMc07OERESOV7vYAwBExzdn4Z8uJDkhjs1rdwWPGT9eXy7JCXHVeYkiEkE0wiIi1ePAbgBi4luEgslX6cGdb2PI57wn5jJ16ZZquzwRiSwKLCJSPXKCoykHY5oCwZVDLyzYBkA98nGN4YFpq/H69CBEEVFgEZFqMHXpFvKzdwLwyYZ8pi7dQnpWDgdNcFmzbRlsXBxj2JR1oDovVUQihAKLiFQpry+XsdNWHXrwoYnngWmraRBj41p2qF0UDrZl0T6xfnVdqohEEAUWEalS6Vk5uAaahZY1x+MYw4F8l7GXdQ21q2cFePyqM1R4KyKAVgmJSBVLSWyAxzI0J/gcoSwSQiMpvdo3htnBdh+M6snJHdpW34WKSETRCIuIVKnkhDgeGtyWWMsPwG4SQiMpHtsmYII/lprWq86rFJFIoxEWEaly5ycbAPabOObePyRs2ieATRQufr82jxORQzTCIiJVLudXLwA+T0KxGhV/wd9Rjt9f5dclIpFLgUVEqtzBvRkA7PU0KbbPSsAqCCwBjbCIyCEKLCJS5X7ZlA7A1vyGxXa0DRSMsAQ0wiIiRSiwiEiV8vpy2bE9GFCyTDyuIWxHW4fgXiyuRlhEpAgFFhGpUulZOSQWWdIMhO1oG5oS0giLiBShVUIiUqVSEhuQXbBpXJYJBpaiO9o6VhQYjbCISDgFFhGpUskJcWRF7wM3GFhsywrb0dYp+LHkBjTCIiKHKLCISJVrYvYCcMV5XRnX58LwfVis4AMQNcIiIkWphkVEqpQxhibuXgBOaNOu2D4sbmhZs0ZYROQQBRYRqVLvLlxLA+sgANdP/iVsSTMU1LAAxsmv8msTkcilwCIiVcbry+U/M74FIM9Ek23iwpY0A7iegsASUGARkUMUWESkyqRn5dCU4AqhXSQAVtiSZgAnVMOiKSEROUSBRUSqTEpiA5pbBXuwmHggfEkzgCkYYUFTQiJShAKLiFSZ5IQ4LmprASUvaQZwPQUjLE6gWq5RRCKTljWLSJU6IXofALEJLVk46sISVgkFAwta1iwiRWiERUSqlLtvJwCehs2LhRUoMiXkqoZFRA5RYBGRKjN16Rayd3sB+HKrKbakGcAUTAkZR4FFRA5RYBGRKuH15TJ22ioSQ0W3CcWWNMOhwIICi4gUocAiIlUiPSsH10Bz9gLBJzUfvqQZwNjBwGIpsIhIEQosIlIlUhIb4LGghbUXgAzTtNiSZgBUwyIiJVBgEZEqkZwQx0ND2tHICk4B7aJJsSXNAMaOCf6LRlhEpAgtaxaRKnNBcnBvlX0mjjn3X1LiKqHCERbLKLCIyCEaYRGRKrM/axsAu62mpTcqGGHJO3iwWEGuiNRdCiwiUmVWr10LwHanMec9MbfEZc3efcFRmJ2+/aW2EZG6R4FFRKqE15fLLxs3AJBBE1xDsWXNXl8uqzOCq4ZiCJTYRkTqJgUWEakS6Vk5tLD2ALDTNAEotqw5PSuHADYAHtwS24hI3aSiWxGpEimJDdhj/QpAZkFgOXxZc0piA5yCwGJjSmwjInWTRlhEpEokJ8TRLjobOLQHy+HLmpMT4ujathkANk6JbUSkbjqmwPLiiy/Svn176tWrR69evViyZEmpbV955RXOP/98mjRpQpMmTRgwYECx9jfddBOWZYX9M2TIkGO5NBGJYE1NcITlwu5nsPD+CxnWs22xNu1bJATbxnlKbSMidU+5A8vUqVMZM2YM48aN4/vvv6dr164MHjyYnTt3ltg+LS2N4cOHM2/ePBYtWkSbNm0YNGgQ27dvD2s3ZMgQvF5v6J/JkycfW49EJCJNWbyZZm4wsLzwXQ4Lft5VYjvLE5wSivW4GlkRkZByB5Znn32WUaNGMXLkSE477TQmTZpE/fr1ef3110ts/+677/LnP/+Zbt260alTJ1599VVc1yU1NTWsXWxsLC1btgz906RJk2PrkYhEHK8vl6enf0OsFVyynGmalLr6x2MXbhznVOk1ikhkK1fRbX5+PsuWLWPs2LGhYx6PhwEDBrBo0aIynePAgQP4/X6aNg3fOCotLY0WLVrQpEkT+vfvz6OPPkqzZs1KPEdeXh55eXmhr7Ozg/Pifr8fv7/03TELXztSm9qurt8D9b96+r8hI5skdgOw0zTGTxQYw8bMbBLrh/8Ycgv+jrKMUynXqc9A3e4/6B5EUv/Lcw3lCixZWVk4jkNSUlLY8aSkJNYWbAh1NPfddx+tWrViwIABoWNDhgzhqquuIiUlhY0bN/LAAw9w8cUXs2jRImzbLnaOCRMm8NBDDxU7Pnv2bOrXP/pqgjlz5pTpWmuzun4P1P+q7f/ePGhtZQGwwwT/ELEwbFz+LbvXhLfN3bqZswHXn8eMGTMq7Zr0Gajb/Qfdg0jo/4EDZd+yoEqXNT/xxBNMmTKFtLQ06tWrFzp+7bXXhv69c+fOdOnShY4dO5KWlsZFF11U7Dxjx45lzJgxoa+zs7NDtTHx8fGlfn+/38+cOXMYOHAg0dHRFdSrmqWu3wP1v/r63yhrCeyE7aYZHgseveJ0ru5+QrF2K+buhyyIsS0uueSSCr8OfQbqdv9B9yCS+l84Q1IW5QosiYmJ2LZNZmZm2PHMzExatmx5xPc+/fTTPPHEE3z55Zd06dLliG07dOhAYmIiGzZsKDGwxMbGEhsbW+x4dHR0mW5+WdvVZnX9Hqj/Vd//llZwSshKOIGvR/UvtaA2quC6PMap1GvUZ6Bu9x90DyKh/+X5/uUquo2JiaF79+5hBbOFBbS9e/cu9X1PPfUUjzzyCDNnzqRHjx5H/T7btm1j9+7dJCcnl+fyRCRCTV26hV93/ALA0j0NSl0hBOCxCwILKroVkUPKvUpozJgxvPLKK7z55pusWbOG2267jZycHEaOHAnAiBEjwopyn3zySf7+97/z+uuv0759ezIyMsjIyGD//v0A7N+/n3vuuYdvv/2WTZs2kZqayhVXXMGJJ57I4MGDK6ibIlJdvL5cxk5bReuCEZYdJvGIzweyPMGBX49xq+waRSTylbuGZdiwYezatYsHH3yQjIwMunXrxsyZM0OFuFu2bMHjOZSDXnrpJfLz8/nd734Xdp5x48Yxfvx4bNtm5cqVvPnmm+zdu5dWrVoxaNAgHnnkkRKnfUSkZknPysE1h4put5nE0POBSpoWsgqWNWuERUSKOqai29GjRzN69OgSX0tLSwv7etOmTUc8V1xcHLNmzTqWyxCRGiAlsQH1LD8trL1AcJXQkZ4P5IkKTgnZ2odFRIrQs4REpFIlJ8TxUL/gRpC5Jgaf1eiIzwfy2IVPa1ZgEZFDFFhEpPL5tgHB0RVjrCM29RTUsNiqYRGRIhRYRKRSeX25LF2xAigILHDkolutEhKREiiwiEilSs/KoY0VfDjqVtMCIFR0WxI7qmCEBY2wiMghVbrTrYjUPSmJDdhZEFg2m+BqwiMV3dqFRbcaYRGRIjTCIiKVKjkhjpNjgkuat5gW2JZ1xKJbyxMsulVgEZGiFFhEpFJNXbqFFgEvAFtMEvcOOYVhPduW2t62taxZRIpTYBGRSuP15fLotCUkWsEHnG0xLXhq5rpSC24BPIXPElINi4gUocAiIpUmPSuHEwjWr/xqGrKP+kcsuAWIKtjpNkqBRUSKUGARkUqTktiAdp7g0923lKHgFoosa7YMxtW0kIgEKbCISKVJTohjSKuDQNkKbuHQCAuA6wQq/RpFpGZQYBGRSjN16Rb2e9cDwSXNRyu4BfBEHwosTsBfqdcnIjWHAouIVAqvL5ex01bR3soAylZwCxBVsA8LgBPQCIuIBCmwiEilSM/KwTXQwRNc0rzRbXXUgls4tHEcQMDRCIuIBCmwiEilSElsQEPrIK2sXwHYaFodteAWwPYUqWHRlJCIFFBgEZFKkZwQxw0nBwNHlonHR0OGntnqiAW3ALbtwSl4orOmhESkkAKLiFQKry+XHRtWAvCLSQZg+g87jlrDYlkWAYLb87uaEhKRAgosIlIp0rNy6GAF61d+cYOBpSw1LABOQWDRCIuIFNLTmkWkUqQkNuBXawcQrF+Bo28aV8gp+FtK+7CISCGNsIhIpVjw865DIywmGcviqJvGFXI0JSQih1FgEZEK5/Xl8tdpK0gJBZZWWAb6nty8TO93reCPJk0JiUghBRYRqXDBhx5mEmflc9BEs9kk4UKZ6leg6AiLAouIBCmwiEiFS0lsQCfPVgDWm9a4eMpcvwJFim41JSQiBRRYRKTCLfh5F6cQDCzrTNty1a+ARlhEpDgFFhGpUIXPEDqlYIRlrdumXPUrAE5BDcue/WWbQhKR2k+BRUQqVOEzhE6xCkdY2pSrfmXq0i3kO8Gdbp+duYapS7dU1qWKSA2iwCIiFSolsQFxVn7oKc1r3TZlrl8pHJ0p3OnWwuWBaauPujuuiNR+CiwiUqGSE+IYeXIetmX41TRkF43L9AwhODQ6U7hxXBROmXfHFZHaTYFFRCqU15fL7g3fAbDGbQdYZXqGEARHZzwWoREWG6dcq4tEpPZSYBGRCpWelcMZVjoAq0wKUPZnCCUnxDHhqs6hEZZoyy3X6iIRqb0UWESkQq3a5qOzJxhYVrvBwFKeUZJhPdsSGxMDwI29TmBYz7aVc6EiUqMosIhIhfH6cnlm5mpOtYIre1ab9gDce/Ep5RslsYJTQg1irIq+RBGpoRRYRKTCpGfl0JHtxFp+sk0cm00SAF1aNy7XedyCwII2jhORAgosIlJhUhIbhKaDfnRTMHiwLMpdNFsYWLTTrUhk8Ppy+WZjVrVuMRBVbd9ZRGqlztYvwKGCW0z5z2Gsgh9NrgKLSHXx+nL5btOvfLbSy+wfMzGAx4IJV3WultoyBRYRqTDpWTmc5VkPwA/uiUAwr2zKOlCuGhZTsDW/0QiLSJVbsXUPz6euZ+7aXUWOGhLJJssk8MC01fQ9uXmVr95TYBGRCrNmk5ebCgpuv3dPAsq3QqiQWzDCYlynYi9QRErk9eUy56cM3lq0mQ07c0LHm7OX39oLuMZOI5dYfpM/IbRNgQKLiNRIXl8uqalfcHOMYbtpRiZNgWNYIQSYghoWoykhkUpV0miKjcOFnuUMs9O40PMDUZYLQI6JJZndZFjNqmUzRwUWEakQ6Vk5dLOC00GFoytQ/hVCAMZTsEpIgUWkwnl9B1notfjn81+zMevQaEp7y8s19nx+ay8gydobOr7MPYmpTj8+d84hhzhG9+tYLZs5KrCISIVYtc0Xql85nukgKDolpMAiUhGKFtDO+jETsIEc6pHHJZ7FDItKo5dnbah9lolnmnM+7zsXsMGcEDp+8RktuXtwp6rvAAosIlIBvL5c/jHzJ5bFrANgmXsycGzTQQAUFN1qHxaR4+P15fLEF2v4eLm3yFFDZyudYfY8Lre/Id4KLlV2jMUCtwtTnAuZ656Fv0hEuKhTc/5y0Ul0bdOkintwiAKLiBy39KwcTmEzCdYBsk0cPxbscHss00EAxlPwo8mo6FakvIqPpgQlsJ8r7YUMs9M41bMldHyL25z3nX78z+lLBs1CxwefmsTlZ7birHZNIuJ5XgosInLcUhIbcJ7nRwCWuJ1wsI9pw7gQ1bCIlFtJBbQWLud6fmSYncZgz1JireD/p/JMNDPdnkx1+rHIPQ1TZB/ZoV1bcd8lnSIipBSlwCIiFeIcz08ALHJPCx44hg3jCrnaOE6kTEpbjpzEr1xtz2eYnUYbz6EA85PbjilOPz52zsNHw9DxSBtNKYkCi4gct00793J2QcHeIvd04Ng2jAspfJaQ9mERKVFpy5H7eZZzrT2P/p4fsK3gXw3Zpj4fO+cy1enHapMCWIChQ2Icf+jTgYtOTYrYkFKUAouIHDfvT9/S2zrIHtOQNSa4ZfexrhACQlNClkZYREJKG005wdrFNfY8rrHn09LaEzq+2O3E1EA/Zri9OEhs6Hj/UxLpFp3BbcPOJzo6ukr7cDwUWETkuHh9uWxY+gVEwWL31NBc+DGvEAIoLLrVCItIiSt9ogkwwLOM4fZc+nhW4ykYTdltGvGh05epTj82mtah9h0T6zOyTwoXnZpEYv0oZsyYUeX9OF4KLCJyXN5YmE5fazUA3xTWr3DsK4SAQ0W3WiUkddSKrXv4ck0mK7f6mL8+K3Q8xfIyzJ7Hb+0FNLeyQ8e/cs5gitOfOW538jk0alLScmS/3181nahgCiwicsy8vlze++on7o4N1q8sdDsDwSe6Hs/W3YVPa9aUkNQ1Xl8ut72zjOVbfaFjseQzxLOE4VHzOMezJnQ80zTmA+cCpjr92GqSQsdrQgHtsfAcvUlxL774Iu3bt6devXr06tWLJUuWlNr2lVde4fzzz6dJkyY0adKEAQMGFGtvjOHBBx8kOTmZuLg4BgwYwPr164/l0kSkCqVn5XCeZxUxlsMvbkt+Ma0A+GOfDsf3g1IjLFKHeH25fLpiO7e8/R29J8wNhZWTra2Mi3qTxbG383zMvznHswbHWKQ6ZzIqfwzn5r3A04FhobAytGsrFo3tz8s39uA3XVrVqrACxzDCMnXqVMaMGcOkSZPo1asXEydOZPDgwaxbt44WLVoUa5+Wlsbw4cM599xzqVevHk8++SSDBg3ixx9/pHXr4PzaU089xT//+U/efPNNUlJS+Pvf/87gwYP56aefqFev3vH3UkQqRYMYm4s8PwAw1z0zdPw3XVoe13ktj0ZYpPYraaVPHAe51P6W4fZczvJsCB3fZhJ5P9CPD5wL8Ebw5m6VqdyB5dlnn2XUqFGMHDkSgEmTJvH555/z+uuvc//99xdr/+6774Z9/eqrr/Lhhx+SmprKiBEjMMYwceJE/va3v3HFFVcA8NZbb5GUlMT06dO59tprj6VfIlIFPl+xnVF2MLCkumeFjh/Id4/vxBphkVqqtJU+Z1i/MLxgq/xGBVvl+43Nl+5ZTHH685XbGbdgUqRoAW1tDylFlSuw5Ofns2zZMsaOHRs65vF4GDBgAIsWLSrTOQ4cOIDf76dp0+Cj59PT08nIyGDAgAGhNgkJCfTq1YtFixaVGFjy8vLIy8sLfZ2dHSw88vv9RywmKnytphYcVYS6fg/U/4rrv9d3kCVfp/JAbDbZJo7v3FOAYP1K64SY4/oebsGzhCw3UOH/rfQZqNv9h+q5Byu2+XgxbSPz1h0qoG3IAYbaX3OtPY8zPJtCx9PdJKY6F/Kh05ddNA4dPyWpAY8NPYOuJySEjh1LHyLpM1CeayhXYMnKysJxHJKSksKOJyUlsXbt2lLeFe6+++6jVatWoYCSkZEROsfh5yx87XATJkzgoYceKnZ89uzZ1K9/9EK/OXPmlOlaa7O6fg/U/+Pv//RNFhcWjK4scLuEHpTWr6XLD1/P5YfjOLd/524ADh7YX2nLL/UZqNv9h8q/B3vzYPWvFgsyLDIPWgQ3bAuOplxvp3K5/Q0NrOAf33kmipnu2UxxLuTb0PYAhqR6Lt2aGU5vYmjXyMf2lV+zfWXFXF8kfAYOHDhQ5rZVukroiSeeYMqUKaSlpR1XbcrYsWMZM2ZM6Ovs7GzatGnDoEGDiI+PL/V9fr+fOXPmMHDgwBq1WU5Fquv3QP2vmP57fQe5c9EC7o9ZCsBcJ1i/YgHjr+9HcsLx1Z4t+d8aWAf1Y2O45JJLjutch9NnoG73Hyr3Hnh9B/lhy14+W+Vlzprw2pTL7UVcZ6fS1fNL6Ph6tzWTnf5Mc/qwl0ah4yWNplSUSPoMFM6QlEW5AktiYiK2bZOZmRl2PDMzk5Ytj1xk9/TTT/PEE0/w5Zdf0qVLl9DxwvdlZmaSnJwcds5u3bqVeK7Y2FhiY2OLHY+Oji7TzS9ru9qsrt8D9f/4+r/N5+MkayuneLaRZ6L40u0OwKjzO9A2sdFR3n10nqjgtXlwKu2/kz4Ddbv/UPH34OlZa/nXvI1hx06xtnCdncqV9kLiC2pT8kwUX7hn825gAEvNKRSOvEDJ+6ZUlkj4DJTn+5crsMTExNC9e3dSU1MZOnQoAK7rkpqayujRo0t931NPPcVjjz3GrFmz6NGjR9hrKSkptGzZktTU1FBAyc7OZvHixdx2223luTwRqSIpiQ24zA7WrS1wu5JNAwBG9mlfIecPrRJS0a1EuMIi2tcXprNpdzCQxJLPbzzfcl3UXHp4fg61TXeTeM+5iP85fdnDodmAurTS53iUe0pozJgx3HjjjfTo0YOzzz6biRMnkpOTE1o1NGLECFq3bs2ECRMAePLJJ3nwwQd57733aN++fagupWHDhjRs2BDLsrjzzjt59NFHOemkk0LLmlu1ahUKRSISWT75YTuXeoKB5VPnHKDo34jH79CyZgUWiTxeXy7fbfqVz1Z6mfXjoRmHjtZ2httz+Z29gMZWcAWQ39jMdrvzrjOARe5poUdXQHDflPsu6aSQUkblDizDhg1j165dPPjgg2RkZNCtWzdmzpwZKprdsmULHs+h/yAvvfQS+fn5/O53vws7z7hx4xg/fjwA9957Lzk5OfzpT39i79699OnTh5kzZ2oPFpEI5PXl8umsmdwSm0muiQlNBx3X05kPZwd/NHk0wiIRpKR9U2LwM9izlOvsufS2fwod32YSeS/Qnw+cfmErfTSacuyOqeh29OjRpU4BpaWlhX29adOmo57PsiwefvhhHn744WO5HBGpQm8sTOcy+xsA5rrdOEDwD4vj3Y6/KI8d3IdFgUUiQUnb5bexMrnOnsvV9nwSC57p4xiLue5ZvOtcxAK3S53fN6Wi6VlCIlJmXl8ub3y1nm9iFwLwiXNe6LX7Lq7Aoe3CZwmhnW6lepT08MEoAlzk+Z7r7VT62qtCbTNME6Y4FzI1cGHYLrRVWUBbFyiwiEiZpWfl0M+znOaWj10mntSC7fivO7stt/TtWGHfx2MXrBIyx7ljrkg5rdi6h/s+XMnajP2hYy3Yw3VRqQy355Jk7QXANRYL3C6861zEXPdMHOxQe9WmVA4FFhEpswYxNsPseQB86PQlUPAjZFjPEyr0+1iqYZEqVPJ2+YZe1lpuiJrNYM93RFvBz+IuE8/7Tj8mO/3ZZg49P0/TPpVPgUVEymzGoh+417McgA+cC0LHj/vZQYfxKLBIFVixzcdzX67n642/ho41IJcr7YXcYM/hFM+20PEl7im8HRjITPfs0K7OoGmfqqTAIiJl8vL8jdgrJmNHG5a6J7PRBJ+2XpHFtoVCIywosEjFW7HNx5PLPexYtDh07ERrGzfYc7jKXhh6+GCOiWW604e3nYGsNW1DbU9NbsToC0/USp8qpsAiIkfl9eXy9BerWRD7JQCTA/1Dr/2xT4cK/6FduA+LRlikohSf9vEQRYCBnmWMsOeELUne6CbztjOQD52+7ONQGO+U1JAnf9dFoynVRIFFRI4qPSuHIZ4lJFu/sssk8JnbGwhuFldRu9sWFZoSQkW3cuxK2+CtOXsYbs/juqhUWlp7gOCS5DluD95yBvKNezqFWyFecGIi3do1pn+nFgoq1UyBRUSO6uv1WfwhaiYAbwcGkk9wFc/tF3aslCFxT5RGWOT4FH+uj+Fsay0jouYw2LM0rIh2itOf9wIXhS1J1kqfyKPAIiJH5PXl8s38mdwTu4E8E8V7zkWh1847sXmlfE+rYFmzrRoWKYeSnutTjzyutBdyoz2bTp6tobZL3ZN5OzCIL4oU0WqlT2RTYBGRI0rPyuG2qE8A+MQ5lyyCj7uvjGLbQh5PcE8LWyMsUgZeXy5PfLGGj5d7Q8das4sbouZwrT0v9FyfAyaW6c65vO0MYo1pF2p7Xsdm3DvkFE35RDgFFhE5ouVLF/JnexmusZjkXBY6/ud+lTMdBEU2jsPB68vVX7tSTMn1KcFpn5FRMxnk+Q7bMgBsdlvwljOID5wLQk8WB8PlXVsy9pLT9fmqIRRYRKRUL8/fSJsfXwIbZrhnh5YyQ+VNBwF8k76XkwDLuJz3xFwmXNWZYT3bHvV9UjccXp8SSz6X299wkz2L0z2bQ8cXOqfzhjOEee6ZYc/1uaF3O6ztq7juyq5ER0dX+fXLsVFgEZESeX25vD8zlTkxwb0q/hW4MvRaZU4HeX25/HfRVm6MhSgcXAMPTFtN35Ob6y/hOqyk+pQkfuX3UV9ynZ1KM2sfALkmho+cPrzhDGG9ObQDc9EN3vx+PzNmrCrx+0jkUmARkRKlZ+VwV9T/8FiG2U73sI2zKvRBhyV8X3/BX8N2wbJmxxg2ZR1QYKmDitenGM60NjAyaiYXe5aEVvtsN814KzCIKc6F+GgYer9W+9QeCiwiUqJVi+dxi70Y11g8E7g6dPym3u0q9EGHh0tJbIApeJBcYWCxLavSRnQkMh0eVKIJcInnW0ZGzaSb55dQu8VuJ94IDGGO2z30AEKt9qmdFFhEpJiX0zbQec2zYMNHbh/WFRldGXxGcqV+7+SEOG658GT4Jris2bYsHr/qDP3iqSNWbN3DUzPXhp7vE89+rrPnclPUrNAmb3kmik+cc/mvM4QfTfvQe7UTbe2mwCIiYby+XBbNnsItMT+RZ6J41v+70GuVWbtS1JDOreEbiLJcFt7Xj+TGGl2p7VZs3cN9H65kbcZ+AE6wdnKz/QXX2Gk0sPIA2Gka81ZgIJOd/uwuWF4PegBhXaHAIiJh/vH5SsZFvQXAm85gtnNoNVBl1q4UVbisGSA5PrbSv59Un8ODypnWev4Y9TlDPEtDy5LXuG14zbmET5xzQ7ssg+pT6hoFFhEJeXn+RpJ/fJWU6Ex2msb8s8jKoKHdWlVq7UpRdtShH01uwI8nxq6S7ytV4/AHEXpwGez5jlFRM+jh+TnUboHTmVec3/CV25nCZ/uoPqXuUmARESD4S+StL77iy9jpADzmv479RZ5Ue9/FnarsWgoffggQcALEVNl3lsp0eCFtHAcZYc/nD/ZM2nuCm7/lG5uPnfN41bkkrHZK9SmiwCIiADzxxVr+Hv0OcVY+i91OfOyeF3ptbBUPu0cVHWFx/FX2faVyHB5UmrOXm6Jmcr2dGto2f69pwDvOAN4MDGIXh0KJgooUUmAREV6evxH/ymkMiVlKwHh40H8ThUPwVTkVVMiOOlSnEAgEqvR7S8Xx+nJ5IXU97y0JPnSwrZXJn+zPuNpeQKwVDKKb3CRecy7mf05fcqkXeq+e7yOHU2ARqeO8vlz+88ViZse+AcCLzhVhQ/FVORVUyLaL1rAosNQ0hweVU63N3Br1KZd6FoUKaX9wT2RS4DLmuN1D2+aDCmmldAosInXcC6nreTj6DZpZ+1jjtg3bgr+qp4IK2R4PjrGwLYOjKaEaY8XWPTyfup65a3dR+CDC26I+4UJ7RahNmtOVlwKXs9h0onAUDxRU5OgUWETqMK8vl33fTeU3MUvwG5u7/bfiL/ixUB1TQYU8Hos8bGwCOI5GWCJd0aXJFi4DPD9wW9QndPesB8AxFp+75zApcBk/FdnoTSt+pDwUWETqsFc+TuXx6NeA4FRQ0V1Dq2MqqKjCaQI3oBGWSOX15XLbO8tYvtWHjcNVnq+5NepTTvZsByDPRPOB05f/OJeyxSSF3texeQOevaar6lOkXBRYROqoV+atYeiGv9HIk8sS9xReKDIVdN3Zbav9L97C58JohCXyFF31E02Aa+yvuN3+mHaenQBkmzjecQbyRmAIu2gc9t7b+3XkniHVG4alZlJgEamDvL6DeFIfoktUOntMQ+7IHx0KCAD/d9GJ1Xh1QU7hCIsCS8QoGlRi8HOdvYA/R33MCVYWAFkmntcDF/O2M5B9hD9O4bqz2/B/F51U7UFYai4FFpE6aNbUFxkV9QUAd/tvwUuz0GvVVWh7OMcqnBJSYKluRYNKLPncYKdxW9QntLKCDyjcZRKYFLiU95yLwpYmg4KKVBwFFpE6Zs6PW/hH3jNgwaTAZaS63UOvVWeh7eEKR3w0wlJ9Dg8qI+1Ubo36lCRrLwAZpgmTApcx2elPXpH9iAefmsTlZ7birHZNFFSkwiiwiNQhz0z/mvvzniPOyifN6cpTgWFhr1d3oW1RrqaEqk3RfVRiyedmew63Rn1Gc8sHwA7TlH8HruAD54KwoNK1TQKTft9dIUUqhQKLSB3x3IzlDFx1Nyd4dvOL25K/+EeHbdgVKVNBhVyNsFSLlxdsZMKMtUQT4Pf2PEZHTaeltQeAbSaRFwNX8KHTN+ypydo+X6qCAotIHfD0zB/pvOj/0d1ej8/UZ5T//5FNg9DrN/VuFzFTQYUcywajwFJVvL5cxn28mtSfvPzOXsgd9jTaeHYBwaDyQuBKPnTOJ1Dk14aCilQlBRaRWu4fM9eQtHAcg6O+I89E88f8u9loWodev7BTc8ZfcUY1XmHJNCVUNQrrVD5Zvp1LPEuYHfMBHT3BhxTuNI35V+AKpjj9NaIi1U6BRaQWe3n+RsxXzzIieg6usbjDfztLzaE6lcGnJfHyiB7VeIWlcwtGWIyrwFIZvL6DPPPlKj5evoP+nh/4POYDTvNsBmCPachLgct4yxnEQWJD79GGb1KdFFhEaqkVW/ewc/az/D36fQAeCoxgpnt2WJvxV5xeHZdWJhphqTyp2y3ueHoB3awNTI15j16etQDsM3G8GriE15yL2X/YPira8E2qmwKLSC00dekWVk9/hkei3wFgYuAq3nQGh7V58redI6rI9nCupaLbiub15fLgR6tYt3UX/4p+n0vtbwE4aKL5rzOESYFL2UujsPdoHxWJFAosIrXMiq17WD59IhOi/wvAi4HLmRj4bZEWhv/dcg49UhKr5frKqnAfFuM61XwlNV9hncr85T/zl6iPeDFmDjGWg2ssPnTO55nA1WQU2TwQ4Oz2TXh++JkKKhIxFFhEapGpS7ewZvo/mBD9FgD/CfyGfwSGAVaozeVtXbqekFBNV1h2pmCExTh6+OHxeHrWWl6Zt4ab7FksiP2YeOsAAPOdLjwRGM4a0y6svQpqJVIpsIjUEiu2/Mr26Q8xPvp/ALwauJjHA9dRNKzcdkF7OuVvqKYrLB9NCR2fFVv3MGbqD5z8axqpse+Gnvfzk9uOxwPXsdDtHNZeBbUS6RRYRGqBl+evJ2rO3xkTHXw+0LP+3/FP50qKhpXbL+zInf07MmNGzQgspnBTO00JlYvXl8udU35g76YVPBL1FufG/AQEd6d9xn8NH7l9wjYMBBXUSs2gwCJSwz08fTmnfvd3ro5aAMB4/wj+6wwJa3P7hR25Z3An/P6aM70SGmHRsuYye3rWWt6at4K7oj7khpg5RFkuB000LzuX8VLgsrAlyqA6FalZFFhEaiivL5e735rPn3c+zHlRP+IYi3v9t/Ch2zesXWFYqWncUA2LRliOxuvL5fa3l9DJ+zFpsVNpau0HYIZzNo8HrmebaR7WvlU9l3/e2DviC69FilJgEamBpi7dwgvTUnkj+h+cZG8nx8Qy2v8X5rlnhrWrqWEFDhXdohGWUhU+pHDF0q94LPpVukX/AsA69wQeCozgGzd8B+OOzRvw5FVnsH3l1zWi8FqkKAUWkRrG68tlyrRpTI95hkQrG69pys35d/OTaR/WriaHFSi6SkiBpSQvL9jI8zOWMybqAx6JmYltGbJNHM8FfsfbzsCwZ/7AoToVv9/P9pXVdNEix0GBRaQG8fpyee/fjzAl5mVirQCr3fbcnH83mTQNazf24k7cckFkPcywvEKBRUW3xYz/eDXbF3/InNg3aW3tBuAz5xwe9t/ATsJX+Qw+LYnxV5yuOhWp8RRYRGoAry+Xl+as5tTlj/H/ouaBBTOdnozx38YB6oXadWuTwEu/714rfjmFalg0JRSyYuseHp0ylz9m/5vBMd8BsNVtzt8DI0lzuxVrXxuCq0ghBRaRCPfygo38d8bXvBTzHN2ifsE1Fk8HruHfzuUUXbZ8Y+92PBSBT10+VodqWDTCAvCH1xeTsOEjXo1+kwT7AH5j86pzCc8Hriq2+kejKlIbeY7epLgXX3yR9u3bU69ePXr16sWSJUtKbfvjjz/y29/+lvbt22NZFhMnTizWZvz48ViWFfZPp041d+5dpKKM/3g1X8+cyqexf6Wb5xf2mIbc6L+PfztXUDSs3FTLwgoAHhXdQnB07frnpjM8/X6ei3mJBOsAK90ULst/jCcDw4uFlbEXd+LlET0UVqTWKfcIy9SpUxkzZgyTJk2iV69eTJw4kcGDB7Nu3TpatGhRrP2BAwfo0KEDV199NXfddVep5z399NP58ssvD11YlAZ/pO7y+nL5v7e/ZVDGK4yP+RyA1W57bvXfVWyJ6oWdmjO+toUVDk0J1eXA8vL8DayZ9RovRr9JYzuHfGPzfOC3vOxcWqyoVg8plNqu3Kng2WefZdSoUYwcORKASZMm8fnnn/P6669z//33F2vfs2dPevbsCVDi66ELiYqiZcuW5b0ckVrn5QUbmfzFPP4Z/S+6RKUD8N/AICYEriOPmLC2tW0aKEwdL7p94sNv6Lx8HLfEBEewV7op3O2/lZ9Nm7B2taluSeRIyhVY8vPzWbZsGWPHjg0d83g8DBgwgEWLFh3Xhaxfv55WrVpRr149evfuzYQJE2jbtm2JbfPy8sjLywt9nZ2dDYDf7z/iTp6Fr9Wk3T4rWl2/B5Hcf6/vIE/PWkfUjx/wecwbNLDy2GMacq//T8xxexRrf9/gk/hjn5Ry9SWS+384t8jDDyvyeiP9Hnh9B3nprXcZ7XuK1vZu/Mbm+cBVTHIuKzaqctsF7Rkz4GSg7P2J9P5Xhbp+DyKp/+W5BssYY8raeMeOHbRu3ZpvvvmG3r17h47fe++9zJ8/n8WLFx/x/e3bt+fOO+/kzjvvDDv+xRdfsH//fk455RS8Xi8PPfQQ27dvZ/Xq1TRq1KjYecaPH89DDz1U7Ph7771H/fr1y9odkYiRut1i4Zb9PBL9Br+xg39Rf+ueyp35fyaDZkVaGs5t4TL4BEPj2JLPVVvE/fg2g/Ln8HncUAKdrqruy6l0e/Pgy60uPfdMZ7T9MR7LkO4mcYd/NCtN0ZU+hlb1Dbd0cmv9Z0BqvwMHDnDdddfh8/mIj48/YtuIKBS5+OKLQ//epUsXevXqRbt27Xj//fe5+eabi7UfO3YsY8aMCX2dnZ1NmzZtGDRo0BE77Pf7mTNnDgMHDiQ6OrpiO1FD1PV7EIn9f/jzNeRv+5DZsa+TaGUTMB6eD1zFi87QsIfUdT0hnheu7UZyQr0jnO3IIrH/pVm69RPIgqZNEuhxySUVdt5IvAcfLNvGKx+n8UL0vzgzKvhwyvcDFzA+cGPYsnWAG85pw4O/Oe2Yv1ck9r+q1fV7EEn9L5whKYtyBZbExERs2yYzMzPseGZmZoXWnzRu3JiTTz6ZDRtKfqpsbGwssbHF/7SIjo4u080va7varK7fg0jo/4qtexg/ZQF/yP43l8V8C8Batw13+29htekQ1raia1Uiof9H5Qn+ePLgVsq1Rso9WLF1D7M/eZfPYv5NYyuHbFOfsf4/8rl7TrG2FbmvSqT0vzrV9XsQCf0vz/cvV2CJiYmhe/fupKamMnToUABc1yU1NZXRo0eX6yKPZP/+/WzcuJEbbrihws4pEim8vlzunPIDCZtn85/o12huB0dVXnIu54XAleQT/n/gmr7F/jGrA/uw/Gf+z+TOmcDr0R/hsQw/uCcyOv//2E74SjAV1oocw5TQmDFjuPHGG+nRowdnn302EydOJCcnJ7RqaMSIEbRu3ZoJEyYAwULdn376KfTv27dvZ/ny5TRs2JATTzwRgLvvvpvLLruMdu3asWPHDsaNG4dt2wwfPryi+ikSEZ6etZYP5i1lfPSbXByzFICf3dbc7b/1sDqFoDq9U6ld8OOpli5rfuGzxXRefA/9olYA8FZgII8Gfl8ssNbqlWAi5VDuwDJs2DB27drFgw8+SEZGBt26dWPmzJkkJSUBsGXLFjyeQ/PuO3bs4MwzDz1B9umnn+bpp5/mggsuIC0tDYBt27YxfPhwdu/eTfPmzenTpw/ffvstzZuH/5UhUlN5fbnc/vYSOns/5MvY92lk5RIwHv7jXMrzgauKLVfWnhqERlgsU/tGWP495ROG/jSGNvYuck0MD/hv5iP3/GLt6nRgFTnMMRXdjh49utQpoMIQUqh9+/YcbSHSlClTjuUyRCKe15fLC6nrWbH0Kx6PfpWu0b8A8L17Ig/4/8haE750X0P/RRTsdHvgYD5eX26tuCdeXy6vvPYyd/meoJEnl81uC27138Ua0y6snbbWFykuIlYJidQ2hUHl0yXruCPqQx6JmYltGbJNfZ4MXMt7Tn/MYU/GuL1fR+4ZUgdrVUqRuT84FeTds58/PDGXCVd1ZljPkvdmqgleXrCRHbOe58Got7Atw7fuqdyafyd7Cd+64eIzWvLS77tX01WKRC4FFpEK9vKCjTwx4yd+Zy9gbuwUmlvBZXufOufwsP8GdtEkrL3+mi7O68vl5525EA02Lq6BB6atpu/JzWvkfXp65o8kLhzPQ9GzgeCS5b8GbsZ/2I/g127szkWnasdvkZIosIhUEK8vl3EfryZrzUKmx7xFV09w+mejm8xDgREscLsWe49qFEqWnpVDoGAEyraCNSyOMWzKOlDjAsuzX6yk0zf3cGnUt7jG4snAtbzsXErRh1cCPPnbzgorIkegwCJynAqnf75cspL7oifz29iFAGSbOJ4PXMVbzuBif0lrVOXIUhIb8CXBGpYoXABsy6J9Ys3ayfrxaUs4/4e7ON9eTb6xuct/e7H9VVS3JFI2Ciwix6gwqHy4ZCN/sGcyL/YjGlh5uMbiA+cC/hEYRhYJxd6nUZWjS06I49RWjWFXcErItiwev+qMGvVL/f9em8PNm++jm72RHBPLLf4xLHQ7h7XRkmWRslNgESmnwqAyeclmrvQsZG7sB7S2dgOwzD2J8f4bWXXYTrWgpcrl1SYxHnZB8wY2C2+7sEbdt6f+9xWjN9/JKZ5t7DENGZl/L8vNiWFtFFxFykeBRaSMCoPKe0u20sezis9j3uM0z2YAtptmPO2/hunuecVW/yioHKOCZc2xHmrUvXvxs2+4YuWtnOLZRoZpwvX5D7DRtA5r8/Ht59K1TZNSziAiJVFgETmKokHlNGsTb0VPpq+9CoBsU58XA1fwX2dwsc3fVJtwfKyCZwlZpubsdPuvzxYxYMmfOMWzjUzTmOH5fyPdJIe1efK3nRVWRI6BAovIETw9ay3/mreRVmTxTPQHXOlZiMcy5Bubt5xB/CswtNg+GqA9VSqEHRxh8dSQnW7/+fkSBi4ZRSfPVjJNY67N/3tYWOnYvAHv/LGXAqzIMVJgESnBiq17GPP+crJ3bWdc1CdcZ6cSawX/0v/YOZenA1ez1SQVe5+mfyqOZRWMsBSsEopkz81YTp/Ft3OqZys7SxlZUVgROT4KLCJFrNi6h/s+XElmxg5uifqMG2NnE2flA/CNcxpPBIaX+JBCBZWKZxU8/NAT4VNCT89cTbdFd9LT/plsU58R+ffzi2kV1ubJ33bWZ0PkOCmwiHAoqOzIyOTmqBncHPsFDa2DQHDlz9OBa1jknl7sfQoqlcfyFD78MHJHWF5O20DbhQ8wIOoHDppobs6/u9jzoVRgK1IxFFikTisMKlsysrjJnsktsZ+RYB0AYLXbnqcDV5PmduPwXUkVVCpfYdFtpNawrNi6h+w5T3JL9HwcYzHa/xeWmvC6JRXYilQcBRapc/bmwYxVGfxn4SZ+2bGT6+1Ubo39lMSCZ/6sc0/g2cDvmOX2REGl+hyaEoq8wDJ16RZSP3qd/8S8D8CDgZF86YY/sFAjKyIVS4FF6gyvL5fn5/zMlO9tGn7/LSPsObwVO4Nm1j4A0t0kngv8js/c3riH7aUytGsr7rukk4JKFfLYhVNCkRVYvL5cXp/2OdNi/g3Am4GBvOsMCGujkRWRiqfAIrVe0X1U4tnPHfYsRkbNpLGVA8AmN4kXnSuY5pyPU/D8mkIKKtUnNCVEZAWW12Yt5dXoZ2hg5fG1czqPBG4Ie10jKyKVQ4FFaq0VW/fwfOp65q7dRROyuTvqC260Z9PIygVgg9uKfwWG8qnbW0ElAnkKpoTsCBph8e7N4fxVf6WNvYtNbhK3+/9CoMiP0bGXdFJYEakkCixS63h9udz2zjKWb/XRnL2Mjfqc39tf0sDKA2CN24YXAlcy0z1bUz8RrLCGJZL2YVn01oNcZa/koInmFv9dYZsG3n5hR27pq2cDiVQWBRapNby+XJ74Yg0fL/fSiizGRX3OcHsu9Sw/AKvc9rwQuJI5bvdiz/vp2iaBSdpGP6JE2gjLY5Ne577dr4MF4wI3sa7I8uWh3Vpxz2DtbCxSmRRYpEbz+nL5btOvfLbSy6wfMznZ2soz0Z9yhecboqzgX+bfuyfyz8CVJS5PvqhTc/5y0Ukaxo9AoVVCETDCMuHDRdzkfZQoy+Vj51ymOv3CXr/vYoUVkcqmwCI1UtFCWjD0tNbxWvSnXGT/EGrztXM6/3Yu52v3DMKDimF4zxP4y4BTNKISwTx2dPB/q3mE5eX5G+n4wwRaR+1mk5vEA/6bKfp5GqspRJEqocAiNU7hAwktXAZ6vufWqE/p7lkPgGssZrhn83LgMlaZDsXeO7xnazo5m7nu8tOJjo6u6kuXcrALljXb1bhKyOvLZfGs93g9Zj6usbjbfws5HAonN/Vup7oVkSqiwCI1gteXy5yfMnh9YTrbd+/jansht9ifcaJnBwB5Jpr/OX35j/MbNpuWYe89NbkRoy88kbPaNSGxfhQzZmyuji5IOR1a1lx9U0L//GwJE6JfBeA152K+K7KT7YWdmjP+ijOq69JE6hwFFoloRQtpG5DLcHsuN8d+QbL1KwDZpj5vOwP4b2AIu2gc9t5OSQ158nddwupT/H5/VV6+HAc7qqDotpoCy8vzN3LWmqdJitrLRjeZpwPXhF4bfFoSL4/oUS3XJVJXKbBIxDm8kLYVWYyNmsVwey7xBXuoZJgmvBa4mMlOf/ZTP+z9JQUVqXk8dvVtHOf15TJ75sd8GLsAgHv8t5BHTOj18VcUfxCmiFQuBRaJGEU3egPoam3gn9FfcIlncWjFz0Y3mZedS5nu9CGf8BoUrfipXQqLbu1qeFrzUzNW82j0GwBMDlzI9+bk0GsqshWpHgosUu2KbvTmwWWw5zv+GDWDnp6fQ20WOqfzqnMJ892uxfZQ0QMJa6fCZwlFVfEIy8vzN5Kw+i1Ojd7CXtOApwLDQq8N7dZKRbYi1USBRarF4dM+DcjlJns+f7C/oK0nOMKSb2w+cc/jtcDFrDHtip1Du9LWbnZUwbLmKqxh8fpyeeWLxcyN/QCApwLXsof40Ovab0Wk+iiwSJUK3z8FktnN/VGzuM6eS7x1AIA9piHvOAN4KzCQXYRP73RMrM/IPilcdGqSgkot5/EUjLBYLhgDlnWUdxy/9Kwcbo+aTryVyyq3PVOcC0OvaSpIpHopsEiVOLw+pYu1kT9GzShWn/K6czEfOudzkNiw96uQtu4pHGEBcB0HT1Tl/7havWoFN9lfAvB44PrQs6a034pI9VNgkUpTOO0zaf4v/LgjmygCXOZZwk1Rs0IbvQF845zGq84lzHO7FatPUSFt3WVHHVqV4zj+Sg8sXl8uicueJcZ2WOB0ZpF7aCXQ4DOSK/V7i8jRKbBIhTt82icRH/9np/L7qC9JsvYCwfqUT93evB64hB9N+7D3F93oTUPwdZfHPhRenYCf6NjK/Sy89dHn3OP5GoAnA9ceug4L2ifWL+1tIlJFFFikwpQ07XNj1Cwu9XxLrBUAYKdpzDuBAUx2+pdpozepu6LCRlgClfq9Xp6/ke4b/4XHNnzqnMOPJiX02rU92yo4i0QABRY5LoVb5r+1aDMbduYQTYDLPYu5KWoWZ3k2hNp9757IfwOD+cLthf+wj52mfaQkhcuaAZxA5QUWry+Xj2fOYkbsDzjG4tnA1WGv/99FJ1ba9xaRslNgkWNy+GhKc/Zyh53K9VGptDhs2ufNwGBWmuIFi9o/RY4kKqzotvICS3pWDrdGfQLA5+45pJtD9SpaGSQSORRYpFxWbN3DfR+uZG3GfiC4G+2NUbO51LOIGCu4wVemacy7pUz7qD5Fysrj8eAYC9sylTrCsnTZd4z2fAvAS4HLQ8e1MkgksiiwyFEdPu0Tg5/LPUsYGTWLM4tM+yxzT+LNwGC+cM/WtI8cN8uycPBg4+A4lfPQypfnb6T5ypexowxznW5hGxRqZZBIZFFgkVKt2LqHp2au5euNwScjt2YX90SlMsxOI9HKBiDPRPGZe46mfaRSONiAUylTQl7fQSZ9sZRFsV8BMClwWeg1rQwSiTwKLBLm8NEUC5cLPKv4vT2H/p4fsC0DBJ+W/G7gIiY7F5FFQtg5Bp+axOVnttK0jxy3wo3b3EqYEtq8+wDX2GnUs/z86LZjiTm07f59F6t2RSTSKLBIsef6ADQhmz/Z87neTqWdZ2eo7ULndN52BpLqnkXgsI+Pnu0jFS04wkKlTAkt2pjJDVFzAPivMxgIbv2v2hWRyKTAUocdvtIHDGdaG/h91JcFe6cEf0lkm/p84FzAu85F/GJahZ1DoylSmQJWcITFuBU7wrI3DzYsnsYJMVn8ahryiXNu6DXVrohEJgWWOsbrO8hCr8U/n/+ajVk5AMRxkMvtRdxgz+EMz6ZQ29Vue95yBvKp05tc6oWdR6MpUhXcwhGWCp4SSvNa3GSnAjDVuZA8gpvUqXZFJHIpsNQR4aMpNpBDR2s719up/M5eEHpScp6J5lO3N+8EBrDcdKRwmBz0pGSpek5BDcvufbmkHKVtWXl9B1nj3cP5sasAmOz0D72m2hWRyKXAUosdXkALEEWAAZ7vucGew3n2j6G2m90WvOMM4APnAvbSKOw853Vsxr1DTtGSZKlSU5du4TzjAQse/XQlw6M6Mqxn2+M+7+bdB7jKXojHMix2O7HFJAFw3dltVbsiEsEUWGqZkgpoAZL4leFRc7nWnkdLaw8AjrGY657F284AvnI7hz0pWaMpUp28vlzGTlvFvOhgYPEYlwemrabvyc2P+/P4zcZdXGPPB+AD54LQ8WE9Tziu84pI5VJgqSW8vlye+GINHy/3ho55cOnrWcH19lz6e74PLUneZeKZ6lzI5EB/ttM87Dza4E0iQXpWDq6BQEENSxQOjjFsyjpwXIHF68vlu69mcV9sJjkmlhlOr9BrB/Ld475uEak8Ciw1WGmjKS3YwzB7HsOi0jjBygodX+x24p3AAGYethOtVvpIpElJbIDHKhJYLAcb67gLYt9YmM6V9kIAPnfO4UBBMbmKbUUinwJLDVR8OXLhaMpKhttzucjzPVFW8K/FvaYBHzp9ec/pz0bTOuw8WukjkSo5IY4JV3Um8GkwsMTg8PhVZxz36MrrX21gSewSAKa754VeU7GtSOTzHL1JcS+++CLt27enXr169OrViyVLlpTa9scff+S3v/0t7du3x7IsJk6ceNznrIu8vlzeWpTOgGfTuOLFb4o8JXkPt9vTWRB7J/+NeYrB9ndEWS5L3FO4K/82euW9yCOBG0JhZeCpidx0ksOCu/sycfiZ+iEtEWtYz7ZERwef2DyqT5vjLrhNz8rhHM9PNLX2s9s0YrF7KqBiW5GaotwjLFOnTmXMmDFMmjSJXr16MXHiRAYPHsy6deto0aJFsfYHDhygQ4cOXH311dx1110Vcs66pKTRFAuX8z2ruM6eywDPstBois/U50OnL5Od/qw3hwoIixbQJtaPYsaMGSQn1Cv2vUQijWsFA0uDChgLbhBjc0nBU5lnOT1Du+iq2FakZij3j4Fnn32WUaNGMXLkSAAmTZrE559/zuuvv879999frH3Pnj3p2bMnQImvH8s5a7uSliMDNGcvV9tpDLfn0cZzKMAsdU9mcqA/n7vnhDbAgpILaP3+ynnqrUhlcK1gqHArYGv+GSu28if7OwA+c88JHVexrUjNUK7Akp+fz7Jlyxg7dmzomMfjYcCAASxatOiYLuBYzpmXl0deXl7o6+zs4JOD/X7/EX8hF74Wib+0V2zzMW/dTlZu8/HVhl9Dxy1c+nhWM9yey0DPMqItBwhul/+hcz6Tnf78bNqE2ndIjGNE7/b0P6V5aBSlaH8j+R5UBfW/ZvXfsYI/ogL5ecd1zV7fQX78ZgbNYvaFTQd5LGidEFNj7kdFqGmfgcpQ1+9BJPW/PNdQrsCSlZWF4zgkJSWFHU9KSmLt2rXlOdVxnXPChAk89NBDxY7Pnj2b+vWPXuk/Z86cY7rWirY3D1b/arEgwyLzoEXRXWUT8XG1PZ9r7blhDx9c5p7Ee4GL+NztxUFiC44aTm/sMvgEQ7tG+yBrFT9kwQ9H+N6Rcg+qi/pfM/rf2h8M6Fs2/YJ3xoxjPs96n8Vgz1IgfDqoX0uXH76ee8T/r9RWNeUzUJnq+j2IhP4fOHCgzG1r5CqhsWPHMmbMmNDX2dnZtGnThkGDBhEfH1/q+/x+P3PmzGHgwIGhYr7qsGKbjxfTNjJvXVbYcQuXcz0/cp2dyqDDRlOmOX2Y7PRnnTlUeDjw1EQu7dyKM9s2LnNNSqTcg+qi/tes/q9e8yIchDatkjnrkkuO+Twrtu6l5cZgDd0ct3vo+J8v703XExKO+zprkpr2GagMdf0eRFL/C2dIyqJcgSUxMRHbtsnMzAw7npmZScuWLctzquM6Z2xsLLGxscWOR0dHl+nml7VdRSqtLgWCu9D+zl7AMHsebYvUpnzvnshkpz+fOr2LjKZUzHLk6rgHkUT9rxn9N57gNVo4x3W933+/hD9ZWeSZaBa5p4WO+12rRtyHylBTPgOVqa7fg0jof3m+f7kCS0xMDN27dyc1NZWhQ4cC4LouqampjB49ulwXWZnnjBSlbewGwWf6XOhZzjB7Hhd6lod2oc02cUwvGE1ZY9qF2mtzN6mLjCc4dWOOo+jW68sl64dPIRoWuaeFwr82ixOpWco9JTRmzBhuvPFGevTowdlnn83EiRPJyckJrfAZMWIErVu3ZsKECUCwqPann34K/fv27dtZvnw5DRs25MQTTyzTOWuSI4UUgHZWBsPsNH5nL6CFtTd0fLHbiamBfswoUpui5/lIXWcKljUfT2B5Y2E6F3pWADDX7RY6/ofz2un/VyI1SLkDy7Bhw9i1axcPPvggGRkZdOvWjZkzZ4aKZrds2YLHc2g/uh07dnDmmWeGvn766ad5+umnueCCC0hLSyvTOWuCkvZLKRRLPkM8S7jWTqO3/VPoeJaJ539OX953+vGLaQXABScm0q1dY/p3aqHn+Uid53oKfkQ5gWN6v9eXy5SvfuSe2HUAzAsFFsOIc9qV+j4RiTzHVHQ7evToUqdrCkNIofbt22OMOa5zRqoj1aUAdLK2MMyex5X2QhpbwdddYzHf7cIU50LmumeFnumjbfJFSlAwJYR7bIElPSuH8zyriLYcNrrJbDXBP4L6JxttnihSw9TIVULVqTCkfLLcy3eb9xR7vSEHuMxexDB7Ht08v4SObzOJvB/ox/+cvuwgEVBdisjRFBbdcoxTQg1ibPp4VgMw3+0aOt6tmTaLE6lpFFjKYMXWPXy5JpOVW33MX59VQgvDWdZ6rrXncan9LfWt4KZ2+cZmttuDqc6FfO2egYuHjon1eVR1KSJlYgqmhMwxjrDk5Duc4wlOw37jnh46nu9apb1FRCKUAstR/PndZcxYlVHia03J5kr7K6610zjJsz10fL3bmilOPz5yzudXgvvClLRNvogcRWENi3tsIywbN27gXI8X11gscU8JntKC5vWOPk0tIpFFgeUI/jFzbbGwYuFynudHrrXnMsjzHTEFm7sdMLF85pzDFOdCvjcnARbndWzKxZ2TNZoicowKR1isYxhh8fpyWTL/U26Ihp9MO7JpCMDdg06icfaaCr1OEal8Ciyl8PpyeTFtY+jrluzmans+w6LSOME6NC203O3AVOdCPnV6s5/6DD41iRdVlyJSMQo3jjuGwPLGwnTOsYLB5NuCZwcBdGmdwO6yb64pIhFCgaUU6Vk5RBHgIs8PDLPncYFnRWhzN5+pzzTnfN53+rHGtKNjYn3uV12KSMULTQmVL7B4fbm88lU6X8YE61e+Ldjd1mNB26b12V2hFykiVUGBpRQpiQ1o59nFyzHPhY4tck5jitOPme7ZtGwSz0WnteSJbq1UlyJSWezCKaHy1bCkZ+WQyB46Hla/8sc+HUhOqFcnH3YoUtMpsJQiOSGOP105iM8/OYfNpgXvOxfQrmNnurVrzPva1E2kahzjlFBKYgPO8QSng4rWr4zs075CL09Eqo4CyxEM69kW78nTaZp1gCsT62u6R6SKWYUjLMYp93vP8qwHYGnB6IoWMovUbAosR5GcEKegIlJdCkZYPMcwJdTVEyyaX+52BMAAm7IOkNg2vkIvUUSqhufoTUREqodlH9uU0I9bsjjd2gzAchN8yKptWXo6s0gNpsAiIhHrWKaEvL5cPp8zm1jLzx7TkM0Fzw+69+JTNFoqUoMpsIhIxCocYfGYso+wpGfl0MXaAMAKtyOF1StdWjeu6MsTkSqkwCIiEetYAsuqbT66FdavmGD9iqaDRGo+BRYRiViewsDilm1KyOvL5cmZa+lWMMKy3A3Wr2g6SKTmU2ARkYhlRZVvhCU9K4dGZj8dPMFngBWuENJ0kEjNp8AiIhGrcErIpmyBJSWxQWg6aJObxF4aYVloOkikFlBgEZGI5SlYJeQpxyqhUwuWM682KcEDpsIvS0SqgQKLiEQsO7QPix+vL/eo7dOzcjjVswWAn9y2wKEN40SkZlNgEZGItXxHDgDGCXDeE3OZunTLEduv2uajkxVss8a0A7RCSKS2UGARkYjk9eUybUUmANEEcA08MG11qSMtXl8uz81cSUdrBwBrCkZYtEJIpHZQYBGRiJSelUO+CdawRFnBGhbHmFKnd9KzcujIDqIsl72mARk0BbRCSKS2UGARkYiUktiAgBUMLNEFq4SONL2zapuPUz3Bgts1bjvA0nSQSC2iwCIiESk5IY7rzzsJgFgC2JbF41edUeL0TuGGcYX1K2tNG0DTQSK1SVR1X4CISGkuOqMNLA2OsCy8/8JSw0d6Vg6ugVMLAstPBQW3mg4SqT00wiIiESs6Jjb4vwRoGV+v1HYpiQ3wWKbIlFBbTQeJ1DIKLCISsWKigyElynIJBErf7TY5IY4Rp8fS1NqPYyzWmxMYemYrTQeJ1CIKLCISsaJiY0P/np93sNR2Xl8u6T8tBSDdJJNHDNN/2FGmzeZEpGZQYBGRiBUTc2gaKJBfemBJz8qhQ8H+K+tNa+DIS6BFpOZRYBGRiGVHFxlhOUJgSUlsENow7heTHHyvalhEahUFFhGJWJbHQ76xAQjk55XabsHPu+hgeQHY6LbCsih1CbSI1EwKLCIS0QIFuy/4Sxlh8fpyGTttFR09wRGWjaYVloG+JzevsmsUkcqnwCIiES3fCj6x2fHnl/h6elYO9c0Bkqy9APxiWuGiJzSL1DYKLCIS0QpHWEqbEkpJbEBHT3A6aKdpzD7qq35FpBZSYBGRiOYvGGEJ+EueElrw8y5SCAaWX0yy6ldEaikFFhGJaE5oSqj4CEux+hVX9SsitZUCi4hEtMIpIbeEwFL4DKGiS5pVvyJSOymwiEhEC3higJJHWILPEOLQkmbTSvUrIrWUAouIRDTXKhhhCRRfJZScEMdV3VqSYmUAsMG00jOERGopBRYRiWgBKzjC4gaKF916fbksXb6CWMtPnolmh0nUM4REaikFFhGJaK6nsIal+AhLelYOba1MADabFrh49AwhkVpKgUVEIprrCa4SKmlKKCWxAW2tnQBsNkmAniEkUlspsIhIRHMKim4JFC+6TU6Io3eTfQBsNS2wLUt7sIjUUgosIhLRCpc15x4sXpcydekWPL7NAGwxLbh3yCkM69m2Sq9PRKqGAouIRKypS7ew2ecAsGR9BlOXbgm9VrhpXOGU0BbTgqdmrlPBrUgtpcAiIhGpMJDkGxuAKAI8MG11KJAEN40zoaLbLaaFCm5FajEFFhGJSIW72PoLpoRiLH9YIElJbEATK4d4KxhgtpnmKrgVqcUUWEQkIhXuYptLLAD18IcFkuSEOK5s7wcg0zTmILHaNE6kFjumwPLiiy/Svn176tWrR69evViyZMkR23/wwQd06tSJevXq0blzZ2bMmBH2+k033YRlWWH/DBky5FguTURqieSEOCZc1ZmDBFcJxZEXtgLI68tl5+Z1QHA6CNCmcSK1WLkDy9SpUxkzZgzjxo3j+++/p2vXrgwePJidO3eW2P6bb75h+PDh3Hzzzfzwww8MHTqUoUOHsnr16rB2Q4YMwev1hv6ZPHnysfVIRGqNYT3b0uPEVgCkNLbDVgClZ+XQJlRwG9yDRTUsIrVXuQPLs88+y6hRoxg5ciSnnXYakyZNon79+rz++usltn/++ecZMmQI99xzD6eeeiqPPPIIZ511Fv/617/C2sXGxtKyZcvQP02aNDm2HolIrRJXvyEAsSZ8a/7gpnEFBbducIRFNSwitVdUeRrn5+ezbNkyxo4dGzrm8XgYMGAAixYtKvE9ixYtYsyYMWHHBg8ezPTp08OOpaWl0aJFC5o0aUL//v159NFHadasWYnnzMvLIy/v0CZS2dnZAPj9fvx+f6nXX/jakdrUdnX9Hqj/NbD/UcEpIDtwMOy6E+tHcXJMFrjBKSGPBY9ccSqJ9aP0c+AI6nr/QfcgkvpfnmsoV2DJysrCcRySkpLCjiclJbF27doS35ORkVFi+4yMjNDXQ4YM4aqrriIlJYWNGzfywAMPcPHFF7No0SJs2y52zgkTJvDQQw8VOz579mzq1z/6X1dz5sw5apvarq7fA/W/5vTf2ZFJd8Dk7w+rf1uUaXF7IAM8sMU059I2Dg0yVzJjxsoynbcm3YPKUNf7D7oHkdD/AwfKPoVbrsBSWa699trQv3fu3JkuXbrQsWNH0tLSuOiii4q1Hzt2bNioTXZ2Nm3atGHQoEHEx8eX+n38fj9z5sxh4MCBREdHV2wnaoi6fg/U/5rX/zVp2ZAFcR6HSy65BACv7yD3PDOXx2KygGANyw9bbe6+pi/JCfWOeL6aeA8qUl3vP+geRFL/C2dIyqJcgSUxMRHbtsnMzAw7npmZScuWLUt8T8uWLcvVHqBDhw4kJiayYcOGEgNLbGwssbGxxY5HR0eX6eaXtV1tVtfvgfpfc/ofW78RADEmL3TN23w+WrIb2zIcNNHsojEY2O7Lp21iozKdtybdg8pQ1/sPugeR0P/yfP9yFd3GxMTQvXt3UlNTQ8dc1yU1NZXevXuX+J7evXuHtYfgMFRp7QG2bdvG7t27SU5OLs/liUgtFF2vAQAx7qGi25TEBrQrsiU/WCq4Fanlyr1KaMyYMbzyyiu8+eabrFmzhttuu42cnBxGjhwJwIgRI8KKcu+44w5mzpzJM888w9q1axk/fjzfffcdo0ePBmD//v3cc889fPvtt2zatInU1FSuuOIKTjzxRAYPHlxB3RSRmiq6XsEqIQ4V2icnxDEwObjfyhY9pVmkTih3DcuwYcPYtWsXDz74IBkZGXTr1o2ZM2eGCmu3bNmCx3MoB5177rm89957/O1vf+OBBx7gpJNOYvr06ZxxxhkA2LbNypUrefPNN9m7dy+tWrVi0KBBPPLIIyVO+4hI3RITFxw1iTWHAsvUpVs4kLkRomCrntIsUiccU9Ht6NGjQyMkh0tLSyt27Oqrr+bqq68usX1cXByzZs06lssQkTogtmCEpR75OK5h576DjJ22iheiDj308K2Z67i8m7blF6nN9CwhEYlosXEFgcXys2nXvtBDEdsWqWHRDrcitZ8Ci4hEtE/X7An9++UT57Bqmw+PVTSwJKngVqQOUGARkYjl9eUy9tP1oa9jTT5PzVzHX85LJMEKjqhsp7kKbkXqAAUWEYlY6Vk5OMZDngnu1VCPfBxjOJj5CwA7TWNyjYrzReoCBRYRiVgpiQ3wWJBLDAD1rYN4gK0bfwKC9SsGeGDaary+3Oq7UBGpdAosIhKxkhPimHBVZ7JNsD6lsXWAP56fQjvr0AohQEW3InWAAouIRLRhPdsSiEkA4I89mjCyz6HAsskNPuJDRbcitZ8Ci4hEPH9M8KGm9QL7WPDzLtp7gk9732RaYlmo6FakDlBgEZGI548OjrDkZu9m7LRVpFjBwJJuWmIZ6Hty8+q8PBGpAgosIhLxnNhgYMnP+ZU4k0sLay8Am00SLqh+RaQOUGARkchXrzEAnjxfqH5lt2lENg1UvyJSRyiwiEjE23YwuKw5b9+vtLdUvyJSFymwiEhE8/py+Xq7A0A8OUUCS5LqV0TqEAUWEYlo6Vk5+EwDABKsHNoXWdKs+hWRuiOqui9ARORIUhIbsIdGADRnL7EePwC/mFZYFqpfEakjFFhEJKIlJ8TR6fRusB46eDLwGxuAH007MNV7bSJSdTQlJCIRzevL5c3VeRwoeMhhtOWwz8Sx2SRh0JSQSF2hwCIiEa3wic2bTVLo2E+mHQYPHk0JidQZCiwiEtFSEhtgARtNq9CxOU53AP7Yp4OWNIvUEQosIhLRkhPiuP/iTrwWuJiDJpqDJppPnHPxACP7tK/uyxORKqKiWxGJeLdc0BGsy/jNzIbYJsBuqykTtGGcSJ2iwCIiNcItfTtyeddWbMo6QPvE+gorInWMAouI1BjJCXEKKiJ1lGpYREREJOIpsIiIiEjEU2ARERGRiKfAIiIiIhFPgUVEREQingKLiIiIRDwFFhEREYl4CiwiIiIS8RRYREREJOIpsIiIiEjEU2ARERGRiKfAIiIiIhGvVjz80BgDQHZ29hHb+f1+Dhw4QHZ2NtHR0VVxaRGnrt8D9b9u9x90D+p6/0H3IJL6X/h7u/D3+JHUisCyb98+ANq0aVPNVyIiIiLltW/fPhISEo7YxjJliTURznVdduzYQaNGjbAsq9R22dnZtGnThq1btxIfH1+FVxg56vo9UP/rdv9B96Cu9x90DyKp/8YY9u3bR6tWrfB4jlylUitGWDweDyeccEKZ28fHx1f7f6TqVtfvgfpft/sPugd1vf+gexAp/T/ayEohFd2KiIhIxFNgERERkYhXpwJLbGws48aNIzY2trovpdrU9Xug/tft/oPuQV3vP+ge1NT+14qiWxEREand6tQIi4iIiNRMCiwiIiIS8RRYREREJOIpsIiIiEjEqzGBpX379liWVeyf22+/vdT37N27l9tvv53k5GRiY2M5+eSTmTFjRuj18ePHFztfp06dws5x8OBBbr/9dpo1a0bDhg357W9/S2ZmZqX1szSV0f+ynLNfv37FXr/11lsrta8lKW//S7puy7L4zW9+E2pjjOHBBx8kOTmZuLg4BgwYwPr168PO8+uvv3L99dcTHx9P48aNufnmm9m/f3+l9rU0FX0P/H4/9913H507d6ZBgwa0atWKESNGsGPHjqN+3yeeeKLS+3u4yvgM3HTTTcVeHzJkSNh5avNnACjxdcuy+Mc//nHE71sTPgMAEydO5JRTTiEuLo42bdpw1113cfDgwbA2L774Iu3bt6devXr06tWLJUuWhL1ek38PHK3/EyZMoGfPnjRq1IgWLVowdOhQ1q1bF3aOSPk9gKkhdu7cabxeb+ifOXPmGMDMmzevxPZ5eXmmR48e5pJLLjELFy406enpJi0tzSxfvjzUZty4ceb0008PO++uXbvCznPrrbeaNm3amNTUVPPdd9+Zc845x5x77rmV2dUSVUb/y3LOCy64wIwaNSqsnc/nq+TeFlfe/u/evTus/erVq41t2+aNN94ItXniiSdMQkKCmT59ulmxYoW5/PLLTUpKisnNzQ21GTJkiOnatav59ttvzVdffWVOPPFEM3z48Erubckq+h7s3bvXDBgwwEydOtWsXbvWLFq0yJx99tmme/fuYedp166defjhh8POtX///krubXGV8Rm48cYbzZAhQ8La/frrr2Hnqc2fAWNM2Oter9e8/vrrxrIss3HjxlCbmvoZePfdd01sbKx59913TXp6upk1a5ZJTk42d911V6jNlClTTExMjHn99dfNjz/+aEaNGmUaN25sMjMzQ21q6u+BsvR/8ODB5o033jCrV682y5cvN5dccolp27Zt2H/fSPk9UGMCy+HuuOMO07FjR+O6bomvv/TSS6ZDhw4mPz+/1HOMGzfOdO3atdTX9+7da6Kjo80HH3wQOrZmzRoDmEWLFh3ztVeEiuh/Wc55wQUXmDvuuON4L7fCHa3/h3vuuedMo0aNQv8ndF3XtGzZ0vzjH/8Itdm7d6+JjY01kydPNsYY89NPPxnALF26NNTmiy++MJZlme3bt1dgb47N8d6DkixZssQAZvPmzaFj7dq1M88999zxXm6Fq4j+33jjjeaKK64o9T118TNwxRVXmP79+4cdq6mfgdtvv71YX8aMGWPOO++80Ndnn322uf3220NfO45jWrVqZSZMmGCMqdm/B8rS/8Pt3LnTAGb+/PmhY5Hye6BGBpa8vDzTrFkz89hjj5Xa5uKLLzbXX3+9GTVqlGnRooU5/fTTzWOPPWYCgUCozbhx40z9+vVNcnKySUlJMdddd13YD+rU1FQDmD179oSdu23btubZZ5+t8H6VVUX1vyznvOCCC0xiYqJp1qyZOf300839999vcnJyKrQ/5VWW/h/ujDPOMKNGjQp9vXHjRgOYH374Iaxd3759zV/+8hdjjDGvvfaaady4cdjrfr/f2LZtpk2bduwdqAAVcQ9KMmfOHGNZVthfT+3atTNJSUmmadOmplu3buapp54yfr//mK+9IlRU/2+88UaTkJBgmjdvbk4++WRz6623mqysrNDrde0zkJGRYaKiosy7774bdrymfgbeffddk5CQYBYvXmyMCf7/vlOnTqH35OXlGdu2zUcffRT2vhEjRpjLL7/cGFOzfw8crf8lWb9+vQHMqlWrQsci5fdAjQwsU6dONbZtH/EvnFNOOcXExsaaP/zhD+a7774zU6ZMMU2bNjXjx48PtZkxY4Z5//33zYoVK8zMmTNN7969Tdu2bU12drYxJvgfOyYmpti5e/bsae69996K71gZVVT/y3LOl19+2cycOdOsXLnSvPPOO6Z169bmyiuvrND+lFdZ+l/U4sWLDRD6P60xxnz99dcGMDt27Ahre/XVV5trrrnGGGPMY489Zk4++eRi52vevLn597//fRw9OH4VcQ8Ol5uba8466yxz3XXXhR1/5plnzLx588yKFSvMSy+9ZBo3bhw2pFwdKqr/kydPNh9//LFZuXKl+eijj8ypp55qevbsGQr2de0z8OSTT5omTZqETYsaU7M/A88//7yJjo42UVFRBjC33npr6LXt27cbwHzzzTdh77nnnnvM2WefbYyp2b8HjDly/w/nOI75zW9+U2wEJlJ+D9TIwDJo0CBz6aWXHrHNSSedZNq0aRM2ovDMM8+Yli1blvqePXv2mPj4ePPqq68aYyL3g1oZ/S/LOY059NfGhg0bynfRFais11roT3/6k+ncuXPYsZoeWCriHhSVn59vLrvsMnPmmWcedW76tddeM1FRUebgwYNl/v4VraL7X6hw5O3LL780xtStz4AxwT90Ro8efdRz1ZTPwLx580xSUpJ55ZVXzMqVK820adNMmzZtzMMPP2yMqdmBpSL6f7hbb73VtGvXzmzduvWI562u3wM1LrBs2rTJeDweM3369CO269u3r7nooovCjs2YMcMAJi8vr9T39ejRw9x///3GmMgcCqyM/pf1nMYYs3//fgOYmTNnlv/iK0B5rtWY4PXGx8ebiRMnhh2vyVNCFXUPCuXn55uhQ4eaLl26hE2HlGb16tUGMGvXri3XdVeUiu7/4RITE82kSZOMMXXnM2CMMQsWLDBAWGF+aWrKZ6BPnz7m7rvvDjv29ttvm7i4OOM4To2dEqqo/hd1++23mxNOOMH88ssvR/3+1fV7oMYsay70xhtv0KJFi7BleSU577zz2LBhA67rho79/PPPJCcnExMTU+J79u/fz8aNG0lOTgage/fuREdHk5qaGmqzbt06tmzZQu/evSugN+VXGf0v6zkBli9fDhC6R1WtPNcK8MEHH5CXl8fvf//7sOMpKSm0bNky7L9tdnY2ixcvDv237d27N3v37mXZsmWhNnPnzsV1XXr16lUBvTk2FXUPILi0+ZprrmH9+vV8+eWXNGvW7KjnW758OR6PhxYtWpT72itCRfb/cNu2bWP37t2hz3dd+AwUeu211+jevTtdu3Y96vlqymfgwIEDeDzhv+Zs2waC2xrExMTQvXv3sJ8DruuSmpoa+jlQk38PHK3/hf87evRoPvroI+bOnUtKSspRv3+1/R6o0nh0nBzHMW3btjX33XdfsdduuOGG0MiIMcZs2bLFNGrUyIwePdqsW7fOfPbZZ6ZFixbm0UcfDbX5f//v/5m0tDSTnp5uvv76azNgwACTmJhodu7cGWpz6623mrZt25q5c+ea7777zvTu3dv07t27cjtaioru/9HOuWHDBvPwww+b7777zqSnp5uPP/7YdOjQwfTt27fiO1cG5el/oT59+phhw4aVeL4nnnjCNG7cOFTDcMUVV5S4rPnMM880ixcvNgsXLjQnnXRStS1pNaZi70F+fr65/PLLzQknnGCWL18etmSxcBTum2++Mc8995xZvny52bhxo3nnnXdM8+bNzYgRIyq+c2VQkf3ft2+fufvuu82iRYtMenq6+fLLL81ZZ51lTjrppLCpjtr8GSjk8/lM/fr1zUsvvVTstZr8GRg3bpxp1KiRmTx5svnll1/M7NmzTceOHUPTvsYElzXHxsaa//73v+ann34yf/rTn0zjxo1NRkZGqE1N/T1Qlv7fdtttJiEhwaSlpYX9DDhw4IAxJrJ+D9SowDJr1iwDmHXr1hV77YILLjA33nhj2LFvvvnG9OrVy8TGxpoOHToUWyUzbNgwk5ycbGJiYkzr1q3NsGHDis3J5ebmmj//+c+mSZMmpn79+ubKK680Xq+3Uvp3NBXd/6Odc8uWLaZv376madOmJjY21px44onmnnvuqZb198aUv/9r1641gJk9e3aJ53Nd1/z97383SUlJJjY21lx00UXFzr17924zfPhw07BhQxMfH29Gjhxp9u3bV2F9Kq+KvAfp6ekGKPGfwn0dli1bZnr16mUSEhJMvXr1zKmnnmoef/zxaqtdqMj+HzhwwAwaNMg0b97cREdHm3bt2plRo0aF/aIypnZ/Bgq9/PLLJi4uzuzdu7fYazX5M+D3+8348eNNx44dTb169UybNm3Mn//852LTOy+88IJp27atiYmJMWeffbb59ttvw16vqb8HytL/0n4GFO7VE0m/B6yCCxYRERGJWDWuhkVERETqHgUWERERiXgKLCIiIhLxFFhEREQk4imwiIiISMRTYBEREZGIp8AiIiIiEU+BRUREREq1YMECLrvsMlq1aoVlWUyfPr3c53j//ffp1q0b9evXp127dvzjH/8o9zkUWERERKRUOTk5dO3alRdffPGY3v/FF19w/fXXc+utt7J69Wr+/e9/89xzz/Gvf/2rXOfRTrciIiJSJpZl8dFHHzF06NDQsby8PP76178yefJk9u7dyxlnnMGTTz5Jv379ALjuuuvw+/188MEHofe88MILPPXUU2zZsgXLssr0vTXCIiIiIsds9OjRLFq0iClTprBy5UquvvpqhgwZwvr164FgoKlXr17Ye+Li4ti2bRubN28u8/dRYBEREZFjsmXLFt544w0++OADzj//fDp27Mjdd99Nnz59eOONNwAYPHgw06ZNIzU1Fdd1+fnnn3nmmWcA8Hq9Zf5eUZXSAxEREan1Vq1aheM4nHzyyWHH8/LyaNasGQCjRo1i48aNXHrppfj9fuLj47njjjsYP348Hk/Zx00UWEREROSY7N+/H9u2WbZsGbZth73WsGFDIFj38uSTT/L444+TkZFB8+bNSU1NBaBDhw5l/l4KLCIiInJMzjzzTBzHYefOnZx//vlHbGvbNq1btwZg8uTJ9O7dm+bNm5f5eymwiIiISKn279/Phg0bQl+np6ezfPlymjZtysknn8z111/PiBEjeOaZZzjzzDPZtWsXqampdOnShd/85jdkZWXxv//9j379+nHw4MFQzcv8+fPLdR1a1iwiIiKlSktL48ILLyx2/MYbb+S///0vfr+fRx99lLfeeovt27eTmJjIOeecw0MPPUTnzp3JysrisssuY9WqVRhj6N27N4899hi9evUq13UosIiIiEjE07JmERERiXgKLCIiIhLxFFhEREQk4imwiIiISMRTYBEREZGIp8AiIiIiEU+BRURERCKeAouIiIhEPAUWERERiXgKLCIiIhLxFFhEREQk4imwiIiISMT7/92a7vTj4zJHAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "[dBmag], [phase], [freq] = sqil.extract_h5_data(hanger, ['mag', 'phase', 'frequency'])\n", + "freq = freq[100:]\n", + "linmag = 10**(dBmag/20)[100:]\n", + "[c, beta] = estimate_linear_background(freq, linmag)\n", + "print(c, beta)\n", + "\n", + "phase = shift_phase(np.unwrap(phase))[100:]\n", + "data = linmag * np.exp(1j*phase)\n", + "\n", + "MEASUREMENT = 'hanger'\n", + "\n", + "z_data = (linmag * np.exp(1j*phase))[100:]\n", + "\n", + "maxval = np.max(np.absolute(z_data))\n", + "z_data = z_data/maxval\n", + "params, percent_err = fit_skewed_lorentzian(freq, linmag**2)\n", + "(A1, A2, A3, A4, fr, Q_tot) = params\n", + "# z_data = (np.sqrt(np.absolute(z_data)**2-A2*(freq-fr))) * np.exp(np.angle(z_data)*1j)\n", + "\n", + "# ##\n", + "# z_data = (z_data-params[1]*(freq-params[4]))*np.exp(2.*1j*np.pi*-1.2490871418390001e-10*freq)\n", + "# fitparams = phase_fit(f_data,center(z_data,zc),0.,np.absolute(params[5]),params[4])\n", + "# theta, Ql, fr = fitparams\n", + "# beta = periodic_boundary(theta+np.pi,np.pi)\n", + "# offrespoint = complex((xc+r0*np.cos(beta)),(yc+r0*np.sin(beta)))\n", + "# alpha = np.angle(offrespoint)\n", + "# a = np.absolute(offrespoint)\n", + "\n", + "# plt.plot(np.real(data), np.angle(data), '.-')\n", + "# plt.plot(np.real(z_data), np.angle(z_data))\n", + "plt.plot(freq, linmag**2, '.-')\n", + "plt.plot(freq, skewed_lorenzian(freq, A1, A2, A3, A4, fr, Q_tot))\n", + "plt.grid()\n", + "\n", + "print_fit_result(['A1', 'A2', 'A3', 'A4', 'fr', 'Q_tot'], params, percent_err)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cable delay (linear guess)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(-2.3772912682037306e-10)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "[c, tau] = estimate_linear_background(freq, phase)\n", + "tau /= 2*np.pi\n", + "\n", + "# delay = fit_delay(freq,data,tau,maxiter=200)\n", + "# delay /= 2*np.pi\n", + "\n", + "# The frequency correction must be relative to the first point we are considering\n", + "# In other words, the first point doesn't need to be corrected\n", + "phase1 = shift_phase(phase-2*np.pi*tau*(freq - freq[0]))\n", + "data1 = linmag * np.exp(1j*phase1)\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase, '.-')\n", + "plt.plot(freq, phase1, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data), np.imag(data), '.-')\n", + "plt.plot(np.real(linmag * np.exp(1j*phase1)), np.imag(linmag * np.exp(1j*phase1)), '.-')\n", + "plt.axis('equal')\n", + "\n", + "tau" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Move circle to center" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circle fit: xc = -0.38315215302486183, yc = 0.10042880571155877, r0 = 0.19833185249775195\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xc, yc, r0 = fit_circle_algebraic(data1)\n", + "data3 = data1 - xc - 1j*yc\n", + "phase3 = np.unwrap(np.angle(data3))\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase, '.-')\n", + "plt.plot(freq, phase3, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data), np.imag(data), '.-')\n", + "plt.plot(np.real(data3), np.imag(data3), '.-')\n", + "plt.axis('equal')\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Phase vs freq" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimization terminated successfully.\n", + " Current function value: 43.366913\n", + " Iterations: 133\n", + " Function evaluations: 275\n", + "-4.660265208746777 2878.941920907083 7741123452.837948\n" + ] + } + ], + "source": [ + "theta0, Q_tot, fr = fit_phase_vs_freq_taketo(freq, phase3, Q_tot=(Q_tot if Q_tot > 0 else None), f_r=fr)\n", + "print(theta0, Q_tot, fr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculate the off-resonant point and choose a and alpha" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.38539118449045995 -2.885464850940988\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p_offres = (xc+1j*yc) + r0*np.exp(1j*(theta0+np.pi))\n", + "a = np.abs(p_offres)\n", + "alpha = np.angle(p_offres)\n", + "\n", + "linmag5 = linmag / a\n", + "phase5 = phase1 - alpha\n", + "data5 = linmag5 * np.exp(1j*phase5)\n", + "\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase, '.-')\n", + "plt.plot(freq, phase5, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data1), np.imag(data1), '.-')\n", + "plt.plot(np.real(data5), np.imag(data5), '.-')\n", + "plt.scatter(np.real(p_offres), np.imag(p_offres), color='red')\n", + "plt.scatter(xc, yc, color='blue')\n", + "plt.axis('equal')\n", + "plt.grid()\n", + "\n", + "print(a, alpha)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Impedence mismatch and Q_ext" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circle fit: xc = 0.8957411655616807, yc = -0.5039531296330356, r0 = 0.5146247773139205\n" + ] + }, + { + "data": { + "text/plain": [ + "(np.float64(1.3667922957836747),\n", + " np.complex128(566.6754383109705+2739.123856132184j),\n", + " np.float64(-705.5526199861511),\n", + " np.float64(-2.899673182721388))" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xc6, yc6, r06 = fit_circle_algebraic(data5)\n", + "phi0 = -np.arcsin(yc6/r06)\n", + "\n", + "if MEASUREMENT == 'reflection':\n", + " Q_ext = Q_tot / (r06*np.exp(-1j*phi0))\n", + "elif MEASUREMENT == 'hanger':\n", + " Q_ext = Q_tot / (2*r06*np.exp(-1j*phi0))\n", + "Q_int=1/(1/Q_tot-1/np.real(Q_ext))\n", + "\n", + "# refl6 = S11_reflection(freq, a, alpha, tau, Q_tot, Q_ext, fr, phi0)\n", + "if MEASUREMENT == 'reflection':\n", + " res6 = S11_reflection(freq, a, alpha, tau, Q_tot, Q_ext, fr, phi0)\n", + "elif MEASUREMENT == 'hanger':\n", + " res6 = S21_hanger(freq, a, alpha, tau, Q_tot, Q_ext, fr, phi0)\n", + "theta0 = phase[0] - np.unwrap(np.angle(res6))[0]\n", + "\n", + "phi0, Q_ext, Q_int, theta0" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------\n", + "Q_total : 2878.941920907083\n", + "Q_external : (566.6754383109705+2739.123856132184j)\n", + "Q_internal : -705.5526199861511\n", + "resonance freq [Hz] : 7741123452.837948\n", + "kappa_tot/2pi [Hz] : 2688877.950826779\n", + "kappa_external/2pi [Hz] : 13660594.635813218\n", + "kappa_internal/2pi [Hz] : -10971716.684986437\n", + "Phi (Impedance mismatch) : 1.3667922957836747\n", + "\n" + ] + } + ], + "source": [ + "print(\n", + "\"-----------------------------------------\\n\" \\\n", + "+f\"Q_total : {Q_tot}\\n\" \\\n", + "+f\"Q_external : {Q_ext}\\n\" \\\n", + "+f\"Q_internal : {Q_int}\\n\" \\\n", + "+f\"resonance freq [Hz] : {fr}\\n\" \\\n", + "+f\"kappa_tot/2pi [Hz] : {fr/Q_tot}\\n\" \\\n", + "+f\"kappa_external/2pi [Hz] : {fr/np.real(Q_ext)}\\n\" \\\n", + "+f\"kappa_internal/2pi [Hz] : {fr/Q_int}\\n\" \\\n", + "+f\"Phi (Impedance mismatch) : {phi0}\\n\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGvCAYAAABmcr6xAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAANgNJREFUeJzt3Xt8FOXB9//vJiEhIckmkAABwhnEKiJyMh4QK0+l9Vx/yF1tPbQvFItPvWtthad3BX1VAdFqb2vVp1X0br3x9HhoPSt4KIIo3oaDGhQEghACAXIkbEL2+v0x2SWbbJLdMLOzYT/v12tfszszO3vNbJL55rquucZjjDECAABwQZLbBQAAAImLIAIAAFxDEAEAAK4hiAAAANcQRAAAgGsIIgAAwDUEEQAA4BqCCAAAcE2K2wXoiN/v1+7du5WVlSWPx+N2cQAAQASMMaqpqdGAAQOUlNRxnUdcB5Hdu3ersLDQ7WIAAIAu2LlzpwYNGtThOnEdRLKysiRZO5Kdne1yaQAAQCSqq6tVWFgYPI93JK6DSKA5Jjs7myACAEA3E0m3CjqrAgAA1xBEAACAawgiAADANQQRAADgGoIIAABwDUEEAAC4hiACAABcQxABAACuIYgAAADXEEQAAIBrCCIAAMA1BBEAAOCauL7pnaN2fya9v1TyeKTUXi0emRE+z5RSUt3eCwAAurXEDSJr/6+0+dVj20ZSjzAhpaMAE0HQ6ZFuhSMAABJA4gaRhlpretIPpQHjpYY6a15DXYtHO6+bfNZ7/Y3S4UrrYRtP+PCSFmlNTZjnPXpJSbTCAQDiT+IGkSOHrenI86TxP47uvU2NHQSWjsJMbTvTOqnxUPPGjdRQYz3s1CMjylqa1tMw70vuYW8ZAQAJhyCS0jP69yb3kNJzrIdd/E1WGOk03EQaeppfG7+1/cZD1qNun31lTk6LINhEWGuTlmVNU9LsKx8AIO4lbhBpPIYg4oSkZOtknJZl3zaNsQJXQ53kqzmGGpyWr2sl/xFr+00+qd4n1R+wr8xJPZqPQ6aU2jxNyzraPJWW3aKpqvl18Hmr5T0y6G8DAHEucYPIsdSIdBcej9X5tUe61CvPvu0eaYgiwNREtl7g+/A3WsHGjnDjSToaZoJBJRBqWkzDhp7WyzOtsAgAsBVBpMdxHESckpIqpfSWMnrbt82mI1Yw8dU0T2utEOOraX7eclmreSHvaZ4nYzVL+aqshx16ZDQHk2ypp1fq2TwNeZ3T/vLUTDoNA0ArBJHjuUakO0lOsa/fjd/f3N+mOZz4qtsGlQ4DTyD0NM/zN1rbDfSzqS3vYsE8VjhJ84YPKhl9rHCXnnv0eUYfKb23lJpx7McFAOJQ4gaReOsjAvskJTU3s2RKdnS5OeI7Gmh8Ndb0cLV0uKr5eVXoIzivxTJ/oyRz9HW0lTQpPY+GkozeR0NKr3wps5+U1d96ZPa35iUn7q82gO4lcf9aHWkeC4Qggs6kpFmPXn269v5Ap+GW4cRX1SqsVEqHmvvGHDooHdrf/PyAFWKOHJaqd1mPzniSQgOKd5CUOzT00dPbtX1xk98vlW+yRkXeV2LVTNXutcKh/4h1Wb2/UfIkS8mpVhNictrRaZsxeTJDOz63vHqr5TKu5AIclcBBpN6a0kcETmvZaTirf3TvNcY60QZCSTCsHLDCSt1eqaZcqilrPjGXW31jAs/3bAi/3fRcKXeY1O87Ur+TpX4nWVM7+/3YpXaf9NFDUvFyqXZP7D8/ObVFYAnX+bnVvNSs0E7OLa/6YnBBoI3EDCJ+v9TUYD2nRgTxzNPcr6RntlWT0Rl/k1RXYZ2wa/ZYAaXqW+ng9qOPun1S/UHrsft/Qt+fM1gafIY0pEgaerbUZ4T9+xSNjc9L//z3owP8pWZJA0+T+o+VsgdYtT5pWVJSijW+T1IPK4g1+ayru5p8Vk3JkcNSw6GjV3EF+gMF+wnVtegQ3fw80I+sqcG+K7kCIyentaqNaX0ZemqrIBNuHve7wnEiMYNI4A+MRBDB8SUpWcrqZz0KxoVfx1crVe6QKr6W9n4hlX8u7dlozasstR4bnrbWzRstnfB9aewVUv+TY7cfkrT6Qemt/7CeF4yTpv5aGvW92DWVNB052mE5pGNzJ1dshXR4bvE+45ftIycnp4WpeWmnNiYk8LRofmo5wCB9i+ACjzHGuF2I9lRXV8vr9aqqqkrZ2dn2bfjQAemeYdbz3+3nlw+QrL4q366TStdIO9ZIOz86OnidJA2aJE38mTR2pvO/M1/8Q3r2J9bzM/9d+u7vuvfvqTFSY30UAaadABRYr+U/U3bqaLTkLt3vilqbRBXN+bsb/2Yfg8AvcVJK9/7jBtipp9e699LI86zXh6ukLe9IX7wslbwqffuJ9fjXvdJ5t0snXuzMyLV1FdI/f2E9n3y9NH1h9x8h1+OxLsFOzZAy+x779poaWwWZdi5Tb1M7UxN+UMFAU7VToyVHcuuHaIJOSs/u/zOBoMQ8CzOGCNC5nl7p5MutR0259NnfpI/+LO3fIj17tXTCD6SL/lPKzLf3c1fdb/Vf6XeydP4iTjjhJPewOhyn59qzvSMNUmOLEZCDfWgiud9VBKMl232Xck9y9Pe46izocEsI18QkiDz00ENaunSp9uzZo3HjxunBBx/U5MmTY/HR4TGGCBCdrH7S1FulKTdIH/6nFRY2v2b1LfnRcqvzqB0OV0vrllnPz1tAjWWspDRf7mxXsJGsPjYh4aa9+11FcVuIwF3KTZO9oyZLsjoS9wp99GgdbDLahpc2AajVe1PSCDidcPy3/JlnntEtt9yiRx55RFOmTNEDDzyg888/X5s3b1bfvjZUUXYFNSJA16RlSd/9rfSdS6w+HAe+kZ64ULr2FXvCyOcvWievvNHSqP917NuDe5JTpGSvvWPWtLxLecS1Nq3DTZgQJMnqSFzb4rVNgrU3GaGhpkerUBNtyDmO+t44HkT+8Ic/aPbs2bruuuskSY888oheffVVPf7445o3b57THx8e95kBjk3/k6XZK6WnZlr9Rv7rUumG963B047F5y9Y01Ov5L9ItNXyLuV23ajc77fGlWpZaxO4RURIYKnrfFlD3dFaoMB5xpHaG7XqexMuxLQOOZlta2sC66Tn2Htj1Cg5GkQaGhr06aefav78+cF5SUlJmj59utasWdNmfZ/PJ5/PF3xdXV3tTMGoEQGOXXqudNXzVo1I+Ubp+Z9K175q9V/oCl+ttP1D6/mYi+wrJ9CRpKSjJ2U7OhIHBJumDoXWxHQYZGqP1vi0tyzQsdjOvjfDzpGu+cexb6eLHA0iFRUVampqUr9+/ULm9+vXTyUlJW3WX7Roke644w4ni2RJzZQGF1kjSwLouvQcadbfpEfPkXauldY8JJ31713b1vZV1h/X3KHuD6QGHCsnmqakVh2LW4WaxlbBpeFQZMt62jg8RhfEVU+w+fPn65Zbbgm+rq6uVmFhof0fVDhZ+ukb9m8XSES9h0nfXyy9dKP0wb1Ws0pX/rPc+ZE1HXo2zTJAe5zoWOwyR296kJeXp+TkZJWXh942vby8XP37t73nRlpamrKzs0MeALqBU/5NGnCa1Snw/SVd28a366zpoEn2lQtA3HM0iKSmpmrChAlasWJFcJ7f79eKFStUVFTk5EcDiKWkJGvgMUkq/m+pvjK69/v90q7m+94QRICE4vhtIG+55Rb95S9/0ZNPPqkvv/xSN954o+rq6oJX0QA4TgybKuWfaHWoW788uvdWlVpt2Mmp1qW7ABKG431EZs2apX379un222/Xnj17dOqpp+qNN95o04EVQDfn8UiTZ0uv3iJ98ldpypzI+3rsbe683mcUg5gBCcbxGhFJuummm7Rjxw75fD6tXbtWU6ZMicXHAoi1U2ZJKenWMPB7NkT+vn3NQaTvGGfKBSBuxSSIAEgQaZnSqOnW8y9ejvx9FV9b07wT7C8TgLhGEAFgrzEXWtMt70T+nsod1rQ3Y/sAiYYgAsBew8+1pmXrpbqKyN5TWWpNvQ6MGwQgrhFEANgrq5/U9yTr+fZVna/fdESq3mU9zxnsXLkAxCWCCAD7DT7dmn77Sefr1pRJ/iPWTbyy2g50COD4RhABYL/C5ivjSj/qfN2qndbUO9C6uyqAhEIQAWC/QROt6Z6NVtNLR2r2WNOsAc6WCUBcIogAsF/uMOsu100+af/XHa9b23wvKjtvwQ6g2yCIALBfUpLU72Tr+Z5NHa8bCCL0DwESEkEEgDP6NweR8o0dr1e715pSIwIkJIIIAGcERkmtiLRphvtPAYmIIALAGXmjrGnEQYSmGSAREUQAOCMQRA5uk5oa21+vdp817ZXnfJkAxB2CCABnZA2QemRYg5Ud3NH+eoerrGl6bmzKBSCuEEQAOCMpybqMV5Iqt4df54hPOlJvPe/pjUmxAMQXgggA5wTuHRO4qV1rgdoQeaS07JgUCUB8IYgAcE6kQaRntlWDAiDh8JsPwDmBINJeH5FgEKFZBkhUBBEAzgnWiLQXRCqtKUEESFgEEQDO8Q60ptVl4ZfXV1rTnjmxKA2AOEQQAeCcwB11a8slf1Pb5TTNAAmPIALAOb3yJU+SZJqkun1tlweDSE5MiwUgfhBEADgnOeXoPWSqd7ddTo0IkPAIIgCclVVgTWv2tF1GZ1Ug4RFEADgrGEQ6qBFJz4lZcQDEF4IIAGdlNTfN1O5tu4ymGSDhEUQAOKtXvjWtq2i7jCACJDyCCABnZeRZ03BXzQTHESGIAImKIALAWb2ag8ih/W2XcfkukPAIIgCc1audGhFjaJoBQBAB4LD2+og01kv+Rus5QQRIWAQRAM4K9BGpPyA1HTk6PzCGiCdZSu0V82IBiA8EEQDOyugtyWM9rz9wdH7LZhmPJ+bFAhAfCCIAnJWU3BxGFNpPhMHMAIggAiAWwvUToaMqABFEAMRCuLFEGEMEgAgiAGIh3Fgi1IgAEEEEQCyEG0uEwcwAiCACIBbC9hGptKbUiAAJjSACwHkZfazpIYIIgFAEEQDOCzbNcNUMgFAEEQDOy+ggiKTnxr48AOIGQQSA8wJ9RA5RIwIgFEEEgPMCTTP1B4/eb4ZxRACIIAIgFtJz1eZ+M9SIABBBBEAstL7fjN8v+aqt1wQRIKERRADERssOqw21kvFbrxnQDEhoBBEAsREc5r3i6BgiyWlSj56uFQmA+wgiAGIjMKhZ3X76hwAIIogAiI2QGhGCCAALQQRAbLTsIxIczCzHteIAiA8EEQCx0bJGhDFEADQjiACIDfqIAAiDIAIgNlrWiBzabz1P7+1eeQDEBYIIgNho2Uekttx6ntnPvfIAiAsEEQCxEbzfzAGpZo/1PDPfvfIAiAsEEQCxkZEneZKtEVXLN1nzqBEBEh5BBEBsJKdI2QOt5zVl1rRXX/fKAyAuEEQAxE7ukNDXmQQRINERRADETs7g0Ne96CMCJDqCCIDYyWlRI5I9kBveASCIAIihvmOOPh800b1yAIgbBBEAsTN6xtHn/ca6Vw4AcYMgAiB2UtKkWX+XTrpMmnK926UBEAdS3C4AgARz4kXWAwBEjQgAAHCRY0Hkrrvu0hlnnKGMjAzl5OQ49TEAAKAbcyyINDQ0aObMmbrxxhud+ggAANDNOdZH5I477pAkPfHEE059BAAA6ObiqrOqz+eTz+cLvq6urnaxNAAAwGlx1Vl10aJF8nq9wUdhYaHbRQIAAA6KKojMmzdPHo+nw0dJSUmXCzN//nxVVVUFHzt37uzytgAAQPyLqmnmV7/6la699toO1xk+fHiXC5OWlqa0tLQuvx8AAHQvUQWR/Px85edzt0wAAGAPxzqrlpaW6sCBAyotLVVTU5OKi4slSSNHjlRmZqZTHwsAALoRx4LI7bffrieffDL4evz48ZKkd999V9OmTXPqYwEAQDfiMcYYtwvRnurqanm9XlVVVSk7O9vt4gAAgAhEc/6Oq8t3AQBAYiGIAAAA1xBEAACAawgiAADANQQRAADgGoIIAABwDUEEAAC4hiACAABcQxABAACuIYgAAADXEEQAAIBrCCIAAMA1BBEAAOAagggAAHANQQQAALiGIAIAAFxDEAEAAK4hiAAAANcQRAAAgGsIIgAAwDUEEQAA4BqCCAAAcA1BBAAAuIYgAgAAXEMQAQAAriGIAAAA1xBEAACAawgiAADANQQRAADgGoIIAABwDUEEAAC4hiACAABcQxABAACuIYgAAADXEEQAAIBrCCIAAMA1BBEAAOAagggAAHANQQQAALiGIAIAAFxDEAEAAK4hiAAAANcQRAAAgGsIIgAAwDUEEQAA4BqCCAAAcA1BBAAAuIYgAgAAXEMQAQAAriGIAAAA1xBEAACAawgiAADANQQRAADgGoIIAABwDUEEAAC4hiACAABcQxABAACuIYgAAADXEEQAAIBrCCIAAMA1BBEAAOAagggAAHANQQQAALiGIAIAAFxDEAEAAK4hiAAAANc4FkS2b9+un/3sZxo2bJjS09M1YsQILViwQA0NDU59JAAA6GZSnNpwSUmJ/H6/Hn30UY0cOVKbNm3S7NmzVVdXp3vvvdepjwUAAN2IxxhjYvVhS5cu1cMPP6xvvvkmovWrq6vl9XpVVVWl7Oxsh0sHAADsEM3527EakXCqqqrUu3fvdpf7fD75fL7g6+rq6lgUCwAAuCRmnVW3bNmiBx98UDfccEO76yxatEherzf4KCwsjFXxAACAC6IOIvPmzZPH4+nwUVJSEvKeXbt2acaMGZo5c6Zmz57d7rbnz5+vqqqq4GPnzp3R7xEAAOg2ou4jsm/fPu3fv7/DdYYPH67U1FRJ0u7duzVt2jSdfvrpeuKJJ5SUFHn2oY8IAADdj6N9RPLz85Wfnx/Rurt27dK5556rCRMmaNmyZVGFEAAAcPxzrLPqrl27NG3aNA0ZMkT33nuv9u3bF1zWv39/pz4WAAB0I44FkbfffltbtmzRli1bNGjQoJBlMbxiGAAAxDHH2kquvfZaGWPCPgAAACTuNQMAAFxEEAEAAK4hiAAAANcQRAAAgGsIIgAAwDUEEQAA4BqCCAAAcA1BBAAAuIYgAgAAXEMQAQAAriGIAAAA1xBEAACAawgiAADANQQRAADgGoIIAABwDUEEAAC4hiACAABcQxABAACuIYgAAADXEEQAAIBrCCIAAMA1BBEAAOAagggAAHANQQQAALiGIAIAAFxDEAEAAK4hiAAAANcQRAAAgGsIIgAAwDUEEQAA4BqCCAAAcA1BBAAAuIYgAgAAXEMQAQAAriGIAAAA1xBEAACAawgiAADANQQRAADgGoIIAABwDUEEAAC4hiACAABcQxABAACuIYgAAADXEEQAAIBrCCIAAMA1BBEAAOAagggAAHANQQQAALiGIAIAAFxDEAEAAK4hiAAAANcQRAAAgGsIIgAAwDUEEQAA4BqCCAAAcA1BBAAAuIYgAgAAXEMQAQAAriGIAAAA16S4XQC3rN95UO98Wa6GI341NBmlJnuC04OHGiUj5fbq0WZZQ5NRn16pGprXSxOG5KrAm+72rgAA0G0lZBD5xfLP9I/1u23Z1sQhORqel9luaIkk2ATW6ZWaokvHD9C4wlxbygYAQLxLuCCyfudB20KIJK3bUal1Oypt296y1ds1Ii9D07/Tj2ADADjuJVwQ+Xj7AbeL0KmtFYe09YNttmyro2ATaaCRkcYO8mr6d/rRFAUAsJXHGGPcLkR7qqur5fV6VVVVpezsbFu2uX7nQV3y0GpbtpWIpo7M04h+mV2qqaFvDQAkhmjO3wlXIzKuMFeXnzZQ/+9/drldlG7pgy0V+mBLxTFvpyuBhiADAMefhKsRCVi/86BWfrlXvqYmNRwxSk3xBKcH6xolNZ8IWy3btKtaq7bst7UsiF4knYRpXgIAd0Rz/nY0iFx88cUqLi7W3r17lZubq+nTp2vJkiUaMGBARO93Mogci7Kqen26/aB2HKhT6f5DksKHlkiCTWD66fZKfbLjoJu7lTDC1cZ01KyU1iNZ543pS6ffOFFWVa912w9ox4FD2l/bQI0ZEIfiJojcf//9KioqUkFBgXbt2qVbb71VkrR6dWR9NOI1iDilrKpe73xRrm0VdWHDCsHGXUNye2rK8LyIamEamoyG5/WiBsYmZVX1evuLPXrz83J9GEGNZGdNf1xRBjgrboJIa//4xz906aWXyufzqUePHp2un2hBxG6dBZtIAs3Bukat/eaAth845PLedF9njuitkwd6O+wLQ61L+x79YKsWvVbiyLYjuVSe0AJELy6DyIEDB3TjjTdq165dWrVqVdh1fD6ffD5f8HV1dbUKCwsJInGgoz419K2xT+sTY+smo0SrZVn6Zokeener28WQ1H5oaf0d0UQExFkQue222/SnP/1Jhw4d0umnn65XXnlFffr0CbvuwoULdccdd7SZTxA5PhxL0xNBJlTLpofAiXBwn4zj6gT46Ptbteh1Z2pCYiVQGxbJmD2JGDRx/HI0iMybN09LlizpcJ0vv/xSY8aMkSRVVFTowIED2rFjh+644w55vV698sor8ng8bd5HjQg6Em0n4URuXmrdHNTdmn7KqupVtGil28VwzYQhOZo4JDeq0ZW723eM45ujQWTfvn3av7/j/0yHDx+u1NTUNvO//fZbFRYWavXq1SoqKur0s+gjAjt15ZLtrftq9f5Xxz5uSrwIdLiN99qTm5/+TC8Xd34rhjNH9NbYQV5qzFoINCFFM3Iy/ZRgN0cHNMvPz1d+fn6XCub3+yUppNYDiJVxhbld+iMbaFLatKtKUue1MPEcXnYcPKwdn34bMu/MEb1VNCIvboLJo+9v7TCEnH9iP108foBOa1XWSJv+jvcryo7lFhH/uWLLMd0SgjCDrnCsj8jatWv1ySef6KyzzlJubq62bt2q3/3udyovL9fnn3+utLS0TrdBjQi6q5bNSPtrGzrsC7On+nBcBZczR/TWjJMLXOmrUFZVrzMWrVR7f5RennuGLSc5QouzRvbtpbNH5Xf5pp0Emu4vLjqrbty4UTfffLPWr1+vuro6FRQUaMaMGfqP//gPDRw4MKJtEESQKNo7MbZsMnrny73asrcupuU6b0y+fnHeqJidEFZvrdCVf1kbdtn8H4zRDVNHxKQcLUVzGTxNRPbqKNBEGmzoAOyOuAgidiCIAKHC9XM5WNeob/bVOfqf+5h+mVry/53ieCBp76aU1xYN0cJLTnb0s+0SrjYskjF73AiaiaQrHYCpqek6ggiQgNprDrKzz8rkobn644/GO/bf5d2vfqH/+6+2/RuWzz5dRSPCX/Z/PFm/86Be/my36hqORHXbiHjul3Q8imSU5UQPNgQRACFadri1o/bkysmF+t/njbI1kLTXPyTJI30477tUrXeidRNSpCMnS/HXTynRHGufmngcCZggAqBDLWtP1mzd3+V+DUsuH6tZkwbbUqb2+odcf/Zw/Z8LTrTlM9C+Y70lxKotFfqqvNblvUCA2yMBE0QARCUQTP65Ybfe/Lw8qveumW9PbUW4GpEkSR/atH0471hvBUGgcY9H0mIb/7EgiADosmhDyamFOXpp7pnH/LnPfFKq2/7fxuBrj0da/EP7/jCi+4gk0EQSbOgAHB07m0EJIgBsUVZVr4Uvf643v+g4kMw8baCWXnHqMX3OmYtXyt/irxG1IbBDVzsAd6eBCu1kV8dwR0dWBZA4CrzpevTqiXr0g61a9Fr7N6B77n92qeJQg5ZdO7lLn7Otoi4khEiSX9L2ikMEERyTro6oHE40oyx3xyaoJI80NC8j5p9LEAHQqRumjtDF4wZ0WDvybsk+LXx5U5fG+xiW10tJHoWEkWSPx5U/ikB7Crzp+knRUNu2Z0efGrtGAvZ4pEU/HOtK8CeIAIhIoHbkuic+1rsl+8Ku88SaHSrITY96BNQCb7pmnNRfr23aE5x36fgB1IbguGZnbU1AtFc/9clM1dA+vdrcuymW6CMCIGq/frZYz/3PrrDLPJJWR9m3o6yqXmcsXinTqkZk1bxzCSNANxTN+TspRmUCcBxZesWpOndM+LtwG0mfbo+uenhbRZ1a/0vUZIy2VxzqYgkBdBcEEQBdsuzayTr/O/3CLlvxZXRjkQzL6yVPq3n0EQESA0EEQJctvOSksPNfLN6tRz/YGvF2Crzpmjj0aFt5sseju394Ms0yQAIgiADosgJvuq4/e1jYZUteL1FZVX3E20ryWHUiV00p1Kp55zKQGZAgCCIAjsl1Zw1r06wiWZfiRtrH45lPSrV22wFJ0n9/vFMffBX+qhwAxx+CCIBjUuBN18+nhb9c98MtnQeKsqp6zX/h6NDuxkj/54VNUdWmAOi+CCIAjtmZo/LCzn/o3a2dBopwo6pyxQyQOAgiAI5ZuKteJOtS3mWrtnf63qRWb+aKGSBxEEQAHLMCb7rmfX9M2GV/XfVNh7UiBd50zT13ZPA1V8wAiYUh3gHY4oZzRmjHgTr999qdIfMDnVY7ChanDbEu3R3SO0NP33A6IQRIINSIALDN//7uqDbzPOr8jp5b91p3Ie2XnUYIARIMQQSArdr0FQnXeaSFZz4p1V2vfilJ+nj7QT3zSakj5QIQnwgiAGyzraJOre+iaToYTyRw6W7L93DpLpBYCCIAbBPuChhJ2rCrMuz6XLoLgCACwDYF3nTdNqPt1TP3vL45bC0Hl+4CIIgAsNXYQd4289qr5SjwpmvRD8cGX3s84tJdIMEQRADYKtzgZh1dOTNr0mCN7pcpSbp35jhudgckGIIIAOd1cuVMfWOTJGlon14xKAyAeEIQAWCraK+ckaTq+iOSJG86YywCiYYgAsBW4TqgJqn9phljjGoON0qSsnv2cLh0AOINQQSArQIdUFtmESPpg6/2hV2/rqEpeAlvna/J8fIBiC8EEQC2mzo6X54WScSo/YHKnvpoR/D5eX94j5FVgQRDEAFgu0gHKiurqtfiN0qCr/2GkVWBREMQAWC7SPuJbKuok2FkVSChEUQA2K71QGVS+H4iw/J6hTThSIysCiQagggAR0wdnd+mw2rrZpcCb7qumDgo+DrZ42FkVSDBcNE+AEeEG08k0OzSMmh8p8Ar6VtNGZarB/5tPCEESDDUiABwRKQ3tKuub2xeP5MQAiQggggARxR403X3ZS1uaKfwN7SrDgxmls5gZkAiIogAcEzrjqjhBIZ3z+5JSzGQiAgiABxRVlWv+S9sDL5ub1CzQI1IFsO7AwmJIALAEZEOalZR65Mk+Y0/VkUDEEcIIgAcEUln1Wc+KdUn2w9Kku585UuGdwcSEEEEgCMCg5q1DCO/mXFCsLNqm6YbhncHEhJBBIBjZk0arB+fPiT4eskbJcFaj0ibbgAc3wgiABxTVlWvv7e4u27Lm9pFOs4IgOMbQQSAYzqq9SjwpuvOS04Ozk/yhB9nBMDxjSACwDGd1Xqcf1L/4Px//eZczZo0OJbFAxAHCCIAHNP6Lrytaz1qAmOIpKVoYC5NMkAiIogAcNSsSYN17ph8SdLN540KqfWoOWyNqprFqKpAwiKIAHDcsD6ZkqSv99aGXJ4bCCKZBBEgYRFEADiuvPqwJOmVDWU6c/HK4CW8NQzvDiQ8gggAR5VV1eu1jWXB1y0v4aVpBgBBBICjtlXUqdUVvMFLeAM3vPMd8TOiKpCgCCIAHNXRJbwffbNfkrRm6/6QJhsAiYMgAsBR7Q1cJkkrvtwbnO/nXjNAQiKIAHDcj08fol5pyZKkB/7tVM2aNLjDJhsAiYMeYgAc98wnparzNUmSbn66WPUNTZo6Or/NetxrBkg81IgAcFRZVb3mv7Ax+No0N8FI0si+mcH5yR4P95oBEhA1IgAc1dGN73qlWs01t35vtC6fMIgQAiQgakQAOKqjq2YC44hMHNqbEAIkKIIIAEcFbnznaRFGAk0wNT4GNAMSHUEEgONmTRqsRZdZd+H9TkF28MZ3gSHesxniHUhYBBEAMTGmIFuSVF5dr7KqejU2+XW40S9JOtRwxM2iAXARQQRATKzdZo2iur+uUWcuXqlbnikOLvv+H//FqKpAgiKIAHBcWVW9lrxeEnztN9I/N4S/ER6AxBKTIOLz+XTqqafK4/GouLg4Fh8JII6Eu4S3NUZVBRJTTILIb37zGw0YMCAWHwUgDoW7hLc1RlUFEpPjQeT111/XW2+9pXvvvdfpjwIQpwKX8LY0dlB28DmjqgKJy9GL98vLyzV79my99NJLysjo/D8dn88nn88XfF1dXe1k8QDE0KxJg7X841IV76ySJG361vr9Pntknu6ZeQohBEhQjtWIGGN07bXXas6cOZo4cWJE71m0aJG8Xm/wUVhY6FTxAMRYWVW91jeHEEnBO+8O6p1OCAESWNRBZN68efJ4PB0+SkpK9OCDD6qmpkbz58+PeNvz589XVVVV8LFz585oiwcgTm2rqFO4/qqMIQIkNo8xppO+7KH27dun/fv3d7jO8OHDdcUVV+if//ynPC3GdW5qalJycrKuuuoqPfnkk51+VnV1tbxer6qqqpSdnd3p+gDiV1lVvc5YvFKt/+J4JC2+fGxwtFUA3V805++og0ikSktLQ/p47N69W+eff76ef/55TZkyRYMGDep0GwQR4Pjy6Adbtei1kjbzkz0erZp3Lk00wHEimvO3Y51VBw8O/e8mMzNTkjRixIiIQgiA409795QJjCFCEAESDyOrAoiJsqp6/fbFjWGXMYYIkLhidu/toUOHyqFWIADdQEejq146fgC1IUCCokYEQEwMy+ul9gZXffGzXdxnBkhQBBEAMVHgTdfss4eFXeY34j4zQIIiiACImevOGha2ViTJI/qIAAmKIAIgZgq86Vp8+diQMOLxSIt+OJY+IkCCillnVQCQrHvOTB2dr0+3H5THI502JJcQAiQwggiAmCvwpuvCcYQPADTNAAAAFxFEAACAawgiAADANQQRAADgGoIIAABwDUEEAAC4hiACAABcQxABAACuIYgAAADXEEQAAIBrCCIAAMA1cX2vGWOMJKm6utrlkgAAgEgFztuB83hH4jqI1NTUSJIKCwtdLgkAAIhWTU2NvF5vh+t4TCRxxSV+v1+7d+9WVlaWPB5Pu+tVV1ersLBQO3fuVHZ2dgxLGB8Sff8ljkGi77/EMWD/E3v/pfg6BsYY1dTUaMCAAUpK6rgXSFzXiCQlJWnQoEERr5+dne36wXdTou+/xDFI9P2XOAbsf2LvvxQ/x6CzmpAAOqsCAADXEEQAAIBrjosgkpaWpgULFigtLc3torgi0fdf4hgk+v5LHAP2P7H3X+q+xyCuO6sCAIDj23FRIwIAALongggAAHANQQQAALiGIAIAAFzjahAZOnSoPB5Pm8fcuXPbfU9lZaXmzp2rgoICpaWlafTo0XrttdeCyxcuXNhme2PGjAnZxuHDhzV37lz16dNHmZmZuvzyy1VeXu7YfnbEiWMQyTanTZvWZvmcOXMc3ddwot3/cOX2eDy64IILgusYY3T77beroKBA6enpmj59ur7++uuQ7Rw4cEBXXXWVsrOzlZOTo5/97Geqra11dF/bY/cxaGxs1G233aaxY8eqV69eGjBggK6++mrt3r27089dvHix4/vbmhM/A9dee22b5TNmzAjZTrz8DDix/+GWezweLV26tMPPdeP7b68snf0dfOCBB3TCCScoPT1dhYWF+uUvf6nDhw+HrPPQQw9p6NCh6tmzp6ZMmaKPP/44ZHm8nAuc2P9FixZp0qRJysrKUt++fXXppZdq8+bNIduIl/OAjIv27t1rysrKgo+3337bSDLvvvtu2PV9Pp+ZOHGi+cEPfmBWrVpltm3bZt577z1TXFwcXGfBggXmpJNOCtnuvn37QrYzZ84cU1hYaFasWGHWrVtnTj/9dHPGGWc4uavtcuIYRLLNc845x8yePTtkvaqqKof3tq1o93///v0h62/atMkkJyebZcuWBddZvHix8Xq95qWXXjLr1683F198sRk2bJipr68PrjNjxgwzbtw489FHH5l//etfZuTIkeZHP/qRw3sbnt3HoLKy0kyfPt0888wzpqSkxKxZs8ZMnjzZTJgwIWQ7Q4YMMXfeeWfItmprax3e27ac+Bm45pprzIwZM0LWO3DgQMh24uVnwIn9b7m8rKzMPP7448bj8ZitW7cG14mX79+Y6I/BU089ZdLS0sxTTz1ltm3bZt58801TUFBgfvnLXwbXefrpp01qaqp5/PHHzeeff25mz55tcnJyTHl5eXCdeDkXOLH/559/vlm2bJnZtGmTKS4uNj/4wQ/M4MGDQ77jeDkPuBpEWrv55pvNiBEjjN/vD7v84YcfNsOHDzcNDQ3tbmPBggVm3Lhx7S6vrKw0PXr0MM8991xw3pdffmkkmTVr1nS57Hax4xhEss1zzjnH3HzzzcdaXNt1tv+t3X///SYrKyv4y+X3+03//v3N0qVLg+tUVlaatLQ0s3z5cmOMMV988YWRZD755JPgOq+//rrxeDxm165dNu5N1xzrMQjn448/NpLMjh07gvOGDBli7r///mMtru3s2P9rrrnGXHLJJe2+J55/Bpz4/i+55BLz3e9+N2RevH7/xnR+DObOndtmf2655RZz5plnBl9PnjzZzJ07N/i6qanJDBgwwCxatMgYE9/nAjv2v7W9e/caSeb9998PzouX80DcBBGfz2f69Olj7rrrrnbX+f73v2+uuuoqM3v2bNO3b19z0kknmbvuusscOXIkuM6CBQtMRkaGKSgoMMOGDTNXXnllyB/fFStWGEnm4MGDIdsePHiw+cMf/mD7fkXDrmMQyTbPOecck5eXZ/r06WNOOukkM2/ePFNXV2fr/kQrkv1v7eSTTzazZ88Ovt66dauRZD777LOQ9aZOnWp+8YtfGGOMeeyxx0xOTk7I8sbGRpOcnGxeeOGFru+ADew4BuG8/fbbxuPxhPy3M2TIENOvXz/Tu3dvc+qpp5p77rnHNDY2drnsdrBr/6+55hrj9XpNfn6+GT16tJkzZ46pqKgILo/XnwEnvv89e/aYlJQU89RTT4XMj8fv35jIjsFTTz1lvF6vWbt2rTHG+r0fM2ZM8D0+n88kJyebF198MeR9V199tbn44ouNMfF7LrBj/8P5+uuvjSSzcePG4Lx4OQ/ETRB55plnTHJycof/jZxwwgkmLS3N/PSnPzXr1q0zTz/9tOndu7dZuHBhcJ3XXnvNPPvss2b9+vXmjTfeMEVFRWbw4MGmurraGGN9gampqW22PWnSJPOb3/zG/h2Lgl3HIJJtPvroo+aNN94wGzZsMH//+9/NwIEDzWWXXWbr/kQrkv1vae3atUZS8JfRGGM+/PBDI8ns3r07ZN2ZM2eaK664whhjzF133WVGjx7dZnv5+fnmz3/+8zHswbGz4xi0Vl9fb0477TRz5ZVXhsy/7777zLvvvmvWr19vHn74YZOTkxNStesGu/Z/+fLl5uWXXzYbNmwwL774ojnxxBPNpEmTgoE9Xn8GnPj+lyxZYnJzc0OaJo2Jz+/fmMiPwR//+EfTo0cPk5KSYiSZOXPmBJft2rXLSDKrV68Oec+vf/1rM3nyZGNM/J4L7Nj/1pqamswFF1zQpsYkXs4DcRNEvve975kLL7yww3VGjRplCgsLQ/77v++++0z//v3bfc/BgwdNdna2+etf/2qMid8fPmOcOQaRbNOYo/8dbNmyJbpC2yjSsgZcf/31ZuzYsSHzunsQseMYtNTQ0GAuuugiM378+E7bfh977DGTkpJiDh8+HPHn283u/Q8I1JS98847xpj4/RlwYv9POOEEc9NNN3W6rXj4/o2J7Bi8++67pl+/fuYvf/mL2bBhg3nhhRdMYWGhufPOO40x3TuI2LH/rc2ZM8cMGTLE7Ny5s8PtunUeiIsgsn37dpOUlGReeumlDtebOnWqOe+880Lmvfbaa0aS8fl87b5v4sSJZt68ecaY+K2Oc+IYRLpNY4ypra01kswbb7wRfeFtEE1ZjbHKm52dbR544IGQ+d25acauYxDQ0NBgLr30UnPKKaeENEu0Z9OmTUaSKSkpiarcdrF7/1vLy8szjzzyiDEmPn8GnNj/Dz74wEgK6czeHre/f2MiPwZnnXWWufXWW0Pm/e1vfzPp6emmqamp2zbN2LX/Lc2dO9cMGjTIfPPNN51+vlvngbgYR2TZsmXq27dvyOVn4Zx55pnasmWL/H5/cN5XX32lgoICpaamhn1PbW2ttm7dqoKCAknShAkT1KNHD61YsSK4zubNm1VaWqqioiIb9qZrnDgGkW5TkoqLiyUpeJxiLZqyStJzzz0nn8+nH//4xyHzhw0bpv79+4d8v9XV1Vq7dm3w+y0qKlJlZaU+/fTT4DorV66U3+/XlClTbNibrrHrGEjWJbxXXHGFvv76a73zzjvq06dPp9srLi5WUlKS+vbtG3XZ7WDn/rf27bffav/+/cGf73j8GXBi/x977DFNmDBB48aN63R7bn//UuTH4NChQ0pKCj19JScnS7Iu309NTdWECRNC/g74/X6tWLEi+HcgHs8Fdu1/YHrTTTfpxRdf1MqVKzVs2LBOP9+180BMY08YTU1NZvDgwea2225rs+wnP/lJsCbDGGNKS0tNVlaWuemmm8zmzZvNK6+8Yvr27Wt+//vfB9f51a9+Zd577z2zbds28+GHH5rp06ebvLw8s3fv3uA6c+bMMYMHDzYrV64069atM0VFRaaoqMjZHe2A3cegs21u2bLF3HnnnWbdunVm27Zt5uWXXzbDhw83U6dOtX/nIhDN/gecddZZZtasWWG3t3jxYpOTkxPsI3DJJZeEvXx3/PjxZu3atWbVqlVm1KhRrl2+a4y9x6ChocFcfPHFZtCgQaa4uDjk0rxArdnq1avN/fffb4qLi83WrVvN3//+d5Ofn2+uvvpq+3cuAnbuf01Njbn11lvNmjVrzLZt28w777xjTjvtNDNq1KiQZod4+hmw+3fAGGOqqqpMRkaGefjhh9ssi7fv35jojsGCBQtMVlaWWb58ufnmm2/MW2+9ZUaMGBFsfjXGunw3LS3NPPHEE+aLL74w119/vcnJyTF79uwJrhNP5wK79//GG280Xq/XvPfeeyF/Aw4dOmSMia/zgOtB5M033zSSzObNm9ssO+ecc8w111wTMm/16tVmypQpJi0tzQwfPrzNFSOzZs0yBQUFJjU11QwcONDMmjWrTXtXfX29+fnPf25yc3NNRkaGueyyy0xZWZkj+xcJu49BZ9ssLS01U6dONb179zZpaWlm5MiR5te//rUr148bE/3+l5SUGEnmrbfeCrs9v99vfve735l+/fqZtLQ0c95557XZ9v79+82PfvQjk5mZabKzs811111nampqbNunaNl5DLZt22YkhX0ExiX49NNPzZQpU4zX6zU9e/Y0J554orn77rtd6x9g5/4fOnTIfO973zP5+fmmR48eZsiQIWb27NkhJyBj4utnwO7fAWOsjojp6emmsrKyzbJ4+/6Nie4YNDY2moULF5oRI0aYnj17msLCQvPzn/+8TTPLgw8+aAYPHmxSU1PN5MmTzUcffRSyPJ7OBXbvf3t/AwLjzcTTecDTXGAAAICYi4s+IgAAIDERRAAAgGsIIgAAwDUEEQAA4BqCCAAAcA1BBAAAuIYgAgAAXEMQAQAgAX3wwQe66KKLNGDAAHk8Hr300ktRb+PZZ5/VqaeeqoyMDA0ZMkRLly6NehsEEQAAElBdXZ3GjRunhx56qEvvf/3113XVVVdpzpw52rRpk/785z/r/vvv15/+9KeotsPIqgAAJDiPx6MXX3xRl156aXCez+fTb3/7Wy1fvlyVlZU6+eSTtWTJEk2bNk2SdOWVV6qxsVHPPfdc8D0PPvig7rnnHpWWlsrj8UT02dSIAACANm666SatWbNGTz/9tDZs2KCZM2dqxowZ+vrrryVZQaVnz54h70lPT9e3336rHTt2RPw5BBEAABCitLRUy5Yt03PPPaezzz5bI0aM0K233qqzzjpLy5YtkySdf/75euGFF7RixQr5/X599dVXuu+++yRJZWVlEX9WiiN7AAAAuq2NGzeqqalJo0ePDpnv8/nUp08fSdLs2bO1detWXXjhhWpsbFR2drZuvvlmLVy4UElJkddzEEQAAECI2tpaJScn69NPP1VycnLIsszMTElWv5IlS5bo7rvv1p49e5Sfn68VK1ZIkoYPHx7xZxFEAABAiPHjx6upqUl79+7V2Wef3eG6ycnJGjhwoCRp+fLlKioqUn5+fsSfRRABACAB1dbWasuWLcHX27ZtU3FxsXr37q3Ro0frqquu0tVXX6377rtP48eP1759+7RixQqdcsopuuCCC1RRUaHnn39e06ZN0+HDh4N9St5///2oysHluwAAJKD33ntP5557bpv511xzjZ544gk1Njbq97//vf7rv/5Lu3btUl5enk4//XTdcccdGjt2rCoqKnTRRRdp48aNMsaoqKhId911l6ZMmRJVOQgiAADANVy+CwAAXEMQAQAAriGIAAAA1xBEAACAawgiAADANQQRAADgGoIIAABwDUEEAAC4hiACAABcQxABAACuIYgAAADXEEQAAIBr/n/vNqY4RBSyOQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if MEASUREMENT == 'reflection':\n", + " res = S11_reflection(freq,a,alpha,tau,Q_tot,Q_ext,fr,phi0)\n", + "elif MEASUREMENT == 'hanger':\n", + " res = S21_hanger(freq,a,alpha,tau,Q_tot,Q_ext,fr,phi0)\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, linmag, '.-')\n", + "plt.plot(freq, np.abs(res))\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase, '.-')\n", + "plt.plot(freq, np.angle(res))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The repeatening" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cable delay" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.3772912682037306e-10 -2.899673182721388\n", + "-2.362107759401467e-10 -3.1607722277323362\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def phase_prediction_error(x):\n", + " tau, theta_0=x\n", + " if MEASUREMENT == 'reflection':\n", + " predicted = S11_reflection(freq,a,alpha,tau,Q_tot,Q_ext,fr,phi0)\n", + " elif MEASUREMENT == 'hanger':\n", + " predicted = S21_hanger(freq,a,alpha,tau,Q_tot,Q_ext,fr,phi0)\n", + " predicted_phase = shift_phase(np.unwrap(np.angle(predicted)))\n", + " return np.sum((phase - predicted_phase - theta_0)**2)\n", + "\n", + "# Minimize the phase prediction error as a function of cable delay (tau)\n", + "# and a global phase offset theta_0\n", + "res = minimize(fun=phase_prediction_error,\n", + " x0 = [tau, theta0], # initial value\n", + " method = \"Nelder-Mead\",\n", + " jac = False,\n", + " options={\"maxiter\":3000000}, # maximum of iteration\n", + " )\n", + "new_tau, new_theta0 = res.x\n", + "\n", + "print(tau, theta0)\n", + "print(new_tau, new_theta0)\n", + "\n", + "phase8 = shift_phase(phase - 2*np.pi * new_tau * (freq-freq[0]))\n", + "data8 = linmag * np.exp(1j * phase8)\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase1, '.-')\n", + "plt.plot(freq, phase8, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data1), np.imag(data1), '.-')\n", + "plt.plot(np.real(linmag * np.exp(1j*phase8)), np.imag(linmag * np.exp(1j*phase8)), '.-')\n", + "plt.axis('equal');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Move circle to center" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circle fit: xc = -0.38269317017752164, yc = 0.10075475575805305, r0 = 0.19828184517737868\n" + ] + }, + { + "data": { + "text/plain": [ + "0.015314472601579615" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xc9, yc9, r09 = fit_circle_algebraic(data8)\n", + "\n", + "data9 = data8 - (xc9+1j*yc9)\n", + "linmag9 = np.abs(data9)\n", + "phase9 = shift_phase(np.unwrap(np.angle(data9)))\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase3, '.-')\n", + "plt.plot(freq, phase9, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data3), np.imag(data3), '.-')\n", + "plt.plot(np.real(data9), np.imag(data9), '.-')\n", + "plt.axis('equal')\n", + "\n", + "norm(data3-data9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Phase vs frequency fit" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.899673182721388 2878.941920907083 7741123452.837948\n", + "Optimization terminated successfully.\n", + " Current function value: 43.406327\n", + " Iterations: 410\n", + " Function evaluations: 750\n", + "-4.6631691835931655 2878.8592798260747 7741127088.895765\n" + ] + } + ], + "source": [ + "print(theta0, Q_tot, fr)\n", + "new_theta0, new_Q_tot, new_fr = fit_phase_vs_freq_taketo(freq, phase9)\n", + "print(new_theta0, new_Q_tot, new_fr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Find off-resonance point (a and alpha)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.38539118449045995 -2.885464850940988\n", + "0.38541833661091807 -2.8864131252929672\n" + ] + }, + { + "data": { + "text/plain": [ + "0.0128050418894855" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p_offres = (xc9+1j*yc9) + r09*np.exp(1j*(new_theta0+np.pi))\n", + "new_a = np.abs(p_offres)\n", + "new_alpha = np.angle(p_offres)\n", + "\n", + "linmag10 = linmag / new_a\n", + "phase10 = phase8 - new_alpha\n", + "data10 = linmag10 * np.exp(1j*phase10)\n", + "\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase5, '.-')\n", + "plt.plot(freq, phase10, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data5), np.imag(data5), '.-')\n", + "plt.plot(np.real(data10), np.imag(data10), '.-')\n", + "plt.axis('equal')\n", + "plt.grid()\n", + "\n", + "print(a, alpha)\n", + "print(new_a, new_alpha)\n", + "norm(data5-data10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Impedence mismatch and Q_ext" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circle fit: xc = 0.8947897328465858, yc = -0.5035857727262903, r0 = 0.5144587746426486\n", + "1.3667922957836747 (566.6754383109705+2739.123856132184j) -705.5526199861511 -2.899673182721388\n", + "1.364836595289646 (572.1994112471098+2738.815236030062j) -714.1415201342965 -2.899673182721388\n" + ] + } + ], + "source": [ + "xc11, yc11, r011 = fit_circle_algebraic(data10)\n", + "new_phi0 = -np.arcsin(yc11/r011)\n", + "\n", + "# FIXME: where does this come from?\n", + "# new_Q_ext = new_Q_tot/(r011*np.exp(-1j*new_phi0)) # REFLECTION ONLY\n", + "if MEASUREMENT == 'reflection':\n", + " new_Q_ext = new_Q_tot / (r011*np.exp(-1j*new_phi0))\n", + "elif MEASUREMENT == 'hanger':\n", + " new_Q_ext = new_Q_tot / (2*r011*np.exp(-1j*new_phi0))\n", + "\n", + "new_Q_int = 1/(1/new_Q_tot-1/np.real(new_Q_ext))\n", + "\n", + "# res11 = S11_reflection(freq, new_a, new_alpha, new_tau, new_Q_tot, new_Q_ext, new_fr, new_phi0)\n", + "if MEASUREMENT == 'reflection':\n", + " res11 = S11_reflection(freq, new_a, new_alpha, new_tau, new_Q_tot, new_Q_ext, new_fr, new_phi0)\n", + "elif MEASUREMENT == 'hanger':\n", + " res11 = S21_hanger(freq, new_a, new_alpha, new_tau, new_Q_tot, new_Q_ext, new_fr, new_phi0)\n", + "new_theta0 = phase[0] - np.unwrap(np.angle(res11))[0]\n", + "\n", + "print(phi0, Q_ext, Q_int, theta0)\n", + "print(new_phi0, new_Q_ext, new_Q_int, new_theta0)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------\n", + "Q_total : 2878.8592798260747\n", + "Q_external : (572.1994112471098+2738.815236030062j)\n", + "Q_internal : -714.1415201342965\n", + "resonance freq [Hz] : 7741127088.895765\n", + "kappa_tot/2pi [Hz] : 2688956.401288028\n", + "kappa_external/2pi [Hz] : 13528722.568979865\n", + "kappa_internal/2pi [Hz] : -10839766.167691836\n", + "Phi (Impedance mismatch) : 1.364836595289646\n", + "\n" + ] + } + ], + "source": [ + "print(\n", + "\"-----------------------------------------\\n\" \\\n", + "+f\"Q_total : {new_Q_tot}\\n\" \\\n", + "+f\"Q_external : {new_Q_ext}\\n\" \\\n", + "+f\"Q_internal : {new_Q_int}\\n\" \\\n", + "+f\"resonance freq [Hz] : {new_fr}\\n\" \\\n", + "+f\"kappa_tot/2pi [Hz] : {new_fr/new_Q_tot}\\n\" \\\n", + "+f\"kappa_external/2pi [Hz] : {new_fr/np.real(new_Q_ext)}\\n\" \\\n", + "+f\"kappa_internal/2pi [Hz] : {new_fr/new_Q_int}\\n\" \\\n", + "+f\"Phi (Impedance mismatch) : {new_phi0}\\n\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(0.38541833661091807),\n", + " np.float64(-2.8864131252929672),\n", + " np.float64(-2.362107759401467e-10),\n", + " np.float64(2878.8592798260747),\n", + " np.complex128(572.1994112471098+2738.815236030062j),\n", + " np.float64(7741127088.895765),\n", + " np.float64(1.364836595289646))" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_a, new_alpha, new_tau, new_Q_tot, new_Q_ext, new_fr, new_phi0" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Fix 2n*pi phase offset\n", + "if MEASUREMENT == 'reflection':\n", + " res11 = S11_reflection(freq, new_a, new_alpha, new_tau, new_Q_tot, new_Q_ext, new_fr, new_phi0)\n", + "elif MEASUREMENT == 'hanger':\n", + " res11 = S21_hanger(freq, new_a, new_alpha, new_tau, new_Q_tot, new_Q_ext, new_fr, new_phi0)\n", + "n = compute_global_2pi_shift(phase, np.unwrap(np.angle(res11)))\n", + "phase_fit = 2*n*np.pi + np.unwrap(np.angle(res11))\n", + "\n", + "# [c,beta] = estimate_linear_background(freq, linmag)\n", + "# linmag2 = linmag - freq*beta - c\n", + "linmag2 = linmag\n", + "linmag2 += np.abs(res11)[0] - linmag2[0]\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, linmag, '.-')\n", + "plt.plot(freq, np.abs(res11))\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase, '.-')\n", + "plt.plot(freq, phase_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TODO:\n", + "- check phase_fit_kit with skewed lorenzian guess\n", + "- check kit's rotation to the canonical position" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/sketching/taketo.ipynb b/sketching/taketo.ipynb new file mode 100644 index 0000000..94eee13 --- /dev/null +++ b/sketching/taketo.ipynb @@ -0,0 +1,1181 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "# Deep\n", + "deep = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00075-cavity_check_2024-12-12T171954'\n", + "# Tiny\n", + "tiny = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00032-cavity_check_2024-12-12T144742'\n", + "# Good\n", + "good = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00077-cavity_check_2024-12-12T172355'\n", + "# Bad\n", + "bad = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00062-cavity_check_2024-12-12T160601'\n", + "# Very bad\n", + "very_bad = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00053-cavity_check_2024-12-12T155026'" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Fit the refrection data of cavity\n", + "\n", + "Reference:\n", + "Gao's thesis,\n", + "Efficient and robust analysis of complex scattering data under noise in\n", + "microwave resonators, by S.Probst et al.\n", + "\n", + "\"\"\"\n", + "import h5py\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import curve_fit, minimize, newton\n", + "# import seaborn as sns\n", + "import csv\n", + "# sns.set()\n", + "# colors = sns.color_palette(\"hls\", 12)\n", + "# sns.set(palette=\"tab10\")\n", + "# sns.set_context(\"notebook\")\n", + "# sns.set_style(\"whitegrid\")\n", + "# sns.set_style(\"ticks\")\n", + "\n", + "###################################################################################################\n", + "path = good\n", + "filename = path+r\"\\data.ddh5\"\n", + "h5file = h5py.File(filename,\"r\")\n", + "# # ZI instrument\n", + "# data = h5file[\"data\"][\"data\"][0]\n", + "# freq= h5file[\"data\"][\"ro_freq\"][0]\n", + "\n", + "# VNA\n", + "dBmag = h5file[\"data\"][\"mag\"][0]\n", + "phase = h5file[\"data\"][\"phase\"][0]\n", + "data = 10**(dBmag/20)*np.exp(1j*phase)\n", + "freq = h5file[\"data\"][\"frequency\"][0]\n", + "\n", + "# cut the data\n", + "data_cut=data[:]\n", + "freq_cut=freq[:]\n", + "\n", + "# # cut the data\n", + "# data_cut=np.hstack((data[0:400],data[650:1001]))\n", + "# freq_cut=np.hstack((freq[0:400],freq[650:1001]))\n", + "\n", + "measurement = \"Reflection_S11\" # \"Reflection_S11\" or \"Reflection_S21\"\n", + "###################################################################################################\n", + "\n", + "markersize=1.5\n", + "fit_npts = 6000\n", + "\n", + "def circle_fit(linmag, uwphase):\n", + " \"\"\"\n", + " Fit the complex data to a circle.\n", + " Fitting parameters are the center position and the radius.\n", + " The fitting protocol is written in \"Gao's thesis\"\n", + "\n", + " Parameters\n", + " ----------\n", + " linmag:\n", + " array of linear magnitude\n", + " uwphase:\n", + " array of unwrapped phase\n", + "\n", + " Returns\n", + " -------\n", + " x_circle, y_circle :\n", + " center position of the circle\n", + " r_circle :\n", + " radius of the circle\n", + " \"\"\"\n", + " data = linmag * np.exp(1j*uwphase)\n", + " x = np.real(data)\n", + " y = np.imag(data)\n", + " z = np.abs(data)\n", + "\n", + " # stupid guess\n", + " x_circle = (np.max(x)+np.min(x))/2\n", + " y_circle = (np.max(y)+np.min(y))/2\n", + " r_circle = np.average([np.max(x)-np.min(x),np.max(y)-np.min(y)])/2\n", + "\n", + " # function to be minimized\n", + " def func(xlist):\n", + " x_circle = xlist[0]\n", + " y_circle = xlist[1]\n", + " r_circle = xlist[2]\n", + " return np.sum(np.abs(r_circle**2-(x-x_circle)**2-(y-y_circle)**2))\n", + " # minimize the \"func\"\n", + " res = minimize(fun=func,\n", + " x0 = [x_circle, y_circle, r_circle], # initial value\n", + " method = \"Nelder-Mead\",\n", + " jac = False,\n", + " options={\"maxiter\":3000000}, # maximum of iteration\n", + " )\n", + " x_circle, y_circle, r_circle = res.x\n", + "\n", + " # M = np.array([\n", + " # [np.dot(z,z), np.dot(x,z), np.dot(y,z), np.sum(z)],\n", + " # [np.dot(x,z), np.dot(x,x), np.dot(x,y), np.sum(x)],\n", + " # [np.dot(y,z), np.dot(x,y), np.dot(y,y), np.sum(y)],\n", + " # [np.sum(z), np.sum(x), np.sum(y), len(x)]\n", + " # ])\n", + " # B = np.array([\n", + " # [0,0,0,-2],\n", + " # [0,1,0,0],\n", + " # [0,0,1,0],\n", + " # [-2,0,0,0]\n", + " # ])\n", + "\n", + " # # function to be minimize\n", + " # def func(mu):\n", + " # return np.linalg.det(M-mu*B)\n", + " # # minimize the \"func\"\n", + " # res = minimize(fun=func,\n", + " # x0 = [0], # initial value\n", + " # method = \"Nelder-Mead\",\n", + " # jac = False,\n", + " # options={\"maxiter\":3000000}, # maximum of iteration\n", + " # )\n", + " # mu = res.x[0]\n", + " # print(\n", + " # \"-----------------------------------------\\n\" \\\n", + " # +\"Circle fitting finished.\\n\" \\\n", + " # +f\"fitted parameter : mu = {mu}\\n\" \\\n", + " # +\"number of iteration : \"+f\"{str(res.nit)}\\n\" \\\n", + " # )\n", + "\n", + " # # culculate A, B, C, and D\n", + " # A, B, C, D = np.linalg.solve(\n", + " # a = M-mu*B,\n", + " # b = [0,0,0,0],\n", + " # )\n", + " # print(\n", + " # \"-----------------------------------------\\n\" \\\n", + " # +f\"A={A}, B={B}, C={C}, D={D}\\n\"\n", + " # )\n", + "\n", + " # # culculate the center and the radius of the circle\n", + " # x_circle = -B/2/A\n", + " # y_circle = -C/2/A\n", + " # r_circle = 1/2/np.abs(A)\n", + " print(\n", + " \"-----------------------------------------\\n\" \\\n", + " +f\"center position of the circle : (x, y) = ({x_circle}, {y_circle})\\n\" \\\n", + " +f\"radius of the circle : r = {r_circle}\\n\"\n", + " )\n", + "\n", + " return x_circle, y_circle, r_circle\n", + "\n", + "def shift_phase(uwphase):\n", + " \"\"\"\n", + " Shift the unwrapped phase data for the first phase data to be placed\n", + " between -pi and pi.\n", + " \"\"\"\n", + " n=0\n", + " if uwphase[0]>np.pi:\n", + " while (uwphase[0]-2*n*np.pi)>np.pi:\n", + " n=n+1\n", + " elif uwphase[0]<=-np.pi:\n", + " while (uwphase[0]-2*n*np.pi)<=-np.pi:\n", + " n=n-1\n", + "\n", + " return uwphase - 2*n*np.pi\n", + "\n", + "def guess_cable_delay(freq, uwphase):\n", + " \"\"\"\n", + " Roughly guess the cable delay term.\n", + " Calculate the average slope of the uwphase data.\n", + "\n", + " Parameters\n", + " ----------\n", + " freq:\n", + " array of frequency [Hz]\n", + " uwphase:\n", + " array of unwrapped phase\n", + "\n", + " Returns\n", + " -------\n", + " rough_tau:\n", + " roughly estimated cable delay [s]\n", + " fitting:\n", + " fitted line\n", + " \"\"\"\n", + "\n", + " def linear_phase(freq, tau, theta_0):\n", + " return 2*np.pi*tau*freq + theta_0\n", + "\n", + " # simple guess\n", + " idx = len(uwphase) // 10 #-1\n", + " rough_tau = (uwphase[idx]-uwphase[0])/(freq[idx]-freq[0])/2/np.pi\n", + " theta_0 = uwphase[0]-2*np.pi*rough_tau*freq[0]\n", + "\n", + " freq_fit = np.linspace(freq[0],freq[idx],fit_npts)\n", + " fitting = linear_phase(freq_fit,\n", + " rough_tau,\n", + " theta_0)\n", + " print(\n", + " \"-----------------------------------------\\n\" \\\n", + " +f\"rough_tau [s] : {rough_tau}\\n\"\\\n", + " +f\"theta_0 : {theta_0}\\n\"\n", + " )\n", + " return rough_tau, theta_0, freq_fit, fitting\n", + "\n", + "def fit_cable_delay(freq, linmag, uwphase, rough_tau,\n", + " x_circle, y_circle, r_circle):\n", + " \"\"\"\n", + " Fine fitting for the cable delay term\n", + " by fitting complex data to pure circle.\n", + "\n", + " Parameters\n", + " ----------\n", + " data:\n", + " complex data\n", + " rough_tau:\n", + " first estimation of tau\n", + "\n", + " Returns\n", + " -------\n", + " fine_tau:\n", + " fine fitted tau\n", + " \"\"\"\n", + " # definition of minimized function\n", + " def func(tau):\n", + " linmag_temp = linmag\n", + " uwphase_temp = uwphase-2*np.pi*tau*(freq-freq[0])\n", + " x_array = linmag_temp*np.cos(uwphase_temp)\n", + " y_array = linmag_temp*np.sin(uwphase_temp)\n", + " a = np.array(\n", + " [np.abs(r_circle**2-(x_i-x_circle)**2-(y_i-y_circle)**2) \\\n", + " for x_i, y_i in zip(x_array, y_array)]\n", + " )\n", + " return np.sum(a)\n", + " # minimize the \"func\"\n", + " res = minimize(fun=func,\n", + " x0 = [0], # initial value\n", + " method = \"Nelder-Mead\",\n", + " jac = False,\n", + " bounds=[(-np.abs(rough_tau), np.abs(rough_tau))],\n", + " options={\"maxiter\":3000000, # maximum of iteration\n", + " # \"xatol\":1e-20,\n", + " \"disp\":True},\n", + " )\n", + " fine_tau = res.x[0]\n", + " print(\n", + " \"-----------------------------------------\\n\" \\\n", + " +f\"fine tau [s] : {fine_tau}\\n\" \\\n", + " )\n", + " return fine_tau\n", + "\n", + "def fit_phase_vs_freq(freq,uwphase):\n", + " \"\"\"\n", + " fit phase data and decide the offset phase, Q_total\n", + " and the resonance frequence f_r\n", + "\n", + " Parameters\n", + " ----------\n", + " freq:\n", + " array of frequency [Hz]\n", + " uwphase:\n", + " array of unwrapped phase\n", + "\n", + " Returns\n", + " -------\n", + " theta_0:\n", + " offset phase [radian]\n", + " Q_tot:\n", + " total quality factor\n", + " f_r:\n", + " resonance frequency [Hz]\n", + " fitting:\n", + " fitted line\n", + " \"\"\"\n", + " # # definition of the function to be fitted\n", + " # def func(f, theta_0, Q_tot, f_r):\n", + " # return theta_0+2*np.arctan(2*Q_tot*(1-f/f_r))\n", + "\n", + " # define first guess\n", + " theta_0 = np.average(uwphase)\n", + " Q_tot = 0\n", + " f_r = np.average(freq)\n", + "\n", + " # fit to the func to unwrap phase data\n", + " # popt, pcov = curve_fit(\n", + " # f=func,\n", + " # xdata=freq,\n", + " # ydata=uwphase,\n", + " # p0=[theta_0, Q_tot, f_r],\n", + " # )\n", + " # theta_0, Q_tot, f_r = popt\n", + "\n", + " def func(x):\n", + " theta_0, Q_tot, f_r = x\n", + " return np.sum((uwphase-(theta_0+2*np.arctan(2*Q_tot*(1-freq/f_r))))**2)\n", + " res = minimize(fun=func,\n", + " x0 = [theta_0, Q_tot, f_r], # initial value\n", + " method = \"Nelder-Mead\",\n", + " jac = False,\n", + " options={\"maxiter\":3000000, # maximum of iteration\n", + " # \"xatol\":1e-15,\n", + " \"disp\":True},\n", + " )\n", + " theta_0, Q_tot, f_r = res.x\n", + " freq_fit = np.linspace(freq[0],freq[-1],fit_npts)\n", + " # fitting = func(freq_fit,\n", + " # theta_0, Q_tot, f_r)\n", + " fitting = theta_0+2*np.arctan(2*Q_tot*(1-freq_fit/f_r))\n", + " return theta_0, Q_tot, f_r, freq_fit, fitting\n", + "\n", + "def S11_refrection(freq,a,alpha,tau,Q_tot,Q_ext,f_r,phi):\n", + " env=a*np.exp(1j*alpha)*np.exp(2j*np.pi*(freq-freq[0])*tau)\n", + " resonator=1-2*Q_tot/np.abs(Q_ext)*np.exp(1j*phi)/(1+2j*Q_tot*(freq/f_r-1))\n", + " return env*resonator\n", + "\n", + "def S21_refrection_taketo(freq,a,alpha,tau,Q_tot,Q_ext,f_r,phi):\n", + " env=a*np.exp(1j*alpha)*np.exp(2j*np.pi*(freq-freq[0])*tau)\n", + " resonator=1-Q_tot/np.abs(Q_ext)*np.exp(1j*phi)/(1+2j*Q_tot*(freq/f_r-1))\n", + " return env*resonator\n", + "\n", + "# Marco\n", + "def S21_refrection(f, a, alpha, t, Q_L, Q_e, f_0, phi):\n", + " env = (a) * np.exp(1j*alpha) *np.exp(-2j*np.pi*(f-f[0])*t)\n", + " resonator = 1 - Q_L * np.exp(1j*phi) / np.abs(Q_e) / (1 + 2j * Q_L * (f - f_0) / f_0)\n", + " return env*resonator\n", + "\n", + "# def s21_transmission(freq, tau, Q_tot, f_r, Cx, Cy):\n", + " # cable_delay=np.exp(2j*np.pi*(freq-freq[0])*tau)\n", + " # resonator=1/(1+2j*Q_tot*(freq/f_r-1))\n", + " # return (Cx+1j*Cy)*cable_delay*resonator" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "# MAIN PART!!!!!!!!!!!!!!!!!!!!!!!!!\n", + "# prepare the data\n", + "linmag0 = np.abs(data_cut) # linear scale\n", + "uwphase0 = shift_phase(np.unwrap(np.angle(data_cut))) # unwrapped radian" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------\n", + "rough_tau [s] : -1.7931480020758977e-10\n", + "theta_0 : 9.327516678463798\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "(np.float64(-0.4065840492457034),\n", + " np.float64(0.9635683342974146),\n", + " np.float64(-0.4356888380337984),\n", + " np.float64(0.939955366709765))" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## PART 1: rough guess of cable delay\"tau\"\n", + "rough_tau, theta_0, freq_fit, fitting=guess_cable_delay(freq_cut, uwphase0)\n", + "\n", + "linmag1 = linmag0\n", + "uwphase1 = shift_phase(uwphase0-2*np.pi*rough_tau*(freq_cut-freq_cut[0]))\n", + "\n", + "plt.figure()\n", + "plt.plot(freq_cut, uwphase0, '.-')\n", + "plt.plot(freq_cut, uwphase1, '.-')\n", + "\n", + "plt.figure()\n", + "d0 = linmag0*np.exp(1j*uwphase0)\n", + "d = linmag1*np.exp(1j*uwphase1)\n", + "plt.plot(np.real(d0), np.imag(d0), '.-')\n", + "plt.plot(np.real(d), np.imag(d), '.-')\n", + "plt.axis('equal')" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------\n", + "center position of the circle : (x, y) = (0.26506548684899356, 0.2680124168558461)\n", + "radius of the circle : r = 0.6094433191290822\n", + "\n", + "Optimization terminated successfully.\n", + " Current function value: 0.170297\n", + " Iterations: 10\n", + " Function evaluations: 20\n", + "-----------------------------------------\n", + "fine tau [s] : 3.5022421915544876e-13\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "(np.float64(-0.4052316476896242),\n", + " np.float64(0.9351679016197522),\n", + " np.float64(-0.4020662820738749),\n", + " np.float64(0.9383542926164352))" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGyCAYAAADZOq/0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAANo5JREFUeJzt3Xt0VPW9///XnkkyBCFBSAiXhABBRFQQ0NCoVTzyU2rr7VD1qBVRv1gsnoq3Cr/zq4CriteKx1pbrWIvfL3i5XiWWhVF28pFQETEIAQMhEsIIAnXSTLz/v0RMjLkQoKZ2Tszz8das8zes2fv92dtybzy2Z/92Y6ZmQAAAFzgc7sAAACQvAgiAADANQQRAADgGoIIAABwDUEEAAC4hiACAABcQxABAACuIYgAAADXEEQAAIBrCCIAAMA1MQ0iH3/8sS688EL16tVLjuPo9ddfj+XhAABAO5MSy53v3btXQ4cO1fXXX69///d/b/Xnw+GwNm/erM6dO8txnBhUCAAA2pqZaffu3erVq5d8vub7PGIaRH70ox/pRz/60VF/fvPmzcrLy2vDigAAQLxs3LhRubm5zW4T0yDSWsFgUMFgMLJc/2DgjRs3KiMjw62yAABAK1RVVSkvL0+dO3c+4raeCiIzZ87UjBkzGqzPyMggiAAA0M60ZFiFp+6amTp1qiorKyOvjRs3ul0SAACIIU/1iAQCAQUCAbfLAAAAceKpHhEAAJBcYtojsmfPHq1duzayvH79ei1fvlxdu3ZVnz59YnloAADQDsQ0iCxZskTnnHNOZPm2226TJF177bV67rnnYnloAADQDsQ0iIwaNSpyCy4AAMDhGCMCAABcQxABAACuIYgAAADXEEQAAIBrPDWhWTx9vWy+diz4m5zqvQqnd5XvwE75q/cplNoxallSg3VHs02s9hvvY+/v1Ed7jslTwfB/0+BBg+N6zgAAiScpg8jiR6/Qabve0cD6KfArD9vg8OW22iZW+3Xh2OHV0kqnQHsyj0+YABaqDWvnsSep4IyxhCwAiBPHPHx/bVVVlTIzM1VZWdlmD737etl8HffGxWrBc3iQpMykhf5hcjJ6tkkIkknqdYr6nfFT5eQWuNs4AIiD1nx/J12PyI5VH33XEwI0wnGkovBn0q7Pvlv5fXuhKt+SrbpPn3UYoWB6zhEDjhOqlpM1gPACIOElXRDpNvhs2Zrf0iOCuHMcaVhwqRQ8ZGVzAadCDcKL9F1YqVaq9vUdrWFF56pnZnqsyweAmEi6SzPSd2NECCNo78ykdeEcfZlxlrqn7o30tHApCICbWvP9nZRBRKobK7J9wRz5avYq3OHYuu7xmn0KpR4TtSypwbqj2SZW+43nsbuGd6jf/i+457udMJOKfQO0Jz2XcAIgrggiiJ3KTdqwcK4qihcrXL07YQJYTuXnSRGy6sNJZcZA7c8aotBx5+vEE07g0g6ANkUQAY5Gfchav0pB+dskBGVu/0wn1Hwpn0cvA5pJn4X7aWvGUA049zoNHD7K7ZIAJACCCOAh5WUlWvevV6TtJTJ/6hEDTof95RpyYEncw4uZVOLkaVvuecoafhGhBMBRI4gA7VxT4UWqCyu99qxUXk1pzAZcm0kbnR7afML1jCsB0GoEESAJVKz+RNv+9Tcd2FOpYFqXSFjJ2btaebalzUKKmfRp59HK/48HCSQAWoQgAiS5+rvCUvdtk6Q2CSdm0oLe1+n0G2e1TZEAEhZBBEADh4aTXvu/Vq/Q5lYHEzNpjb+/Mq9/hd4RAE0iiAA4ovpLO102vKdetq1VoYTLNQCaQxAB0CpfL5uvHcveVM6md9UvvKHFocRMWlgwWUXjZsS2QADtCkEEwFGrv4TTp2K+eregp6Ru7Mh4nX7jY/EpEIDnEUQAtIkFT92ikZueO+KcJmbSwuyfqujmZ+JTGABPa833d6LPaA3geyi68TFVTFimYv/xau5PFseRflDxij67//+JX3EAEgJBBECzcnILNOjXi7Xm4je0XrlNBhLHkU7Zv1gLfnd9fAsE0K4RRAC0yMDho9Rv+pdamD222TDyg4q5WvDXafEtDkC7RRAB0CpFNz+rhQMmK9xMGBm5dpa+XjY/rnUBaJ8IIgBareiaGaqYsEzrldvo+z5HGvDGxVo8d1Z8CwPQ7hBEAByVnNwCdfw//9Nkz4jPkU5dMU3lZSXxLQxAu0IQAXDUcnILtKhgcpNjRnyOtP7V6XGtCUD7QhAB8L0UjZuhBb3HNxlGCnf8D70iAJpEEAHwvZ1+42NNhhF6RQA0hyACoE2cfuNj+jRjdKPv0SsCoCkEEQBtJv+KBxsdvOpzpLLPP4p/QQA8jyACoM3k5BZocdeLGn2vpmR+fIsB0C4QRAC0qX5jpzfaK1K44w0uzwBogCACoE011SvCoFUAjSGIAGhzqQNGNbr+NAatAjgMQQRAm8sdOqrRyzN+R1r35iPxLwiAZxFEALS55mZcHbl1Dr0iACIIIgBiomjcDC1pZF4RbuUFcCiCCICY8Q26oNH13MoLoB5BBEDMNDVWhEGrAOoRRADETE5ugRb3uKrBer9j2l5a7EJFALyGIAIgprqOvKLBoFUzKTX9GHcKAuApcQkiTzzxhPr27asOHTpo5MiRWrx4cTwOC8ADqvfvluNEr3Mcaceil9wpCICnxDyIvPjii7rttts0bdo0LVu2TEOHDtX555+vbdu2xfrQADwgO3+wQo1N+b71/zJOBEDsg8hvf/tbTZgwQdddd50GDx6sP/zhD+rYsaOeffbZBtsGg0FVVVVFvQC0bzm5BfqUcSIAmhDTIFJdXa2lS5dq9Ojv5hLw+XwaPXq0FixY0GD7mTNnKjMzM/LKy8uLZXkA4qTfhXc0uHsmZI6y8ge5UxAAz4hpENm+fbtCoZBycnKi1ufk5Gjr1q0Ntp86daoqKysjr40bN8ayPABx5TSzBCBZpbhdwKECgYACgYDbZQBoYxWlq5TjRHeJ+A5emsnJLXCpKgBeENMekaysLPn9fpWXl0etLy8vV48ePWJ5aAAeUjdgNboPxEyqWscddECyi2kQSUtL04gRIzRv3rzIunA4rHnz5qmoqCiWhwbgITm5BVpccEvUfCKOI5229jHunAGSXMzvmrntttv09NNP689//rO++uor3XTTTdq7d6+uu+66WB8agId0Lji1wXwiKY5p3ZuPuFMQAE+I+RiRK664QhUVFbr77ru1detWnXLKKXrnnXcaDGAFkNjq5xPxHxZG6uYTuZ2xIkCSisvMqjfffLNKS0sVDAa1aNEijRw5Mh6HBeAhzCcCoDE8awZA3DQ2n0it+ZhPBEhiBBEAcZOTW6AVHb/rETWTlnU5j8syQBIjiACIm/KyEp2877tbdh1HGr7rXe6cAZIYQQRA3FSUrpL/sInNUpwwY0SAJEYQARA3jU1sVmuOPtt7rEsVAXAbQQRA3OTkFugfg34dNWDVJ2nlR69pS+V+1+oC4B6CCIC46nTieVHLPsf0m5Q/aXMp40SAZEQQARBX/Xxb5Wsww2pYfX0Nn8gNIPERRADEVbe8wQorOomEHZ+65Z3gUkUA3EQQARBfmb21vucFkQfgmUnf9PqJlNnb3boAuIIgAiCuystK1HfzW5EH4DmO1Kfsf5lLBEhSBBEAccVcIgAORRABEFdNzSXC82aA5EQQARBXObkFWjpkeoO5REoXvelaTQDcQxABEHf5Iy+MWvY5puErZjBOBEhCBBEAcVdRuqrRuUQYJwIkH4IIgLhrfJyIj3EiQBIiiACIu5zcAn16/B2R5ZD5tGzINOXkFrhYFQA3EEQAuGLkf/y/qj7YK/L5mU+ocOxkdwsC4AqCCABXfPrafytVdbfOnPLPX2jx3FnuFgTAFQQRAHFXXlaiESumR2ZX5a4ZIHkRRADEHbOrAqhHEAEQd9w1A6AeQQRA3H03u2pdGAmbuGsGSFIEEQCuKBw7WYv63SRJWuMf0GC2VQDJgSACwDXO7q2SpOPDa5X19AjunAGSEEEEgCvKy0pUuP21yLKfO2eApEQQAeCKuufNcOcMkOwIIgBcwZ0zACSCCACX5OQWaOnJ02QHO0VC5nDnDJCECCIAXFP401u108mQJK0c9TTPmwGSEEEEgKt2+7pIknz+NHcLAeAKgggAVx3wpUuS9m7+yuVKALiBIALANYvnztLxNaslSYVf3c88IkASIogAcAVP4AUgEUQAuIQn8AKQCCIAXMI8IgAkgggAlxz+BF7jCbxAUiKIAHBN4djJWnzCXZKk4tQTmEcESEIEEQCuSs+p6wFJtWqXKwHgBoIIAFcFjjlWkpQe3uNyJQDcQBAB4Kr0zl0lSZnhSm7dBZIQQQSAq7YsfVOS1Mk5oKynRzCpGZBkYhZE7r33Xp1++unq2LGjunTpEqvDAGjHystKdNqaWZFlP5OaAUknZkGkurpal112mW666aZYHQJAO8ekZgBSYrXjGTNmSJKee+65WB0CQDtXP6nZoWGESc2A5OKpMSLBYFBVVVVRLwCJq35SMzuYQ0LmMKkZkGQ8FURmzpypzMzMyCsvL8/tkgDEWOHYySpzekiSPit8mEnNgCTTqiAyZcoUOY7T7Ku4+Oiv7U6dOlWVlZWR18aNG496XwDaj/0pGZKklMAxLlcCIN5aNUbk9ttv1/jx45vdpn///kddTCAQUCAQOOrPA2ifqv0dpVqpdj+XY4Fk06ogkp2drezs7FjVAiBJ1fg7SpJCB5hdFUg2MbtrZsOGDdq5c6c2bNigUCik5cuXS5IGDBigTp06xeqwANqhUEpdELHgbpcrARBvMQsid999t/785z9HlocNGyZJ+vDDDzVq1KhYHRZAOxRKrfvjpHLXt9pSuV89M9NdrghAvMTsrpnnnntOZtbgRQgBcLgd1XV/E1WXf6Wx97+sFz/d4HJFAOLFU7fvAkg+Wyr3K+Xb9ZKkC/2L9I+0X+qz1x/Xlsr9LlcGIB4IIgBctal0rUb7l0aW/Y7pNyl/0uZSnjcDJAOCCABX9fNtlc+JXpfihNXXt9WdggDEFUEEgKu65Q2WKTqJhB2fuuWd4FJFAOKJIALAXZm9taHfFZFFc/zyXfiYlNnbxaIAxAtBBIDrduWdK0kq8/WSM/kLafg4lysCEC8EEQCu8wfq5g2plZ+eECDJEEQAuC714MPu0izociUA4o0gAsB1ael1QSRAEAGSDkEEgOvqe0QCVu1yJQDijSACwHWBjnXPmumgoCwcdrkaAPFEEAHgurT0uiCS4oRVU0OvCJBMCCIAXJd+cIyIJO3fv9fFSgDEG0EEgOtS0wIKWd3P27750t1iAMQVQQSA6z597b8jv4z6v3aRFs+d5WY5AOKIIALAVeVlJRqxYrqcg4+b8Tum4StmqLyMp+8CyYAgAsBVFaWr5Hcsal2KE9b20mKXKgIQTwQRAK7Kzh+skEU/fbfWfMrKH+RSRQDiiSACwFU5uQVaOmS67GCnSMgcLRsyTTm5Be4WBiAuCCIAXFc4drLW+ftKkpaeco8Kx052tR4A8UMQAeAJ1f66uURS0jNcrgRAPBFEAHhCrS9NkhSuPuByJQDiiSACwBPCB4OI1fIEXiCZEEQAeEKovkekhiACJBOCCABPCPsDkiSr5dIMkEwIIgA8gUszQHIiiADwBPPXBRERRICkQhAB4Al28NKMQgQRIJkQRAB4Qn0QcULVLlcCIJ4IIgC8IeVgEGGwKpBUCCIAvCGlbowIPSJAciGIAPAE52CPiC9MEAGSCUEEgCc4KR0kST56RICkQhAB4An1PSIdg9tUXlbicjUA4oUgAsAbyhZLkgbVFivr6RFaPHeWu/UAiAuCCADXlZeV6NSdb0WW/Y5p+IoZ9IwASYAgAsB1FaWr5HMsal2KE9b20mKXKgIQLwQRAK7Lzh+ssDlR62rNp6z8QS5VBCBeCCIAXJeTW6BFPa6MLNeaT8uGTFNOboGLVQGIB4IIAE84dvilkqRyddWOCUtUOHayuwUBiAuCCABP8KXW3b4blp+eECCJEEQAeIL/YBBJUa3LlQCIJ4IIAE9ISU2t+y9BBEgqBBEAnuA/OLNqqhFEgGQSsyDyzTff6IYbblC/fv2Unp6ugoICTZs2TdXVPEcCQEMpaQeDCD0iQFJJidWOi4uLFQ6H9cc//lEDBgzQypUrNWHCBO3du1cPP/xwrA4LoJ06NIhYOCzHR4ctkAxiFkTGjBmjMWPGRJb79++v1atX68knnySIAGgg9eBgVZ9jqg3VKsWX5nJFAOIhZkGkMZWVleratWuT7weDQQWDwchyVVVVPMoC4AH1PSKSVFMdVEoqQQRIBnHr+1y7dq0ef/xx/fznP29ym5kzZyozMzPyysvLi1d5AFyWmtYh8nN1DWPJgGTR6iAyZcoUOY7T7Ku4OPpBVZs2bdKYMWN02WWXacKECU3ue+rUqaqsrIy8Nm7c2PoWAWiXUg/pAQlVH3CxEgDx1OpLM7fffrvGjx/f7Db9+/eP/Lx582adc845Ov300/XUU081+7lAIKBAINDsNgASk+Pzqdr8SnNCqqVHBEgarQ4i2dnZys7ObtG2mzZt0jnnnKMRI0Zo9uzZ8jEKHkAzapWiNIVUWx088sYAEkLMBqtu2rRJo0aNUn5+vh5++GFVVFRE3uvRo0esDgugHatxUiQFVVvDpRkgWcQsiLz33ntau3at1q5dq9zc3Kj3zCxWhwXQjtWobpr3UA09IkCyiNm1kvHjx8vMGn0BQGNqD/5txBgRIHkwaAOAZ9Q6dUGEHhEgeRBEAHhGyKm/NEOPCJAsCCIAPKO+RyRcS48IkCwIIgC84+AYsv07y1wuBEC8EEQAeMLiubPUP/SNJOnUz36txXNnuVoPgPggiABwXXlZiUasmC7HqVv2OabhK2aovKzE1boAxB5BBIDrKkpXye9E39qf4oS1vbS4iU8ASBQEEQCuy84frJA5Uetqzaes/EEuVQQgXggiAFyXk1ugpUOm149VVdgcLRsyTTm5Be4WBiDmCCIAPKFw7GQt71gkSVrU5/+ocOxkdwsCEBcEEQCeUZuWIUly0jq6XAmAeCGIAPAM89XNrGqhGpcrARAvBBEAnmH+tLofCCJA0iCIAPCM+h4RhXjWDJAsCCIAPMP8dUHEIYgASYMgAsA7Dl6accJcmgGSBUEEgHfUjxEhiABJgyACwDvqe0QYrAokDYIIAM9wDo4R8YUZIwIkC4IIAM9wUup6RHxcmgGSBkEEgGc4DFYFkg5BBIBnOCn1l2YIIkCyIIgA8Iz6HhG/EUSAZEEQAeAZvsgYkVqXKwEQLwQRAJ7hSwlIokcESCYEEQCeUd8j4jd6RIBkQRAB4Bm+1LogkkKPCJA0CCIAPMOfWn9phh4RIFkQRAB4RiSIiCACJAuCCADP8B8cI5Ju+1ReVuJyNQDigSACwDO2LXldknSs9ijr6RFaPHeWq/UAiD2CCABPKC8rUWHpU5Flv2MavmIGPSNAgiOIAPCEitJV8jsWtS7FCWt7abFLFQGIB4IIAE/Izh+skDlR62rNp6z8QS5VBCAeCCIAPCEnt0CfDrozshwyn5YNmaac3AIXqwIQawQRAJ5x8k8mRX7ecs3HKhw72b1iAMQFQQSAZ6SmdYj8nJHVy8VKAMQLQQSAZ6QenOJdkmqrD7hYCYB4IYgA8AzH51ON+SVJtTXVLlcDIB4IIgA8pUYpkqTa6qDLlQCIB4IIAE+pdQ4GkRouzQDJgCACwFPqe0RCNfSIAMmAIALAU2rrL80wRgRICgQRAJ5Sf2mGHhEgOcQ0iFx00UXq06ePOnTooJ49e+qaa67R5s2bY3lIAO1crZMqSQrRIwIkhZgGkXPOOUcvvfSSVq9erblz56qkpEQ//elPY3lIAO1c6OClmXAtQQRIBimx3Pmtt94a+Tk/P19TpkzRJZdcopqaGqWmpjbYPhgMKhj8rju2qqoqluUB8KCQL1UKE0SAZBG3MSI7d+7UnDlzdPrppzcaQiRp5syZyszMjLzy8vLiVR4AjwgdvDRDEAGSQ8yDyF133aVjjjlG3bp104YNG/TGG280ue3UqVNVWVkZeW3cuDHW5QHwmJBTf2mGwapAMmh1EJkyZYocx2n2VVxcHNn+zjvv1GeffaZ3331Xfr9f48aNk5k1uu9AIKCMjIyoF4DkEvLV9YgYPSJAUmj1GJHbb79d48ePb3ab/v37R37OyspSVlaWBg4cqBNOOEF5eXlauHChioqKWl0sgMQXdggiQDJpdRDJzs5Wdnb2UR0sHA5LUtSAVAA4lGMhSVJtVbnLlQCIh5iNEVm0aJF+97vfafny5SotLdUHH3ygK6+8UgUFBfSGAGjU4rmzNGT/p5Kkket/r8VzZ7lbEICYi1kQ6dixo1599VWde+65Ov7443XDDTdoyJAh+uijjxQIBGJ1WADtVHlZiUasmC7HqVv2OabhK2aovKzE1boAxFbM5hE5+eST9cEHH8Rq9wASTEXpKuU40QPZU5ywtpcWKye3wKWqAMQaz5oB4AnZ+YMVMidqXa35lJU/yKWKAMQDQQSAJ+TkFmjpkOkKHwwjYZOWDZlGbwiQ4AgiADyjcOxkLcq5XJK0pMv5Khw72d2CAMQcQQSAtxxzcHoAx+9uHQDigiACwFOc1A6SJH/ogMuVAIgHgggAT3FS0yVJvhATHwLJgCACwFN8B4OIP0wQAZIBQQSAp/jSDl6aIYgASYEgAsBT/GkdJUmpBBEgKRBEAHiK/2CPSEqYp+8CyYAgAsBTUgIHe0SMIAIkA4IIAE9JSasbrJpmXJoBkgFBBICnpHao6xFJU43LlQCIB4IIAE9JO3hppoPtV3lZicvVAIg1gggAT9nwyUuSpHSnRllPj9DiubPcLQhATBFEAHhGeVmJTlszK7Lsd0zDV8ygZwRIYAQRAJ5RUbpKfsei1qU4YW0vLXapIgCxRhAB4BnZ+YMVMidqXa35lJU/yKWKAMQaQQSAZ+TkFmjpkOmyg50iIXO0bMg05eQWuFsYgJghiADwlMKxk7XD6SJJWjnqaRWOnexqPQBiiyACwHP2OwdnV03v7HIlAGKNIALAc6p9dc+bqd2/x+VKAMQaQQSA59TUB5EgQQRIdAQRAJ5T7a+7NBM6QBABEh1BBIDn1PrrHnwXDu51uRIAsUYQAeA5oZS6IGLVBBEg0RFEAHhOOKXu0oyvopjp3YEERxAB4DnpezZKkgqr/s6D74AERxAB4CnlZSU66cDSyDIPvgMSG0EEgKdUlK6SL/pxMzz4DkhgBBEAnpKdP1hhHnwHJA2CCABPyckt0OKsSyPLtebjwXdAAiOIAPCczsN/KknaoiztmLCEB98BCSzF7QIA4HAdOneRJKUopGx6QoCERo8IAM9J79xNktTJmNAMSHQEEQCec0xmXRBJd6oVPLDP5WoAxBJBBIDndMo4NvLzxq+Xu1cIgJgjiADwnKVv/E5mdT/3m3sBM6sCCYwgAsBTystKNGLFdDkHpxJhZlUgsRFEAHhKRekq+R2LWsfMqkDiIogA8JTs/MEKMbMqkDQIIgA8JSe3QEuHTI+MEQmbw8yqQAIjiADwnMKxk7Ws01mSpEW9r2VmVSCBEUQAeFJtx+51PzjNbwegfYtLEAkGgzrllFPkOI6WL18ej0MCaOcskClJ6rDza+6YARJYXILIr371K/Xq1SsehwKQIFJ31YWPYfs/UdbTI5hLBEhQMQ8ib7/9tt599109/PDDR9w2GAyqqqoq6gUg+ZSXlWjY7o8iy8wlAiSumAaR8vJyTZgwQX/961/VsWPHI24/c+ZMZWZmRl55eXmxLA+AR1WUrpKPuUSApBCzIGJmGj9+vCZOnKhTTz21RZ+ZOnWqKisrI6+NGzfGqjwAHpadP1hh5hIBkkKrg8iUKVPkOE6zr+LiYj3++OPavXu3pk6d2uJ9BwIBZWRkRL0AJJ+c3AItKvjPyHKt+ZhLBEhQjpnZkTf7TkVFhXbs2NHsNv3799fll1+uN998U47z3V81oVBIfr9fV199tf785z8f8VhVVVXKzMxUZWUloQRIMgf27VGHB3tLkr449686+YcXuVwRgJZqzfd3q4NIS23YsCFqsOnmzZt1/vnn65VXXtHIkSOVm5t7xH0QRIDktXjuLJ22YpocRwqZo6VDpjOxGdBOtOb7OyVWRfTp0ydquVOnTpKkgoKCFoUQAMmrySfwjryQyzNAgmFmVQCewxN4geQRsx6Rw/Xt21cxugoEIMHUP4H30DDCXTNAYqJHBIDn1D+BN8wTeIGERxAB4EmFYydrUY8rJUlfpg1R/sgLXa4IQCwQRAB4Vsr+7ZKkk2s+53kzQIIiiADwpPKyEo2ofD+yzPNmgMREEAHgSTxvBkgOBBEAnlR/58yhuHMGSDwEEQCelJNboCUn3636u/5DJu6cARIQQQSAZznOd7+iHDnNbAmgvSKIAPCkw6d59zFYFUhIBBEAnsQ070ByIIgA8CQGqwLJgSACwJO+m+a9LoyYSZ8W/JLBqkCCIYgA8KzCsZO1uOtPJEmOIxWWPMbsqkCCIYgA8KzyshKdtvN/I8vMrgokHoIIAM9iwCqQ+AgiADyLAatA4iOIAPCsnNwCLe1yfmR2VTNpWZfzGLAKJBCCCADPKi8r0Yhdf49MauY40vBd7zJGBEggBBEAnsUYESDxEUQAeFZjY0TMpKp1i12qCEBbI4gA8Kyc3AItLrglMkZEqrs8c9ra/+byDJAgCCIAPK1zwamRMSL1uDwDJA6CCABP4/IMkNgIIgA8jcszQGIjiADwPC7PAImLIALA87LzByscfRevQuYwwyqQAAgiANoJ57Ala2I7AO0JQQSA51WUrpLvsInNfI607s1HXKoIQFshiADwvLo7ZxquL9z6fxmwCrRzBBEAnpeTW6BPe1zVYL3fMQasAu0cQQRAu9DvwjsYsAokIIIIgHaEAatAoiGIAGgXGLAKJCaCCIB2gQGrQGIiiABoFxiwCiQmggiAdqPryCuinjkjHXwA3pfvulMQgO+NIAKg3ajev7vBM2ccRyrc9ByXZ4B2iiACoN1oapyIn0GrQLtFEAHQbuTkFmhxweQGl2ckaeTWOfSKAO0QQQRAu1I0boaWZIxusN7nSGWff+RCRQC+D4IIgHbHN+iCRtfXlMyPbyEAvjeCCIB2J3foqAbTvUtS4Y43uDwDtDMEEQDtTk5ugRZ3vajBep8jrX91evwLAnDUYhpE+vbtK8dxol73339/LA8JIEmkDhjV6PrCHf9DrwjQjsS8R+See+7Rli1bIq///M//jPUhASSBpi7P+Byp9MVfxb8gAEcl5kGkc+fO6tGjR+R1zDHHxPqQAJJAU5dnJOm0qve14K/T4lwRgKMR8yBy//33q1u3bho2bJgeeugh1dbWNrltMBhUVVVV1AsAmtJv7PRGe0UcRxq5dhaXaIB2IKZB5Je//KVeeOEFffjhh/r5z3+u++67T7/6VdNdpjNnzlRmZmbklZeXF8vyALRzObkFWtTEBGc+R9o5u+FD8gB4i2PW2D/hpk2ZMkUPPPBAs9t89dVXGjRoUIP1zz77rH7+859rz549CgQCDd4PBoMKBoOR5aqqKuXl5amyslIZGRmtKRNAEln8yFgV7n6/wXozaWH2WBXd/KwLVQHJq6qqSpmZmS36/m51EKmoqNCOHTua3aZ///5KS0trsP7LL7/USSedpOLiYh1//PFHPFZrGgIgeZWXlSj76eHyOQ3fM5Pm59+sc66/N/6FAUmqNd/fKa3deXZ2trKzs4+qsOXLl8vn86l79+5H9XkAaExOboE+6X2dijbNbvTpvGeX/k5/eWW4xv10rDsFAmhSzMaILFiwQLNmzdLnn3+udevWac6cObr11lv1s5/9TMcee2ysDgsgSZ1+4ywVpzTe0+pzpJ99cb3+/tTUOFcF4EhiFkQCgYBeeOEFnX322TrxxBN177336tZbb9VTTz0Vq0MCSHJdr3u+0btopLowct6m3+vtB6+Jb1EAmtXqMSLxxBgRAK214C/T9IOSWQ0u0dQzk750jpPvP/6iwYMGx7c4IEm05vubZ80ASChF42ZoWd8bGr2lV6obM3KS1mjQ80V64f4J2lK5P74FAohCEAGQcEZc91uVnzKpyTAi1V2quWL/S9r38FD95eW58SsOQBSCCICE1OPS+7RqwIRmw4jjSAX+cl2z8nqtnz5YC198gNlYgThjjAiAhFY57xF1/sc9Lf6ry0z6tPNo5f/Hg8rJLYhpbUCiiumEZvFEEAHQJio3afXsX2jgt/ObHMR6ODOp2DdA32YNV1bR1Ro4fFRMSwQSCUEEABrR2t6RemZSiZOnzV1HqvKYvio4Yyx33ADNIIgAQFMqN2nTU5er156VLe4dOZyZtNA/TE5GT8kk9TpF/c74KZdygIMIIgBwBBWrP9GO1/8/Ddy3tNFn1LSWmbQqZbD2BeoeYVFzTHcu6SBpEUQAoIXKy0pU+uJdOrXqvTYJJIcykzY6OSrveIJCqR0VTu8q34GdCtWGtfPYk7jEg4RFEAGAViovK9G6f72iHsV/Ud9w2VFftmmNQy/x+Kv3RYUVf/U+SdL+QJb2HH+phhWdq56Z6bEvCmgDBBEA+B6+XjZf2xfMUX7FfPWybXEJJc0xk9aFu2tDh+OV3rFzVFhpLLzQ+wK3EUQAoI18vWy+dix7U9lVK9W/amG7nQXSTFruDFJtxx6S1CDAHCnQNLZNc5+prT7AHUZJjCACALFQuUkbFs5VxfpVCsqvzO2f6YSaL9t8bEkiOfzykxT7EBTrbRLp2E6oWk7WgDa/64sgAgBxUl5WorLPP1KwYo18u76Rv2afOh/YpIG1awgoaDfMpE+HzFDh2Mltsj+CCAC4rH7wq7Nlufw1+xRKPUbhDscqp/Jz9dv/Rbu9xIPEFTJH2ycsbZOekdZ8f6d876MBABrIyS1QzhV3Nf7mYZd4fAd2RoWV+uWsmi3Kr15NaEFc+B3T9tLiuE/MRxABgHjL7K0+5/9SfVqybX1oKV6scPXuBmHl8GVJUb0v/fd/Ia4QoSVC5igrf1Dcj0sQAQAvqw8t5x/l5ys36dvV/9S6r79QzfaSBmGlJYGmqW2a+kxWeEe7vsMoGYVNWjpkugpdeEwBY0QAAG2victPUmxDUDy2SaRjO6Ea+bIGqO8ZY127a4YeEQBA22vN5SckNXrOAACAawgiAADANQQRAADgGoIIAABwDUEEAAC4hiACAABcQxABAACuIYgAAADXEEQAAIBrCCIAAMA1BBEAAOAaTz9rpv55fFVVVS5XAgAAWqr+e7slz9X1dBDZvXu3JCkvL8/lSgAAQGvt3r1bmZmZzW7jWEviikvC4bA2b96szp07y3GcZretqqpSXl6eNm7ceMRHDrdXid7GRG+flPhtpH3tX6K3kfbFh5lp9+7d6tWrl3y+5keBeLpHxOfzKTc3t1WfycjISMj/uQ6V6G1M9PZJid9G2tf+JXobaV/sHaknpB6DVQEAgGsIIgAAwDUJE0QCgYCmTZumQCDgdikxk+htTPT2SYnfRtrX/iV6G2mf93h6sCoAAEhsCdMjAgAA2h+CCAAAcA1BBAAAuIYgAgAAXEMQAQAArvFEEOnbt68cx2nwmjRpUpOf2bVrlyZNmqSePXsqEAho4MCBeuuttyLvz5w5U6eddpo6d+6s7t2765JLLtHq1auj9jFq1KgGx5w4cWK7aN/06dMb7G/QoEFR+zhw4IAmTZqkbt26qVOnTho7dqzKy8vbvH2xamNL9unVc9hYXY7j6Mc//nFkGzPT3XffrZ49eyo9PV2jR4/WmjVrovazc+dOXX311crIyFCXLl10ww03aM+ePZ5vX01Nje666y6dfPLJOuaYY9SrVy+NGzdOmzdvPuJx77///jZvXyzaKEnjx49v8P6YMWOi9tNez6GkRt93HEcPPfRQs8eNxTk8mt8xs2bN0vHHH6/09HTl5eXp1ltv1YEDB6K2eeKJJ9S3b1916NBBI0eO1OLFi6Pe9/rv0SO10UvfhU0yD9i2bZtt2bIl8nrvvfdMkn344YeNbh8MBu3UU0+1Cy64wP75z3/a+vXrbf78+bZ8+fLINueff77Nnj3bVq5cacuXL7cLLrjA+vTpY3v27Ilsc/bZZ9uECROijl1ZWdku2jdt2jQ78cQTo/ZbUVERtZ+JEydaXl6ezZs3z5YsWWI/+MEP7PTTT2/z9sWqjS3Zp1fP4Y4dO6K2X7lypfn9fps9e3Zkm/vvv98yMzPt9ddft88//9wuuugi69evn+3fvz+yzZgxY2zo0KG2cOFC+8c//mEDBgywK6+80vPt27Vrl40ePdpefPFFKy4utgULFlhhYaGNGDEiaj/5+fl2zz33RO3r0H+jXm6jmdm1115rY8aMidpu586dUftpr+fQzKLe37Jliz377LPmOI6VlJREtonXOWxt++bMmWOBQMDmzJlj69evt7///e/Ws2dPu/XWWyPbvPDCC5aWlmbPPvusffnllzZhwgTr0qWLlZeXR7bx8u/RlrTRS9+FTfFEEDncLbfcYgUFBRYOhxt9/8knn7T+/ftbdXV1i/e5bds2k2QfffRRZN3ZZ59tt9xyy/ctt9Xaon3Tpk2zoUOHNvn+rl27LDU11V5++eXIuq+++sok2YIFC4669paKxTlsbJ9ePYeHe/TRR61z586Rf/zhcNh69OhhDz30UGSbXbt2WSAQsOeff97MzFatWmWS7NNPP41s8/bbb5vjOLZp06Y2bE1D37d9jVm8eLFJstLS0si6/Px8e/TRR79vuUelLdp47bXX2sUXX9zkZxLtHF588cX2b//2b1Hr3DqHR2rfpEmTGtR622232RlnnBFZLiwstEmTJkWWQ6GQ9erVy2bOnGlm3v892pI2Hs5L34X1PBdEgsGgdevWze69994mt/nRj35kV199tU2YMMG6d+9uJ554ot17771WW1vb5GfWrFljkuyLL76IrDv77LMtKyvLunXrZieeeKJNmTLF9u7d26btOVxbtW/atGnWsWNH69mzp/Xr18+uuuqqqF/w8+bNM0n27bffRu27T58+9tvf/rbN23WoWJzDpvbp1XN4uJNOOskmTJgQWS4pKTFJ9tlnn0Vtd9ZZZ9kvf/lLMzN75plnrEuXLlHv19TUmN/vt1dfffXoG3AEbdG+xrz33nvmOE7UX1r5+fmWk5NjXbt2tVNOOcUefPBBq6mpOeraW6qt2njttddaZmamZWdn28CBA23ixIm2ffv2yPuJdA63bt1qKSkpNmfOnKj1bpzDlrRvzpw5lpmZaYsWLTKzun9zgwYNinwmGAya3++31157Lepz48aNs4suusjMvP979EhtbIxXvgsP5bkg8uKLL5rf72/2r4Xjjz/eAoGAXX/99bZkyRJ74YUXrGvXrjZ9+vRGtw+FQvbjH/+4QUr84x//aO+8846tWLHC/va3v1nv3r3t0ksvbdP2HK6t2vfWW2/ZSy+9ZJ9//rm98847VlRUZH369LGqqiozq/sfNC0trcG+TzvtNPvVr37V9g07RCzOYVP79Oo5PNSiRYtMUuSXhZnZv/71L5Nkmzdvjtr2sssus8svv9zMzO69914bOHBgg/1lZ2fb73//++/Rgua1RfsOt3//fhs+fLhdddVVUesfeeQR+/DDD+3zzz+3J5980rp06RLVrRwrbdXG559/3t544w1bsWKFvfbaa3bCCSfYaaedFgnUiXQOH3jgATv22GOjLh2auXMOW9q+xx57zFJTUy0lJcUk2cSJEyPvbdq0ySTZJ598EvWZO++80woLC83M+79HzZpv4+G89F14KM8FkfPOO89+8pOfNLvNcccdZ3l5eVF/PT/yyCPWo0ePRrefOHGi5efn28aNG5vdb336Xbt2besLb6FYtM/M7Ntvv7WMjAz705/+ZGbu/gOKRRtbsk8z75zDQ91444128sknR63zchBpi/Ydqrq62i688EIbNmzYEa87P/PMM5aSkmIHDhxo8fGPRlu3sV59T9f7779vZolzDs3q/ni4+eabj7iveJzDlrTvww8/tJycHHv66adtxYoV9uqrr1peXp7dc889Zub9INIWbTycl74LD+WpIPLNN9+Yz+ez119/vdntzjrrLDv33HOj1r311lsmyYLBYNT6SZMmWW5urq1bt+6Ix9+zZ49Jsnfeeaf1xbdALNp3qFNPPdWmTJliZu51KcaijS3dp5l3zuGh9WRkZNisWbOi1nv10kxbta9edXW1XXLJJTZkyJCoSxZNWblypUmy4uLiVtXdGm3dxsNlZWXZH/7wBzNLjHNoZvbxxx+bpKjB5E2J9TlsafvOPPNMu+OOO6LW/fWvf7X09HQLhUKevjTTVm08lJe+Cw/nidt3682ePVvdu3ePun2sMWeccYbWrl2rcDgcWff111+rZ8+eSktLk1R3a+TNN9+s1157TR988IH69et3xOMvX75cktSzZ8+jb0Qz2rJ9h9uzZ49KSkoitY8YMUKpqamaN29eZJvVq1drw4YNKioqaoPWNC4WbWzpPiXvnMN6L7/8soLBoH72s59Fre/Xr5969OgRdX6qqqq0aNGiyPkpKirSrl27tHTp0sg2H3zwgcLhsEaOHNkGrWmordon1d3Ce/nll2vNmjV6//331a1btyPub/ny5fL5fOrevXura2+ptmzj4crKyrRjx47I/3/t/RzWe+aZZzRixAgNHTr0iPuL9Tlsafv27dsnny/6K87v90uq+35IS0vTiBEjov4NhsNhzZs3L/Jv0Ou/R4/Uxvr/eu27sIG4xJ0WCIVC1qdPH7vrrrsavHfNNddE/tI3M9uwYYN17tzZbr75Zlu9erX97//+r3Xv3t1+85vfRLa56aabLDMz0+bPnx91S9K+ffvMzGzt2rV2zz332JIlS2z9+vX2xhtvWP/+/e2ss85qF+27/fbbbf78+bZ+/Xr717/+ZaNHj7asrCzbtm1bZJuJEydanz597IMPPrAlS5ZYUVGRFRUVxaR9sWjjkfbp5XNY78wzz7Qrrrii0f3df//91qVLl8gYg4svvrjR23eHDRtmixYtsn/+85923HHHxeTWT7O2bV91dbVddNFFlpuba8uXL4/6N1jf4/XJJ5/Yo48+asuXL7eSkhL729/+ZtnZ2TZu3Li2b9xBbdnG3bt32x133GELFiyw9evX2/vvv2/Dhw+34447LuqyRHs9h/UqKyutY8eO9uSTTzZ4L97nsDXtmzZtmnXu3Nmef/55W7dunb377rtWUFAQufRpVnf7biAQsOeee85WrVplN954o3Xp0sW2bt0a2cbLv0db0kavfRc2xjNB5O9//7tJstWrVzd47+yzz7Zrr702at0nn3xiI0eOtEAgYP37929wx4WkRl/198hv2LDBzjrrLOvatasFAgEbMGCA3XnnnTG7d7qt23fFFVdYz549LS0tzXr37m1XXHFFg+t5+/fvt1/84hd27LHHWseOHe3SSy+1LVu2xKR9Zm3fxiPt0+vnsLi42CTZu+++2+j+wuGw/frXv7acnBwLBAJ27rnnNtj3jh077Morr7ROnTpZRkaGXXfddbZ79+42a9Oh2rJ969evb/LfYP2cCEuXLrWRI0daZmamdejQwU444QS77777Yjq2oC3buG/fPjvvvPMsOzvbUlNTLT8/3yZMmBD1JWbWfs9hvT/+8Y+Wnp5uu3btavBevM9ha9pXU1Nj06dPt4KCAuvQoYPl5eXZL37xiwaXWR5//HHr06ePpaWlWWFhoS1cuDDqfS//Hm1JG732XdgY52ChAAAAceepMSIAACC5EEQAAIBrCCIAAMA1BBEAAOAagggAAHANQQQAALiGIAIAAFxDEAEAIAl9/PHHuvDCC9WrVy85jqPXX3+91ft46aWXdMopp6hjx47Kz8/XQw891Op9EEQAAEhCe/fu1dChQ/XEE08c1efffvttXX311Zo4caJWrlyp3//+93r00Uf1u9/9rlX7YWZVAACSnOM4eu2113TJJZdE1gWDQf3Xf/2Xnn/+ee3atUsnnXSSHnjgAY0aNUqSdNVVV6mmpkYvv/xy5DOPP/64HnzwQW3YsEGO47To2PSIAACABm6++WYtWLBAL7zwglasWKHLLrtMY8aM0Zo1ayTVBZUOHTpEfSY9PV1lZWUqLS1t8XEIIgAAIMqGDRs0e/Zsvfzyy/rhD3+ogoIC3XHHHTrzzDM1e/ZsSdL555+vV199VfPmzVM4HNbXX3+tRx55RJK0ZcuWFh8rJSYtAAAA7dYXX3yhUCikgQMHRq0PBoPq1q2bJGnChAkqKSnRT37yE9XU1CgjI0O33HKLpk+fLp+v5f0cBBEAABBlz5498vv9Wrp0qfx+f9R7nTp1klQ3ruSBBx7Qfffdp61btyo7O1vz5s2TJPXv37/FxyKIAACAKMOGDVMoFNK2bdv0wx/+sNlt/X6/evfuLUl6/vnnVVRUpOzs7BYfiyACAEAS2rNnj9auXRtZXr9+vZYvX66uXbtq4MCBuvrqqzVu3Dg98sgjGjZsmCoqKjRv3jwNGTJEP/7xj7V9+3a98sorGjVqlA4cOBAZU/LRRx+1qg5u3wUAIAnNnz9f55xzToP11157rZ577jnV1NToN7/5jf7yl79o06ZNysrK0g9+8APNmDFDJ598srZv364LL7xQX3zxhcxMRUVFuvfeezVy5MhW1UEQAQAAruH2XQAA4BqCCAAAcA1BBAAAuIYgAgAAXEMQAQAAriGIAAAA1xBEAACAawgiAADANQQRAADgGoIIAABwDUEEAAC45v8HyhVQmc96kEMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAV5RJREFUeJzt3XlcVPX+P/DXmWFHFhUYVkFxQVRQQRCXNilLr2XZzcqyvF67la12u+mtFNusrhktlj8pW75qmpplaaZRViqCgogiYCCiqIwssu8zn98fyOTIvsycGXg9H495xJw5Z+Z9Amde8/l8zucjCSEEiIiIiMyEQu4CiIiIiDqC4YWIiIjMCsMLERERmRWGFyIiIjIrDC9ERERkVhheiIiIyKwwvBAREZFZYXghIiIis2IhdwHdTavV4sKFC3BwcIAkSXKXQ0RERO0ghEBZWRk8PT2hULTettLjwsuFCxfg4+MjdxlERETUCefOnYO3t3er+/S48OLg4ACg4eQdHR1lroaIiIjao7S0FD4+PrrP8db0uPDS2FXk6OjI8EJERGRm2jPkgwN2iYiIyKwwvBAREZFZYXghIiIis8LwQkRERGaF4YWIiIjMCsMLERERmRWGFyIiIjIrDC9ERERkVhheiIiIyKwwvBAREZFZYXghIrOgzs3CiQPfQ52bBQC4WFKFg1kFuFhSJXNlRGRsPW5tIyIyXRdLqnA+JxMDFXno7xMIOHkBaAgm+Tkn4eobCJW3f5P7CduiEZISBZUkoBESNns+j/fO+MBXykOOcMfTd92AGzzqdMdoHTz1XkddVq17DIDecxOR+ZGEEELuIrpTaWkpnJycUFJSwoUZiWR0bQDZfPgsjn77Pl63+ARKSUBAgYqbXkNKVi7Gn/kYCklAKySkWwYioO7klftAik0ogqqPQHHVWm3aK+9aCqnh5xTtQAQpzuie44A2EBMVV54DAISkez6g4WeNkJDg/zQc/EObhJqrf2bAITKOjnx+M7wQUZdcG1IA4NDXKzEu9TUor4SJJJswnK+QcLvyENqxYKzRCAFIEvRCzbUBZ5/P4xg9/kZoLe2hLihkoCEyEIYXhheibndtSBFCIG7Dqxj/5yrdh/4ZxQDYikq4i4JuDSmNIUMOja/d+F+NAA673w/HG59EZa2mSRcYEXUOwwvDC1GntDQm5dDWVRh3/JUrLSnAWYUPHEUx+qGs3c+9oz4cf1MmQCH99ZYjIEErAOXV264JKvVCgcODn8K4zPdhIWlRLyQoJUBCy8cYI+zotdZAwsXh81ExZAZqq8rYOkPUCQwvDC9EHXbtmBQtJGT1nYSa8ssYUXui3WEgbsAjCMuJ0Qsk9UKBTRN34sRv2/GaxSewkLTQSgooZryHhOwijE1ZfiWYKJDkfAvGFu/5637QMoTNegbq3CwU5KTDxTcAqksHIL5/BpLQQEhKZHtOx4DcH3THfKuZiJnKAw2vAwkQ0HUDSWj42RAB5+rWmRTVnbAbdiOch01ikCFqB4YXhheiFjU3RuXPs+exdk003rJcqzcwtjVxfo8jLPvjJiGlcMER5MR/rx9IrgSQiyVVuJCTBT9FHvr7DNe72kgXTK5cbXT1/WaVnAeKTgP9BgFOXnrHaB089V5HXVatewwACnLSUXo6Qdeac3Wo6e6AoxVAgvv96Bc+GwVFRajs44cRw4fDw8m2a09M1MMwvDC8EDWr8ZLjxoG0x2zDYFNfgiF1p2AhaZs9Js39Dgy7uEOvu6etkAI0DSSm6OoaAej9vPePOJw9cQD/sdgEC0nb5SBzdavM6vo74OI/FsNUDvAOvsFk//8QGRPDC8MLUROZJ+IxaMtUvRBytbNaF3hLBXotL0JSQnrmOBJ+3mLWIaWzrm4p0lraIfOX9QjL2wilroVGtLul6mpXByGtABL63Q7LwTcwyFCvxvDC8EK9XGPXkNLWCZdPxcH+9G6MqElutnUlweMBDJz2NH7Js8HRbz9oMiYFY+fqnrOnhpSOaPz/IPUfiKpaLZRH/h9G5ayHshtaZxqDzMBZUb36/zH1TgwvDC/Uix38chnGZ0VDIbV9FU5j90/jB2VLY1KodY2BJuliNSqTt2GBcmenWmQaNYYYuI+EZR8XtshQr8DwwvBCvUxlRRmOx34Fu+NfYmTt8SaBJcF7HgZM+SfOHf25xe4f6h6NAbDf5aMoOhGL0Ze+bZhRuAutMmyRod6A4YXhhXo4dW4W8rNTUVVejPpTezCiKBaOUmWL+6fevBEjJk7XHcvuH+Np/P/d/9JBqI59BAmd717SCuCI4xQoA6azNYZ6HIYXhhfqweLWv4LwP99p0i2RJ7nirOsNCFFvbfbyZX7QmYArl3fn1ypxNjMddVn7EFb4Xae6mLQCSHa+GV5/f4u/W+oRGF4YXqiHEUIgPekPVMS+jZCKP/S+tWsFcGz8Koye+jAkhRIJ26LZNWRG1LlZyP4mCmGFOzp95VKybTjsb/kvho69odvrIzIWhheGFzJjV08i5+zqhWN716NP8qcIrD/Z4jFXdws1Pge7hsyLOjcLucd+63RrjBBAlsIP2hnvMcSQWWJ4YXghM6U/iRxQBns4SRUAgFqhRGqfCASXH2h2wjiGlJ6jMchoMnYhtGRvh4IMQwyZK4YXhhcyQ+rcLLjEhOiNVwGAy3BApu+98L/tKfRzH8BuoV6ms91KQgBnFN4oC/oHVONmMtySyWN4YXghM3P+zCmoNz2BsdXxTR47fuNnGHX9XXrb2C3U+6hzsxC753sMy/4/jFVkduhqJSGAww6R8L33bf69kMlieGF4ITNxIScTZ757DaGFO2AlaZo8zi4hutbFkipkHv0dzoejMaL8YIdbYxLd70HoYzGGK5Cokzry+a0wdDGrV6+Gn58fbGxsEB4ejoSEhFb3j46OxrBhw2BrawsfHx88++yzqK6uNnSZREahzs3CiQPfIy3pNxz84B9wWReOCUXbYSVpcNJ6NA55PIh60fDPsrFLiMGFrubhZIvJN0zFqOd/RP6CJCQ43AxtO7+CShIQkvc1SqI8cPTnrwxbKJEBGbTlZfPmzZg7dy7WrFmD8PBwREdHY8uWLcjIyICbm1uT/Tdu3Ih//OMfWLduHSZMmIBTp07h4Ycfxr333otVq1a16zXZ8kKm6urBuFdPUpZuPQrSjf/FsPHTALBLiDpOnZuFnM0vILS0/YN7hQAKJAdcvn09B/aSSTCZbqPw8HCMGzcOH374IQBAq9XCx8cHTz75JBYvXtxk/yeeeAJpaWmIjY3VbXvuuecQHx+P/fv3t+s1GV7IFJ378wS81k/UX7FZAMnh72DMbfO7tpof0RXq3Cyc/HIRrq/Z16EQc05Sofr2tQwxJCuT6Daqra1FYmIiIiMj/3oxhQKRkZGIi4tr9pgJEyYgMTFR17V0+vRp7Nq1C9OmTWvxdWpqalBaWqp3IzIVQqvFkZ82wHrD35p8mEgSYOXkweBC3Ubl7Y8b//sd0u+LwwG7Ke3qTpIkYADUGPLdHciMGgl1bpbhCyXqIgtDPXFBQQE0Gg1UKpXedpVKhfT09GaPuf/++1FQUIBJkyZBCIH6+no8+uij+O9//9vi66xYsQLLly/v1tqJukN2ejJKtj+H0JojAJpf0dnFN0Cm6qgnCwwIBAK+6VBLjCQBg3EOImYsDjndivGLNhunWKJOMPiA3Y7Yt28f3njjDXz00UdISkrCN998g507d+LVV19t8ZglS5agpKREdzt37pwRKyZqqqS4CAc+ehxeX92E0TVHUCuUSPCai4TAJRyMS0Z1dUvMKWkQ2jNIQJKA8JLdqFraD6cPbDV8kUSdYLAxL7W1tbCzs8PWrVsxc+ZM3faHHnoIxcXF+O6775ocM3nyZIwfPx7/+9//dNvWr1+PRx55BOXl5VAo2s5aHPNCclDnZuFSdipKzyRjaNancEUxAOC4XThc7l4Fj0EjdftxMC7J5VTSPrjsmIO+orxdvZVCAHlSX+DZNHg42Rq+QOrVTGLMi5WVFUJCQvQG32q1WsTGxiIiIqLZYyorK5sEFKVSCaBhYToiU5SwLRquMSEYFfsgJma9A1cUI1fhgRM3xGDUf/boggvQ8E14xMTpDC4ki6Fjb0C/qPOId53V7vEw7uIyXN9xx8Y1KwxfIFE7GbTbaNGiRYiJicEXX3yBtLQ0PPbYY6ioqMC8efMAAHPnzsWSJUt0+8+YMQMff/wxNm3ahOzsbOzduxcvv/wyZsyYoQsxRKbkfHY6QlOW6a01pBUSpAe2YeQN98hYGVHLxj+xDvkLkpBoO6nNriRJAiwUwH0X30T50n4c0EsmwWADdgFg9uzZyM/Px9KlS5GXl4fRo0dj9+7dukG8Z8+e1WtpeemllyBJEl566SWcP38erq6umDFjBl5//XVDlknUKafTk6HYfH+TgZAKSaD44hl4DRohT2FE7aDy9ofqhZ1Q52ZB+uRGuIqSVruSJAnoI2lgHzMWiTbhCFmyx3jFEl2DywMQdZBGo0HcphUIPRUNG6mu2auIOKU/mZtDH/4D4fnb2j0WploAtq+UGL4w6jVMYswLUU+Um52Bk2/eiEl//g82Uh1SbUIQP+QZXkVEZm/8E+twaUES8tC3XV1JNhKgXeqE+LfvME6BRFdhywtRK9S5WcjPOQkXnwCcTtiFoOMr0EeqQqWwRtrI5zF21nOQFApeRUQ9ytGfv0LQ749CIbU9h6IQgEYAFmyFoS4ymeUB5MDwQt2lpbWIMiwD4XjfJ/DgmBbq4dRRA+DWxlgYoCHACAEoFACiGGKoc9htRNRF6twsXXABGoKLEEC818MY8sIfDC7UK6iizmL/uA+g1aLVriRJagguQgCIcjJafdR7MbwQNUOdfUIXXBpJEtAn8BYoLAx6kR6RSZn8t7lQvFKCeqFo11gYBhgyBoYXomsUF+YDf6xqsp1rEVFvZvnKZcR5zWtXKwyRoTG8EF0lMzURpR9eh6DaZNQJJbSi4Z2YVxERARMeiYbilRLdGJfm9KxRlGSq2P5NdMXh3esxPO7f6CNVQS25oHLWl7Dr6667iiiMwYUIAKB4pQTapQ1dQ1e3tOgGtnPQLhkYwwv1ehqNBnHr/oNJ5z8BJCDNOgie/9wElasXALC1hagZildKcGTFVIyoPASrK9uUSjC4kFEwvFCvVnK5CFlr78ekqjgAwGHVPRgz/0NYWFnLXBmR6Qtd8pPcJVAvxfBCvZI6NwvZh3fD69j7GIs81AhLnAxZjnG3L5S7NCIiagPDC/U6CduiEZoSBdWVS6FLYI/CO7/CmNHXy1sYERG1C8ML9Srq3CyEpkRBcdUcLn1EFapdvOUrioiIOoSXSlOvIYTA6W36wQUAlJIWBTnpMlVFREQdxfBCvYLQanHgk38j4vKOJo9x8jkiIvPC8EI9nlajxcE1jzdcCg0g2X4S6kXDnz4nnyMiMj8c80I9mkajQfyH8zDx8ncAgCPDFyN09hKoc7M4+RwRkZlieKEeq66uFknv348JZXuhFRKSxyxH6MynATRMPMfWFiIi88TwQj1SdXUVTrx/D8Irf0e9UCA1/G2MnbZA7rKIiKgbMLxQj1NZUYaMD+5CaHUCaoUFMq77AMFT7pe7LCIi6iYML9RjqHOzcCHjCGwOrsIYTTqqhBWyI2MwavJMuUsjIqJuxPBCPULCtmiEpPw1a261sMTZ6esRGDZV3sKIiKjb8VJpMnvq3CyEpERBedXkc5aoh7PnYPmKIiIig2F4IbOXl3VML7gAgFISnDWXiKiHYnghsya0WtQkfNFkO2fNJSLquRheyKwd+Gwxwir2QSsAjZAAcNZcIqKejgN2yWzFbV+NSef+HwDg6KiX4D3+Ls6aS0TUCzC8kFlK/u07hCS/DEjAYa+5GHf38wDA1hYiol6A3UZkdv48noBBvzwKK0mDo443IXR+tNwlERGREbHlhczKxdxsOGy7D45SJdKtRmLE4xsgKZRyl0VERlK12AlWlg0/19YBtm+WyFsQyYItL2Q2SoqLULHuTrijAOcUXvB8bDusbOzkLouIjES71Ak21oBS2XCzsW7YRr0PwwuZhdqaGpz5+G4M1majCE6weugbOPZ1k7ssIjKSqsVOkCRAkv7a1nifAab3YXghk6bOzcKJP3Yg+f3ZCK5JRJWwwuWZ66HiHC5EvYqVpX5wadQYYOJW3Wv8okg2HPNCJuva9Yq0Asi6/n2MHH2dvIURkdHV1gE2ipYDTHjxj8YvimTDlhcySc2tVwRIcB0aJldJRCQj2zdLIAQgRPOPs/uod2F4IZOUn3OyyXpFCq5XRNSrKV4paTW8SBJQs7SfcYsiWTC8kEnq6zmkyZsU1ysiIsVzJ1sNMFaSBt9+tMS4RZHRMbyQSTod+wkk6a8mYq5XREQAACcv5Hjc0mqAuT3vI1wsqTJuXWRUkhAt/QmYp9LSUjg5OaGkpASOjo5yl0OdcCL+ZwTs+jssJC2OBCyGrU8QXHwDGFyISKdiaT/YSZpmB/AKAdQLwPIVTmBnTjry+c2WFzIpJcVF6Pvj47CQtEhyikTovUswYuJ0Bhci0mP/ShHqWxjAK0mAhQRkLQ8yfmFkFAwvZFLS1j0OL6iRJ7li6D/Wyl0OEZkwyzYG8A7S5uBU0j6j1kTGwfBCJiNh52cYX/ojtEJC6W0foo9Tf7lLIiITlznzu1YDjO+3M41aDxkHwwuZhAs5mRiW8CIAINHnYQwNu1XmiojIHAwdewNSLQJaDDBWkkBq1FjjFkUGx/BCstNoNCjYMB9OUgUyLYZgzNw35S6JiMzIyJfjUSEsm31MkoBAkYWE/XuMXBUZksHDy+rVq+Hn5wcbGxuEh4cjISGh1f2Li4uxcOFCeHh4wNraGkOHDsWuXbsMXSbJKG7DKwiqTUalsIbdvZ/BwspG7pKIyMxUPBLfavfRiD33G7cgMiiDhpfNmzdj0aJFWLZsGZKSkhAcHIypU6fi0qVLze5fW1uLm2++GWfOnMHWrVuRkZGBmJgYeHl5GbJMklFG8gGEZX0IAEgPXgzPwaNkroiIzJHK2x9xXvNaDDB2Uh1+XnG3cYsigzHoPC/h4eEYN24cPvyw4cNJq9XCx8cHTz75JBYvXtxk/zVr1uB///sf0tPTYWnZfBNgWzjPi/moKC9D/jvj4Sdyccx+IoKe+wGSgj2ZRNR5mVFB8Bc5Lc7/knZfHAIDAo1fGLXJJOZ5qa2tRWJiIiIjI/96MYUCkZGRiIuLa/aYHTt2ICIiAgsXLoRKpcLIkSPxxhtvQKPRtPg6NTU1KC0t1buR6VPnZiF99T3wE7kogDMGzvuUwYWIumxwVApqRfPvJZIEuGzixQA9gcE+LQoKCqDRaKBSqfS2q1Qq5OXlNXvM6dOnsXXrVmg0GuzatQsvv/wy3nnnHbz22mstvs6KFSvg5OSku/n4+HTreVD3S9gWDdeYEIRUHQQAZKmmwtHFQ+aqiKinyJm5vcXuI1dRgkMf/sO4BVG3M6mvulqtFm5ubli7di1CQkIwe/ZsvPjii1izZk2LxyxZsgQlJSW627lz54xYMXWUOjcLISlRUFy1YnRI3haoc7PkK4qIepShY29AutXwFmffDcvfxvccM2ew8OLi4gKlUgm1Wq23Xa1Ww93dvdljPDw8MHToUCiVSt224cOHIy8vD7W1tc0eY21tDUdHR70bma78nJNQSvrvKBaSFgU56TJVREQ90fAXD6FCan7spEICKj6ZadyCqFsZLLxYWVkhJCQEsbGxum1arRaxsbGIiIho9piJEyciMzMTWq1Wt+3UqVPw8PCAlZWVoUolI7K0c2rybaheKODiGyBPQUTUY124fWuL3UcDxVnErX3auAVRtzFot9GiRYsQExODL774AmlpaXjsscdQUVGBefPmAQDmzp2LJUuW6PZ/7LHHUFRUhKeffhqnTp3Czp078cYbb2DhwoWGLJOMqPD3GEjSX4up1QsFkoKWceFFIup2Q8fegOPWwS12H4Wf/5zdR2bKwpBPPnv2bOTn52Pp0qXIy8vD6NGjsXv3bt0g3rNnz0Jx1RUmPj4++Omnn/Dss88iKCgIXl5eePrpp/HCCy8YskwykszUwwgv+h6QgGMT3odlHxe4+AYgjMGFiAwk6L+/oyjKC/1Q3uQxhQTkbH4Bque2ylAZdYVB53mRA+d5MU1CCCS/NRVjquNxrM8kBP97p9wlEVEvcSppH4Z8d0ezc79oBZC/IImtvybAJOZ5Ibrasd93YEx1POqEEm53cu0iIjKeoWNvQLrF0GYfU0hAxf89YOSKqKsYXsjgNBoN7H+LAgAkq+6Ehz+XACAi4+o3b1PLg3erTyI/46BxC6IuYXghgzu8Yw2GaE+jDLYYdk/LEw4SERmKytsfP/V7oMXBu4XfvmT8oqjTGF7IoCrKy+B3bBUAIM3/n5xJl4hkE/zwSpzWqpp9bGhlIq88MiMML2RQR7esgDsKoJZcEHx308U4iYiMxcPJFgeCVjTb+tJ45RGZB4YXMpj8vFwEn1kHALgQ8jysbfvIXBER9XZz/z4LmQq/Zh8LLd3L1hczwfBCBvPnlpfhIFUhy2IwRk9bIHc5REQAADHjvRZbX3I3PGn8gqjDGF7IILIzjmFcwXcAgLopyyEplG0cQURkHEPH3oCsFlpfxlYeQNz/LTNuQdRhDC9kEEXfLoGlpEGK3XgERPxN7nKIiPRoW2h9kSQgPDOa3UcmjuGFul3Crs8QUnUAGgH0vWOF3OUQETUxdOwNSLUa2exjCgnIPfabkSuijmB4oW4Vv/VdjIt/BkDDH9fFE7/LWg8RUUtcH/oS2hYmrtNk7DJuMdQhDC/UbdS5WRh3fLlu/RBJAsamLGfzKxGZJJW3PxL63d7sY6ElvPLIlDG8ULfJzzkJhaT/NcZC0qIgJ12mioiIWjdwVlSzrS8KCcj+Jsro9VD7MLxQt5EsbJsMgKsXCrj4BshTEBFRG1prfQkr3MHWFxPF8ELdpvjYD5Ak6AJMvVAgKWgZl5onIpPWWusLB+6aJgu5C6CeoaamGkMvbAcAHBm1FHYeAXDxDUAYgwsRmTiVtz8SHKcgrCy2yWOajF3A9H/IUBW1huGFusWxn79CGIpRAGeMuf0JWFhZy10SEVG7KQOmA4ebhpfGgbtsQTYt7DaibmFz7AsAwGmfuxhciMjseAffwIG7ZoThhbosO+MYgmqPQisk+N3yuNzlEBF1GAfumheGF+qyC7FrAACpdmFw8xkiczVERJ3Dy6bNB8MLdUlVZQUCL30PAJDGcVAbEZkvtr6YD4YX6pJje75EX5RBLbkg8Lq75S6HiKhLeNm0eWB4oS5xOPF/AIAc379DYcGL14jIvLXW+lKXtc+4xVCLGF6o0/48noAR9amoFwoMvvUxucshIuoWLbW+hBV+x64jE8HwQp2W/9v/AwCccJiEfu6+MldDRNQ9Wmp94cBd08HwQp1SXlaCkfkNS8Zbj58vczVERN3LcvANzW4fV/g9W19MAMMLdcrxnz6Do1SJ85I7AibMkLscIqJu1dKkdUpJoCAn3fgFkR6GF+owIQT6pa0HAJz3nw1JoZS5IiKi7qXy9schr3m6hWYbCQGUpu6RpyjSYXihDjsa+zWGaf5ErVBg2K2Pyl0OEZFBOI6YAknS3yZJQNj5L9h1JDOGF+qQhG3RGPPHIwAAS2iR8dvXMldERGQYrr6B0LDryCQxvFC7qXOzEJISpfsmIknA2JTl/AZCRD2Sytsf8S10HVna2stTFAFgeKEOyM85CaWk/6/YQtLyGwgR9VgtdR0V/bFOnoIIAMMLdYCrb2CT0ff1QgEX3wB5CiIiMrCWuo7Ci75D3P8tM35BBIDhhTrAzWsQLktOuvv1QoGkoGVQefvLWBURkeGovP1x2P3+JtslCQjLfI/d5jJheKF2O5/zJ/qjBBoBpFy3FoULjiBs1jNyl0VEZFADZ/ybA3dNDMMLtVtu0k8AgNNWwxB002y2uBBRr8CBu6aH4YXaTTrzBwDgstt4mSshIjKulgbuFsZzugg5MLxQuwitFr6lRwAADsOnyFwNEZFxtTRwNyxvI8e9yIDhhdol+9RxuKMQtcICg0JukrscIiKjamngLse9yIPhhdolL7lhvEumzQhY2zrIXA0RkfH1C5/NcS8mguGF2sXq3H4AQLnHBJkrISKSR21VGce9mAiGF2qTRqOBf0USAKDvSI53IaLeieNeTAfDC7Up83g8+qIMlbDGoODr5S6HiEgWHPdiOhheqE0Fx/cCALJsg6G0tJK5GiIi+Qyc8e8my6RohMRlUozMKOFl9erV8PPzg42NDcLDw5GQkNCu4zZt2gRJkjBz5kzDFkitsjt/AABQ7T1R5kqIiEyBdM29ZvqSyKAMHl42b96MRYsWYdmyZUhKSkJwcDCmTp2KS5cutXrcmTNn8O9//xuTJ082dInUipqaagytOgYAcA2eKnM1RETyys85CYWkH1YUEnD6+3dkqqh3Mnh4WbVqFRYsWIB58+YhMDAQa9asgZ2dHdata3k5cY1Ggzlz5mD58uUYNGiQoUukVmQm/wF7qRol6APfwDC5yyEikhUH7ZoGg4aX2tpaJCYmIjIy8q8XVCgQGRmJuLi4Fo975ZVX4Obmhvnz57f5GjU1NSgtLdW7UfcpTo0FAGT3GQtJoZS5GiIieXHQrmkwaHgpKCiARqOBSqXS265SqZCXl9fsMfv378enn36KmJiYdr3GihUr4OTkpLv5+Ph0uW76i2NeQ8is82X3HRER0LjKtP64FyGA0tPtG89JXWdSVxuVlZXhwQcfRExMDFxcXNp1zJIlS1BSUqK7nTt3zsBV9h6VFWUYWpMKAPAcfYvM1RARmQaVtz8S/J/Wm21XkoBxme+z68hILAz55C4uLlAqlVCr1Xrb1Wo13N3dm+yflZWFM2fOYMaMGbptWq22oVALC2RkZMDf31/vGGtra1hbWxugevoz8VcES3XIRz94+gfJXQ4Rkclw8A+FdFp/m4WkRUFOOlTe/s0fRN3GoC0vVlZWCAkJQWxsrG6bVqtFbGwsIiIimuwfEBCA48ePIzk5WXe7/fbbceONNyI5OZldQkZWkfItACDXPhCSwqQa6YiIZGVl68B1jmRk0JYXAFi0aBEeeughhIaGIiwsDNHR0aioqMC8efMAAHPnzoWXlxdWrFgBGxsbjBw5Uu94Z2dnAGiynQwrYVs0IvK3ARIQXH4ACduiETbrGbnLIiIyCS2tc1RXVSFPQb2MwcPL7NmzkZ+fj6VLlyIvLw+jR4/G7t27dYN4z549CwW/1ZsUdW4WQlKidP8wFZLA2JTlUIfPYHMoEREaL5mWoLxqzhfdoN2J02WsrHeQhLi24cu8lZaWwsnJCSUlJXB0dJS7HLN04sD3GLn3gSbbU2/eiBH8R0lEBACI+3IZxmdF67XA1AsFChcc4Re9TujI5zebPKgJV99AaK+5DLBeKLh2BxHRVRz8Q5t0HTUO2iXDYnihJlTe/kjoO013v14okBS0jN8kiIiu0vBFT38bF2k0DoOPeSHzpHEeCBQDx63Hwu3BTxDG4EJE1AwJuGphRqnlHakbseWFmqUoOw8AqHQNZosLEVEzml+kkcsEGAPDCzXLpvIiAEDp7C1zJUREpqnxiqOrcZkA42B4oWb1qbkEALDpP0DmSoiITBOXCZAPwws1q782HwDgqPKVuRIiItPFK47kwfBCTZSXl6EfygAA/TwHyVwNEZHp4tQS8mB4oSYKLzSsNlYJa/Rxat/q3kREvZHK2x9H7f5aq08IIMn5Fl7oYGAML9RESV4OAKBQ4YIm7aFERKSjzs3C6Mo43X1JAsYW7+GYFwNjeKEmqgrPAgBKLd1kroSIyLTl55zUW98I4JgXY2B4oSbqi3MBAFV27jJXQkRk2jjLrjwYXqgJZekFAICmj5fMlRARmQOplXtkCAwv1IRNFSeoIyJqD86yKw+GF2rCobZhgjrb/j4yV0JEZNqam2W3nt1GBsfwQk24aK5MUOfuJ28hREQmTuXtj8SgKL1xLwoAOfHfy1ZTb8DwQnpKS4vhJFUAAPpzgjoiojb5hs/A1SNdFJLA2JTlvFzagBheSE/h+WwAQDlsYefYT+ZqiIhMX3PjXni5tGExvJCe0ktnAFyZoI6IiNrEJQKMj+GF9FQVNExQV2bFCeqIiNpD5e2PpD6TdPe5RIDhMbyQHq06DQBQa+kocyVEROZBnZuFMeX7dfe5RIDhMbyQTsK2aESovwIAjC79FQnbouUtiIjIDHCJAONjeCEADd8cQlKidOswKiRwtDwRUTs0P9cLx7wYEsMLAeA3ByKizlJ5+2Or5/MQV95CNQLY5vlvjnkxIIYXAsBvDkREnXWxpApHz17W3Zcg4ejZYlwsqZKxqp6N4YUA/DVLZOM3B62QkBS0jN8ciIjacD4nE69bfHJVt7vAaxaf4EIOu90NheGFdMJmPYNk2zAAQMLARxE26xl5CyIiMgMDFXnNdrv7KfJkqqjnY3ghPbVWfQEACqWlzJUQEZmH/j6BENd8nGolBfr7DJepop6P4YX0aC3tAACitlLmSoiIzISTF7K9/qbrdhcCOOP5N8DJS966ejCGF9IjLBrCi1TH8EJE1B7q3Cz45n6vG/MiScCA3B841YQBMbyQHmHZGF4qZK6EiMg8cKoJ42N4IX1WDeFFUV8tcyFEROaBU00YH8ML6VE0hhcNu42IiNrj2qkmNAKcasLAGF5Ij8LaHgBgUc/JlYiIOkOC1PZO1CUML6RHYd0HAGCpZXghImqPpmvDCa4NZ2AML6TH4krLi6WGY16IiNqDA3aNj+GF9FjaNLS8WAmGFyKi9uCAXeNjeCE9FrYN4cVay/BCRNQeKm9/HB7xou6+Rig4YNfAGF5Ij7WtAwDABgwvRETtNfiGB3Q//zn9a64NZ2AML6TH6krLi42okbkSIiLzcerHj3Q/D9n5dyRsi5avmF6A4YX0WNtdGfMi1UNbXydzNUREpk+dm4Xw0x/o7it5tZHBMbyQHlt7B93P1ZVlMlZCRGQeeLWR8TG8kB5bGzvdqHmGFyKitrn6BkLLq42MiuGF9CiUClTBBgBQw/BCRNQmlbc/ku0idPfrebWRwRklvKxevRp+fn6wsbFBeHg4EhISWtw3JiYGkydPRt++fdG3b19ERka2uj91vyrJGgBQU1kucyVERKYvYVs0RlceBAAIARwe/BSvNjIwg4eXzZs3Y9GiRVi2bBmSkpIQHByMqVOn4tKlS83uv2/fPtx333349ddfERcXBx8fH9xyyy04f/68oUulK2qkhpaX2iq2vBARtaZxaQDFlV4jSQLGZb7PwboGZvDwsmrVKixYsADz5s1DYGAg1qxZAzs7O6xbt67Z/Tds2IDHH38co0ePRkBAAD755BNotVrExsYaulS6ojG81FVXyFwJEZFp42BdeRg0vNTW1iIxMRGRkZF/vaBCgcjISMTFxbXrOSorK1FXV4d+/fo1+3hNTQ1KS0v1btQ1GigBABWXzshbCBGRiePSAPIwaHgpKCiARqOBSqXS265SqZCXl9eu53jhhRfg6empF4CutmLFCjg5OeluPj4+Xa67N0vYFo0hmobmztCUKE60RETUCpW3PxKDoiCuNL5ohMTBukZg0lcbvfnmm9i0aRO2b98OGxubZvdZsmQJSkpKdLdz584Zucqeg8u6ExF13LCb5ureNzNuWc/BukZg0PDi4uICpVIJtVqtt12tVsPd3b3VY1euXIk333wTe/bsQVBQUIv7WVtbw9HRUe9GncO+WyKijjvxzQrdz8P2PMAWayMwaHixsrJCSEiI3mDbxsG3ERERLR739ttv49VXX8Xu3bsRGhpqyBLpKuy7JSLqGHVuFiLOxujuc2kA4zB4t9GiRYsQExODL774AmlpaXjsscdQUVGBefPmAQDmzp2LJUuW6PZ/66238PLLL2PdunXw8/NDXl4e8vLyUF7OOUcMrbHvtjHACAEkjXqJfbdERC3IzzkJBVusjc7C0C8we/Zs5OfnY+nSpcjLy8Po0aOxe/du3SDes2fPQqH4K0N9/PHHqK2txd133633PMuWLUNUVJShy+31wmY9gwsht6HvZxNhK9XBfcRkuUsiIjJZDUsDQDfPC8AWa2OQhBCi7d3MR2lpKZycnFBSUsLxL11w4o3JGFmbgiPBryD0zqflLoeIyGSdWT4CfiIXwF9LA3DQbsd15PPb4C0vZJ5K+wUBeSnQ5ibKXQoRkUmzFVUAgIThS+A78e8IY1e7wZn0pdIkH8sBDQOl+xefkLkSIiLTVVp6GSoUAgDcRt3EMYJGwvBCzfIMnAgAGFB/BjVVHCxNRNSc45tf1f3ss/kWXiZtJAwv1CzPAYNRACdYShrkpMbLXQ4RkclR52YhIvevdfp4mbTxMLxQsySFAudshgMAijMPyVwNEZHp4WXS8mF4oRZVugUDAJQXj8pcCRGR6XH1DcS11+vyMmnjYHihFtkPHAcAUJWmylwJEZHpcfEYiGpY6e43XibNQbuGx0ulqUU+IycBvwHe4gJKi/Ph6Owqd0lERCYj9/QJ+Eq1qBEW+DPyU7gOHMXLpI2ELS/Uov6uHsiVGhbQPHf8gMzVEBGZlvNHdgIAci0GYOTkmWxxMSKGF2pVnn0gAKD8NK84IiJqlLAtGuPT3wQADKw/zUukjYzhhVpV6z4aAGCtPiZvIUREJkKdm4WQlCjdekYKCbxE2sgYXqhVjoPHAwC8K1PRZFg9EVEvlJ9zEkpeIi0rhhdq1cCREQ2X/qEYBRey5S6HiEh2DStJS3rbeIm0cTG8UKvs+zgiR+kLAMhN5aBdIiKVtz+O2k/U3ecl0sbH8EJtyncaCQCoOXNY5kqIiEyDhebKStIus1C44AjCZj0jb0G9DMMLtc1zDADAvjBF5kKIiORXW1uLwdUNk3eqbnyELS4yYHihNvUfOgEA4FuTDqHVyFwNEZG8TuzbCnupGmWwxYCAULnL6ZUYXqhNvsNDUCWs4IAqnM86Lnc5RESySdgWjdEHHgMA9BFVOPzthzJX1DsxvFCbrKyscMZqMABAnRYnczVERPK4dn4XifO7yIbhhdqluO8oAIDm3BGZKyEikgfndzEdDC/ULhY+IQAAVeEhfssgol6J87uYDoYXape6whwAgK82Fy4xIVzHg4h6HZW3P9Ith+vuc34X+TC8UJvUuVkIz/5Id18pCfbzElGvo9Fo4FZ/AQCQ4P8M53eREcMLtYn9vEREwKmk3+CCYlTABmPuWcwWFxkxvFCbXH0Dobmmn1fDfl4i6mUux28AAGTZBMHS2lbmano3hhdqk8rbH4lBUagXf/25HHW6kd86iKjXSNgWjYj8rQCAkVWHOe5PZgwv1C5hsxr6d+Nc7gYA9K/IgtBqZa6KiMjwGud3ka40QCs47k92DC/UbipvfwTe/yaqhSUGas4g8+g+uUsiIjI4jvszPQwv1CFO/VyR4jwFAFCyP0bmaoiIDM/FJwBCP7twfheZMbxQh/WZ8E8AwIiin1FWXChzNUREhlVSdAmSBF2A4fwu8mN4oQ4bPm4KshUDYCvVIm3PJ3KXQ0RkUAUH1wMAjtuFIfXmjZzfxQQwvFCHSQoF8gbPBgC4ZmxEk/ZUIqIeor6uDkMu7QYASCEPY8TE6WxxMQEML9Qpw29ZoBu4++fR3+Quh4jIIBJ//AxuKEIpbBEw+S65y6ErGF6oU5xdVEhxuhEAUPzHWpmrISLqfgnbohGW+DwAwEFU4egP/0/miqgRwwt1mn3EfAANA3fLS4tkroaIqPtcO7eLJIFzu5gQhhfqtMDwW3BG4Q07qQYnd38qdzlERN2Gc7uYNoYX6jRJocBF/3sBAC4ZGzhwl4h6DJcBwzm3iwljeKEuCZi6ADXCEoM02chM/kPucoiIusXlvLOc28WEMbxQl/R1cUeK4/UAgMscuEtEPUTpH2sAAMl9JnNuFxPE8EJdZhtxZcbdwj0cuEtEZi8/7xzGlMQCAJxufp5zu5gghhfqshHjp+Ks5NUwcHfPOrnLISLqkoxdH8FKqkem5VAMGn293OVQMxheqMskhQLn/Rtm3O2XtlHmaoiIOq+2thZDzm4GAJQF/UPmaqglDC/ULYbdsgC1wgKDNVkcuEtEZuvI9vehQiEuow9G3PyQ3OVQCxheqFv0c/NEiuN1AICi3zlwl4jMT8K2aEScfBUA4CTKkbyT72WmyijhZfXq1fDz84ONjQ3Cw8ORkJDQ6v5btmxBQEAAbGxsMGrUKOzatcsYZVIX2YRfmXG3cA8qSi/LXA0RUfupc7MQmvLXjLoKzqhr0gweXjZv3oxFixZh2bJlSEpKQnBwMKZOnYpLly41u//Bgwdx3333Yf78+Th69ChmzpyJmTNn4sSJE4YulbpoxIRpOCt5wl6qxsm9n8ldDhFRu+XnnISCM+qaDYOHl1WrVmHBggWYN28eAgMDsWbNGtjZ2WHduuavSnnvvfdw66234vnnn8fw4cPx6quvYuzYsfjwww8NXSp1kaRQ4PyghoG7zhy4S0RmpK6musk2zqhrugwaXmpra5GYmIjIyMi/XlChQGRkJOLi4po9Ji4uTm9/AJg6dWqL+9fU1KC0tFTvRvIZOvUR1AoLDKn/E/FbVrLJlYjMgvZwQ2uxljPqmgWDhpeCggJoNBqoVCq97SqVCnl5ec0ek5eX16H9V6xYAScnJ93Nx8ene4qnTunv5olsi4EAgPDUV+ESE4KEbdHyFkVE1IqMo/sRUnUAWiEhY+oGzqhrBsz+aqMlS5agpKREdzt37pzcJfVq6twsDKnP1N1XSoKD3ojIpJXveQMAkOw8BcMn/I0z6poBC0M+uYuLC5RKJdRqtd52tVoNd3f3Zo9xd3fv0P7W1tawtrbunoKpy/JzTkLVwqA3vhkQkam5utVF9beX5S6H2smgLS9WVlYICQlBbGysbptWq0VsbCwiIiKaPSYiIkJvfwDYu3dvi/uTaXH1DYRGSHrbNELioDciMjkXS6pw+cfXADS0ungNGS1vQdRuBu82WrRoEWJiYvDFF18gLS0Njz32GCoqKjBv3jwAwNy5c7FkyRLd/k8//TR2796Nd955B+np6YiKisKRI0fwxBNPGLpU6gYqb38kBkWhXvz1p5Uv9Ud/FcciEZHp2Hz4LF54612Mr42DVgBpQx+VuyTqAIOHl9mzZ2PlypVYunQpRo8ejeTkZOzevVs3KPfs2bO4ePGibv8JEyZg48aNWLt2LYKDg7F161Z8++23GDlypKFLpW4SNusZFC44gsTxH6BU2MIdBUj8+k25yyIiAtDQ4nL02/fxheVbAAAJwPGDe3CxpErewqjdJCGEaHs381FaWgonJyeUlJTA0dFR7nJ6vUNbV2H8ieWoFNYom38AqgFD5C6JiHq5IynHMXbbZL1J6eqFAsdm/YGQIH5RlktHPr/N/mojMm1hdz6Nk5YjYCfV4OKmp+Quh4gIPtrzzc6m66dofkoOMj0ML2RQCqUSNne+j1qhxOjKgzi6Z73cJRFRL3f2+B9NtmklBfr7DJehGuoMhhcyuEGBoTjiPRcA4HXwZZRz0UYikknBpYsYkvk5AECg4cpIISmhmPEe4OQlY2XUEQwvZBRj7n8NuZI73FCE1PX/kbscIuql/vzqBThL5chW+kH71DHgoR8gPXMcGDtX7tKoAxheyChs7fug8PqGWSxD1VuQmfy7zBURUW+TfvQPhBftAADU3vImlP18gYGT2eJihhheyGiCb5iFww6RUEoC+P4ZaOrr5C6JiHoJrUYLsfN5KCSBJMebMCz8NrlLoi5geCGj8pvzLkphj8GaLBzh3C9EZCQJOz7G8Po0VAprDLj3HbnLoS5ieCGjcnUfgJMjnwMAjMz4EOrczDaOICLqmuz0JAQcex0AcMJ/AVw8B8lcEXUVwwsZXdidzyDNMhD2UjUufMW5X4jIcBK2RcP3qxvhjAoIAQgbZ7lLom7A8EJGp1AqYX3n+6gTSoypOMC5X4jIINS5WQhNiYLiylqxkgSEpL4BdW6WrHVR1zG8kCwGBY7DEa8HAACeB5dy7hci6nZ5fyY3O5NuQU66TBVRd2F4IdmMnvM6zksqqFCIE+tfkLscIuphKo9922RbvVDAxTfA+MVQt2J4IdnY2jug4PoVAIBx6q+Rmdx0ym4ios449scPCL/8PQBAIxr6jeqFAklBy6Dy9pezNOoGDC8kq+AbZuGIwxQoJQHx/TPQ1NfLXRIRmbniywVwi30aCkngSL+/oWBBIlJv3ojCBUcQNusZucujbsDwQrLzmxONUthjiCYTh7e8JXc5RGTmMj57HB4owAVJhcB5H0Ll7Y8RE6ezxaUHYXgh2bm4D0DaiIa5X0alv88rAYio0xJ2fY7w0p+gERIqpq+GnUNfuUsiA2B4IZMw7q5nkG45nHO/EFGnqS/kYEjCSwCARJ+HMCT0ZpkrIkNheCGToFAqYaWb+2U/534hog7RarS48OU/0RdlOK0chDFz2QXdkzG8kMkYFBiGI15zAADeB1/EsdhN7EIiojapc7MQt+ZRjKlOQI2whMXfP4GllY3cZZEBMbyQSRk95w0UwQGuKEbwH/+CS0wIErZFy10WEZmohG3RcIkJwcT8zQCAVMdJGBAQInNVZGgML2RSSi9fgrMo191XSgJjU5azBYaImlDnZiEkJQrKq2bRDS79je8XvQDDC5mU/JyTnM6biNrlUnaqXnABACXfL3oFhhcyKa6+gbrZMBsJASgsrWSqiIhMVWnKzibbOP1/78DwQiZF5e2PxKAo1IuGP00hGlaCdfjxSRSqc2WujohMRcLOzzAxfxMAQMvp/3sdSQgh2t7NfJSWlsLJyQklJSVwdHSUuxzqJHVuFgpy0mFp64A+38+Hp7iETKU/VE/9DAenfnKXR0Qyykg+CJ/tM2En1eCw+70Y8Lf/oCAnHS6+AQwuZqwjn98ML2TyzmUeh9366eiPEqRaBcP/2R9hY2svd1lEJIP8vHOoX3MDPFCAEzYhGP7vn6C0sJS7LOoGHfn8ZrcRmTyfwaNw+c6NKBe2GFF7DCc/nM0FHIl6oerqKlz6dDY8UIBchSd8H93M4NJLMbyQWRgcPAlnbolBrbDA2Io/kPjRwxBardxlEZGRCK0WyWvmY0RdKspgC+m+r+Dg7Cp3WSQThhcyGyMnzkDqhFXQCAlhRd/j0KfPyl0SERnJwU0rML54JzRCwtkbP4TXkNFyl0QyYnghszJm6kNIHLUUABBx/nMc2viqzBURkSGpc7Nw4MtlCM/4HwAgadizGHH93TJXRXJjeCGzE3b3IsQNXAgAGH9qJY7s+FjmiojIEHRT/5+OhoUkkGE5HKH3vix3WWQCGF7ILI1/8DUccpsNAAhOfBHHfvla5oqIqDs1N/X/4NoMXLqQLV9RZDIYXsgsSQoFwv71MY443gxLSYOhvy1EesJeucsiom5yNuU3Tv1PLWJ4IbOlUCoR/MQGHLMZB1upFp67HkL2ycNyl0VEXaS+kAOPhLeabOfU/9SI4YXMmqWVNYY8sQ3pFsPhiArYf30PLpzJkLssIuqkS3nnUBUzDd7IQzH66NY649T/dDXOsEs9QkmhGpdXR8JPexbnJE/YPboX/VXecpdFRB2Qn5eLsrXTMEibA7XUH+KhnZAsrDj1fy/BGXap13Hqr4Ld/B24CFf4iAu4vPZ2lJUUyV0WEbVTgfoCStdOxyBtDvLRD9oHd8DdbzhU3v4YMXE6gwvpYXihHsPNayDq52zDZThisCYLOR/dieqqCrnLIqI2FObnofj/TYO/9gwK4Iy6B76Dx6CRcpdFJozhhXoUnyHBKLxjAyqEDUbWJOPkh/dyHSQiE3a58BKK1kzDYG02CuGMmjnfwXNwkNxlkYljeKEeZ/CY63Amcu2VdZB+x5GP5nEdJCITVFKUj0sfTcMQTRaK4IjK+7Zz2n9qF4YX6pFGTL4DJ8avhFZICC/agUPrnpO7JCK6Qp2bhaS9m3Dpw5sxTPMnLsMR5bO3w2fYWLlLIzNhIXcBRIYy9rZ5SCgvRFjqq4jIXYe4dRZwGHYdXH0DOfiPSCYJ26IRkhIF1ZUJ6CqFNUrv2Qrf4aHyFkZmhS0v1KOF/f3fOOT7KAAg4uxajNz7AFxiQpCwLVrewoh6oeam/LdGLWycXOQriswSwwv1eH5T/gntVbMZKSWBsSnLoc7Nkq8ool4o6+D2Zqb8F5zynzrMYOGlqKgIc+bMgaOjI5ydnTF//nyUl5e3uv+TTz6JYcOGwdbWFgMGDMBTTz2FkpISQ5VIvUTBuXQoJP1tFpIWF9O5lACRsSTs+hxjUjnlP3UPg4WXOXPmIDU1FXv37sUPP/yA33//HY888kiL+1+4cAEXLlzAypUrceLECXz++efYvXs35s+fb6gSqZdw9Q3UTTF+NdX+F5F5bL8MFRH1HlqNFvs//Q/CEp6GrVSLM4oB0IiGjx5O+U+dZZDlAdLS0hAYGIjDhw8jNLRhENbu3bsxbdo05ObmwtPTs13Ps2XLFjzwwAOoqKiAhUX7xhZzeQBqTsK2aIxNWQ4LSQuNkFAm2cMZ5agVFjga+B+E/f15SAr2ohJ1p4ryMqSumYuw8l8AAIdV92Dsgo9QkHeWU/5TE7IvDxAXFwdnZ2ddcAGAyMhIKBQKxMfHt/t5Gk+gvcGFqCVhs55B4YIjSL15IwoWJEJ6KhlH7SbASqpHeNobSFp1J5cTIOpGF3OzkfvujQgr/wV1QonEoGUY91gMlBaWnPKfuswg4SUvLw9ubm562ywsLNCvXz/k5eW16zkKCgrw6quvttrVBAA1NTUoLS3VuxE15+o3TKd+rhj97504NOQ51AklQsr3oSQ6ApnHDshdJpHZS0v8HYpPbsIwzZ8oRh+cvm09Qu5aJHdZ1IN0KLwsXrwYkiS1ektP7/qo8dLSUkyfPh2BgYGIiopqdd8VK1bAyclJd/Px8eny61PvICkUGD9nKU7P2II8uMJb5MHnmztw6Ov/cUZeok6K/+FT+O2YBRWKkKPwQdVDezFs/DS5y6IepkNjXvLz81FYWNjqPoMGDcL69evx3HPP4fLly7rt9fX1sLGxwZYtW3DnnXe2eHxZWRmmTp0KOzs7/PDDD7CxsWn19WpqalBTU6O7X1paCh8fH455oQ4pKVQj+9OHMLoyDgCQ6HAjhv5zHRyc+slcGZF50Go0OLjuP5h0/hMAwHHbcAx6bBPsHflviNqnI2NeDDpg98iRIwgJCQEA7NmzB7feemurA3ZLS0sxdepUWFtbY9euXbCzs+vwa3PALnWW0GqRsPEVjP3zfVhKGpyTPFF756fwD5ogd2lEJkudm4WLpxIhEj7BmOqGMY0JHvcjdP4HUHC8InWA7OEFAG677Tao1WqsWbMGdXV1mDdvHkJDQ7Fx40YAwPnz5zFlyhR8+eWXCAsLQ2lpKW655RZUVlZi+/btsLe31z2Xq6srlEplu16X4YW6Kv3wz3De+S+4owA1whLJIxcjbNYiXo1EdI3Gqf4bJ56rFxJSxryCsTOfkrcwMkuyX20EABs2bEBAQACmTJmCadOmYdKkSVi7dq3u8bq6OmRkZKCyshIAkJSUhPj4eBw/fhyDBw+Gh4eH7nbu3DlDlUnURMC4SNg+eQDHbMNhLdUhPPVVJL57N8pLL7d9MFEvoc7NQmiK/lT/EgCv0Omy1US9h8FaXuTClhfqLlqNBgkblyM08wNYSFqclTxRd9fn8B8VLndpRLIqzM9Dbsy9CK492uSx1Js3YsREBhjqOJNoeSEydwqlEuMffAWZ0zdDjf4YIC7Aa+t0xG97l1cjUa8khMDh3euhXR2O4NqjuParL6f6J2NheCFqQ0DYLbBeeAApNuNgI9Uh/HgUEqP/jvKyYrlLIzKagksXkfDO3Rh3aCFcUYyzCm/Eez+Mek71TzJgtxFRO2k1GiRsiEJo1odXupG8UD/rMwwayW4k6rkaWlu+xKD4l+GCEmiEhETvBzH6wbdgZWMHdW4Wp/qnbmESVxvJheGFDC09/if0+/FRuKEIVcIKKUEvIezOJ3k1EvU4+erzyP6/hQgr/xUAkKMYgPoZH8J/zPUyV0Y9Ece8EBlQQPhUWF7pRrKVahF+fCmOvDcbFWUlcpdG1C2EEEjY+RkUH0cgrPxX1AsFErwfhsd/4hlcyCSw5YWok7QaDRLWL8W406uhlATOKLxResMbUCgVcPUNZBM6maV8dS7OfLkQ4yr2AQDOKAZAe8dHGBQ8Wd7CqMdjtxHDCxlR2qEf0X/343BDEYQAJAkN4wKCohA26xm5yyNqFyEEDu9ch8FHotAPpQ0DcAc8jDEPvAFLa1u5y6NegOGF4YWMLCvlIAZtuw2S9Nc2rZCQN+8QPP146SiZLnVuFnKP74fi2HqMqU4AAGQr/YA7VmNg0CR5i6NepSOf31x4gqgbVJUV6gUXAFBIAhaf34r44H9j7N8egaWllTzFEbUgfus7GHf8Vaiumt4/yXc+xjzwOiytWl8Ul0hOHLBL1A1cfQOhEfrpRQjADZcRfuxFqN8YhYRvPkBdXa1MFRL9RaPR4OCmtxB2/BUorpne3/eWxxlcyOQxvBB1A5W3PxKDovQm7EoIXIJ4/2dQBEd4izyEpbyES2+MRMI376Gutkbmiqk30mg0SNj5Gc68PgYT0t9o0lqolAQKctLlKY6oAzjmhagbNTdhV1V5KVK+XYXBmevQHw2XU1+QVDg3ciHGzngUllbWcpZMvYBWo0XinvXoe3gVBmuzAQBlsIG9qIbiqgBTLxQoXHCEV8qRLDhgl+GFTFBzIea8pELuyMcx5m+PwcqaIYa6l1ajRdLPX8EpfiWGaE8DAMphi5M+czB81mKkxW7A2JTlsJC0uun9eYUcyYXhheGFTFhVRRlSvn0Xg//8FP1RDAC4ILnh3IjHMWbGY7Cy5ngD6hqh1SIp9ms4HPofhmoyAQAVsEGq930ImPVfOPZ10+3L6f3JVDC8MLyQGaiuLMOx7foh5iJckTPyMYydsZAhhjpMaLU4+us22B98G8M0pwAAlcIaJ7zvRcBd/4Vjf3eZKyRqGcMLwwuZkerKMhz7Nhr+pz6By5UQkwcXnBnxOMbc/jisOUEYtUFotTj223bYHHgbAfUNA24rhTVOeP0dw+56EU4unjJXSNQ2hheGFzJD1ZXlOPZdNPwzYnQh5iJckBP4KMbc8QRDDOlR52YhPzsV5Zfz4JjyGQLrTwIAqoUlUjz/jiF3voi+bt4yV0nUfgwvDC9kxhpCzHsYlBEDV1wGcKUlJvBfGD3jCdjY2slcIcktYeu7CD2+XG+OlhphiRT3u+B/50vo5z5AxuqIOofhheGFeoDqynKk7HgfA9PX6kKMGv2RPfxRjL79CZQUXkR+zkkuAtmLnPnzOC7sXY0I9VfXLEUBZN/1PfyDr5OvOKIuYnhheKEepLqqAinfvQ+/9LVwQxEAoAT2cBCVUEiCi0D2cOoLOcj89f/Q//QOBGgyWtwv9eaNGDFxuhErI+peDC8ML9QD1VRXIPm7DzEo7SO4XhkT00gjJJy97xcMDBgrT3HUrYovFyL9142wzfgGI6uPQnmle0gjJJyyHolhNSf0uow4uRz1BFyYkagHsraxR/jsF3Bs32C47vuH3mNKScD7qyk4YR2EsgE3wXPcHRgwJAiSgiuAmIuqykqc+H0rpJQtGFkRh/FSXcMDEnDKMgAl/ndg8E1zMdzNGwnboptOLsfgQr0IW16IzIw6NwsuMSG6b+NAwyKQ165Tc15S4ZzLZNiOmIZh4bfCxtbeyJVSW+rr6pAa9yOqEjchsPhXOEqVusfOKrxxccDtGHD9g/AYGNjkWE4uRz0Nu40YXqiHa+6bt1fwTTif8B3szv6CoVXHYCVpdPtXCmtk2I1FzcBI+EXMhLvPYBmr713UuVl6A6uFVov05P24HLcBg/P36MYxAcAl9McZj1vhNvFB+I0Y3zSREvVgDC8ML9QLtPbNu7LsMk7F/YC69J/gV3QArld9QAJAlsIPatV1cAqajqGhN8HS0sqYpfcaCduiEZISBeWVgdUpduPRvzoHA8QF3T6lsMep/lPgEHYfho6bCkmhlK9gIhkxvDC8EOkIrRbZqYeQn7gDzuf3YUhtut5gzxLY45RDOMTgqfCPuB393Tgba1cJrRbpSb9j2Pcz9f5fN6oSVkhzmgSL4HswfNJMWHICQiKGF4YXopaVFFxEVtx3wJ8/YXBpPBxRoXtMIyT8aRmAIq8b4Dr2dviPHA+FsmHQ77XdH9RACIG8Czm4kHoQ1WcTYVdwHN7VGU2uCGsU7/kQgu57BbYOzkatk8jUMbwwvBC1i6a+DplJv6L42A9wy/sNAzVn9B6/hH7Idp4AobTCuILtuu6P3jqvjBACly6ew/mTcajKOQK7ghR4VZ3SG7fSSCMABfSHrfCSZqKWMbwwvBB1Sn5uJnIOfQvL0z9jSEUS7KSaZvfTCgmH/J+Gvd8YOLn5wcV7EPr0Mc9/b621KOXn5SI3NQ6VOUdgm58Cz6oMuKOwyXNohIRzSh8UOgZC6zEafQeHwScwDMd2fdr0kuZeGPqI2oPhheGFqMtqqiuQmbAbtfHrMKZif5v7F6MPCpRuKLNyQ42dB7SOXrBw9oGdqy+cPQbC1dMP1tY27X59Y3RTXTugNkH1dwhbF9jkp8CjMh0eKGhyjFZIOKf0RoHDcGg9RsN5cBh8hofDxr759xte0kzUPgwvDC9E3aa5eWW0Aki3HgX7+mK4aPNhj+o2n0crJBRIfVFk4Ypya3fU2nsATl6w6jsA9m6+6Oc5CC4qbyiVyiahoqVuKiEEautqUVlehqqyYtRUlqGmqhR1lWWoqypDfXUZtNXl0NaUQ9RWALUVUNRVQFlXAcvaIoyuOtzm1cjnFF7I7zMcGo/RcBwUhgGB4RyvQmQADC8ML0TdqtkZXRvDhBAoLy1C4fkslKrPoLrgLLQlubAouwDbqotwrrsEF20BrKT6Nl+nRligSHKCuyjUCxVCACctA6GEFlbaKthoq2CDKtiJatg0zkTbTVKtglHhOwWO/uMwYMR42Dn069bnJ6LmMbwwvBB1u650fwitBiUFF1F44TTKL51BTdE5iOJcWFVcgH11Hpzr8tFfFOm17nRUvVCgUrJFlWSDaskOtQpb1CltUae0g8bCDhpLewhLO8CyD2BtD1Ffh3HZH3ONICITwbWNiKjbqbz9O/2hLimUcHbzhrObN4Drmt1HU1eLfPVZnE89gKCDT+uFCq2QkDD8P7Bz8YWFrQOsbB1hZecAG3tH2PZxhJ29EywsreEoSejIV5aEbSquEURkhtjyQkQmp9Vuqm7GAbVEpoHdRgwvRGaPoYKod2G3ERGZva50UxFRz6aQuwAiIiKijmB4ISIiIrPC8EJERERmheGFiIiIzArDCxEREZkVhhciIiIyKwwvREREZFYYXoiIiMisGCy8FBUVYc6cOXB0dISzszPmz5+P8vLydh0rhMBtt90GSZLw7bffGqpEIiIiMkMGCy9z5sxBamoq9u7dix9++AG///47HnnkkXYdGx0dDUmSDFUaERERmTGDLA+QlpaG3bt34/DhwwgNDQUAfPDBB5g2bRpWrlwJT0/PFo9NTk7GO++8gyNHjsDDw8MQ5REREZEZM0h4iYuLg7Ozsy64AEBkZCQUCgXi4+Nx5513NntcZWUl7r//fqxevRru7u7teq2amhrU1NTo7peUlABoWOCJiIiIzEPj53Z71os2SHjJy8uDm5ub/gtZWKBfv37Iy8tr8bhnn30WEyZMwB133NHu11qxYgWWL1/eZLuPj0/7CyYiIiKTUFZWBicnp1b36VB4Wbx4Md56661W90lLS+vIU+rs2LEDv/zyC44ePdqh45YsWYJFixbp7mu1WhQVFaF///6tjpspLS2Fj48Pzp071+bS2+aG52aeeG7mqSefG9Czz4/nZlqEECgrK2t1aEmjDoWX5557Dg8//HCr+wwaNAju7u64dOmS3vb6+noUFRW12B30yy+/ICsrC87OznrbZ82ahcmTJ2Pfvn3NHmdtbQ1ra2u9bdc+R2scHR3N5hfbUTw388RzM089+dyAnn1+PDfT0VaLS6MOhRdXV1e4urq2uV9ERASKi4uRmJiIkJAQAA3hRKvVIjw8vNljFi9ejH/+859620aNGoV3330XM2bM6EiZRERE1IMZZMzL8OHDceutt2LBggVYs2YN6urq8MQTT+Dee+/VNQedP38eU6ZMwZdffomwsDC4u7s32yozYMAADBw40BBlEhERkRky2DwvGzZsQEBAAKZMmYJp06Zh0qRJWLt2re7xuro6ZGRkoLKy0lAltMra2hrLli1r0uXUE/DczBPPzTz15HMDevb58dzMlyTac00SERERkYng2kZERERkVhheiIiIyKwwvBAREZFZYXghIiIis9JrwktRURHmzJkDR0dHODs7Y/78+SgvL2/zuLi4ONx0002wt7eHo6MjrrvuOlRVVRmh4o7p7PkBDbMa3nbbbZAkCd9++61hC+2Ejp5bUVERnnzySQwbNgy2trYYMGAAnnrqKd26V3JavXo1/Pz8YGNjg/DwcCQkJLS6/5YtWxAQEAAbGxuMGjUKu3btMlKlHdeRc4uJicHkyZPRt29f9O3bF5GRkW3+v5BTR39vjTZt2gRJkjBz5kzDFtgFHT234uJiLFy4EB4eHrC2tsbQoUN7zN8lAERHR+veO3x8fPDss8+iurraSNW2z++//44ZM2bA09Oz3e/b+/btw9ixY2FtbY3Bgwfj888/N3idBiV6iVtvvVUEBweLQ4cOiT/++EMMHjxY3Hfffa0ec/DgQeHo6ChWrFghTpw4IdLT08XmzZtFdXW1kapuv86cX6NVq1aJ2267TQAQ27dvN2yhndDRczt+/Li46667xI4dO0RmZqaIjY0VQ4YMEbNmzTJi1U1t2rRJWFlZiXXr1onU1FSxYMEC4ezsLNRqdbP7HzhwQCiVSvH222+LkydPipdeeklYWlqK48ePG7nytnX03O6//36xevVqcfToUZGWliYefvhh4eTkJHJzc41ceds6em6NsrOzhZeXl5g8ebK44447jFNsB3X03GpqakRoaKiYNm2a2L9/v8jOzhb79u0TycnJRq68fTp6fhs2bBDW1tZiw4YNIjs7W/z000/Cw8NDPPvss0auvHW7du0SL774ovjmm2/a9b59+vRpYWdnJxYtWiROnjwpPvjgA6FUKsXu3buNU7AB9IrwcvLkSQFAHD58WLftxx9/FJIkifPnz7d4XHh4uHjppZeMUWKXdPb8hBDi6NGjwsvLS1y8eNEkw0tXzu1qX3/9tbCyshJ1dXWGKLNdwsLCxMKFC3X3NRqN8PT0FCtWrGh2/3vuuUdMnz5db1t4eLj417/+ZdA6O6Oj53at+vp64eDgIL744gtDldhpnTm3+vp6MWHCBPHJJ5+Ihx56yGTDS0fP7eOPPxaDBg0StbW1xiqxSzp6fgsXLhQ33XST3rZFixaJiRMnGrTOrmjP+/Z//vMfMWLECL1ts2fPFlOnTjVgZYbVK7qN4uLi4OzsjNDQUN22yMhIKBQKxMfHN3vMpUuXEB8fDzc3N0yYMAEqlQrXX3899u/fb6yy260z5wcAlZWVuP/++7F69eoW15ySW2fP7VolJSVwdHSEhYVBJpVuU21tLRITExEZGanbplAoEBkZibi4uGaPiYuL09sfAKZOndri/nLpzLldq7KyEnV1dejXr5+hyuyUzp7bK6+8Ajc3N8yfP98YZXZKZ85tx44diIiIwMKFC6FSqTBy5Ei88cYb0Gg0xiq73TpzfhMmTEBiYqKua+n06dPYtWsXpk2bZpSaDcVc3ks6Qp53ciPLy8uDm5ub3jYLCwv069cPeXl5zR5z+vRpAEBUVBRWrlyJ0aNH48svv8SUKVNw4sQJDBkyxOB1t1dnzg8Ann32WUyYMAF33HGHoUvstM6e29UKCgrw6quv4pFHHjFEie2uQaPRQKVS6W1XqVRIT09v9pi8vLxm92/veRtLZ87tWi+88AI8PT2bvMHKrTPntn//fnz66adITk42QoWd15lzO336NH755RfMmTMHu3btQmZmJh5//HHU1dVh2bJlxii73Tpzfvfffz8KCgowadIkCCFQX1+PRx99FP/973+NUbLBtPReUlpaiqqqKtja2spUWeeZdcvL4sWLIUlSq7f2vnleS6vVAgD+9a9/Yd68eRgzZgzeffddDBs2DOvWrevO02iRIc9vx44d+OWXXxAdHd29RbeTIc/taqWlpZg+fToCAwMRFRXV9cKp27355pvYtGkTtm/fDhsbG7nL6ZKysjI8+OCDiImJgYuLi9zldDutVgs3NzesXbsWISEhmD17Nl588UWsWbNG7tK6xb59+/DGG2/go48+QlJSEr755hvs3LkTr776qtyl0TXMuuXlueeew8MPP9zqPoMGDYK7uzsuXbqkt72+vh5FRUUtdpd4eHgAAAIDA/W2Dx8+HGfPnu180R1gyPP75ZdfkJWVBWdnZ73ts2bNwuTJk7Fv374uVN42Q55bo7KyMtx6661wcHDA9u3bYWlp2dWyO83FxQVKpRJqtVpvu1qtbvE83N3dO7S/XDpzbo1WrlyJN998Ez///DOCgoIMWWandPTcsrKycObMGcyYMUO3rfGLkIWFBTIyMuDv72/YotupM783Dw8PWFpaQqlU6rYNHz4ceXl5qK2thZWVlUFr7ojOnN/LL7+MBx98EP/85z8BAKNGjUJFRQUeeeQRvPjii1AozPP7fkvvJY6OjmbZ6gKYeXhxdXWFq6trm/tFRESguLgYiYmJCAkJAdDw4a3VahEeHt7sMX5+fvD09ERGRobe9lOnTuG2227revHtYMjzW7x4se4faKNRo0bh3Xff1XvjNRRDnhvQ0OIydepUWFtbY8eOHbJ/o7eyskJISAhiY2N1l81qtVrExsbiiSeeaPaYiIgIxMbG4plnntFt27t3LyIiIoxQcft15twA4O2338brr7+On376SW9Mkynp6LkFBATg+PHjetteeukllJWV4b333oOPj48xym6XzvzeJk6ciI0bN0Kr1eo+yE+dOgUPDw+TCi5A586vsrKySUBpDGrCjJcBjIiIaHI5uym+l3SI3COGjeXWW28VY8aMEfHx8WL//v1iyJAhepfb5ubmimHDhon4+HjdtnfffVc4OjqKLVu2iD///FO89NJLwsbGRmRmZspxCq3qzPldCyZ4tZEQHT+3kpISER4eLkaNGiUyMzPFxYsXdbf6+nq5TkNs2rRJWFtbi88//1ycPHlSPPLII8LZ2Vnk5eUJIYR48MEHxeLFi3X7HzhwQFhYWIiVK1eKtLQ0sWzZMpO+VLoj5/bmm28KKysrsXXrVr3fT1lZmVyn0KKOntu1TPlqo46e29mzZ4WDg4N44oknREZGhvjhhx+Em5ubeO211+Q6hVZ19PyWLVsmHBwcxFdffSVOnz4t9uzZI/z9/cU999wj1yk0q6ysTBw9elQcPXpUABCrVq0SR48eFTk5OUIIIRYvXiwefPBB3f6Nl0o///zzIi0tTaxevZqXSpuLwsJCcd9994k+ffoIR0dHMW/ePL03yuzsbAFA/Prrr3rHrVixQnh7ews7OzsREREh/vjjDyNX3j6dPb+rmWp46ei5/frrrwJAs7fs7Gx5TuKKDz74QAwYMEBYWVmJsLAwcejQId1j119/vXjooYf09v/666/F0KFDhZWVlRgxYoTYuXOnkStuv46cm6+vb7O/n2XLlhm/8Hbo6O/taqYcXoTo+LkdPHhQhIeHC2trazFo0CDx+uuvy/qloC0dOb+6ujoRFRUl/P39hY2NjfDx8RGPP/64uHz5svELb0VL73GN5/LQQw+J66+/vskxo0ePFlZWVmLQoEHis88+M3rd3UkSwozbwoiIiKjXMc/RR0RERNRrMbwQERGRWWF4ISIiIrPC8EJERERmheGFiIiIzArDCxEREZkVhhciIiIyKwwvREREZFYYXoiIiMisMLwQERGRWWF4ISIiIrPC8EJERERm5f8DwW5wyP+8GJUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## PART 2: fine guess of cable delay\"tau\"\n", + "x_circle2, y_circle2, r_circle2=circle_fit(linmag1, uwphase1)\n", + "fine_tau=fit_cable_delay(freq_cut, linmag1, uwphase1, rough_tau,\n", + " x_circle2, y_circle2, r_circle2)\n", + "\n", + "linmag2 = linmag1\n", + "uwphase2 = shift_phase(uwphase1-2*np.pi*fine_tau*(freq_cut-freq_cut[0]))\n", + "\n", + "\n", + "plt.figure()\n", + "plt.plot(freq_cut, uwphase1, '.-')\n", + "plt.plot(freq_cut, uwphase2, '.-')\n", + "\n", + "plt.figure()\n", + "d0 = linmag2*np.exp(1j*uwphase1)\n", + "d = linmag2*np.exp(1j*uwphase2)\n", + "plt.plot(np.real(d0), np.imag(d0), '.-')\n", + "plt.plot(np.real(d), np.imag(d), '.-')\n", + "plt.axis('equal')" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PART 3\n", + "-----------------------------------------\n", + "center position of the circle : (x, y) = (0.26509033907406704, 0.26796245563322996)\n", + "radius of the circle : r = 0.6094520096072371\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "(np.float64(-0.6848594512424464),\n", + " np.float64(0.9768195439163072),\n", + " np.float64(-0.6817214892399681),\n", + " np.float64(0.9159396191733319))" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGyCAYAAADZOq/0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAARMpJREFUeJzt3Xl8VNX9//H3nUkyJCEZCAlMgIRNUKtRFgHBDSstWOrStGjVVrB+qX7VulYF+2sjtgrutNZa2yq231q1tqhdXMGtVUQBg6CiAsFEIECArGSdOb8/QsYMmWyQmXsz83o+HvMo986Zez+nI8mbc8891zLGGAEAANjAZXcBAAAgfhFEAACAbQgiAADANgQRAABgG4IIAACwDUEEAADYhiACAABsQxABAAC2IYgAAADbEEQAAIBtIhpE3nzzTZ111lkaPHiwLMvSs88+G8nTAQCAXiYhkgevqanR8ccfrx/84AfKz8/v9ucDgYC2b9+utLQ0WZYVgQoBAEBPM8aoqqpKgwcPlsvV8ZhHRIPImWeeqTPPPPOQP799+3bl5OT0YEUAACBaSkpKNHTo0A7bRDSIdFd9fb3q6+uD2y0PBi4pKVF6erpdZQEAgG6orKxUTk6O0tLSOm3rqCCyaNEiLVy4sM3+9PR0gggAAL1MV6ZVOOqumQULFqiioiL4KikpsbskAAAQQY4aEfF4PPJ4PHaXAQAAosRRIyIAACC+RHREpLq6Wps2bQpuFxUVqbCwUBkZGcrNzY3kqQEAQC8Q0SCyevVqnX766cHt66+/XpI0Z84cPfbYY5E8NQAA6AUiGkSmTZsWvAUXAADgYMwRAQAAtiGIAAAA2xBEAACAbQgiAADANo5a0CyaPl37uvas/LOshhoFkjPkqtsrd8N++RNTlNp/oEak1KuvDjz3JilVSs6QavdKDTVtt7vS5lA+49RzBxqkAUdIR54peYdE5wsDAMSkuAwi795/viaWv6gxLUvgVxzU4OBthPf8DVLOidLQybETwJJSpcFjCVkAECWWcfD9tZWVlfJ6vaqoqOixh959uvZ1jX7uHG3wJOr51GTVWC71CwRUbrlU67KUbEzItqQ2+w6lTaSOG41zN8jS8KYmTautk8/v75HvoVfIOVFKG9wzIYiAAyCOdOf3d9yNiOz56A39MStD/+ibKnXhqYD40u3GaOr+Wg1qbHJ8AEuR0aya/cpraDz0Dpe8c3j/hx2s8P++HEXqSsCRCC8AYl7cBZF9w4fpH5sIIYfEsvR2aordVXTZ4950jaqr13H1DYcdcIY2+ZXb1KSx9Q2HPyrUnYBzcHiRQsOKp6+UN1saOuHwagIAm8RdECnr7yKExAvL0ubkPtqc3KfnjmmMvlJXpyMbGrs0EpRkpNNqaw9vZEbqOLysekjKPEoaOjH0slCiRxozk5ACwNHiLoiMGzjO7hLQm1mWPkpO1kfJyV3+yMPGq+yGRp1YVxe5sFK2sfl1sDfvktJzpJHTCCcAHCnuJqtK0k/++xP9Y/M/eux4wGEzJmxYGRAIHP5cl3D6jZCOPptgAiAiuvP7Oy6DiCSt371eLxS9oOrGavVL6qfy+nLV+muVnJAcsi2pzb5DaXO4x91RvVdb9+xVXaNbya50VTZUqD5QJ0nyuPooPckb3NfZdlc+09Im4CrXjqZ1Pfr/PbrJGOU0NOiY+gZJzXNYvtLQ2LN3MaXnSEd/k/kmAHoEQQQ9qrSmVG988YY+3LVZ2/bWa1vlnoiFoH21VdpX2ySZJAWaUuVKqJGshrbbUrttEtPXy520N/anArWar9Kjk2n7jZCOnEkoAXDICCLo1XZU1GrN1n36fG+Nivfs1/6GJqUkJah/aqL21TRqf0OTJLXZ13p7R92nqrLWKzHBr8qGCpVWV2h/Q+CQAo4rsUIJKZ/3jmBjjMbW1emU/XU9E0wGHSedcp2UM5lbiAF0GUEECGNdyT69+vEu1fv9YcNLRwHH06dSL21+XfvMlvABJsy2O7lEbs9OewPMgWAyq3r/4V/KyZstTV9IIAHQKYIIECHrSvbpufe3q6ahqd3RmNbb//x4lXaZd2QlVNsfVozR5P11mr7/MEPJKTdIZ/ysZ2sDEFMIIoCDdBZetlRu1Iflr2l33d6QsOLylCoh+YvIhBQjTawKaPb+PRrXcAiXb4acIJ33J0ZHAIRFEAF6oXBzY6yEClW7P9Anez/W7v3VkiR38hc9OxnXSCdWSreVb1N2oJuBhNERAGEQRIAYtKOiVss/2qmishpVBTZrY9V/VO3fp5qmPdrv3nT4wcRIR+wZrnvKP9FIVzcuFw0/TZrLujwAvkQQAeLMB6Vb9dja5/XRno9UY3aoPPCpdAjBxBgpUJelIaVTdWPTfzXd/b5cXTnOoOOkC5/kUg0ASQQRIO6V1pTqH58u17JP/qlt9R91+/PGSP79OUrbPks369/6lvutrgWSr90mnXRN9wsGEFMIIgCCSmtKtW73Or2w5QWtKFnRrc8aIzXumyTvnvG6Vct0pnt155dsvvZz6aSrD71gAL0eQQRAWC2r5C7fulzvlHbwRN+DGCPV7zxTcyurtCDhL52Pjlz3EZdpgDhGEAHQqdKaUi1Zu0T/3vLvLrU3RqovO10Dyk7Q7xLvVZ5ra/ujI0NOkOZ1b/QFQOzozu9vV5RqAuAwvlSfFp+yWK985xXNGjmr0/aWJXkyX9OezNU6u/EOLW36utr9Z8y21dLzN/VswQBiEkEEiHOtA8lR/Y/qsG1LGEnMfEm3+efqgaZz2w8j7z4srfh5zxcMIKYQRABIag4kT5/9tOblzeuwXeswcp//PC1tmtF+GPnPPdJbv+r5YgHEDIIIgBBXj7+6+XLNiPYv14SOjMzRCv/Y9sPIKz+VKrZFplgAvR5BBEAbvlSfFp+6uMPRkWAYyXhT/9N0k17wn9D+Ad+8OwJVAogFBBEA7bp6/NWdh5GBz8tKqNBtTXMUaG9UZM1jjIoACIsgAqBDV4+/WtdPuL7d9y1L6jP4zyrVAC1quqCdSzRGKnk3YjUC6L0IIgA6dcmxl+gv3/hLu++7U0qUNPA5/d5/lp7xnxS+UdEbEaoOQG9GEAHQJXlZee2OjFiWlJSxUokZb+qupu+Gv0SzZimXZwC0QRAB0GWXHHuJLjjqgrDvtcwX2ZmQoL/4vxr+AExaBXAQggiAbrll8i06ZcgpYd+zLClpwAq9HTgm/IeZtArgIAQRAN32m+m/0Vdzwo96JPZ/V6td2e3cQWOkVb+NaG0AeheCCIBDsmDygrD7LUuqGLC2/Tto3n6AUREAQQQRAIfEl+rTd8Z8J+x7if3f1R+sU9u5g4ZbeQF8iSAC4JBddtxlYfdblpSU+YKWB8aH/yC38gI4gCAC4JB1OCrSr1Dv9CsPP1dk7R+5PANAEkEEwGHqaFSkYeAbut/6ets3TUDauyXClQHoDaISRB588EENHz5cffr00eTJk/Xuu1wfBmKFL9XX4UJn/0rMbjNp1UhSYkrEawPgfBEPIk899ZSuv/56FRQUaO3atTr++OM1Y8YM7dq1K9KnBhAllxx7iWaNmBX2PX/qF7Ks0H2WJH30bKTLAtALRDyI3HfffZo3b54uueQSfeUrX9Fvf/tbpaSk6NFHH430qQFE0bUTrg27f1+/z7Td5W77xspfM08EQGSDSENDg9asWaPp06d/eUKXS9OnT9fKlSvbtK+vr1dlZWXIC0Dv4Ev1afaY2W3fsKT7kk5su595IgAU4SBSVlYmv9+vQYMGhewfNGiQSktL27RftGiRvF5v8JWTkxPJ8gD0sEm+SWH3v+VJZZ4IgLAcddfMggULVFFREXyVlJTYXRKAbhg7cGzY/dX9N2pnQujlGUuSGvdHvCYAzhbRIJKZmSm3262dO3eG7N+5c6d8Pl+b9h6PR+np6SEvAL1HR5dn1iZ5QnYZSdr+flTqAuBcEQ0iSUlJmjBhglasWBHcFwgEtGLFCk2ZMiWSpwZgk/Yuz/yuzzEhl2csSVp+KxNWgTiXEOkTXH/99ZozZ45OOOEETZo0SUuWLFFNTY0uueSSSJ8agA3auzyz2btLOyvd8vn9X+40/uYJq94h0SkOgONEfI7I+eefr3vuuUc/+9nPNHbsWBUWFurFF19sM4EVQGzwpfo095i5bd+wjLYmJIbs4vIMAMuYsA/qdoTKykp5vV5VVFQwXwToRdbvXq8Ln78wZJ8x0teLj9O9/n+FLnBmuaVr1zMqAsSQ7vz+dtRdMwBiQ21TbZt9liWt7dvUZpXV4OUZAHGJIAKgx+Wm58rSwYlD2pPxsXa0WWXVkjJGRqcwAI5DEAHQ43ypPs05Zk7bNyyj4sQw80QAxC2CCICIuOjoi+Q6+EeMkT7yhAYRS4ZLM0AcI4gAiAhfqq/tg/AsaUlGP5W6v7w8E+DSDBDXCCIAIuaYAce02RewLH2e0GoJIyOVb3gxilUBcBKCCICISU5IbrvTSMmBQHDTZRl5l9/ICqtAnCKIAIiYcLfxypLq3aE/eixu4QXiFkEEQMTkpufKZbWdsLr+4AfgWW7miQBxiiACIGJ8qT5dO/7a0J0HJqy2rCdijLR7xDmsrArEKYIIgIgKN2HVWNIXSc0TVi1Lyip6jjkiQJwiiACIqHCrrFrGKKexqdU2c0SAeEUQAWC7JmNpZ+Jgu8sAYAOCCICIKq4sljloIXdz0FoiLknVG16KcmUAnIAgAiCi2rtz5kNPUnDTZRmNXPX/mCcCxCGCCICIau/OmV8etNQ780SA+EQQARBx7S31XpL45eUZ1hIB4hNBBEDEhbtzRkbBO2f8xqUtk3/BWiJAHCKIALCFkaX9pnmeyDUNVyhlyiU2VwTADgQRABEX7s4ZyzIqS2x++N2vkh5UyfKH7SgNgM0IIgAiLtydM5Yxym1qvjTjsozGf7BQO7/YbEd5AGxEEAEQcb5UnwqmFLTZ/3Zyn+CfE6yAyj7fGM2yADgAQQRAVEwdPDVkwqqxLC3MzAjewttkXMocdpRd5QGwCUEEQFSEmyfScgtvwEhrjyvQoKGjbKoOgF0IIgCior0VVnMam1TlHaNJ02fbUxgAWxFEAERFR/NEvJWfytx/rLT2TzZUBsBOBBEAUTN18NTQHZaC80QsBWT+eS3PmwHiDEEEQNQUVxa32dd6qXeeNwPEH4IIgKgJt9S7y5jgUu88bwaIPwQRAFHjS/XpB8f+4MsdRvpZ2V75/H4F5JJ11hKeNwPEGYIIgKjq36d/8M+WZancpEqSys96RBp/sV1lAbAJQQRA1JTWlOq+NfcFt42MfpXVR6Vut+5c9paeeq/tHBIAsY0gAiBqiiuLFTCBkH0BSypJTNCihEf0/rMPaEdFrU3VAbADQQRA1LT38Lucxia5LKNfJPxB2z/nwXdAPCGIAIiazh5+l2AFNNxVGu2yANiIIAIgqg5e1Kz1w+8ClksDco62qTIAdiCIAIiq9hY1K05MkOusX3L7LhBnCCIAoqq9Rc36Jh/J7btAHCKIAIgqX6pP846b9+UOY6mgbK/Mngpu3wXiEEEEQNRdcNQFkiRjpCFbZym/ukbp2q9blm3g9l0gzhBEAETd6yWvS5IsS9o2/N9a1jdVGValskyZtpbtt7U2ANFFEAEQVaU1pfr5Oz//codltDAzQ1UJTXrLc7WOLn3WttoARF/Egsjtt9+uqVOnKiUlRf369YvUaQD0MuFXV7VUkpggt2XUb/mNUsU2m6oDEG0RCyINDQ2aPXu2/vd//zdSpwDQC4VbXdV1YHVVSZLxS3u32FAZADtELIgsXLhQ1113nfLy8iJ1CgC9UMvqqi238FrGqKBsr3x+f3MDyy1ljLSxQgDR5Kg5IvX19aqsrAx5AYg9+aPzddHRF0mSjvPkaMr+uuY3LJd01hIWNQPiiKOCyKJFi+T1eoOvnJwcu0sCECH76vZJktY1fKEZuYO1rG+q9s14gEXNgDjTrSAyf/58WZbV4Wvjxo2HXMyCBQtUUVERfJWUlBzysQA4V2lNqZ4vej643fK8mR+/sI5FzYA4k9CdxjfccIPmzp3bYZuRIw/92q7H45HH4znkzwPoHYori2VkQvYFLEsmca9uWbZBp47JUrY32abqAERTt4JIVlaWsrKyIlULgDjR8ryZ1mHEZYwGNLrlN0Zby/YTRIA4EbE5IsXFxSosLFRxcbH8fr8KCwtVWFio6urqSJ0SQC/hS/VpweQFwW3LSAVle5XVZOS2LA3PTLGxOgDRFLEg8rOf/Uzjxo1TQUGBqqurNW7cOI0bN06rV6+O1CkB9CLfPfK7SrKSJEnf3D5U+dU1OtL1he4/M5PRECCORCyIPPbYYzLGtHlNmzYtUqcE0Is8s+kZNZgGSdK/Bn+hZX1TdY77bZ392gxp7Z9srg5AtDjq9l0A8aG0plQLVy4MbhtLWpiZoVK3WzIB6Z/Xssw7ECcIIgCirqPnzUhimXcgjhBEAERdp8+bYZl3IG4QRABE3cHPm9GBu2Z8fn9zCGGZdyBuEEQA2CJ/dL4uzbtUknSkNUr51TUqTczVzkvfY5l3II4QRADYJiet+XlS1U3NT94trzea8uBGlnkH4ghBBIBt+nn6SZJ2+fep1O1WiuoUMNItyzZoR0WtvcUBiAqCCADbrNu9TpLU6KnQjJzBei29ecn3lmXeAcQ+gggAW5TWlGrphqXB7YBl6b7MZFkJFSzzDsQRgggAW7T3BN4ET5nuyD+WZd6BONGtp+8CQE/JTc+VSy4F9OXCZi5j9PcfnKnjhuTaWBmAaGJEBIAtfKk+FUwtCG67jFFB2V4dl5FlY1UAoo0gAsA2+aPzNaRv88Jld+4sU351jbS3yOaqAEQTQQSArdKS0iRJNa4DP47+8FWevgvEEYIIANss+2yZNu7dKElamJWhZX1TefouEGcIIgBsUVpTqoUrFwa3jWVpYWaGSt1unr4LxBGCCABbFFcWK2ACIfsClqWSxASevgvEEYIIAFvkpufKZYX+CHIZo6FNAZ6+C8QRgggAW/hSfSqYUiBLVvMOIxWU7VXTlNt5+i4QRwgiAGyTPzpfN028SZJ0RJ2l/Ooa3fnqFzx9F4gjBBEAturrHiRJajhwmSbRNPL0XSCOEEQA2Kpyf/OTJsrdAZW63fJYjTx9F4gjBBEAttrZsEGSVJloNCNnsHakf87Td4E4wkPvANimtKZUf974h+B2wLL0/qBPNP8UH0/fBeIEIyIAbFNcWRzy9F1JMpY0dqTfpooARBtBBIBtwq4lIks5aTk2VQQg2ggiAGzTspZIC5cxusw6Sr5Un41VAYgmgggAW+WPztfQvkMlSXftKtN0f4bNFQGIJoIIANtlJDeHjwRJamqwtRYA0UUQAWC7tKQ0SVKVyyX562yuBkA0EUQA2C49KV2StCEpSXv81TZXAyCaCCIAbFe2v0yS9JQ3TZelFmnZukdsrghAtBBEANiqtKZUq3euDm4bS1r4/v0qXfWgjVUBiBaCCABbFVcWy8iE7AtYlkpe/7lUsc2mqgBEC0EEgK1y03NlHbTPZYxyGhqkvVtsqQlA9BBEANjKl+rT7OGzgtsuY1RQtle+gKSMkfYVBiAqCCIAbPe1MedKkgY3Nuqlku3Kr6mTzloieYfYWheAyOPpuwBs17KOSJNlKcH0185LX9agoaNsrgpANDAiAsB2LeuIVLlcqvNLUx7cqKfeK7a5KgDRQBABYLv9dYmSpFqXS7vdfgWMdMuyDdpRUWtzZQAijSACwHbPfvpi8M9zcvsq0fue/MZoa9l+G6sCEA0RCyJbt27VpZdeqhEjRig5OVmjRo1SQUGBGhp4oBWAL5XWlOovm+4PbhvLkid7mRISKzQ8M8XGygBEQ8Qmq27cuFGBQEAPP/ywjjjiCG3YsEHz5s1TTU2N7rnnnkidFkAvU1xZrIACIfssy2jeGenK9ibbVBWAaIlYEJk5c6ZmzpwZ3B45cqQ++eQTPfTQQwQRAEG56blyWS4FzJdhxGW5NGfiCTZWBSBaojpHpKKiQhkZGe2+X19fr8rKypAXgNjmS/WpYEpBcNsyRgWT/598qT4bqwIQLVELIps2bdIDDzygyy67rN02ixYtktfrDb5ycnKiVR4AG+WPzldev3GSpGv3lSt/xDdsrghAtHQ7iMyfP1+WZXX42rhxY8hntm3bppkzZ2r27NmaN29eu8desGCBKioqgq+SkpLu9whArzQgZaAkyWUk+ZnUDsSLbs8RueGGGzR37twO24wc+eXzIbZv367TTz9dU6dO1e9+97sOP+fxeOTxeLpbEoAY0DexeXXVSrdLaiKIAPGi20EkKytLWVlZXWq7bds2nX766ZowYYKWLl0ql4tlSwCEl+5pXl212nIxIgLEkYglg23btmnatGnKzc3VPffco927d6u0tFSlpaWROiWAXqzleTNFSQnaUb3d5moAREvEbt995ZVXtGnTJm3atElDhw4Nec8YE6nTAuilPq/aLEl6JzlZM1fMU8HUW5U/Ot/mqgBEWsRGRObOnStjTNgXALRWWlOqlz7/d3A7IKOFKxeqtIYRVCDWMWkDgO2KK4tlFPqPlIAJqKSKO+eAWEcQAWC73PRcWbJC9rksl3LSWEsIiHUEEQC286X6dNXYq4LbLlkqmFLA6qpAHCCIAHCE/DEHJqYao8dz/4eJqkCcIIgAcIS0D//R/AfLUu6bBdLaP9lbEICoIIgAsF/FNnn+fYOSAs0TVqvdlvTPa6WKbfbWBSDiCCIA7Ld3s2QCSgsEJElVlksyfmnvFpsLAxBpBBEA9ssYJVkuJR8IIp8nJkiWW8oY2ckHAfR2BBEA9vMO0bKTLtUXic2LPf94YKaWnfQDyTvE5sIARBpBBIDtSmtKtXD7K5LVvJaIsSwt3P4KK6sCcYAgAsB2xZXFCphAyD5WVgXiA0EEgO36WANlTOjKqsZY8ijLpooARAtBBIDtqmv6qn5HvoKPmzFS/Y581dSk2VoXgMgjiACw3YjMVPkrJ2r8vgGSpFFV/RSonKThmSk2VwYg0ggiAGyX7U3Wovw8pTb1kSS5rIDuyD9W2d5kmysDEGkEEQCOcP7EXPlSUiVJnhRL50/MtbkiANFAEAHgGKmu5hGQvVY9t+4CcYIgAsAxihKrJEnbXXWa8fcZWvbZMpsrAhBpBBEAjlBaU6o3E758tkzABLRw5UJGRoAYRxAB4AjFlcU6aCkRFjUD4gBBBIAj5Kbn6qAcIpflUk5aji31AIgOgggAR/Cl+pRvTZVM86pmLsulgikF8qX6bK4MQCQRRAA4xuTEPKUGmoPII19/RPmj822uCECkEUQAOIaV4FH6gYffedwem6sBEA0EEQCOYSUkKc3fHESqGqtsrgZANBBEADiGKyFJfQ+MiFQ1EESAeEAQAeAYroQkJR2YrLqtapvN1QCIBoIIAMdYVf+B3unT/OC7JWuXsLIqEAcIIgAcobSmVE9WPCNZzauJGBlWVgXiAEEEgCMUVxbLyITsY2VVIPYRRAA4Qq6VJJcJDSIuY5SjRJsqAhANBBEAjuCrrVRB2V5ZLWHEGBWU7ZWvlrtngFhGEAHgDBmj9K3qWt2yZ58kKa+uXvk1dVLGSJsLAxBJBBEAzuAdopJJ/0+5TU2SpHq3WzprieQdYm9dACKKIALAMaqOOl99A80LmlWkDZbGX2xzRQAijSACwDFe3bRPaQeCyM795fr922ttrghApBFEADjCjopaLXltq95Mbl7QTO5G/fLTuXp03ZP2FgYgoggiAByhqKxGAXeV7svoH9xnWUa/LFzEomZADCOIAHCEEZmpcnvKFDiwsmqLgFjUDIhlBBEAjpDtTdaPTpnSdlEzy6WctBybqgIQaQQRAI7xgxPH6vqyWulAGHHJpYIpBfKl+myuDECkEEQAOEai26WvVQV0ZEODJGnh1IXKH51vc1UAIimiQeTss89Wbm6u+vTpo+zsbH3/+9/X9u3bI3lKAL1YotulBpOo/gdu4XW73DZXBCDSIhpETj/9dP31r3/VJ598or///e/avHmzvvOd70TylAB6MbfLUqOVoLRA86WZ6sZqmysCEGkJkTz4ddddF/zzsGHDNH/+fJ177rlqbGxUYiJP1ATQVpMSlBaolSR9vOdjldaUMkcEiGFRmyOyd+9ePf7445o6dWq7IaS+vl6VlZUhLwDxpclKUKm7+ZLMM5ue0Yy/z9Cyz5bZXBWASIl4ELn55puVmpqqAQMGqLi4WM8991y7bRctWiSv1xt85eRwyx4Qb3a73VrZsrqqpIAJaOHKhSxqBsSobgeR+fPny7KsDl8bN24Mtr/xxhv1/vvv6+WXX5bb7dbFF18sc9A6AS0WLFigioqK4KukhEWMgHizLcklc/CiZoZFzYBY1e05IjfccIPmzp3bYZuRI0cG/5yZmanMzEyNGTNGRx99tHJycvTOO+9oypQpbT7n8Xjk8Xi6WxKAGDKgySPL1ISEERY1A2JXt4NIVlaWsrKyDulkgQO35NXX1x/S5wHEPq/x6LuV1XrCmyapOYSwqBkQuyJ218yqVav03nvv6eSTT1b//v21efNm/fSnP9WoUaPCjoYAgCQlKKCv7d+vJ7xpGpQySH/+xp8JIUAMi9hk1ZSUFC1btkxnnHGGjjzySF166aU67rjj9MYbb3D5BUB4a/+kSU2rlX5g9NTfUE0IAWJcxEZE8vLy9Oqrr0bq8ABiTcU26Z/XyJLU90AQqWqobt7vHWJvbQAihmfNAHCGvZsl0xxA0lrmk7kslWxbZWdVACKMIALAGTJGSVbzj6SXU1KCu7/53q0saAbEMIIIAGfwDpHO+qV2uBP088yM4O6ADAuaATGMIALAOcZfrL95v6oAC5oBcYMgAsAxnnqvWDv2pMt10OrLLGgGxC6CCABH2FFRqwXL1svVlKaCsr3SgSxiyWJBMyCGEUQAOEJRWY0CRqpXovKra3RsTfNTur+R833lj863uToAkUIQAeAIIzJT5bKkOpMkScpsat5fa3YyURWIYQQRAI6Q7U3Wovw81at5JKQ8oTmJvPrFS5rx9xncwgvEKIIIAMc4f2KuTj82V6Vut9alfjlhNWAC3MILxCiCCABHSU3tq+LEBJnQO3i5hReIUQQRAI7i9qQot7FJFrfwAnGBIALAUdxJKfL5/ZpTUR/c57Jc3MILxKiIPX0XAA6F25MsScqvqtJj/foowUrQ8/nPK7tvts2VAYgERkQAOErOzlclSYP8dZKkJtMkr8drZ0kAIoggAsA5KrbpyA/ukSQlG6OEA/NENn2x0s6qAEQQQQSAc+zdLEsBSdIzfVN1YE0zfe/N61hHBIhRBBEAzpExSsZyqdTt1sLMDOnAU3iNDOuIADGKIALAObxDVHrqnfo8IUEBK3QhEdYRAWITQQSAo9TnXaSUxhS5WEcEiAsEEQCO8vJHO5XS1EcFZXulA1nEksU6IkCMIogAcIwdFbVa/MLHqlEf5VfXyLf3KElS3oBxmjp4qs3VAYgEgggAxygqq1HASPvVR5IUSKiRJH2wZy1P4AViFEEEgGOMyEyVy5JqTB+Vut3alf7l5FSewAvEJoIIAMfI9iZrUX6eauVRcWKCxBN4gZhHEAHgKOdPzJU/4cATeA96jztngNhDEAHgOENdZfL5/fpJ2Z7gPp7AC8QmgggAZ6nYpvH+DyRJ51fVqE+gecn3uybcrPzR+XZWBiACCCIAnGXv5uAlmWV9U1V3YIXVG1cv5q4ZIAYRRAA4S8YoBWTxvBkgThBEADiLd4jeSp+l4kSeNwPEA4IIAMf5uP805TY28bwZIA4QRAA4TklNonx+v64ua5DheTNATCOIAHCUHRW1emtbkyRpdlWl6kq/KUnK7TuC580AMYggAsBRispqVG5SJUnpVq3cSeWSpM+rt/C8GSAGEUQAOMqIzFRVK0WSVOp2Kynjv8H3eN4MEHsIIgAcJdubrDtGfShjxPNmgDhAEAHgLBXb9O1td8uyxJ0zQBwgiABwlr2bZal5WXef36+Csr1quXWGO2eA2EMQAeAsGaNkLH40AfGCv+0AnMU7RFVfu0fGiGXegThAEAHgOEkT5+qFwESWeQfiQFSCSH19vcaOHSvLslRYWBiNUwLoxZ4r3KadJkO5jU2yQueqMlkViDFRCSI33XSTBg8eHI1TAejldlTUasGy9apUqnx+v2bv6iuZL0dFrh1/LZNVgRgS8SDywgsv6OWXX9Y999wT6VMBiAFFZTUKGGmktkuSfrr/I/2gvDz4/pK1S1hdFYghCZE8+M6dOzVv3jw9++yzSklJ6bR9fX296uvrg9uVlZWRLA+AA43ITNVga49muVdJap6w+li/9OD7LaurTh08lZERIAZEbETEGKO5c+fq8ssv1wknnNClzyxatEherzf4ysnhOjAQb7K9ybr91BS5DkwOYcIqENu6HUTmz58vy7I6fG3cuFEPPPCAqqqqtGDBgi4fe8GCBaqoqAi+Skr4QQPEo9OnTlHgwNru4VZXtWQxYRWIEZYxB/0N78Tu3bu1Z8+eDtuMHDlS5513nv75z3/KavUvGb/fL7fbrYsuukh//OMfOz1XZWWlvF6vKioqlJ6e3ml7ALHjxd/dopnbH5QkLUtLU0Fm/+B7lizdOvVW5Y/Ot6s8AB3ozu/vbgeRriouLg6Z47F9+3bNmDFDf/vb3zR58mQNHTq002MQRID4dd8LH+rad6bKZUkfz3pI53+0WEZf/rhyWS699O2XmCcCOFB3fn9HbLJqbm5uyHbfvn0lSaNGjepSCAEQ3wYWLQs+eLdi+XUygweGvN8yT4QgAvRurKwKwHF2frFZF+y8t2Vldw1vapTFU3iBmBTR23dbGz58uCJ0FQhAjNn9+Uca1GpJVZ/frzOra/R8Wt/gvm+O/CajIUAMYEQEgONkDfuK/K1WUy11u/Vi39SQNv/a8i8efgfEAIIIAMcZNHSU/nPUTxU4EEa2JrCWCBCrCCIAHGnK7Gv1QNO5kqQB6UfLJatNmw1lG6JcFYCeRhAB4EjPvr9NA619kqTRuwt1zZ69bdosWbuEyzNAL0cQAeA4Oypq9ctlr+t89xvBfcc2NLRpx+UZoPcjiABwnKKyGg2zSoPPm5HCL/XOLbxA70cQAeA4IzJT9bnxhdw54/P7Nat6f0g7buEFej+CCADHyfYm65r8abql6X/UMgiyw52gf7daR0SS/rn5n8wRAXo5gggARzp/Yq6mHZkV3C5OTFBAoZdmjIwe//jxaJcGoAcRRAA4U8U2zdiyOLjM+7DGtsu8S9KfPvoToyJAL0YQAeBIe0o+kkuB4LbP79eciso27bhzBujdCCIAHKkoEDpZVZK+W1HTpp0liztngF6MIALAkYYMO0I/afofBVpdjXFJYdZXBdCbEUQAOFK2N1lTZ5yn1tGjJMmtg2eJGBkuzQC9GEEEgGOl1RR3uqiZxDNngN6MIALAkXZU1Oonb+5vs6jZNfsq2rS9f8393DkD9FIEEQCOVFRWo+1mgJb5Tw4uamaMNCRjUpu2rCcC9F4EEQCONCIzVYOtPcp3/ze4lohlSceVvBF2wirriQC9E0EEgCNle5N1+6kpcluhc0Kymxo1Z8gZbdqzngjQOxFEADjWV/LGtVlLxBhpakOfsO37uMPvB+BcBBEAjrW53qvFTd9V6xtlLEtyrX8sbPuXP385OoUB6DEEEQCONSIzVR+akcE5Ii2GNTQwTwSIEQQRAI6V7U3WUceMbXN5xuf3a06/vDbtmScC9D4EEQCOtaOiVo9taGxzeUaSvv7R8rCfYZ4I0LsQRAA4VlFZjQJG2hDm8kxtOw+dYZ4I0LsQRAA41ojMVLksqTrgaTMiktvYFHaeyB8//CPzRIBehCACwLGyvcm6eeZR6uuqbzMi4vP79R3fSW0+Y2S0bve6KFUI4HARRAA4Wt5Qr4oCvrbriUiaZDxhP/Pa569FoTIAPYEgAsDRRmSmapc1oO16IpLGrg7/fJl/b/23lm5YGp0CARwWgggAR2u5PBNuwqqvqVFzwyz3LvFEXqC3IIgAcLy8od6wE1aNpIuGzwr7GeaKAL0DQQSA443ITA07YdWS5Nvypr4z5jthP7dq+6rIFwfgsBBEAPQKWwM++U2YN1b+WpeNOCfsZ57+7GkuzwAORxAB4HhFZTXaoQH6gz/MZRgTkK+2SrPHzA772d998LsIVwfgcBBEADjeiMxUWZL+1TQ57DwRbXldk3yTwn726U8ZFQGcjCACwPGyvcmad8qIdueJ6D/3amyyr93PMyoCOBdBBECvMOu47AMLm4V718j3wd/bnbTKqAjgXAQRAL1CTYNfpRqgxU0XtLk8I0l6+4F2J61K0qJViyJXHIBDRhAB0Cu0zBP5vf8sPeNv+4wZychXVtTuqMirJa/qiuVXRLRGAN1HEAHQK7TME5Gk5YHx4RsVvaHLjrus3WP8Z9t/dMeqOyJRHoBDRBAB0GvMOi5bkrQ2MEaBcJdn1iyVr8mv6ydc3+4xntj4BM+hARyEIAKg16hp8EuSSjVAf/F/NXyjN+/WJcdeoguOuqDd49y35j6t370+EiUC6KaIBpHhw4fLsqyQ1+LFiyN5SgAxrGWeiCS9HTgmfKM1S6WKbbpl8i3Ky8xr91gXPn8hIyOAA0R8ROS2227Tjh07gq8f/ehHkT4lgBjVep5Iu5dnJGn5rZKk+6bd1+Hx7ltzn3619lc9WCGA7op4EElLS5PP5wu+UlNTI31KADHskpNHyFInl2fW/1Va8XP5Un0dzheRpN+v/z1hBLBRxIPI4sWLNWDAAI0bN0533323mpqa2m1bX1+vysrKkBcAtJbtTdYV00ZJkn7d9K32R0X+c4/01q90ybGXaF7evA6PSRgB7BPRIHL11VfrySef1GuvvabLLrtMd9xxh2666aZ22y9atEherzf4ysnJiWR5AHqpk0ZnSmoeFVnU3gJnkvTKT6WKbbp6/NVdCiPXvHoNK7ACUWYZ0+5f4bDmz5+vO++8s8M2H3/8sY466qg2+x999FFddtllqq6ulsfjafN+fX296uvrg9uVlZXKyclRRUWF0tPTu1MmgBi2o6JWUxa9Gty+L+FB5Se8Fb7xkBOkeSskSb9a+yv9fv3vOz3+vLx5unr81T1SKxCPKisr5fV6u/T7u9tBZPfu3dqzZ0+HbUaOHKmkpKQ2+z/88EMde+yx2rhxo4488shOz9WdjgCIL7cs+0B/ebdEkuTTHr3t+ZFcVjuNJ10mfeMuSV0PIyPSR+j2k29XXlb7d94ACK87v78TunvwrKwsZWVlHVJhhYWFcrlcGjhw4CF9HgBa/OiM0cEg0nKJ5paEJ9o8nVeS9O7Dzf/7jbuCIx2dhZGiyiJd+PyFysvM033T7pMvtf2n+wI4dBGbI7Jy5UotWbJE69at05YtW/T444/ruuuu0/e+9z31798/UqcFECeyvcm6cNKX88h+7z9LS5tmtD9f5N2HpcfOliRdPf7qTu+mabG+bL2+9rev6ZpXr9GLRS8yhwToYd2+NNNVa9eu1RVXXKGNGzeqvr5eI0aM0Pe//31df/31YeeHhMOlGQAdOXiuiCT9PfGnmuDe3P6HMo+Wvv93yTtEpTWluuH1G/RB2QfdOu+sEbN07YRrGSUB2hHROSLRRBAB0JmH39isRS9sDG53Ol+kRd5safpCyTuky/NGDjbZN1nTh03XtJxphBKgFYIIgLhyzZPv67nC7cHt89yvaXHC7zsPI5J0yg3SGT9TaU2plqxdon9v+fch1TA1e6rysvJ02tDTmOCKuEcQARBXwl2i8WmPfpd4r/JcW8NPYG0t8yhp2s1SzmSVJrj1oxU/0sZ9Gzv5UPuyU7J1YvaJGpo2VLnpuRo7cCwjJogrBBEAcaf17bytPZVQoEkJn6krgyOSgpdsfrX574d0uaY9Y7PGalzWOCUlJDFqgphHEAEQd8KNirT4Q8JdOsNd2PnISGsjTlPpEafrjZRkLd+1Ru+UvtMzhR7QMmrSz9NP5fXlSklM0ayRswgoiAkEEQBx6eCJq63laZPuSfytxri3d310pEXOiSodPlVLaj7Rv/etP+w6OzLKO0rHZR6n2qZaSVJyQjKXeNDrEEQAxK2C5zbojys/b/f9691P6UeJz3U/jBxQ6nZr3ZBj9ELfNK2obXspKNJaLvGU15ertqlWyQnJjKrAcQgiAOLaJY+9q9c27m73fZ/26MHEX2q8e9MhBxKpOZS8kdxHWzNy9E6SW5v8VYdxtJ6T0zdH03Onhw0rrUdaCDCIFIIIgLh363Mb9FgHIyNS8+Wan/d/XsfXvnNYgaTF+qREvZCarN0ut3b2SdP7bR+55WjhLgu1DjCdbbf+TEOgQcO9w1ljJU4RRABA0t0vbdSDr3WwyuoBPu3Rbwb9Q+MqXumRQNKiZcTkw8REyZLW9/FoU1KSujdrtvebmj1Vg1IGdTngdKXNoXymO22Yl3N4CCIAcEBXw4jUHEi+m71Dc9PWqF/xSxGpp/WoSbIx6hcIaEVKioqTEuMuoPQWHc3LiUQIimYAi9TIFUEEAFp5+M3NWvR89xYoO6FfteZkfqopySXKrCuWSlZGqLpm65MS9Z+UPqqTpXLLpdoDy8LuTEjQ+8l9CCmIuIVTFyp/dH6PHIsgAgAH2VFRqztf2KhnWy0F31XDMpJ19cRUneF6X/32bZD2bIp4MGnt4Es8/QKBYFhhVAU9xSWXXvrOSz0yMkIQAYB2HMroSGt5Q9J1tC9dkzPrvgwmsqTkDGnjP6R9W3qu2G5quexTbbnChpXWIy0EGITz6IxHNdE38bCPQxABgA4czujIwVqCSe6AFA3PTNVkz1ZlFf1DqqtpDie1e6SG/VLV9qiOonRHe5eFDg4wnW23fGZXQoLeSkkm3PQyLmP00sw/y+cbe9jHIogAQBfsqKjVAys26S/vFvfocVvCSf/URHkS3TrjqIE6Pqe/VLFN+uRFafv7zeEkKTU0rCSlSpXbpS3Le7QeOwTXWElIUKJMtwJOV9ocyme62iYe5+VYxujWsr3K//ZT0ohTDvt4BBEA6IYdFbVa/tFO/aNwu977fF9EzjEsI1kzj/Vp3/5G7a9vUkpSgvKGejX9K4OU7U0Obdw6sLRc9mkdVtrb3vmhtGNtROqPN12ZlxOJEBTtANYoS8ObmnRabZ18ASNdu0HyDjns//8IIgBwiFpCySP/KdLWvfujcs4ThvWTL72PUpIS1D81MRhWstL66Nxxg5tHU7qqYptU8q60Z4u0ryh8eJE6DjRdbbPjfVvnxKAnWdLZv5LGX9wjRyOIAEAPWFeyT8+9v12vbtwVtVASzhEDUzU+t39wJKV1WGnZbvAbjcxMDT/CEklfrJE2PC1V7mre7omA05U2kTpuvJ07UC8NGC0dObNHRkJaEEQAoIe1hJLd1XVa/0WlrcGkMxOG9dMJw/q3CSst25KC+0LmsAA9hCACABHWOpiUVtRHbG5JtBw8h0VSu6MvjhmNgWMRRAAgylrmlmzYVqH9Dc2/pN8vKdenO6vtLi2qujMa01mblluiJwzrT8DpZQgiAOAQLSMnNQ1Nzb9saxq1sbRS676otLu0XqUnAw6jOpFHEAEAh9tRUas1W/fp8701Kt6zPziK0hJW3tpcpi/21dldZlzqLPT0dAjat79RMmr/du5eiCACADFgXck+vfrxLtX7/dpX09gmrLRsl1bW6Y1Py+wuFz3k1CMy5evXJyohKFIjQQQRAIgzreeoSGoTVlpvS4rbOSxo353fztP5E3N75FgEEQBAl4Sbw9I6rHQUaBiNiS0uS3pr/ld7ZGSkO7+/Ew77bACAXuv4nP6HvYbIoYzGdNYmFm6J7m0CRtpatj/qc1QIIgCAw5LtTdb3pwzv8eNGIuAwqtM+lyUNz0yJ+nkJIgAAR4pUwAmnO6GnJ0NQ/9RErdlabvvojyVpUX6eLXfsEEQAAHEvmqEnnJYgVFRWo6QEK2ohqKHJaGRWqs442r7bhgkiAADYzO4gZCeX3QUAAID4RRABAAC2IYgAAADbEEQAAIBtCCIAAMA2BBEAAGAbgggAALANQQQAANiGIAIAAGxDEAEAALYhiAAAANs4+lkzxhhJUmVlpc2VAACArmr5vd3ye7wjjg4iVVVVkqScnBybKwEAAN1VVVUlr9fbYRvLdCWu2CQQCGj79u1KS0uTZVkdtq2srFROTo5KSkqUnp4epQqjK9b7GOv9k2K/j/Sv94v1PtK/6DDGqKqqSoMHD5bL1fEsEEePiLhcLg0dOrRbn0lPT4/J/7hai/U+xnr/pNjvI/3r/WK9j/Qv8jobCWnBZFUAAGAbgggAALBNzAQRj8ejgoICeTweu0uJmFjvY6z3T4r9PtK/3i/W+0j/nMfRk1UBAEBsi5kREQAA0PsQRAAAgG0IIgAAwDYEEQAAYBtHBJHhw4fLsqw2ryuvvLLdz5SXl+vKK69Udna2PB6PxowZo+effz74/qJFizRx4kSlpaVp4MCBOvfcc/XJJ5+EHGPatGltznn55Zf3iv7deuutbY531FFHhRyjrq5OV155pQYMGKC+ffvq29/+tnbu3Nnj/YtUH7tyTKd+h+HqsixLs2bNCrYxxuhnP/uZsrOzlZycrOnTp+uzzz4LOc7evXt10UUXKT09Xf369dOll16q6upqx/evsbFRN998s/Ly8pSamqrBgwfr4osv1vbt2zs97+LFi3u8f5HooyTNnTu3zfszZ84MOU5v/Q4lhX3fsizdfffdHZ43Et/hofyMWbJkiY488kglJycrJydH1113nerq6kLaPPjggxo+fLj69OmjyZMn69133w153+k/Rzvro5N+F7bLOMCuXbvMjh07gq9XXnnFSDKvvfZa2Pb19fXmhBNOMN/4xjfMf//7X1NUVGRef/11U1hYGGwzY8YMs3TpUrNhwwZTWFhovvGNb5jc3FxTXV0dbHPaaaeZefPmhZy7oqKiV/SvoKDAHHPMMSHH3b17d8hxLr/8cpOTk2NWrFhhVq9ebU488UQzderUHu9fpPrYlWM69Tvcs2dPSPsNGzYYt9ttli5dGmyzePFi4/V6zbPPPmvWrVtnzj77bDNixAhTW1sbbDNz5kxz/PHHm3feecf85z//MUcccYS54IILHN+/8vJyM336dPPUU0+ZjRs3mpUrV5pJkyaZCRMmhBxn2LBh5rbbbgs5Vuu/o07uozHGzJkzx8ycOTOk3d69e0OO01u/Q2NMyPs7duwwjz76qLEsy2zevDnYJlrfYXf79/jjjxuPx2Mef/xxU1RUZF566SWTnZ1trrvuumCbJ5980iQlJZlHH33UfPjhh2bevHmmX79+ZufOncE2Tv452pU+Oul3YXscEUQOds0115hRo0aZQCAQ9v2HHnrIjBw50jQ0NHT5mLt27TKSzBtvvBHcd9ppp5lrrrnmcMvttp7oX0FBgTn++OPbfb+8vNwkJiaap59+Orjv448/NpLMypUrD7n2rorEdxjumE79Dg92//33m7S0tOBf/kAgYHw+n7n77ruDbcrLy43H4zFPPPGEMcaYjz76yEgy7733XrDNCy+8YCzLMtu2bevB3rR1uP0L59133zWSzOeffx7cN2zYMHP//fcfbrmHpCf6OGfOHHPOOee0+5lY+w7POecc89WvfjVkn13fYWf9u/LKK9vUev3115uTTjopuD1p0iRz5ZVXBrf9fr8ZPHiwWbRokTHG+T9Hu9LHgznpd2ELxwWR+vp6M2DAAHP77be32+bMM880F110kZk3b54ZOHCgOeaYY8ztt99umpqa2v3MZ599ZiSZ9evXB/eddtppJjMz0wwYMMAcc8wxZv78+aampqZH+3OwnupfQUGBSUlJMdnZ2WbEiBHmwgsvDPkBv2LFCiPJ7Nu3L+TYubm55r777uvxfrUWie+wvWM69Ts82LHHHmvmzZsX3N68ebORZN5///2Qdqeeeqq5+uqrjTHGPPLII6Zfv34h7zc2Nhq3222WLVt26B3oRE/0L5xXXnnFWJYV8i+tYcOGmUGDBpmMjAwzduxYc9ddd5nGxsZDrr2reqqPc+bMMV6v12RlZZkxY8aYyy+/3JSVlQXfj6XvsLS01CQkJJjHH388ZL8d32FX+vf4448br9drVq1aZYxp/jt31FFHBT9TX19v3G63eeaZZ0I+d/HFF5uzzz7bGOP8n6Od9TEcp/wubM1xQeSpp54ybre7w38tHHnkkcbj8Zgf/OAHZvXq1ebJJ580GRkZ5tZbbw3b3u/3m1mzZrVJiQ8//LB58cUXzQcffGD+/Oc/myFDhphvfetbPdqfg/VU/55//nnz17/+1axbt868+OKLZsqUKSY3N9dUVlYaY5r/A01KSmpz7IkTJ5qbbrqp5zvWSiS+w/aO6dTvsLVVq1YZScEfFsYY89ZbbxlJZvv27SFtZ8+ebc477zxjjDG33367GTNmTJvjZWVlmd/85jeH0YOO9UT/DlZbW2vGjx9vLrzwwpD99957r3nttdfMunXrzEMPPWT69esXMqwcKT3VxyeeeMI899xz5oMPPjDPPPOMOfroo83EiRODgTqWvsM777zT9O/fP+TSoTH2fIdd7d8vf/lLk5iYaBISEowkc/nllwff27Ztm5Fk3n777ZDP3HjjjWbSpEnGGOf/HDWm4z4ezEm/C1tzXBD5+te/br75zW922Gb06NEmJycn5F/P9957r/H5fGHbX3755WbYsGGmpKSkw+O2pN9NmzZ1v/AuikT/jDFm3759Jj093fzhD38wxtj7FygSfezKMY1xznfY2g9/+EOTl5cXss/JQaQn+tdaQ0ODOeuss8y4ceM6ve78yCOPmISEBFNXV9fl8x+Knu5ji5aRruXLlxtjYuc7NKb5Hw9XXXVVp8eKxnfYlf699tprZtCgQeb3v/+9+eCDD8yyZctMTk6Oue2224wxzg8iPdHHgznpd2FrjgoiW7duNS6Xyzz77LMdtjv11FPNGWecEbLv+eefN5JMfX19yP4rr7zSDB061GzZsqXT81dXVxtJ5sUXX+x+8V0Qif61dsIJJ5j58+cbY+wbUoxEH7t6TGOc8x22ric9Pd0sWbIkZL9TL830VP9aNDQ0mHPPPdccd9xxIZcs2rNhwwYjyWzcuLFbdXdHT/fxYJmZmea3v/2tMSY2vkNjjHnzzTeNpJDJ5O2J9HfY1f6dfPLJ5sc//nHIvv/7v/8zycnJxu/3O/rSTE/1sTUn/S48mCNu322xdOlSDRw4MOT2sXBOOukkbdq0SYFAILjv008/VXZ2tpKSkiQ13xp51VVX6ZlnntGrr76qESNGdHr+wsJCSVJ2dvahd6IDPdm/g1VXV2vz5s3B2idMmKDExEStWLEi2OaTTz5RcXGxpkyZ0gO9CS8SfezqMSXnfIctnn76adXX1+t73/teyP4RI0bI5/OFfD+VlZVatWpV8PuZMmWKysvLtWbNmmCbV199VYFAQJMnT+6B3rTVU/2Tmm/hPe+88/TZZ59p+fLlGjBgQKfHKywslMvl0sCBA7tde1f1ZB8P9sUXX2jPnj3B//56+3fY4pFHHtGECRN0/PHHd3q8SH+HXe3f/v375XKF/opzu92Smn8/JCUlacKECSF/BwOBgFasWBH8O+j0n6Od9bHlf532u7CNqMSdLvD7/SY3N9fcfPPNbd77/ve/H/yXvjHGFBcXm7S0NHPVVVeZTz75xPzrX/8yAwcONL/4xS+Cbf73f//XeL1e8/rrr4fckrR//35jjDGbNm0yt912m1m9erUpKioyzz33nBk5cqQ59dRTe0X/brjhBvP666+boqIi89Zbb5np06ebzMxMs2vXrmCbyy+/3OTm5ppXX33VrF692kyZMsVMmTIlIv2LRB87O6aTv8MWJ598sjn//PPDHm/x4sWmX79+wTkG55xzTtjbd8eNG2dWrVpl/vvf/5rRo0dH5NZPY3q2fw0NDebss882Q4cONYWFhSF/B1tGvN5++21z//33m8LCQrN582bz5z//2WRlZZmLL7645zt3QE/2saqqyvz4xz82K1euNEVFRWb58uVm/PjxZvTo0SGXJXrrd9iioqLCpKSkmIceeqjNe9H+DrvTv4KCApOWlmaeeOIJs2XLFvPyyy+bUaNGBS99GtN8+67H4zGPPfaY+eijj8wPf/hD069fP1NaWhps4+Sfo13po9N+F4bjmCDy0ksvGUnmk08+afPeaaedZubMmROy7+233zaTJ082Ho/HjBw5ss0dF5LCvlrukS8uLjannnqqycjIMB6PxxxxxBHmxhtvjNi90z3dv/PPP99kZ2ebpKQkM2TIEHP++ee3uZ5XW1trrrjiCtO/f3+TkpJivvWtb5kdO3ZEpH/G9HwfOzum07/DjRs3Gknm5ZdfDnu8QCBgfvrTn5pBgwYZj8djzjjjjDbH3rNnj7ngggtM3759TXp6urnkkktMVVVVj/WptZ7sX1FRUbt/B1vWRFizZo2ZPHmy8Xq9pk+fPuboo482d9xxR0TnFvRkH/fv32++/vWvm6ysLJOYmGiGDRtm5s2bF/JLzJje+x22ePjhh01ycrIpLy9v8160v8Pu9K+xsdHceuutZtSoUaZPnz4mJyfHXHHFFW0uszzwwAMmNzfXJCUlmUmTJpl33nkn5H0n/xztSh+d9rswHOtAoQAAAFHnqDkiAAAgvhBEAACAbQgiAADANgQRAABgG4IIAACwDUEEAADYhiACAABsQxABACAOvfnmmzrrrLM0ePBgWZalZ599ttvH+Otf/6qxY8cqJSVFw4YN0913393tYxBEAACIQzU1NTr++OP14IMPHtLnX3jhBV100UW6/PLLtWHDBv3mN7/R/fffr1//+tfdOg4rqwIAEOcsy9Izzzyjc889N7ivvr5eP/nJT/TEE0+ovLxcxx57rO68805NmzZNknThhReqsbFRTz/9dPAzDzzwgO666y4VFxfLsqwunZsREQAA0MZVV12llStX6sknn9QHH3yg2bNna+bMmfrss88kNQeVPn36hHwmOTlZX3zxhT7//PMun4cgAgAAQhQXF2vp0qV6+umndcopp2jUqFH68Y9/rJNPPllLly6VJM2YMUPLli3TihUrFAgE9Omnn+ree++VJO3YsaPL50qISA8AAECvtX79evn9fo0ZMyZkf319vQYMGCBJmjdvnjZv3qxvfvObamxsVHp6uq655hrdeuutcrm6Ps5BEAEAACGqq6vldru1Zs0aud3ukPf69u0rqXleyZ133qk77rhDpaWlysrK0ooVKyRJI0eO7PK5CCIAACDEuHHj5Pf7tWvXLp1yyikdtnW73RoyZIgk6YknntCUKVOUlZXV5XMRRAAAiEPV1dXatGlTcLuoqEiFhYXKyMjQmDFjdNFFF+niiy/Wvffeq3Hjxmn37t1asWKFjjvuOM2aNUtlZWX629/+pmnTpqmuri44p+SNN97oVh3cvgsAQBx6/fXXdfrpp7fZP2fOHD322GNqbGzUL37xC/3pT3/Stm3blJmZqRNPPFELFy5UXl6eysrKdNZZZ2n9+vUyxmjKlCm6/fbbNXny5G7VQRABAAC24fZdAABgG4IIAACwDUEEAADYhiACAABsQxABAAC2IYgAAADbEEQAAIBtCCIAAMA2BBEAAGAbgggAALANQQQAANiGIAIAAGzz/wGBb/KVRuiNCAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## PART 3: circle fit and move to the origin\n", + "print('PART 3')\n", + "# plt.figure()\n", + "# plt.plot(np.real(linmag2 * np.exp(1j*uwphase2)), np.imag(linmag2 * np.exp(1j*uwphase2)))\n", + "# plt.axis('equal')\n", + "# plt.grid()\n", + "# plt.show()\n", + "\n", + "x_circle3, y_circle3, r_circle3=circle_fit(linmag2, uwphase2)\n", + "\n", + "data3=linmag2*np.exp(1j*uwphase2)-(x_circle3+1j*y_circle3)\n", + "linmag3 = np.abs(data3)\n", + "uwphase3 = shift_phase(np.unwrap(np.angle(data3)))\n", + "\n", + "\n", + "\n", + "plt.figure()\n", + "plt.plot(freq_cut, uwphase0, '.-')\n", + "plt.plot(freq_cut, uwphase2, '.-')\n", + "plt.plot(freq_cut, uwphase3, '.-')\n", + "\n", + "plt.figure()\n", + "d0 = linmag0*np.exp(1j*uwphase0)\n", + "d = linmag3*np.exp(1j*uwphase3)\n", + "plt.plot(np.real(d0), np.imag(d0), '.-')\n", + "plt.plot(np.real(d), np.imag(d), '.-')\n", + "plt.grid()\n", + "plt.axis('equal')" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PART 4\n", + "Optimization terminated successfully.\n", + " Current function value: 0.895593\n", + " Iterations: 399\n", + " Function evaluations: 735\n" + ] + }, + { + "data": { + "text/plain": [ + "(np.float64(-2.332401770988384),\n", + " np.float64(1377.778034210285),\n", + " np.float64(7732285934.875877))" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## PART 4: phase VS freq fit. Decide Q_total and f_r\n", + "print('PART 4')\n", + "theta_0, Q_tot, f_r, freq_fit, fitting=fit_phase_vs_freq(freq_cut,uwphase3)\n", + "# plot the data\n", + "p1 = (x_circle3+1.1*r_circle3, y_circle3)\n", + "p2 = (x_circle3+1.1*r_circle3*np.cos(theta_0), y_circle3+1.1*r_circle3*np.sin(theta_0))\n", + "\n", + "theta_0, Q_tot, f_r" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PART 5\n", + "0.9863432827669105 0.8021578653392015\n" + ] + }, + { + "data": { + "text/plain": [ + "(np.float64(-0.3810136732187607),\n", + " np.float64(1.0626114243939733),\n", + " np.float64(-0.6948295826944462),\n", + " np.float64(0.9165638140997356))" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## PART 5: calculate off-resonance point and decide a and alpha\n", + "print('PART 5')\n", + "p_offres=(x_circle3+1j*y_circle3)+r_circle3*np.exp(1j*(theta_0+np.pi))\n", + "a = np.abs(p_offres)\n", + "alpha = np.angle(p_offres)\n", + "\n", + "print(a, alpha)\n", + "\n", + "linmag5 = linmag2/a\n", + "uwphase5 = uwphase2-alpha\n", + "\n", + "plt.figure()\n", + "plt.plot(freq_cut, uwphase0, '.-')\n", + "plt.plot(freq_cut, uwphase5, '.-')\n", + "\n", + "plt.figure()\n", + "d0 = linmag0*np.exp(1j*uwphase0)\n", + "d = linmag5*np.exp(1j*uwphase5)\n", + "plt.plot(np.real(d0), np.imag(d0), '.-')\n", + "plt.plot(np.real(d), np.imag(d), '.-')\n", + "plt.grid()\n", + "plt.axis('equal')" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PART 6\n", + "-----------------------------------------\n", + "center position of the circle : (x, y) = (0.3820925925259998, -0.00400343308915947)\n", + "radius of the circle : r = 0.6179399071819187\n", + "\n", + "-----------------------------------------\n", + "Q_total : 1377.778034210285\n", + "Q_external : (2229.584305818359+14.445059808573063j)\n", + "Q_internal : 3606.3039030897476\n", + "resonance freq [Hz] : 7732285934.875877\n", + "kappa_tot/2pi [Hz] : 5612141.9727146905\n", + "kappa_external/2pi [Hz] : 3468039.2729252623\n", + "kappa_internal/2pi [Hz] : 2144102.699789427\n", + "Phi (Impedance mismatch) : 0.006478722363365638\n", + "\n" + ] + } + ], + "source": [ + "## PART 6: circle fit and decide impedance mismatch and Q external\n", + "print('PART 6')\n", + "x_circle6, y_circle6, r_circle6=circle_fit(linmag5, uwphase5)\n", + "phi_mismatch=-np.arcsin(y_circle6/r_circle6)\n", + "if measurement==\"Reflection_S21\":\n", + " Q_ext=Q_tot/(2*r_circle6*np.exp(-1j*phi_mismatch))\n", + "elif measurement==\"Reflection_S11\":\n", + " Q_ext=Q_tot/(r_circle6*np.exp(-1j*phi_mismatch))\n", + "Q_int=1/(1/Q_tot-1/np.real(Q_ext))\n", + "\n", + "print(\n", + "\"-----------------------------------------\\n\" \\\n", + "+f\"Q_total : {Q_tot}\\n\" \\\n", + "+f\"Q_external : {Q_ext}\\n\" \\\n", + "+f\"Q_internal : {Q_int}\\n\" \\\n", + "+f\"resonance freq [Hz] : {f_r}\\n\" \\\n", + "+f\"kappa_tot/2pi [Hz] : {f_r/Q_tot}\\n\" \\\n", + "+f\"kappa_external/2pi [Hz] : {f_r/np.real(Q_ext)}\\n\" \\\n", + "+f\"kappa_internal/2pi [Hz] : {f_r/Q_int}\\n\" \\\n", + "+f\"Phi (Impedance mismatch) : {phi_mismatch}\\n\"\n", + ")\n", + "\n", + "if measurement==\"Reflection_S21\":\n", + " data6=S21_refrection(freq_cut,a,alpha,rough_tau+fine_tau,Q_tot,Q_ext,f_r,phi_mismatch)\n", + "elif measurement==\"Reflection_S11\":\n", + " data6=S11_refrection(freq_cut,a,alpha,rough_tau+fine_tau,Q_tot,Q_ext,f_r,phi_mismatch)\n", + "\n", + "tau = rough_tau+fine_tau\n", + "theta_0 = uwphase0[0]-np.unwrap(np.angle(data6))[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.789645759884343e-10 -0.037223402011657525\n" + ] + }, + { + "data": { + "text/plain": [ + "(np.float64(-1.2509451414663212e-10), np.float64(-0.033842988389463126))" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## Part7: cable delay fitting (2nd)\n", + "print(tau, theta_0)\n", + "def func(x):\n", + " tau, theta_0=x\n", + " if measurement==\"Reflection_S21\":\n", + " data_temp=S21_refrection(freq_cut,a,alpha,tau,Q_tot,Q_ext,f_r,phi_mismatch)\n", + " elif measurement==\"Reflection_S11\":\n", + " data_temp=S11_refrection(freq_cut,a,alpha,tau,Q_tot,Q_ext,f_r,phi_mismatch)\n", + " uwphase_temp=shift_phase(np.unwrap(np.angle(data_temp)))\n", + " return np.sum((uwphase0-uwphase_temp-theta_0)**2)\n", + "# minimize the \"func\"\n", + "res = minimize(fun=func,\n", + " x0 = [tau, theta_0], # initial value\n", + " method = \"Nelder-Mead\",\n", + " jac = False,\n", + " options={\"maxiter\":3000000}, # maximum of iteration\n", + " )\n", + "tau, theta_0 = res.x\n", + "\n", + "\n", + "tau, theta_0" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------\n", + "center position of the circle : (x, y) = (0.2739649672127034, 0.25824236632168446)\n", + "radius of the circle : r = 0.6090609582456581\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "(np.float64(-0.6832736447363016),\n", + " np.float64(0.9767440293207765),\n", + " np.float64(-0.6801634010517484),\n", + " np.float64(0.9158654244977024))" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## Part8: repeat from 3 to 6\n", + "linmag2 = linmag0\n", + "uwphase2 = shift_phase(uwphase0-2*np.pi*tau*(freq_cut-freq_cut[0]))\n", + "\n", + "# 3\": circle fit and move to the origin\n", + "x_circle3, y_circle3, r_circle3=circle_fit(linmag2, uwphase2)\n", + "\n", + "data3=linmag2*np.exp(1j*uwphase2)-(x_circle3+1j*y_circle3)\n", + "linmag3 = np.abs(data3)\n", + "uwphase3 = shift_phase(np.unwrap(np.angle(data3)))\n", + "\n", + "\n", + "plt.figure()\n", + "plt.plot(freq_cut, uwphase0, '.-')\n", + "plt.plot(freq_cut, uwphase3, '.-')\n", + "\n", + "plt.figure()\n", + "d0 = linmag0*np.exp(1j*uwphase0)\n", + "d = linmag3*np.exp(1j*uwphase3)\n", + "plt.plot(np.real(d0), np.imag(d0), '.-')\n", + "plt.plot(np.real(d), np.imag(d), '.-')\n", + "plt.grid()\n", + "plt.axis('equal')" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimization terminated successfully.\n", + " Current function value: 0.009709\n", + " Iterations: 410\n", + " Function evaluations: 724\n" + ] + }, + { + "data": { + "text/plain": [ + "(np.float64(-2.365511407244726),\n", + " np.float64(1427.0334176770991),\n", + " np.float64(7732281892.856205))" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 4\": phase VS freq fit. Decide Q_total and f_r\n", + "theta_0, Q_tot, f_r, freq_fit, fitting=fit_phase_vs_freq(freq_cut,uwphase3)\n", + "# plot the data\n", + "center = (x_circle3, y_circle3)\n", + "p1 = (x_circle3+1.1*r_circle3, y_circle3)\n", + "p2 = (x_circle3+1.1*r_circle3*np.cos(theta_0), y_circle3+1.1*r_circle3*np.sin(theta_0))\n", + "\n", + "theta_0, Q_tot, f_r" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(0.9855050086697862), np.float64(0.7683583122221922))" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 5\": calculate off-resonance point and decide a and alpha\n", + "p_offres=(x_circle3+1j*y_circle3)+r_circle3*np.exp(1j*(theta_0+np.pi))\n", + "a = np.abs(p_offres)\n", + "alpha = np.angle(p_offres)\n", + "\n", + "linmag5 = linmag2/a\n", + "uwphase5 = uwphase2-alpha\n", + "\n", + "a, alpha" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------\n", + "center position of the circle : (x, y) = (0.3819916465471739, -0.004777290547872519)\n", + "radius of the circle : r = 0.6180314982046113\n", + "\n" + ] + } + ], + "source": [ + "\n", + "# 6\": circle fit and decide impedance mismatch and Q external\n", + "x_circle6, y_circle6, r_circle6=circle_fit(linmag5, uwphase5)\n", + "phi_mismatch=-np.arcsin(y_circle6/r_circle6)\n", + "if measurement==\"Reflection_S21\":\n", + " Q_ext=Q_tot/(2*r_circle6*np.exp(-1j*phi_mismatch))\n", + "elif measurement==\"Reflection_S11\":\n", + " Q_ext=Q_tot/(r_circle6*np.exp(-1j*phi_mismatch))\n", + "Q_int=1/(1/Q_tot-1/np.real(Q_ext))" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------\n", + "Q_total : 1427.0334176770991\n", + "Q_external : (2308.928894646671+17.848206390796335j)\n", + "Q_internal : 3736.1782407857054\n", + "resonance freq [Hz] : 7732281892.856205\n", + "kappa_tot/2pi [Hz] : 5418430.848972467\n", + "kappa_external/2pi [Hz] : 3348860.9851883096\n", + "kappa_internal/2pi [Hz] : 2069569.8637841574\n", + "Phi (Impedance mismatch) : 0.007729926609468493\n", + "\n" + ] + } + ], + "source": [ + "print(\n", + "\"-----------------------------------------\\n\" \\\n", + "+f\"Q_total : {Q_tot}\\n\" \\\n", + "+f\"Q_external : {Q_ext}\\n\" \\\n", + "+f\"Q_internal : {Q_int}\\n\" \\\n", + "+f\"resonance freq [Hz] : {f_r}\\n\" \\\n", + "+f\"kappa_tot/2pi [Hz] : {f_r/Q_tot}\\n\" \\\n", + "+f\"kappa_external/2pi [Hz] : {f_r/np.real(Q_ext)}\\n\" \\\n", + "+f\"kappa_internal/2pi [Hz] : {f_r/Q_int}\\n\" \\\n", + "+f\"Phi (Impedance mismatch) : {phi_mismatch}\\n\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(0.9855050086697862),\n", + " np.float64(0.7683583122221922),\n", + " np.float64(-1.2509451414663212e-10),\n", + " np.float64(1427.0334176770991),\n", + " np.complex128(2308.928894646671+17.848206390796335j),\n", + " np.float64(7732281892.856205),\n", + " np.float64(0.007729926609468493))" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a,alpha,tau,Q_tot,Q_ext,f_r,phi_mismatch" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [], + "source": [ + "with open(path+r\"\\fitted_params.md\", \"w\") as f:\n", + " f.write(\n", + " f\"Q_total : {Q_tot}\\n\" \\\n", + " +f\"Q_external : {Q_ext}\\n\" \\\n", + " +f\"Q_internal : {Q_int}\\n\" \\\n", + " +f\"resonance freq [Hz] : {f_r}\\n\" \\\n", + " +f\"kappa_tot/2pi [Hz] : {f_r/Q_tot}\\n\" \\\n", + " +f\"kappa_external/2pi [Hz] : {f_r/np.real(Q_ext)}\\n\" \\\n", + " +f\"kappa_internal/2pi [Hz] : {f_r/Q_int}\\n\" \\\n", + " +f\"Phi (Impedance mismatch) : {phi_mismatch}\\n\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimization terminated successfully.\n", + " Current function value: 0.003844\n", + " Iterations: 4\n", + " Function evaluations: 8\n", + "0.0\n" + ] + } + ], + "source": [ + "freq_fit=np.linspace(freq_cut[0],freq_cut[-1],fit_npts)\n", + "if measurement==\"Reflection_S21\":\n", + " data_fit=S21_refrection(freq_cut,a,alpha,tau,Q_tot,Q_ext,f_r,phi_mismatch)\n", + "elif measurement==\"Reflection_S11\":\n", + " data_fit=S11_refrection(freq_cut,a,alpha,tau,Q_tot,Q_ext,f_r,phi_mismatch)\n", + "\n", + "uwphase_fit_temp=np.unwrap(np.angle(data_fit))\n", + "\n", + "# fix the 2 pi difference in phase\n", + "def func(n):\n", + " return np.sum((2*n*np.pi-(uwphase0 - uwphase_fit_temp))**2)\n", + "res = minimize(fun=func,\n", + " x0 = [0], # initial value\n", + " method = \"Nelder-Mead\",\n", + " jac = False,\n", + " options={\"maxiter\":3000000, # maximum of iteration\n", + " # \"xatol\":1e-15,\n", + " \"disp\":True},\n", + " )\n", + "n = res.x[0]\n", + "print(n)\n", + "\n", + "if measurement==\"Reflection_S21\":\n", + " data_fit=S21_refrection(freq_fit,a,alpha,tau,Q_tot,Q_ext,f_r,phi_mismatch)\n", + "elif measurement==\"Reflection_S11\":\n", + " data_fit=S11_refrection(freq_fit,a,alpha,tau,Q_tot,Q_ext,f_r,phi_mismatch)\n", + "linmag_fit= np.abs(data_fit)\n", + "uwphase_fit=2*n*np.pi+np.unwrap(np.angle(data_fit))" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "plt.figure()\n", + "plt.plot(freq_cut, linmag0, '.')\n", + "plt.plot(freq_fit, linmag_fit, 'red')\n", + "\n", + "plt.figure()\n", + "plt.plot(freq_cut, uwphase0, '.')\n", + "plt.plot(freq_fit, uwphase_fit, 'red')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/sketching/taketwo.ipynb b/sketching/taketwo.ipynb new file mode 100644 index 0000000..2cf41bb --- /dev/null +++ b/sketching/taketwo.ipynb @@ -0,0 +1,1232 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import sqil_core as sqil\n", + "from scipy.optimize import curve_fit, minimize, newton\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import scipy.optimize as spopt\n", + "from scipy import stats\n", + "from scipy.linalg import norm" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Deep\n", + "deep = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00075-cavity_check_2024-12-12T171954'\n", + "# Tiny\n", + "tiny = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00032-cavity_check_2024-12-12T144742'\n", + "# Good\n", + "good = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00077-cavity_check_2024-12-12T172355'\n", + "# Bad\n", + "bad = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00062-cavity_check_2024-12-12T160601'\n", + "# Very bad\n", + "very_bad = r'Z:\\Projects\\BottomLoader\\RT_measurement\\20241212_cavities\\2024-12-12\\00053-cavity_check_2024-12-12T155026'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "My helpers" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def estimate_linear_background(x: np.ndarray, data: np.ndarray, points_cut = 0.1) -> list:\n", + " is1D = len(data.shape) == 1\n", + " points = data.shape[0] if is1D else data.shape[1]\n", + " cut = int(points * points_cut)\n", + "\n", + " # Consider just the cut points\n", + " x_data = x[0:cut] if is1D else x[0:cut,:]\n", + " X = np.vstack([np.ones_like(x_data), x_data]).T\n", + " y_data = data[0:cut] if is1D else data[0:cut,:]\n", + "\n", + " # Linear fit\n", + " coefficients, residuals, _, _ = np.linalg.lstsq(\n", + " X, y_data if is1D else y_data.T, rcond=None)\n", + "\n", + " return coefficients\n", + "\n", + "\n", + "def compute_global_2pi_shift(phase, phase_tmp, make_integer = True):\n", + " \"\"\"Compute the single global 2pi shift n that best aligns `phase` with `phase_tmp`.\"\"\"\n", + " delta_phase = phase - phase_tmp\n", + " n = np.mean(delta_phase) / (2 * np.pi)\n", + " return int(np.round(n)) if make_integer else n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Reviewed Taketo functions" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def shift_phase(phase):\n", + " \"\"\"\n", + " Shifts the (unwrapped) phase data so that the first phase value\n", + " lies within the range (-pi, pi].\n", + "\n", + " Parameters:\n", + " phase (array-like): Unwrapped phase data.\n", + "\n", + " Returns:\n", + " array-like: Phase data shifted to the range (-pi, pi].\n", + " \"\"\"\n", + " # Calculate how many 2*pi shifts are required to bring phase[0] into (-pi, pi]\n", + " n = np.round(phase[0] / (2 * np.pi))\n", + "\n", + " # Shift the entire phase array\n", + " return phase - 2 * n * np.pi\n", + "\n", + "def fit_phase_vs_freq_taketo(freq, phase, theta_0 = None, Q_tot = None, f_r = None):\n", + " if theta_0 is None:\n", + " theta_0 = np.mean(phase)\n", + " if Q_tot is None:\n", + " Q_tot = 0.01\n", + " if f_r is None:\n", + " f_r = np.mean(freq) #freq[np.argmin(np.abs(phase - np.mean(phase)))]\n", + "\n", + " def objective(x):\n", + " theta_0, Q_tot, f_r = x\n", + " model = theta_0 + 2 * np.arctan(2 * Q_tot * (1 - freq / f_r))\n", + " residuals = phase - model\n", + " return np.square(residuals).sum()\n", + "\n", + " res = minimize(\n", + " fun=objective,\n", + " x0=[theta_0, Q_tot, f_r],\n", + " method=\"Nelder-Mead\",\n", + " options={\n", + " \"maxiter\": 3000000,\n", + " \"disp\": True\n", + " }\n", + " )\n", + "\n", + " theta_0, Q_tot, f_r = res.x\n", + " return theta_0, Q_tot, f_r\n", + "\n", + "def S11_reflection(freq, a, alpha, tau, Q_tot, Q_ext, f_r, phi):\n", + " env = a * np.exp(1j * alpha) * np.exp(2j * np.pi * (freq - freq[0]) * tau)\n", + " resonator = 1 - (2 * Q_tot / np.abs(Q_ext)) * np.exp(1j * phi) / (1 + 2j * Q_tot * (freq / f_r - 1))\n", + " return env * resonator\n", + "\n", + "def S11_reflection_mesh(freq, a, alpha, tau, Q_tot, Q_ext, f_r, phi):\n", + " \"\"\"\n", + " Vectorized S11 reflection function.\n", + "\n", + " Parameters\n", + " ----------\n", + " freq : array, shape (N,)\n", + " Frequency points.\n", + " a, alpha, tau, Q_tot, Q_ext, f_r, phi : scalar or array\n", + " Parameters of the S11 model.\n", + "\n", + " Returns\n", + " -------\n", + " S11 : array\n", + " Complex reflection coefficient. Shape is (M1, M2, ..., N) where M1, M2, ... are the broadcasted shapes of the parameters.\n", + " \"\"\"\n", + " # Ensure freq is at least 2D for broadcasting (1, N)\n", + " freq = np.atleast_1d(freq) # (N,)\n", + "\n", + " # Ensure all parameters are at least 1D arrays for broadcasting\n", + " a = np.atleast_1d(a) # (M1,)\n", + " alpha = np.atleast_1d(alpha) # (M2,)\n", + " tau = np.atleast_1d(tau) # (M3,)\n", + " Q_tot = np.atleast_1d(Q_tot) # (M4,)\n", + " Q_ext = np.atleast_1d(Q_ext) # (M5,)\n", + " f_r = np.atleast_1d(f_r) # (M6,)\n", + " phi = np.atleast_1d(phi) # (M7,)\n", + "\n", + " # Reshape frequency to (1, 1, ..., 1, N) for proper broadcasting\n", + " freq = freq[np.newaxis, ...] # This makes sure freq has shape (1, 1, ..., N)\n", + "\n", + " # Calculate the envelope part\n", + " env = a[..., np.newaxis] * np.exp(1j * alpha[..., np.newaxis]) * np.exp(2j * np.pi * (freq - freq[..., 0:1]) * tau[..., np.newaxis])\n", + "\n", + " # Calculate the resonator part\n", + " resonator = 1 - (2 * Q_tot[..., np.newaxis] / np.abs(Q_ext[..., np.newaxis])) * np.exp(1j * phi[..., np.newaxis]) / (1 + 2j * Q_tot[..., np.newaxis] * (freq / f_r[..., np.newaxis] - 1))\n", + "\n", + " return env * resonator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From KIT" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def get_delay(f_data,z_data,delay=None,ignoreslope=True,guess=True):\n", + " '''\n", + " ignoreslope option not used here\n", + " retrieves the cable delay assuming the ideal resonance has a circular shape\n", + " modifies the cable delay until the shape Im(S21) vs Re(S21) is circular\n", + " see \"do_calibration\"\n", + " '''\n", + " maxval = np.max(np.absolute(z_data))\n", + " z_data = z_data/maxval\n", + " A1, A2, A3, A4, fr, Ql = fit_skewed_lorentzian(f_data,z_data)\n", + " if ignoreslope==True:\n", + " A2 = 0\n", + " else:\n", + " z_data = (np.sqrt(np.absolute(z_data)**2-A2*(f_data-fr))) * np.exp(np.angle(z_data)*1j) #usually not necessary\n", + " if delay==None:\n", + " if guess==True:\n", + " delay = guess_delay(f_data,z_data)\n", + " else:\n", + " delay=0.\n", + " delay = fit_delay(f_data,z_data,delay,maxiter=200)\n", + " params = [A1, A2, A3, A4, fr, Ql]\n", + " return delay, params\n", + "\n", + "def fit_skewed_lorentzian(f_data, z_data):\n", + " amplitude = np.absolute(z_data)\n", + " amplitude_sqr = amplitude**2\n", + " A1a = np.minimum(amplitude_sqr[0],amplitude_sqr[-1])\n", + " A3a = -np.max(amplitude_sqr)\n", + " fra = f_data[np.argmin(amplitude_sqr)]\n", + " def residuals(p,x,y):\n", + " A2, A4, Ql = p\n", + " err = y -(A1a+A2*(x-fra)+(A3a+A4*(x-fra))/(1.+4.*Ql**2*((x-fra)/fra)**2))\n", + " return err\n", + " p0 = [0., 0., 1e3]\n", + " p_final = spopt.leastsq(residuals,p0,args=(np.array(f_data),np.array(amplitude_sqr)))\n", + " A2a, A4a, Qla = p_final[0]\n", + "\n", + " def residuals2(p,x,y):\n", + " A1, A2, A3, A4, fr, Ql = p\n", + " err = y -(A1+A2*(x-fr)+(A3+A4*(x-fr))/(1.+4.*Ql**2*((x-fr)/fr)**2))\n", + " return err\n", + " p0 = [A1a, A2a , A3a, A4a, fra, Qla]\n", + " p_final = spopt.leastsq(residuals2,p0,args=(np.array(f_data),np.array(amplitude_sqr)))\n", + " #A1, A2, A3, A4, fr, Ql = p_final[0]\n", + " #print(p_final[0][5])\n", + " return p_final[0]\n", + "\n", + "\n", + "def guess_delay(f_data,z_data):\n", + " phase2 = np.unwrap(np.angle(z_data))\n", + " gradient, intercept, r_value, p_value, std_err = stats.linregress(f_data,phase2)\n", + " return gradient*(-1.)/(np.pi*2.)\n", + "\n", + "\n", + "def fit_delay(f_data,z_data,delay=0.,maxiter=0):\n", + " def residuals(p,x,y):\n", + " phasedelay = p\n", + " z_data_temp = y*np.exp(1j*(2.*np.pi*phasedelay*x))\n", + " xc,yc,r0 = fit_circle_algebraic(z_data_temp)\n", + " err = np.sqrt((z_data_temp.real-xc)**2+(z_data_temp.imag-yc)**2)-r0\n", + " return err\n", + " p_final = spopt.leastsq(residuals,delay,args=(f_data,z_data),maxfev=maxiter,ftol=1e-12,xtol=1e-12)\n", + " return p_final[0][0]\n", + "\n", + "def fit_circle_algebraic(z_data):\n", + " def calc_moments(z_data):\n", + " xi = z_data.real\n", + " xi_sqr = xi*xi\n", + " yi = z_data.imag\n", + " yi_sqr = yi*yi\n", + " zi = xi_sqr+yi_sqr\n", + " Nd = float(len(xi))\n", + " xi_sum = xi.sum()\n", + " yi_sum = yi.sum()\n", + " zi_sum = zi.sum()\n", + " xiyi_sum = (xi*yi).sum()\n", + " xizi_sum = (xi*zi).sum()\n", + " yizi_sum = (yi*zi).sum()\n", + " return np.array([ [(zi*zi).sum(), xizi_sum, yizi_sum, zi_sum], \\\n", + " [xizi_sum, xi_sqr.sum(), xiyi_sum, xi_sum], \\\n", + " [yizi_sum, xiyi_sum, yi_sqr.sum(), yi_sum], \\\n", + " [zi_sum, xi_sum, yi_sum, Nd] ])\n", + "\n", + " M = calc_moments(z_data)\n", + "\n", + " a0 = ((M[2][0]*M[3][2]-M[2][2]*M[3][0])*M[1][1]-M[1][2]*M[2][0]*M[3][1]-M[1][0]*M[2][1]*M[3][2]+M[1][0]*M[2][2]*M[3][1]+M[1][2]*M[2][1]*M[3][0])*M[0][3]+(M[0][2]*M[2][3]*M[3][0]-M[0][2]*M[2][0]*M[3][3]+M[0][0]*M[2][2]*M[3][3]-M[0][0]*M[2][3]*M[3][2])*M[1][1]+(M[0][1]*M[1][3]*M[3][0]-M[0][1]*M[1][0]*M[3][3]-M[0][0]*M[1][3]*M[3][1])*M[2][2]+(-M[0][1]*M[1][2]*M[2][3]-M[0][2]*M[1][3]*M[2][1])*M[3][0]+((M[2][3]*M[3][1]-M[2][1]*M[3][3])*M[1][2]+M[2][1]*M[3][2]*M[1][3])*M[0][0]+(M[1][0]*M[2][3]*M[3][2]+M[2][0]*(M[1][2]*M[3][3]-M[1][3]*M[3][2]))*M[0][1]+((M[2][1]*M[3][3]-M[2][3]*M[3][1])*M[1][0]+M[1][3]*M[2][0]*M[3][1])*M[0][2]\n", + " a1 = (((M[3][0]-2.*M[2][2])*M[1][1]-M[1][0]*M[3][1]+M[2][2]*M[3][0]+2.*M[1][2]*M[2][1]-M[2][0]*M[3][2])*M[0][3]+(2.*M[2][0]*M[3][2]-M[0][0]*M[3][3]-2.*M[2][2]*M[3][0]+2.*M[0][2]*M[2][3])*M[1][1]+(-M[0][0]*M[3][3]+2.*M[0][1]*M[1][3]+2.*M[1][0]*M[3][1])*M[2][2]+(-M[0][1]*M[1][3]+2.*M[1][2]*M[2][1]-M[0][2]*M[2][3])*M[3][0]+(M[1][3]*M[3][1]+M[2][3]*M[3][2])*M[0][0]+(M[1][0]*M[3][3]-2.*M[1][2]*M[2][3])*M[0][1]+(M[2][0]*M[3][3]-2.*M[1][3]*M[2][1])*M[0][2]-2.*M[1][2]*M[2][0]*M[3][1]-2.*M[1][0]*M[2][1]*M[3][2])\n", + " a2 = ((2.*M[1][1]-M[3][0]+2.*M[2][2])*M[0][3]+(2.*M[3][0]-4.*M[2][2])*M[1][1]-2.*M[2][0]*M[3][2]+2.*M[2][2]*M[3][0]+M[0][0]*M[3][3]+4.*M[1][2]*M[2][1]-2.*M[0][1]*M[1][3]-2.*M[1][0]*M[3][1]-2.*M[0][2]*M[2][3])\n", + " a3 = (-2.*M[3][0]+4.*M[1][1]+4.*M[2][2]-2.*M[0][3])\n", + " a4 = -4.\n", + "\n", + " def func(x):\n", + " return a0+a1*x+a2*x*x+a3*x*x*x+a4*x*x*x*x\n", + "\n", + " def d_func(x):\n", + " return a1+2*a2*x+3*a3*x*x+4*a4*x*x*x\n", + "\n", + " x0 = spopt.fsolve(func, 0., fprime=d_func)\n", + "\n", + " def solve_eq_sys(val,M):\n", + " #prepare\n", + " M[3][0] = M[3][0]+2*val\n", + " M[0][3] = M[0][3]+2*val\n", + " M[1][1] = M[1][1]-val\n", + " M[2][2] = M[2][2]-val\n", + " return np.linalg.svd(M)\n", + "\n", + " U,s,Vt = solve_eq_sys(x0[0],M)\n", + "\n", + " A_vec = Vt[np.argmin(s),:]\n", + "\n", + " xc = -A_vec[1]/(2.*A_vec[0])\n", + " yc = -A_vec[2]/(2.*A_vec[0])\n", + " # the term *sqrt term corrects for the constraint, because it may be altered due to numerical inaccuracies during calculation\n", + " r0 = 1./(2.*np.absolute(A_vec[0]))*np.sqrt(A_vec[1]*A_vec[1]+A_vec[2]*A_vec[2]-4.*A_vec[0]*A_vec[3])\n", + "\n", + " print(f'Circle fit: xc = {xc}, yc = {yc}, r0 = {r0}')\n", + " return xc, yc, r0\n", + "\n", + "\n", + "\n", + "#############################\n", + "def phase_fit_kit(f_data,z_data,theta0, Ql, fr):\n", + " phase = np.unwrap(np.angle(z_data)) # ADDED UNWRAPPING\n", + " def residuals_1(p,x,y,Ql):\n", + " theta0, fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_2(p,x,y,theta0):\n", + " Ql, fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_3(p,x,y,theta0,Ql):\n", + " fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_4(p,x,y,theta0,fr):\n", + " Ql = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " def residuals_5(p,x,y):\n", + " theta0, Ql, fr = p\n", + " err = dist(y - (theta0+2.*np.arctan(2.*Ql*(1.-x/fr))))\n", + " return err\n", + " p0 = [theta0, fr]\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_1(a,b,c,Ql),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " theta0, fr = p_final[0]\n", + " p0 = [Ql, fr]\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_2(a,b,c,theta0),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " Ql, fr = p_final[0]\n", + " p0 = fr\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_3(a,b,c,theta0,Ql),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " fr = float(p_final[0])\n", + " p0 = Ql\n", + " p_final = spopt.leastsq(lambda a,b,c: residuals_4(a,b,c,theta0,fr),p0,args=(f_data,phase))#,ftol=1e-12,xtol=1e-12)\n", + " Ql = float(p_final[0])\n", + " p0 = [theta0, Ql, fr]\n", + " p_final = spopt.leastsq(residuals_5,p0,args=(f_data,phase))\n", + " return p_final[0]\n", + "\n", + "def dist(x):\n", + " np.absolute(x,x)\n", + " c = (x > np.pi).astype(int)\n", + " return x+c*(-2.*x+2.*np.pi)\n", + "\n", + "def periodic_boundary(x,bound):\n", + " return np.fmod(x,bound)-np.trunc(x/bound)*bound\n", + "\n", + "def center(z_data,zc):\n", + " return z_data-zc" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "[dBmag], [phase], [freq] = sqil.extract_h5_data(bad, ['mag', 'phase', 'frequency'])\n", + "linmag = 10**(dBmag/20)\n", + "phase = shift_phase(np.unwrap(phase))\n", + "data = linmag * np.exp(1j*phase)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cable delay (linear guess)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(-0.869461536504487),\n", + " np.float64(1.0780189967192613),\n", + " np.float64(-0.9881000186557863),\n", + " np.float64(1.0007893487715098))" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "[c, tau] = estimate_linear_background(freq, phase)\n", + "tau /= 2*np.pi\n", + "\n", + "# delay = fit_delay(freq,data,tau,maxiter=200)\n", + "# delay /= 2*np.pi\n", + "\n", + "# The frequency correction must be relative to the first point we are considering\n", + "# In other words, the first point doesn't need to be corrected\n", + "phase1 = shift_phase(phase-2*np.pi*tau*(freq - freq[0]))\n", + "data1 = linmag * np.exp(1j*phase1)\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase, '.-')\n", + "plt.plot(freq, phase1, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data), np.imag(data), '.-')\n", + "plt.plot(np.real(linmag * np.exp(1j*phase1)), np.imag(linmag * np.exp(1j*phase1)), '.-')\n", + "plt.axis('equal')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Move circle to center" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circle fit: xc = 0.10811106169363328, yc = 0.024572598632727507, r0 = 0.8883731051578609\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xc, yc, r0 = fit_circle_algebraic(data1)\n", + "data3 = data1 - xc - 1j*yc\n", + "phase3 = np.unwrap(np.angle(data3))\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase, '.-')\n", + "plt.plot(freq, phase3, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data), np.imag(data), '.-')\n", + "plt.plot(np.real(data3), np.imag(data3), '.-')\n", + "plt.axis('equal')\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Phase vs freq" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimization terminated successfully.\n", + " Current function value: 14.891430\n", + " Iterations: 391\n", + " Function evaluations: 726\n", + "-2.8289187496454673 333.97125251717 7720371653.932282\n" + ] + } + ], + "source": [ + "theta0, Q_tot, fr = fit_phase_vs_freq_taketo(freq, phase3)\n", + "print(theta0, Q_tot, fr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculate the off-resonant point and choose a and alpha" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.99884978137473 0.3027881613974813\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p_offres = (xc+1j*yc) + r0*np.exp(1j*(theta0+np.pi))\n", + "a = np.abs(p_offres)\n", + "alpha = np.angle(p_offres)\n", + "\n", + "linmag5 = linmag / a\n", + "phase5 = phase1 - alpha\n", + "data5 = linmag5 * np.exp(1j*phase5)\n", + "\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase, '.-')\n", + "plt.plot(freq, phase5, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data1), np.imag(data1), '.-')\n", + "plt.plot(np.real(data5), np.imag(data5), '.-')\n", + "plt.scatter(np.real(p_offres), np.imag(p_offres), color='red')\n", + "plt.scatter(xc, yc, color='blue')\n", + "plt.axis('equal')\n", + "plt.grid()\n", + "\n", + "print(a, alpha)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Impedence mismatch and Q_ext" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circle fit: xc = 0.11064735393220045, yc = -0.008792197708603455, r0 = 0.8893961051232149\n" + ] + }, + { + "data": { + "text/plain": [ + "(np.float64(0.009885742546844512),\n", + " np.complex128(375.48504155892454+3.7120693760859074j),\n", + " np.float64(3020.7122145551966),\n", + " np.float64(-0.22501111973535037))" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xc6, yc6, r06 = fit_circle_algebraic(data5)\n", + "phi0 = -np.arcsin(yc6/r06)\n", + "\n", + "# FIXME: where does this come from?\n", + "Q_ext=Q_tot/(r06*np.exp(-1j*phi0)) # REFLECTION ONLY\n", + "Q_int=1/(1/Q_tot-1/np.real(Q_ext))\n", + "\n", + "refl6 = S11_reflection(freq, a, alpha, tau, Q_tot, Q_ext, fr, phi0)\n", + "theta0 = phase[0] - np.unwrap(np.angle(refl6))[0]\n", + "\n", + "phi0, Q_ext, Q_int, theta0" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------\n", + "Q_total : 333.97125251717\n", + "Q_external : (375.48504155892454+3.7120693760859074j)\n", + "Q_internal : 3020.7122145551966\n", + "resonance freq [Hz] : 7720371653.932282\n", + "kappa_tot/2pi [Hz] : 23116874.867950995\n", + "kappa_external/2pi [Hz] : 20561063.156814814\n", + "kappa_internal/2pi [Hz] : 2555811.711136182\n", + "Phi (Impedance mismatch) : 0.009885742546844512\n", + "\n" + ] + } + ], + "source": [ + "print(\n", + "\"-----------------------------------------\\n\" \\\n", + "+f\"Q_total : {Q_tot}\\n\" \\\n", + "+f\"Q_external : {Q_ext}\\n\" \\\n", + "+f\"Q_internal : {Q_int}\\n\" \\\n", + "+f\"resonance freq [Hz] : {fr}\\n\" \\\n", + "+f\"kappa_tot/2pi [Hz] : {fr/Q_tot}\\n\" \\\n", + "+f\"kappa_external/2pi [Hz] : {fr/np.real(Q_ext)}\\n\" \\\n", + "+f\"kappa_internal/2pi [Hz] : {fr/Q_int}\\n\" \\\n", + "+f\"Phi (Impedance mismatch) : {phi0}\\n\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "res = S11_reflection(freq,a,alpha,tau,Q_tot,Q_ext,fr,phi0)\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, linmag, '.-')\n", + "plt.plot(freq, np.abs(res))\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase, '.-')\n", + "plt.plot(freq, np.angle(res))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The repeatening" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cable delay" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-5.827247363606181e-10 -0.22501111973535037\n", + "-3.1467292451105774e-10 -0.16835161148451544\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def phase_prediction_error(x):\n", + " tau, theta_0=x\n", + " predicted = S11_reflection(freq,a,alpha,tau,Q_tot,Q_ext,fr,phi0)\n", + " predicted_phase = shift_phase(np.unwrap(np.angle(predicted)))\n", + " return np.sum((phase - predicted_phase - theta_0)**2)\n", + "\n", + "# Minimize the phase prediction error as a function of cable delay (tau)\n", + "# and a global phase offset theta_0\n", + "res = minimize(fun=phase_prediction_error,\n", + " x0 = [tau, theta0], # initial value\n", + " method = \"Nelder-Mead\",\n", + " jac = False,\n", + " options={\"maxiter\":3000000}, # maximum of iteration\n", + " )\n", + "new_tau, new_theta0 = res.x\n", + "\n", + "print(tau, theta0)\n", + "print(new_tau, new_theta0)\n", + "\n", + "phase8 = shift_phase(phase - 2*np.pi * new_tau * (freq-freq[0]))\n", + "data8 = linmag * np.exp(1j * phase8)\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase1, '.-')\n", + "plt.plot(freq, phase8, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data1), np.imag(data1), '.-')\n", + "plt.plot(np.real(linmag * np.exp(1j*phase8)), np.imag(linmag * np.exp(1j*phase8)), '.-')\n", + "plt.axis('equal');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Move circle to center" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circle fit: xc = 0.10766197235923959, yc = 0.006328418897151019, r0 = 0.8862372885724991\n" + ] + }, + { + "data": { + "text/plain": [ + "5.048811440883619" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xc9, yc9, r09 = fit_circle_algebraic(data8)\n", + "\n", + "data9 = data8 - (xc9+1j*yc9)\n", + "linmag9 = np.abs(data9)\n", + "phase9 = shift_phase(np.unwrap(np.angle(data9)))\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase3, '.-')\n", + "plt.plot(freq, phase9, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data3), np.imag(data3), '.-')\n", + "plt.plot(np.real(data9), np.imag(data9), '.-')\n", + "plt.axis('equal')\n", + "\n", + "norm(data3-data9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Phase vs frequency fit" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.22501111973535037 333.97125251717 7720371653.932282\n", + "Optimization terminated successfully.\n", + " Current function value: 1.835150\n", + " Iterations: 365\n", + " Function evaluations: 663\n", + "-3.0011858355787364 378.0141329369699 7720564877.30637\n" + ] + } + ], + "source": [ + "print(theta0, Q_tot, fr)\n", + "new_theta0, new_Q_tot, new_fr = fit_phase_vs_freq_taketo(freq, phase9)\n", + "print(new_theta0, new_Q_tot, new_fr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Find off-resonance point (a and alpha)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.99884978137473 0.3027881613974813\n", + "0.9937643817223956 0.13155076584920644\n" + ] + }, + { + "data": { + "text/plain": [ + "2.731923301670993" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGdCAYAAADuR1K7AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAYTZJREFUeJzt3XlcVFX/B/DPnWFXAQFlE0Uw930j1NQUBfXJtdKySB+X0kzN0tSnXHPJTC2zrNx/abaZaSlKmFpKaKK5W+IODIokuMIs5/cHMjIwwz5zh5nP+/XipXeZy3dOE3w895xzJSGEABEREZGNUMhdABEREVFFYrghIiIim8JwQ0RERDaF4YaIiIhsCsMNERER2RSGGyIiIrIpDDdERERkUxhuiIiIyKY4yF2AHHQ6HVJSUlCtWjVIkiR3OURERFQCQgjcvn0bAQEBUChM98/YZbhJSUlBUFCQ3GUQERFRGVy9ehW1atUyedwuw021atUA5DaOu7u7zNWYplarsXv3bvTs2ROOjo5yl2NX2PbyYLvLg+0uD7Z76WVlZSEoKEj/e9wUuww3ebei3N3drT7cuLm5wd3dnR98C2Pby4PtLg+2uzzY7mVX3JASDigmIiIim8JwQ0RERDaF4YaIiIhsCsMNERER2RSGGyIiIrIpDDdERERkUxhuiIiIyKYw3BAREZFNYbghIiIim8JwQ0RERDaF4YaIbFNmMnBxf+6fxraJyGbZ5bOliKgSyUwGMpIAr1DAI9D4vsxk3Lx6Ghd1fgisUw/+Sd9CbJ8ASeggJAWk5kMgjm9+tP3Uh0Bo90LXKHKbiCoNhhsiko+RAJFzJwNn4nfAN6QpfK8fALZPAIQOAgpkdZ4JD0UOxN75kCAgIEGq1R7i2iF4Q6C6AH7TNYOf8iQkCADIDTR/bULeY/YkoYPY9hoA6dE1QrpCXNibuy0pIDV/FuL4NwZhKK1mR9y4fBo16jSGb61Qhh8iK8ZwQ0SWUTAMJG4w7F158m0knf8Hgy5/BcU/gIgDhIRHoQQ6eOyf+fDvefsEcC1Bv62QgC7KE4W+dcHnB+dui0fXuPCrYfj5a3OhMFRTAL4SoBMSrvl2QeCN/fraszq9jasu9Rl8iKwEww0RVTwjQeZRD4yEB6FRcEnaaRAgsGcOGgL6JCIVTCSlIITh6wtuF8doGHq4UyEJ1Lq+99ExoYP7/jlo+jD4JNV4EiHpeyFBB0gKIGIWENCKt7uILIjhhojKp5ggk+PXBs6qP/WnSxBwTdpZpm+lERIkAEpJ6PcVDC4aocB7miF4y2EzHCQdNEKBH7QdMUB54OG2BAVyQ4qpa5Q6DOULPqHpe/JdSAcROwMSACEpcL/R03A9/Z3p4ENEFYLhhojKrkCQyQ4Ig0vKH/rDEoRBsMmvcCgpHFy0IvcEpSSgEQpM14wAAMx3WK0PLlu1nTDQ4XcokLv9tmYk1C2GosvRDgiSVLgq/PB4q2ZYdvQEgiQVruh88YTyOOblu4Zh+Cl9GCpK/t4p11PfPHpdvuDDoENUsRhuiKhk8s1ICvKuBt+rMUDMW/rDEoRBsMlPJ3LHw+Qx1rvytmYkIpvUxBPn5uv3JTafCVWNDtgcsx8XdDVxQ/JB/1YB6HK0hT64jB/YBYr6Sty8egaXdH6YUCcU/h6uSI1sgEvp9xDs41Zoe//fXdFlSwuj4cfY9vjgKxiUsjhfoOqI/g/DT2l6fQru128W6OG51HIK3EPbwjuoMYMOURkw3BBRYQVvNR1eDfHzG/CGgFcxvRYlCTLTNSPwrfZJ/KwLR20pTR9SOrX0xw/f+KBhbW/UrNsE7WuFAgDatWhmMqj4e7gCALw9AuGdrw5/D1f9sYLbg9vVRuf6Txd5zYLbadeGIP3yWfjUaQhtqiO6bNmHIEmF5tIFTDFxC6xUwSfvT6FDcOJCSEcBHRS43IpBh6i0GG6IyFCBW02a6qFw+Pf8o1++Uu4v6SThhxBJVaIg872uG+p0fBE79h7U98AsHNQUnevXMAgQarUaTlW90PDxXnB0dNRft6igUlbFXbPgtm+t0NyZUAAG14JBOLp5+02kXz6Lo3erY+avt/CB5lnUVaShWSmCT376MTwwEXQ8vQD1Xd7CIjKB4YbI3uW73RSsSIPPtvHIP03a8d/zhV4iScDb6pHoHXgfz19fWmyQmT+wKQa3q43uYa0K9biUN6TIxSD8eOQGnyYAuofdz3f76wa6bMkd+3NZ5wuV5I0PNM8i+GHwyQuBpQ06AuBYHaIiMNwQ2bPEDRDbxhd7u0knJIMBtRqhwFXhhx4vPI0df0UZjIkpLshU1jBTUkXd/gKAS+n3cDz5FhbtPIft2eFlCjrGxuow6BA9wnBDZC8ejqNJcwzElVtqNLj2Lar9sbjQ7aa8v+fJu9U0zXGzwYyk8QO7wN/DFX07ty80JgawjyBTEsZud4WHeqNviwCjQSf/GJ6SzMoyGnQgAR3GAWFjGHLILjHcENmDfONoagrAB5LBlOs8kgR8pumDEcqdhW41jRz5JhxuXTSYkZSHQab08tosf9DJ69356/KrSL54CqcO7cXksgQdCODgciB+BXtzyC4x3BDZovyznW5dAfKPo5EAJQTO6QLxmJRS6HbTBm0vVOk8rtCYGd9atYFaoQYzkqhiFOrdad4UbZo3RbuuffVB5+ShvYV6dIoNPOzNITvFcENkawxmOxV+lECemZrhqC2lYaHj6kK3m0yNmSHL8vdwNQg6n+4ZgoOHD+GOzglVFDklGqtTqDfn4McMOWTzGG6IbMn1s4a9NDA9juaSzheHpSZ4Y+QYo7ebeKvJuvh7uOK1AV3wdLf2RQxK/goORm43GjJyy8q9jiXeApHFMNwQVWYPbz+lZ0vI+WsL/P7eBAUMf7nljaMZ5bBT30MzXTOCt5sqKWNjdY4n38J7O85iuzYcwx1iMFK5A0pJFH3bKt8tKwdIaFwzCshqCXgz6FDlx3BDVFnlu/3kne+XmLEHSa7VRKHts9PRptq/uOkYgAHZnnidt5sqvYJBZ+3vl7DwN2+s1USVqDdHP1MOAo9d3wmxPIa3rMgmKOQugIhKIDMZuLg/908AOLcL2PYaIHQAHg0unZgzBm9pRkEjcv/Xzt9LE1AnFKj7BHxrhSI81JvBxsb4e7hiep9GODitG/o+0Q6HRGN8of0POmV/hM80faAt7m4VckMODi6HWNY0NzwTVVLsuSGydgUeh3DXsz6q3jpX6DRJAlTwxh/axghq+xTiDx82mO3EMGMf8kLO8E7B+W5Z5fbmlPSWlSR00G0bj5tV6qFGgw6WfQNEFYDhhsiaZSbrgw2Q+y/rqrfOQStyu12NDRJWShKe7tZeP/CUs53sU3lvWSkg4L2pF/7wex51n3pT/1wtosqAt6WIrNnlg/pgk98b6tzbT0IqfPspr5cm7xcbgw2V9ZaVQgIeT9sEny9a449PxyDtWpJlCycqI/bcEFmbzGRkJB1C9pkY+J7/vtC/QDRCgT90jaGCNwYPGMZBwlRiBW9ZuTkp8PPxduj0WxSGOcRgpPJnKI3cqlI+DDnaLzbhWO0X0fLpaRxwTFbNIj03K1asQHBwMFxcXBAWFoZDhw6ZPLdr166QJKnQV58+ffTnDBs2rNDxqKgoS7wVIvM6vAZiaRN4bRsG/382QyHU+EcXAK3I/Y2T10OjgjeUksRBwlQmeb16LYKqY3qfRvj6zQFIqPEcBmTPgU6YXvJYKQEtr/4fdEsbIzPuAwtWTFQ6Zu+5+frrrzFp0iSsXLkSYWFhWLZsGSIjI3Hu3DnUrFmz0PlbtmxBTk6OfvvmzZto0aIFnnnmGYPzoqKisHbtWv22s7Oz+d4EkSX89TXEz68brCisFRJezJmKmX2bwjnzEt7Zfw/JwgtKSeIgYaow/h4u6BesQ6uh/8XOnx4g8uKCIhcDVABw3z8HiWeOI7D/DI7HIatj9nCzZMkSjBo1CsOHDwcArFy5Ej///DPWrFmDqVOnFjrfy8vLYHvz5s1wc3MrFG6cnZ3h5+dnvsKJzC3fAnzSweXwvrKr0KMSlJJAsOI6PH2DEd6hDRp1uM9BwmQ2/h4uqD3sLaRdexoXtn+A9qqNRm9TAbmD2Vunb4X2i628VUVWx6y3pXJycnDkyBFEREQ8+oYKBSIiIhAfH1+ia6xevRpDhgxBlSpVDPbv3bsXNWvWRIMGDTBmzBjcvHmzQmsnMqvEDcCypsD6p+D91X/gfWUXNEKCrsA/ljVCgavCT/+0aA4SJkvwrRWK8DGfIH1UIvb7PFfkGjm8VUXWyKw9N+np6dBqtfD19TXY7+vri7Nnzxb7+kOHDuHkyZNYvXq1wf6oqCgMHDgQdevWRVJSEqZPn45evXohPj4eSqWy0HWys7ORnZ2t387KygIAqNVqqNXqsrw1i8irzZprtFVmbfusFDhsG5+7YBoeLcAXnTMVtRTpBR5kOQKv9usEHzcHu/gc8DMvD1Pt7uVbG+EvL8eXcUOh/H0Jhir3mFwbJ+9W1cnzJ9Dg6dmAe4CZq678+HkvvZK2lSSEKMG6lWWTkpKCwMBAHDx4EOHh4fr9U6ZMwb59+5CQkFDk619++WXEx8fj+PHjRZ534cIFhIaG4pdffkH37t0LHZ81axZmz55daP+mTZvg5uZWwndDVH4O2vtodekzBGQlFjo2JOdt/KFrjKn1byBYUuGS8INr1erw5HAysgK3sgGXizvw9L3NJm9V5dEBOO3VC8n+kXjg5FX0yUSlcO/ePTz//PPIzMyEu7u7yfPM2nPj4+MDpVKJtLQ0g/1paWnFjpe5e/cuNm/ejDlz5hT7fUJCQuDj44Pz588bDTfTpk3DpEmT9NtZWVkICgpCz549i2wcuanVasTGxqJHjx5wdHSUuxy7UuFtn5WCO0c2wzVxNVwepBU6nLcAn0ICevcdBH8Pl/J/z0qIn3l5lLzde0OVPAnnf1qCTjdMhxwFgKYZO9E4Yyd03WZBhI8zQ9WVHz/vpZd356U4Zg03Tk5OaNOmDeLi4tC/f38AgE6nQ1xcHMaNK/rD/u233yI7OxsvvPBCsd/n2rVruHnzJvz9/Y0ed3Z2NjqbytHRsVJ8oCpLnbaoQto+4TOInVNQ/eFmhq4qvtN1xgiHGCgLPKV7wcCmqO1Trdx1V3b8zMujJO0eGNwAgeM+w5e7XwL2v1/srSppzyxImZeBzpM54NgEft5LrqTtZPbZUpMmTcJLL72Etm3bon379li2bBnu3r2rnz0VHR2NwMBALFiwwOB1q1evRv/+/eHt7W2w/86dO5g9ezYGDRoEPz8/JCUlYcqUKahXrx4iIyPN/XaISuf0jxA7pxjMgvKQ7mGtthf6vjwXfppULsBHldILPTsgNWwTdn41B5Gpn5ieVQUAR9ZCHFkHqcdsoOMES5ZJdsrs4Wbw4MG4ceMGZsyYAZVKhZYtWyImJkY/yPjKlStQKAwnbZ07dw6///47du/eXeh6SqUSx48fx/r163Hr1i0EBASgZ8+emDt3Lte6IauRmpEFza8LUevEJ0amd+tQR0rDxZzq8AutB18AvsYuQmTl/D1c4f/KAny5+ync3f+xyRWOgdznoonYGZAeZAHd37FsoWR3LPL4hXHjxpm8DbV3795C+xo0aABT45xdXV2xa9euiiyPqOJkJuOPPVtR7ehnaKK4DACFnr5ccHo3UWWX24vTCu/vPIhaJz82eatKAiB+Wwzp3k3epiKz4oMziSpK4gaIpU3w+F/T0URxGfeEE17NGY+3NKOgw6MHXL6tGYnxA7vwFhTZFH8PV0wd0h2pTyzAfM3zJtfG0d+mWtoEOPChJUskO8IHZxJVhJtJwLbXDG5BOUONI7rHch9wOXgYghUqXNL5YUKdUAYbslmTIxviM9c30WlHOF51+KGIXpzc21S3MzPg3rvwUh1E5cFwQ1ReGRcgvhxk4tEJabghfBBQJxTeHk3hbfQCRLbl5c6h6NsiAMvjWmH5EXe85rDV5G2qagnLcER1G23+u8TidZLt4m0porLITAYu7se/B9ZA/WlnSP9eRMFhYnlja/iAS7JH/h6umD+wGbI7Tyv6NpUEtL68Gkc/eSn3/yuiCsBwQ1Ra+Z4LVT32dTiqb+NPXX0s0DyvH1sjJCUuh8/Dd1OfxuB2tWUumEg+kyMbwifyTXTKXo4vNd0K/SMAyA04ra5vhW5pY47DoQrB21JEpZGZDGyfAAidfpdOABNzxiJFqokRI9+ErzoFklcIQjkThAhAyW9TKQBOF6cKwZ4botK4dMAg2ACAQgJqKdKhE8CFbE+g7hOc4kpUQN5tKufIGViu6W+0Bwd4NF0ccXMtWh/ZFoYbouI8HF+Tcfhb5Pz8ZqHDec+FUkoS164hKsbLnUPxzJSV2FbzlSKni4vfFuPu5v9yHA6VCcMNURGkY18+Gl/z00g45WTiqs4HWvFo3Zq850Jx4DBRyfh7uKLfq+/h8zbbTI/DAVDl7PcQHIdDZcAxN0QmuORkQLljkv42lCTljq95IWca1JITtg8NgMazLp8LRVRGY/p2wfvOvli+f0GR08U5DodKiz03RCZUfZACycj4Gn/Fv0gR3vjbtRV8a4UiPNSbwYaojCZHNkR252klGoeTtWOmRWujyovhhsgYzQPUu76z8G6OryGqcCUNONUSluHImkkWrY0qJ4Ybovwyk4FzMdCu7wvf2yegFkpoRW5fOcfXEJnP5MiGcI6cgfma56ErZsG/I2sZcKhoHHNDlCdxg34NGxcAD4QjhqunwCuoIT6K9MRNp0COryEyo5c7hyK1xRLM3tYfLc59iAHKA4XG4UgS0PrSaqh+cIHfgPnyFEpWjz03RIDRxfkcocFFnR9irihx3bsdx9cQWYC/hytmvxiJpCeWmLxNJUmA77EVOPfJEE4VJ6MYbogA4GpCocX58h58qRXApfR7MhVGZJ/yblMVFXAaXN+ZO1U8cYPlCySrxnBDlJkMETuj0G4OHiaS18udQ9HllWXFz6Ta9hp7cMgAww3ZtbTkC7i/qhekzKu4qataaPDwdcmbg4eJZNQiqDqcexb/yIaLX0+2aF1k3RhuyD5lJuPAj18g+7OecL19GVd1NdBPPQ/7e/8KvPQT0ob/gZoNOmPvG535VG8imb3cJbTYZ1IFJ/+MjP+LZg8OAWC4IXuUuAFiWVN0PPomaituIENXFUNy3kYKaqBhw4ZA3SdQMzAEj3kI+Hu4yF0tEaH4W1SSBHgl/cgxOASA4YbszcNZUflXHvaQ7kILBXQcOExk1Up6i4pjcIjhhuxL2mmTs6I4cJjI+r3cJbREqxlf2TTOonWRdWG4IbuR+u9t/LtnaaH9GqHAVeHHgcNElURJHtcQpNqD++sGWbYwshoMN2T7MpPx685v8eeSp1FddcDgkQpCUuJy+Dx8N/VpDhwmqkSKCziSBLhc+gXYMcXyxZHs+PgFsm2JGyC2T8CTQgcoAZ0Axqgn4pQuGD+9EADvoEYI9QiUu0oiKoPJkQ3xPqZh+X7gNYethR/VAEAc+gySczWg+zuy1EjyYM8N2S4jg4cBCSd1wUiFN/52bQUw2BBVank9OGs1kcZ7cACI3xYDBz6yeG0kH4Ybsl0ZSYUGDys4eJjI5kyObIjL7WcgTtvSZMDRxb4DXDti8dpIHgw3ZLuEQMGfcxw8TGSbZvdritV1FmKntq3R4woAYlU3roFjJxhuyCapVNdwf8uruV3SDxMOBw8T2bavRoVjs/er0BUxRVzHNXDsAsMN2ZbMZOzdsRkpn/SD652ruKKrgb6ahbjY52tIE08gNGose2yIbNh7/+2FBZrnTE4RVwBIXfWsRWsiy2O4Idvx8LEKXQ+9jNaK83ggHDFCPRmndLXhUr8LBw8T2QF/D1f49Jxc5Bo4flkncWfrJMsWRhbFcEO2wcjMKEdocFu48rEKRHamuFWMJQmocmw1Z1DZMIYbsg1GZkbxsQpE9qskU8R1se9w/I2NYrgh2+DmzZlRRGQgb4p4oi7U6HEFgNSV/S1aE1kGww1VfjodHsTM5MwoIipkdr+mWBM4y+QMKr97f+PB6j6WLYrMjuGGKrfMZJxfOwouF2ORLRwRnfMW1oQu58woItJb8UpfrHIZZnL8jfPV34G4uZYvjMzGIuFmxYoVCA4OhouLC8LCwnDo0CGT565btw6SJBl8ubi4GJwjhMCMGTPg7+8PV1dXRERE4J9//jH32yBrk7gBYmkT1Lv6HQDgJ20YfhMtMO+0D1LhJXNxRGRNnhq7sOjxN78t5vgbG2L2cPP1119j0qRJmDlzJhITE9GiRQtERkbi+vXrJl/j7u6O1NRU/dfly5cNji9atAgfffQRVq5ciYSEBFSpUgWRkZF48OCBud8OWYu82VH5Rtr0Ux6EH25CKwRnRxGRAX8PV9x8Yg5+1zY2GnAUAFI/6W3xusg8zB5ulixZglGjRmH48OFo3LgxVq5cCTc3N6xZs8bkayRJgp+fn/7L19dXf0wIgWXLluHtt99Gv3790Lx5c2zYsAEpKSnYunWrud8OWYub5wvNjnKQdJwdRUQmTY5qiAU138MFna/R434PLuHSRxx/YwvMGm5ycnJw5MgRREREPPqGCgUiIiIQHx9v8nV37txBnTp1EBQUhH79+uHUqVP6YxcvXoRKpTK4poeHB8LCwoq8JtmY62cK7eLsKCIqzuqX2mGi+lWT42/q3PwdN84dtHxhVKEczHnx9PR0aLVag54XAPD19cXZs2eNvqZBgwZYs2YNmjdvjszMTCxevBgdOnTAqVOnUKtWLahUKv01Cl4z71hB2dnZyM7O1m9nZWUBANRqNdRqdZnfn7nl1WbNNcoiKxXKX+dDAUAnJCgkASEpcTFsDr5q1x/+Hi7lbjO2vTzY7vKwp3b3cXNA78heiIvbgu7KY5Akw+OSBNzdPAqe04+ZvRZ7aveKUtK2Mmu4KYvw8HCEh4frtzt06IBGjRrhs88+w9y5ZRvNvmDBAsyePbvQ/t27d8PNzfpvX8TGxspdgvUQAm3/WYzA7Ewc04XgHWk8JoWkIcfVFw9yvIADe3C0Ar8d214ebHd52Eu7BwBY7/0GAjPeQiNlSqHjdXTXELf4Odxt/KJF6rGXdq8I9+6VbDylWcONj48PlEol0tLSDPanpaXBz8+vRNdwdHREq1atcP78eQDQvy4tLQ3+/v4G12zZsqXRa0ybNg2TJj16jkhWVhaCgoLQs2dPuLu7l+YtWZRarUZsbCx69OgBR0dHucuRX1YKzm97D4F3TyBbOOIN9Rj0eCIMnXo8VuHfim0vD7a7POyx3XsD+O/yHGzIHGG096b7g1jccm2Pqk++brYa7LHdyyvvzktxzBpunJyc0KZNG8TFxaF///4AAJ1Oh7i4OIwbN65E19BqtThx4gR6984dxV63bl34+fkhLi5OH2aysrKQkJCAMWPGGL2Gs7MznJ2dC+13dHSsFB+oylKnWSVugNg+AY0eDiLerW2DJBGIS79dwksd65ptjA3bXh5sd3nYW7svGtEHP7zfAQMdCo+xkSTA4+A8KMKGmv2hu/bW7uVR0nYy+2ypSZMm4YsvvsD69etx5swZjBkzBnfv3sXw4cMBANHR0Zg2bZr+/Dlz5mD37t24cOECEhMT8cILL+Dy5csYOXIkgNyZVBMnTsS7776Lbdu24cSJE4iOjkZAQIA+QJGNMfJQzF7KQ5z2TUTl4u/hirR2U00+PVwB4NzasRatiSqG2cfcDB48GDdu3MCMGTOgUqnQsmVLxMTE6AcEX7lyBQrFo4z177//YtSoUVCpVKhevTratGmDgwcPonHjxvpzpkyZgrt372L06NG4desWOnXqhJiYmEKL/ZGNMPJQzLxp3zeED6d9E1GZjenXBZ+dGYbR99cVuj0FAPX/3YvMuA/g0f0NyxdHZWaRAcXjxo0zeRtq7969BttLly7F0qVLi7yeJEmYM2cO5syZU1ElkjV7+FDM/D93OO2biCpK3zELsfP9k+jt8GehY5IEVPttDtB2iNlvT1HF4bOlyPr98SkfiklEZuPv4YrL7WYUeXsq+fNnLVoTlQ/DDVm3y/HA0f8DAIzOeR1/df+SD8Ukogo3pl8XrHMYZDLgBNw5ycX9KhGGG7Je/17Gna/+CwD4SvMkYkU7nHVpwa5hIjKL1sM+MPnsKUkClF8NsXxRVCYMN2SdEjdAfNgCVR+kQAjgnKgFAJi+5SRSM+/LXBwR2aIWQdWxovYSXNH5GD1eXWTixjcTLFwVlQXDDVmfAk/8liTgbYeNnPpNRGa3eXQ4pkgTTfbeeJ9al/sziqwaww1ZnyKmfvOJ30RkbtNHvYATujpGjykk4Oqm1yxcEZUWww1ZH60GBf/RxKnfRGQpLYKqY76H6dlTgao49t5YOYYbsj7xH0MCoOPUbyKSydJRfbBT29boMYUE/P3hfyxcEZUGww1Zl6Q9QFIccoQSQ9Qzkdr/O079JiKL8/dwxe+hk0323jymvYC/E/datCYqOYYbsh63ruD2d+MBAF9qe+CwrgH2qxtw6jcRyWL+8CiTvTeSBHhvHWrhiqikGG7IOiRugFjWHNXuX4UQwBVRAwKc+k1E8tJFLjDZe+Ml3cHfa8dYtiAqEYYbkh+nfhORlfrPE+2xVtPT5NTwepc2cXCxFWK4Iflx6jcRWbE6LyzHTV0Vo8cUErDwvVmWLYiKxXBD8vOozanfRGS1ujfywyu6qSZvT41x2I7gqT9btigqEsMNye/iPj71m4is2juvvIgUXXWjx9yl++iKI+jyXpyFqyJTGG5IXlo11PsWAwA+1AzA7narOfWbiKxOi6DqmCuNNDn25hOnj3D53weWL4yMYrgh+WQm48ymKXDMuoJ04Y6V2r647t2OU7+JyCrNfOMN3NY5Gj3mKqkxAHstWxCZxHBD8kjcALGsKRolrQEAJGgb4gGcMfPHU5z6TURWyd/DFe8pTPfeLHBaY/miyCiGG7K8vKnf+WZIRSn/5NRvIrJ682YvxD2hNHrMWdIARzdauCIyhuGGLM/I1G8lp34TUSVRZegmk7032D7e4vVQYQw3ZHleoQ9/CjzCqd9EVGk0iIKkND72Bjr23lgDhhuyPI9AwL+lflMHBad+E1HlEjHL9LGf37BYGWQcww1ZXmYyROpxAMCUnFFIHX6YU7+JqHLpMM70Mc194FyM5WqhQhhuyOJObV8KSWiRoGuIb3RP4vfrTnKXRERUek0Gmj4WM9VydVAhDDdkUWmXT6PWP7n3o9dqogDwyd9EVEmFF9F78+9FPlBTRgw3ZDmJG1BzbQd4SPcgBOAp3QYATv8mosqpVhvA0d308dg5lquFDDDckGXkrW3z8BGZkgS867AWfrjJ6d9EVHn1Xmj62MnNlquDDDDckGUYWdvGQdIhRHGd07+JqPJqNbTo4wc/tkwdZIDhhizDKxSA4do2QlJi6dgBnP5NRJVb88Gmj+17z3J1kB7DDVlG1ZrQOVXRbwpJCempZfCtFSpjUUREFaD7TNPHsrM4sFgGDDdkGefjoMi5g5uiKt5wmQ1MPA60jpa7KiKi8vMIBByLGDf44wTL1UIAGG7IQq7+ugoA8IP2CWy59Ri++VtXzCuIiCqRoqaFX4i1XB0EgOGGLOB6UiJ8U+MAAN9pu0CAa9sQkY3p9r+ij++ZZ5k6CADDDZlb4gbU+L9ucJJ0EAJorkgCwLVtiMgGedc3fSz+E8vVQQw3ZEZG1raZ77Caa9sQkW3qOdf0MfUdy9VBDDdkRlzbhojsSYOooo9/M9wydRDDDZkR17YhInvjHmT62OktlqvDzlkk3KxYsQLBwcFwcXFBWFgYDh06ZPLcL774Ak888QSqV6+O6tWrIyIiotD5w4YNgyRJBl9RUcUkZrI8j0AI70fr2AhJwbVtiMi29VksdwUEC4Sbr7/+GpMmTcLMmTORmJiIFi1aIDIyEtevXzd6/t69e/Hcc8/h119/RXx8PIKCgtCzZ08kJxsughQVFYXU1FT911dffWXut0KldfcmkHEBADBJ+xqyx/3FtW2IyLYVd2vqo3aWqcPOmT3cLFmyBKNGjcLw4cPRuHFjrFy5Em5ublizZo3R8zdu3IixY8eiZcuWaNiwIVatWgWdToe4uDiD85ydneHn56f/ql69urnfCpXSoV1fQhI6nNLVwRZ1OH68IHdFREQWUK2W6WMZf1uuDjvmYM6L5+Tk4MiRI5g2bZp+n0KhQEREBOLj40t0jXv37kGtVsPLy8tg/969e1GzZk1Ur14d3bp1w7vvvgtvb2+j18jOzkZ2drZ+OysrCwCgVquhVqtL+7YsJq82a67RlNTMB8g++g2gBA5omwAApm05gfC61eHv4SJzdcWrzG1fmbHd5cF2r2DDdsBhefMCIw5z6QBoC7Q3273kStpWkhBCmKuIlJQUBAYG4uDBgwgPD9fvnzJlCvbt24eEhIRirzF27Fjs2rULp06dgotL7i/FzZs3w83NDXXr1kVSUhKmT5+OqlWrIj4+HkqlstA1Zs2ahdmzZxfav2nTJri5cTqyOVS58gu6p2+AJAFaIWGaZiS+0T6JcY21eMzDbB85IiKr8J+j0Sj82wgQAB5Awu5W6y1dkk24d+8enn/+eWRmZsLd3d3keWbtuSmvhQsXYvPmzdi7d68+2ADAkCFD9H9v1qwZmjdvjtDQUOzduxfdu3cvdJ1p06Zh0qRJ+u2srCz9WJ6iGkduarUasbGx6NGjBxwdHeUup+SyUuCw/CVID//ZopQE5jusxu+65ni294BK03NTKdu+kmO7y4PtbgZHFcjtpzEkAXCCQO/evdnuZZB356U4Zg03Pj4+UCqVSEtLM9iflpYGPz+/Il+7ePFiLFy4EL/88guaN29e5LkhISHw8fHB+fPnjYYbZ2dnODs7F9rv6OhYKT5QlaVOvazLAAx7ZxwkHd7tUgW1farJU1MZVbq2txFsd3mw3SvQc18BXw02ekgJQJmvndnuJVfSdjLrgGInJye0adPGYDBw3uDg/LepClq0aBHmzp2LmJgYtG3bttjvc+3aNdy8eRP+/v4VUjeVk1coCt54EpIS3cIfl6UcIiKLaxAFuJsYWNyTz5kyN7PPlpo0aRK++OILrF+/HmfOnMGYMWNw9+5dDB+eu1JjdHS0wYDj9957D++88w7WrFmD4OBgqFQqqFQq3LmTu3T1nTt3MHnyZPzxxx+4dOkS4uLi0K9fP9SrVw+RkZHmfjtUEjoNJAB5o7mEpIT01DLAI1DOqoiILGvSKcC5wNAHNx+gQxFPEKcKYfYxN4MHD8aNGzcwY8YMqFQqtGzZEjExMfD19QUAXLlyBQrFo4z16aefIicnB08//bTBdWbOnIlZs2ZBqVTi+PHjWL9+PW7duoWAgAD07NkTc+fONXrriWRwcT8A4Lioi71B4zHhmUgGGyKyT9OuAgc/Bs5sAxr1ZbCxEIsMKB43bhzGjTP+H3Tv3r0G25cuXSryWq6urti1a1cFVUbmcOnPnQgGsE/XAsvO+8Lvby0Gc90qIrJXHcYx1FgYny1FFSrt6nl4JO8FABzUNYUAMH3LSaRm3pe1LiIish8MN1RxEjeg5up2qC7dhRBAqJT7yAytELiUfk/m4oiIyF4w3FDFyEwGtk+A9HBdB0kCZjushx9uQilJCPbhYolERGQZDDdUMTKSAGG4YJWDpEOI4jrmD2wKfw9XmQojIiJ7Y9UrFFMl4hUKSAqDgKOTFFg6dgB8a9WWsTAiIrI37LmhiuERaLAwlRYKSP9ZBt9aoTIWRURE9ojhhipOjfoAgBRddbwd/BWkNi/JXBAREdkjhhuqOMlHAQCHRCP4+NeVuRgiIrJXDDdUYa6dPgAAOKELwcd7z+Prw1dkroiIiOwRww1ViNTM+3BSJQIArup8IAQX7yMiInkw3FCFeLDvQ9SUMgEAnzp9iGeVv3LxPiIikgXDDZVfZjKCExfqN5WSwHyH1QiUMrh4HxERWRzDDZVfRhIkCINdDpIOc7u4cfE+IiKyOIYbKj+vwmvZCEmJbuGPy1AMERHZO4YbKj+PQIjqj6Z+C0kJ6alluQv7ERERWRjDDVUIzb1bAID/aUdBTDgOtI6WtyAiIrJbDDdUbj8cOA7H7H8BAFvU4fj2H10xryAiIjIfhhsql9TM+9j585bcvwtP3IcL17chIiJZMdxQudyNX4uVjssAAH64xfVtiIhIdgw3VHaZyQhN+B8UUu40cEkC17chIiLZMdxQ2WUkQRKG42u4vg0REcmN4YbKzisUkAw/QlzfhoiI5MZwQ2XnEQg89aF+bWKtkKDrs5Tr2xARkawYbqh8Wr0IITkAAF5xXgBl25dkLoiIiOwdww2Vz70MKIQGAJBRraHMxRARETHcUDnF/HEUAHBTVMOR5Hv4+vAVmSsiIiJ7x3BDZZaaeR9fxR0CANwRrvDDTS7gR0REsmO4oTK7mH4XfRTxAIA6ius44DwegxR7uIAfERHJiuGGyizUORNPK/frt5WSwHyH1QhxviVfUUREZPcYbqjMfNXJUEiG+xwkHXzVKfIUREREBIYbKg+vUAAF0o2kBLxCZCmHiIgIYLih8vAIBAJa6zeFpASeWsZF/IiISFYMN1Q+VWsCAD7T9MHxp38DWkfLXBAREdk7hhsqF1X6TQDASV1dDPjyEte5ISIi2THcUJmlZt7Xh5u7cIFOgOvcEBGR7BhuqMwupt+FO+4CAFyQAwDQCsF1boiISFYWCTcrVqxAcHAwXFxcEBYWhkOHDhV5/rfffouGDRvCxcUFzZo1w44dOwyOCyEwY8YM+Pv7w9XVFREREfjnn3/M+RbIiMaqH1FXUgEAPnZcjmeVv0IpSQj2cZO5MiIismdmDzdff/01Jk2ahJkzZyIxMREtWrRAZGQkrl+/bvT8gwcP4rnnnsOIESNw9OhR9O/fH/3798fJkyf15yxatAgfffQRVq5ciYSEBFSpUgWRkZF48OCBud8O5clMhucvb0J6OBNc8XABv6W9fODv4SpvbUREZNfMHm6WLFmCUaNGYfjw4WjcuDFWrlwJNzc3rFmzxuj5H374IaKiojB58mQ0atQIc+fORevWrfHxxx8DyO21WbZsGd5++23069cPzZs3x4YNG5CSkoKtW7ea++1QnowkQOgMdjlIOvQNypapICIiolwO5rx4Tk4Ojhw5gmnTpun3KRQKREREID4+3uhr4uPjMWnSJIN9kZGR+uBy8eJFqFQqRERE6I97eHggLCwM8fHxGDJkSKFrZmdnIzv70S/drKwsAIBarYZarS7z+zO3vNqsskb3OnCQFJDyBRwhKaFxrw1YY72lZNVtb8PY7vJgu8uD7V56JW0rs4ab9PR0aLVa+Pr6Guz39fXF2bNnjb5GpVIZPV+lUumP5+0zdU5BCxYswOzZswvt3717N9zcrH98SGxsrNwlGFU7aDhaXlkNCYBWSDheexiu/H4MwDF5C6tA1tr2to7tLg+2uzzY7iV3717JJqyYNdxYi2nTphn0BmVlZSEoKAg9e/aEu7u7jJUVTa1WIzY2Fj169ICjo6Pc5RjRG9pF38BBfRtjHWbhf31HoKmHi9xFVQjrb3vbxHaXB9tdHmz30su781Ics4YbHx8fKJVKpKWlGexPS0uDn5+f0df4+fkVeX7en2lpafD39zc4p2XLlkav6ezsDGdn50L7HR0dK8UHyprrvK+T4ADg/D03dP1gPxYMbIbB7WrLXVaFsea2t2Vsd3mw3eXBdi+5kraTWQcUOzk5oU2bNoiLi9Pv0+l0iIuLQ3h4uNHXhIeHG5wP5HbZ5Z1ft25d+Pn5GZyTlZWFhIQEk9ck80jNvI8HmkdjbriIHxERWQOzz5aaNGkSvvjiC6xfvx5nzpzBmDFjcPfuXQwfPhwAEB0dbTDgeMKECYiJicEHH3yAs2fPYtasWfjzzz8xbtw4AIAkSZg4cSLeffddbNu2DSdOnEB0dDQCAgLQv39/c78dyudi+l0AueHGB7cAcBE/IiKSn9nH3AwePBg3btzAjBkzoFKp0LJlS8TExOgHBF+5cgUKxaOM1aFDB2zatAlvv/02pk+fjsceewxbt25F06ZN9edMmTIFd+/exejRo3Hr1i106tQJMTExcHGxjfEelUVj1Y/wQG6Q2eQ0H9M0I/G9rhsX8SMiIllZZEDxuHHj9D0vBe3du7fQvmeeeQbPPPOMyetJkoQ5c+Zgzpw5FVUildbDRfzwcBE/5cNF/Dp1f5aL+BERkaz4bCkqGy7iR0REVorhhsrGKxSQDD8+QlICXiEyFURERJSL4YbKxiMQeOpDiIebWiEhvet7ufuJiIhkxHBDZdc6GirvxwEAizSDERYTgK8PX5G5KCIisncMN1RmqZn3EX89d0y6gMR1boiIyCow3FCZXUy/iyyRO+27oeIK/HCT69wQEZHsGG6ozOr6VEGQdB0AMFB5AAecx2OIci/XuSEiIlkx3FCZ+SMD3ZR/6beVksB8p1XwR4aMVRERkb1juKGyy0iCpJ8vlUshdEDGBZkKIiIiYrih8vAKhX6J4jxc64aIiGTGcENl5xEIdJ2q39RBATy1jGvdEBGRrBhuqHzaj9b/9VWvz5EaavqZYERERJbAcEPl41odOZIzAOBU6m10XLiHC/kREZGsGG6oXFKzHiBZ6wkA8EMGF/IjIiLZMdxQuVxMvwuV8AYAPKE4zoX8iIhIdgw3VC51farARcoBALzm+CMX8iMiItkx3FC5+CMDLRVJ+m0u5EdERHJjuKHy4UJ+RERkZRhuqHy8QgGJC/kREZH1YLih8vEIBHrO129qocCtiPe5kB8REcmG4YbKL3ws7indAQDDs99E65/8uNYNERHJhuGGyi018z5OqgMAANWlO1zrhoiIZMVwQ+V2Mf0uzutyw00X5V9c64aIiGTFcEPlVtenCtyl3CAzUHmAa90QEZGsGG6o3PyRgT7KBP0217ohIiI5MdxQ+XGtGyIisiIMN1R+XqGAVOCjxLVuiIhIJgw3VH4egcBTH+r7bnRCQlYPrnVDRETyYLihitE6GlKH8QCAX3St8GVOF04FJyIiWTDcUMUJ7QYAaChdxaKYc+i4cA8X8yMiIotjuKEKo6raCABQW3EDXsjiYn5ERCQLhhuqMBfuOOgX8xus/JWL+RERkSwYbqjC1PWpgluoAgB4y/FrLuZHRESyYLihCuOPDLRRnNdvczE/IiKSA8MNVRwu5kdERFaA4YYqjpHF/AQX8yMiIgszW7jJyMjA0KFD4e7uDk9PT4wYMQJ37twp8vzXXnsNDRo0gKurK2rXro3x48cjMzPT4DxJkgp9bd682Vxvg0pDv5ifBCB3Mb/E5jOQCi+ZCyMiInviYK4LDx06FKmpqYiNjYVarcbw4cMxevRobNq0yej5KSkpSElJweLFi9G4cWNcvnwZr7zyClJSUvDdd98ZnLt27VpERUXptz09Pc31Nqi0WkdDyr4N7JqOMyIIgxIeg+LQHiwY2AyD29WWuzoiIrIDZgk3Z86cQUxMDA4fPoy2bdsCAJYvX47evXtj8eLFCAgIKPSapk2b4vvvv9dvh4aGYt68eXjhhReg0Wjg4PCoVE9PT/j5+ZmjdKoAabV7wRfT0Ui6Cg/cQaaoiulbTqJz/Rrw93CVuzwiIrJxZgk38fHx8PT01AcbAIiIiIBCoUBCQgIGDBhQoutkZmbC3d3dINgAwKuvvoqRI0ciJCQEr7zyCoYPHw5JkkxeJzs7G9nZ2frtrKwsAIBarYZarS7NW7OovNqsuUZj/r5TBZm6QNRXJOMl5S58o+0KlfBGUloWfNzM1llYoSpr21d2bHd5sN3lwXYvvZK2lVl+06hUKtSsWdPwGzk4wMvLCyqVqkTXSE9Px9y5czF69GiD/XPmzEG3bt3g5uaG3bt3Y+zYsbhz5w7Gjx9v8loLFizA7NmzC+3fvXs33Nysfw2W2NhYuUsolVvZgCQ8UR/JmOT4PSY4bMF0zUgkHdPg5hm5qyudytb2toLtLg+2uzzY7iV3717JFoWVhBCi+NNyTZ06Fe+9916R55w5cwZbtmzB+vXrce7cOYNjNWvWxOzZszFmzJgir5GVlYUePXrAy8sL27Ztg6Ojo8lzZ8yYgbVr1+Lq1asmzzHWcxMUFIT09HS4u7sXWYuc1Go1YmNj0aNHjyLbwOpkpcBheQuDaeE6KKB97RjgXviWpDWqtG1fybHd5cF2lwfbvfSysrLg4+Ojv7NjSql6bt544w0MGzasyHNCQkLg5+eH69evG+zXaDTIyMgodqzM7du3ERUVhWrVquGHH34o9j94WFgY5s6di+zsbDg7Oxs9x9nZ2egxR0fHSvGBqix16mVdBgqudwMdFFlXAO868tRURpWu7W0E210ebPcKtqIDcOMMUKMR8OpBk6ex3UuupO1UqnBTo0YN1KhRo9jzwsPDcevWLRw5cgRt2rQBAOzZswc6nQ5hYWEmX5eVlYXIyEg4Oztj27ZtcHFxKfZ7HTt2DNWrVzcZbEgGeevdCJ1+l5CUkLjeDRHZi1kej/5+41Tu9qxM0+dThTLLOjeNGjVCVFQURo0ahUOHDuHAgQMYN24chgwZop8plZycjIYNG+LQoUMAcoNNz549cffuXaxevRpZWVlQqVRQqVTQarUAgO3bt2PVqlU4efIkzp8/j08//RTz58/Ha6+9Zo63QWX1cL2bvAX9hAC21prM9W6IyD6s6FC6/VThzDZ1ZePGjRg3bhy6d+8OhUKBQYMG4aOPPtIfV6vVOHfunH5wUGJiIhISEgAA9erVM7jWxYsXERwcDEdHR6xYsQKvv/46hBCoV68elixZglGjRpnrbVBZtY4GAttA+2lHKCWBped9cW0h17shIjtw41Tp9lOFM1u48fLyMrlgHwAEBwcj/1jmrl27orixzVFRUQaL95F1S3UJQZKuCTopTqKX4hA+0z7F9W6IyLYd/FjuCgh8thSZ0cX0u9ipbQ8A6Ks8iHDFKdQQ6biUXrKpfERElc6eeXJXQGC4ITOq61MFsbq20AmgieIyvnKahwPO49FItVXu0oiIzENTxD/eGg+0XB12juGGzMbfwxVv93oM+deOVkoCnr9MBjKTZauLiMgsjm4s+vizay1TBzHckHn1DXqAQk/GEFog44Is9RARmU3sLNPHlNa/Gr4tYbgh88pb8yY/SQlwzRsisjX3rps+1nGc5eoghhsys4dr3uTNg9MJ4M/mM7jmDRHZluJmSXX7n2XqIAAMN2QJraMh9VsBAPgXVTEkoS46LtyDrw9fkbkwIqIK8vsy08eq17VYGZSL4YYsIjW4H24ID3hLd/Ck4hh0Api+5SRSM+/LXRoRUfndu2H6WNRCy9VBABhuyEIuZmRji7YTAOAFZSzXvCEi21Hk2jYS0ICLz1qa2VYoJsqvrk8VzNJ1wcv4GZ0VJ9BFeQJaIeG2Sg2EjpC7PCKisvvtA9PHwl6xXB2kx54bsgh/D1eMi2oFIaCfGs41b4io0jsXk7u8hSm9eEtKDgw3ZDFc84aIbM7+Inpt/FtarAwyxHBDlmNkzRshKZDmGCBTQURE5ZR8yPSxrtMsVwcZYLghy9GveZPbfSME8FbOCISvOMtp4URU+RS1to3CkQOJZcRwQ5bVOhrpz+2ARiggScApXV1OCyeiyilutuljEbMsVgYVxnBDFvePQ338rHscADDcIQYAoBWC08KJqPI4FwNoc0wf78DHLciJ4YYsrq5PFazV5nbXPqU4gChFAgKlDAT78MFyRFRJbHvN9LGmgyxXBxnFcEMW5+/hiucGDMAlXU04S1qsdPoQvzmPh3/St3KXRkRUvGtHgLtFPCTz8VctVwsZxXBDshhcX4k6ikfLlSugA7ZP5Jo3RGT9vh1m+ph7baBWG4uVQsYx3JA8MpIg6Z8V/hDXvCEia3ftCJBZxOzOZ9dZrBQyjeGG5GFkzRsduOYNEVm570eaPsZeG6vBcEPyeLjmDSSlftcOTTuueUNE1uvaEeDfInqX2WtjNRhuSD6to5E24jA+1TwFAHhceQbO4gHXvCEi67Rruulj1UPZa2NFGG5IVknZHliseRaXdL7wkbIwRrkN7aWTSLmcJHdpRESPZCYDV/8wfXzQF5arhYrFcEOyqutTBUJS4mNtfwDAaw5b8ZXTPLT+4QkgcYO8xRER5dkxxfQx9tpYHYYbkpW/hysWDGyGBF1jCAH9U8MlwanhRGQlMpMhzv5k+jh7bawOww3JbnC72tg6NFAfbPQ4NZyIrMCJxb0K/3zKw14bq8RwQ1bBO6hx4anhEqeGE5G8oud8iqaKy0aPCQH22lgphhuyDvqp4bkfSSGAD3Ke5tRwIpJNauZ9zFQvNdlrc0JXh702VorhhqxH62ikjfgTR7WhkCSgueICdAKcGk5Eshj//iqEKNKMHhMCiG+33MIVUUkx3JBVScr2wGTNy9AIBSKVf6KXlMCp4URkcXFnVHhfWma010YIYK2mJ17u28XyhVGJMNyQVanrUwUXUAubtU8CAD5x+pBTw4nI4s58OQV1FOlGj93SueK/8761cEVUGgw3ZFXypoZv1kZwajgRyeKn3w5hrMOPJnttdtSbZfGaqHQYbsjqDG5XG+uHPsap4UQki5xds6AwMYhYpXPH0JdesWxBVGoMN2SVjE4N51PDicjMXvjge/RXHjB6TAjgauRqC1dEZcFwQ9apwNRwAPhM3YdTw4nIbP66+i8WZE422WtzXKqH9p16WrYoKhOzhZuMjAwMHToU7u7u8PT0xIgRI3Dnzp0iX9O1a1dIkmTw9corht1/V65cQZ8+feDm5oaaNWti8uTJ0Gg05nobJKeHU8P3aFsCACKUiXAQak4NJyKzOPbZy6gl3TR6TAigxevbLFwRlZXZws3QoUNx6tQpxMbG4qeffsL+/fsxevToYl83atQopKam6r8WLVqkP6bVatGnTx/k5OTg4MGDWL9+PdatW4cZM2aY622QzJKyPTBRPRY3hDseUyRjkvIbTg0nogr37qbdiFbuMjmI+GLjV3J7lKlSMEu4OXPmDGJiYrBq1SqEhYWhU6dOWL58OTZv3oyUlJQiX+vm5gY/Pz/9l7u7u/7Y7t27cfr0aXz55Zdo2bIlevXqhblz52LFihXIyckxx1shmdX1qYI7UlXMVUcDAF52+JlTw4moQqVm3kffM5NNrkT8t1QLIYPfs2xRVC4O5rhofHw8PD090bZtW/2+iIgIKBQKJCQkYMCAASZfu3HjRnz55Zfw8/PDU089hXfeeQdubm766zZr1gy+vr768yMjIzFmzBicOnUKrVq1MnrN7OxsZGdn67ezsrIAAGq1Gmq1ulzv1ZzyarPmGs3Nx80B7/ZrjI9/TC80NVxsnwhNnS6Ae8UPMmbby4PtLg97b/efl47FCMUlo8eEAKoO32KWtrH3di+LkraVWcKNSqVCzZo1Db+RgwO8vLygUqlMvu75559HnTp1EBAQgOPHj+Ott97CuXPnsGXLFv118wcbAPrtoq67YMECzJ49u9D+3bt364OTNYuNjZW7BFlVATCzfgqkAs+uk4QWW77bjAfVG8LT2Tzf297bXi5sd3nYY7vHnf8Xy8QWk7ejtrr0heKvs8BfZ81Wgz22e1ndu3evROeVKtxMnToV771XdNfcmTNnSnNJA/nH5DRr1gz+/v7o3r07kpKSEBoaWubrTps2DZMmTdJvZ2VlISgoCD179jS47WVt1Go1YmNj0aNHDzg6OspdjryyWkJ8vCh3Mb+HtELC0ov+uH4pt3fnmTa1Kuzbse3lwXaXh722e2rmAzgd7g+Fid+Ep6Vg/OfNNWb7/vba7uWRd+elOKUKN2+88QaGDRtW5DkhISHw8/PD9evXDfZrNBpkZGTAz8+vxN8vLCwMAHD+/HmEhobCz88Phw4dMjgnLS33oWZFXdfZ2RnOzoX/ae/o6FgpPlCVpU6z8q6TOzV8+8TcxfwAqER13IQHdAJ458czeLKRH/w9XCv027Lt5cF2l4e9tfvOL97EaOWfRo8JAfiM2mKR9rC3di+PkrZTqcJNjRo1UKNGjWLPCw8Px61bt3DkyBG0aZP7OPg9e/ZAp9PpA0tJHDt2DADg7++vv+68efNw/fp1/W2v2NhYuLu7o3HjxqV5K1QZtY4GQrvj7JFf4btvMgIVGZjg8D0WawZDKwQupd+r8HBDRLZp5bZ9GP1gncnbUft8o9G1VtnvGJC8zDJbqlGjRoiKisKoUaNw6NAhHDhwAOPGjcOQIUMQEJA7+DM5ORkNGzbU98QkJSVh7ty5OHLkCC5duoRt27YhOjoanTt3RvPmzQEAPXv2ROPGjfHiiy/ir7/+wq5du/D222/j1VdfNdozQzbIIxAebQZhuib3FuYY5Y94SRGDAOkmgn2sf/wUEckvNfM+uhwea3KxvhNSPXQdu9yyRVGFMts6Nxs3bkTDhg3RvXt39O7dG506dcLnn3+uP65Wq3Hu3Dn94CAnJyf88ssv6NmzJxo2bIg33ngDgwYNwvbt2/WvUSqV+Omnn6BUKhEeHo4XXngB0dHRmDNnjrneBlkhfw9XdO0/An/qHoNSAmY7bcDvzuPhn8Sn9BJR8c4v7Y2GimtGj+kE4DvyGwtXRBXNLLOlAMDLywubNm0yeTw4OBhCCP12UFAQ9u3bV+x169Spgx07dlRIjVR5Da6vhFAmAQ8/QgoI6LZPQKJDKwTWqcfbU0Rk1Ifrv8J4kWjydtR+3o6yCXy2FFVOGUkGM6cAQCF0WLw5Bh0X7uHzp4iokM/2JyHq/ByTweaI1JS3o2wEww1VTl6hhZ4aLgTgJu5DJ8DnTxGRgdTM+3DcNRX1FcZXyf9bCkLbWcafBk6VD8MNVU76p4YrAUC/evEcp/XwxG397CkiIgCIW/EahjvsNtlr4znyR8sXRWbDcEOVV+toYOIJ3Hz6e/TMWYSLOl/UktKxwvFDdFScRIjzLbkrJCIrsPvz6Ria/a3JYBMfOBy+HGdjUxhuqHLzCIR30wiMHNgL4zSvQy2U6Kg8jY1O81FzdVs+XJPIzn25+yAikleYfCjmOccG6DB6mUVrIvNjuCGbMLhdbawZ2xMO0qNBxnkP1/zz+AmOvyGyQ6mZ99Hot3Em17PRAWj42g8WrYksg+GGbIavOhkShME+SWg5g4rITsV/PAKtFUlGjwkB3H5iRu74PbI5DDdkO0zMoMrUuXEGFZGd2bL4ZQzI+bmIcTbD4NH9DcsXRhbBcEO2w8QMqrlO6+CMHM6gIrITuz+fjgG3N5sMNjFV+qLD6A8tXxhZDMMN2ZZ8M6iGqN9GpnBDW8XfWOb4MTpwBhWRzdvw3fcmBxALAfzp1A69pvyf5Qsji2K4IdvzcAbVwAGDMU49AVohoZfyT2ziDCoimxazYRFeOPFfkwOIf3N4HO3+94tliyJZMNyQzRrcrjYWj33G4AcdZ1AR2aZPt+1Dz6R5pmdGCaDB8E8sWxTJhuGGbBpnUBHZvvd3nYXvoYUmg40QQELoRC7UZ0cYbsi2mZhB5SlucwYVkQ14f9dZeO+fgQHKg0aP582MCo+ebeHKSE4MN2TbTMygWuT0OZ6Q/kJ76SRSLhtfB4OIrNtn+5PQ6reXMdxhV5FTvjkzyv44yF0Akdm1jgZCu+Pm1TMYtPEy3nP8HGGKs9jg9B4kCRA/LAA0H+aeR0SVQt5Tvrs7HGOwoULYc0P24eEMqjEDe+Bt9Qh9Dw7AQcZElU1q5n388nHRT/lmsLFv7LkhuzK4XW1EuNaF9J3h/rxBxodEYywY2AwDW/rLUyARFenrw1eQtvUdvOaw1WSwOeL3DIONnWPPDdkd76DGRgcZZwvHfIOMH8hUHRGZ8tfVf4sNNknVO6DtmFWWL46sCsMN2R8Tg4yXOy1HK+kftJdOQnXtgsxFElF+Xx++gn0rJxYZbP6oMQj1Ju60fHFkdXhbiuxTvkHGwzeexjLHFQhRqLDFaWbuIOMfF+BY0HAAveWulMjuFddjAwAHq3ZDx3FrLFsYWS323JD9ejjIeOjA/pioHldokHGLK2uRePI0BxkTyai4HhsAEAA6jv7YonWRdWO4Ibs3uF1trB3asNAPTgV0WPrtbq5kTCSTkvTY6ABIfZfn3m4meojhhgimBxnXwL9cyZhIBl/uOoikz4YWOcbmpHcUFK+f5hpVVAjDDRFgcpDxB44r0UfxB2qIdGScjAMyk2UulMj2xf/fTDx/sBcGOhwoch2bpq99zR4bMooDiony5BtkPHDjFUxx+Ap9lIew3PEjABIUsQL4RZEbgvgvRSKzUP0wHY+fX2F6fA0X6KMSYM8NUX4PBxm/3O9JjFe/hm81T0AhAQrp4ZPFhQ5i+wSkXePzqIgq2pE1k+B7jMGGyo/hhsiIZ9rUwozWAg17jix0TBI6TPxkCwcZE1Wgg59PQOvLq4sMNonBIxhsqEQYbohM8HQGGjZpZXSg8V2dE6Zv4bOoiMorNfM+Yj56FeHJ60zPiBJAavtpaDN8iWWLo0qL4YaoKO4BwFMfQjwMOHkDjVc7f4An8SeuH4/lIGOiMvpsXxK+XfQKIm9+aXLg8BZNR2zqsBMBfaZavkCqtDigmKg4raNxvWZHTPxkC+7rHLHAaTUaKa7gC6clkOIAsUeBzIjFOO3XD3V9qsDfw1Xuioms3qfb9qHaoQ8x2iHOZLBZrukP58gZeLlzqOULpEqN4YaoBHxrhaL/gMGYvuUkxuaMxx7nNw1WM662+01MynbEdckbCwY2w+B2teUtmMhKpWbeR8KXszD6+kooTfwGEgLY7f0CnnlpMf+xQGXCcENUQoPb1Ubn+jWQcTIOUqzhMaWkQ2vFP9ih88b0LSfRuX4N/lAmKuCzfUnI3j2n6EcpPJwRFcmBw1QOHHNDVAr+Hq5o0rTwIGMAmOe4Cp0Vf3HBPyIjPt22D1ViJxcbbDgjiioCe26ISitvNePtEwGhhVZISBVeqKW4iXWO7wEAFLGA+EWBpLB5qBI+nL04ZNd+XfM2Rl9ebvI2FJD7jKjbnWegTfc3LFYX2S723BCVRetoYOIJ4KWf8HP33eihXoItmo4PF/zLPUUSOgTH/w+DFn7LNXHIbh38fAK6Xl4OZRG9NUdrDoDi9dPwYLChCmK2cJORkYGhQ4fC3d0dnp6eGDFiBO7cuWPy/EuXLkGSJKNf3377rf48Y8c3b95srrdBZJpHIFD3CfTt3B57pkaiQa+xhU5xkHSoLaXxwZtkV1Iz7+OXPxLx+5IXily/Ju82VKux6/iMKKpQZrstNXToUKSmpiI2NhZqtRrDhw/H6NGjsWnTJqPnBwUFITU11WDf559/jvfffx+9evUy2L927VpERUXptz09PSu8fqLS8PdwhX/TVrnPnhI6g2MvKWNwU10NGSfjcs/hD3GyYZ/tS0L67vcx1eGr3N4aUwvzgbehyHzMEm7OnDmDmJgYHD58GG3btgUALF++HL1798bixYsREBBQ6DVKpRJ+fn4G+3744Qc8++yzqFq1qsF+T0/PQucSye7hWByxfSIkoYVOSAAEein/RJTiT0gch0M2rri1a4Dc3ppjvgPQaug8eDDok5mYJdzEx8fD09NTH2wAICIiAgqFAgkJCRgwYECx1zhy5AiOHTuGFStWFDr26quvYuTIkQgJCcErr7yC4cOHQzL1fxKA7OxsZGdn67ezsrIAAGq1Gmq1ujRvzaLyarPmGm1Vmdu+2XNAnS7Y90cCZvz+AE1wAZ87LTVYE6du/P/wxL6qGNfvCTzTplYFV1658TMvj/K2e2rmA5z4dh5Gqz4tctCwEEB8wEto998PoM79hmX6fraCn/fSK2lbmSXcqFQq1KxZ0/AbOTjAy8sLKpWqRNdYvXo1GjVqhA4dOhjsnzNnDrp16wY3Nzfs3r0bY8eOxZ07dzB+/HiT11qwYAFmz55daP/u3bvh5uZWonrkFBsbW/xJZBZlb3tnvNzKGS7/ukAyvNsKpaRDX8UB/G+rF9RXjsPTudxl2hx+5uVRlnY/cuVf1E/7EUOVe0z21gCAVgDbqw6B5NcdO3bsKEeVtoef95K7d+9eic4rVbiZOnUq3nvvvSLPOXPmTGkuadT9+/exadMmvPPOO4WO5d/XqlUr3L17F++//36R4WbatGmYNGmSfjsrKwtBQUHo2bMn3N3dy12vuajVasTGxqJHjx5wdHSUuxy7UmFtn9US4uP3IBUYhzPVcTMaKK4iQxqN3o3ccd0pEBeyPVHH2w3+Hi7lrL7y4mdeHmVp9+vJF3B++weYmf51sb01iTX6w+8/09EnMKSCKrYN/LyXXt6dl+KUKty88cYbGDZsWJHnhISEwM/PD9evXzfYr9FokJGRUaKxMt999x3u3buH6OjoYs8NCwvD3LlzkZ2dDWdn4/8EdnZ2NnrM0dGxUnygKkudtqjcbe9dx2AcjlYocEDXBB0VJzFAeQDi5AFIpwA/IeFDzUh8p3uSj28AP/NyKVG7Zybj2HcL0OzK/yGwiAHDAAcNlxQ/7yVX0nYqVbipUaMGatSoUex54eHhuHXrFo4cOYI2bdoAAPbs2QOdToewsLBiX7969Wr07du3RN/r2LFjqF69uslgQyS71tGQQrtjT/wfeGffPSQLL3RXJGKV02J9N75SEljgsAr7s5vz8Q1klVIz7+Pf2MVoeHIxWgJFhhohgNOBg9Bk8FwOGiZZmGXMTaNGjRAVFYVRo0Zh5cqVUKvVGDduHIYMGaKfKZWcnIzu3btjw4YNaN++vf6158+fx/79+43ek92+fTvS0tLw+OOPw8XFBbGxsZg/fz7efPNNc7wNoorjEYhuUYPQKPw+LqXfQ/37TpC+MzxFKQnMdlyHKeqXkXL5PPyr/Qt4hXLqOMkqNfM+vtuTgOpHPsJQpelZUHnyemuasLeGZGS2dW42btyIcePGoXv37lAoFBg0aBA++ugj/XG1Wo1z584VGhy0Zs0a1KpVCz179ix0TUdHR6xYsQKvv/46hBCoV68elixZglGjRpnrbRBVKH8P19wemczGuc+nKjAWJ1J5BB0Vr8FtSw4AAQEFMnsshmfHEfIUTHbty10Hcfe3jzFW+XOR42qA3AHDJ+pEo+WgqeytIdmZLdx4eXmZXLAPAIKDgyGEKLR//vz5mD9/vtHXREVFGSzeR1RpFXg+lUYosFrbC90ViaineDS9SoIOVXe/iW3aZujbub3p6xFVoLRrSTi3dRGeu7G5RKHmQI3n0KD/ZLSsFWqZAomKwQdnEsmldTQQ2h3IuICbjgFonu2J6ncPA1sGG5zmIOlwKGYjmgZ4IESZhjTHQCRle6CuTxWOy6EKdT35Aq7uXIZ2qk3wLWawsBDARm03oPNkvNCzg+kTiWTAcEMkJ49AwCMQvgB8ASCzGQQUkGB4u+pdp3UQ/7cOkAAfIeEDzqyiCnQ9+QIcT38Fv8Sdxc6AAnJ7a/YGjUP3Z95mwCarxKeCE1kTj0Bk9lgMjcj9X1MrJBzThkAIFJpZVVPc5AM5qVzSriXhj0/HwG9te/TO3mnyyd15dJCQVO+/SB+ViO4j5zHYkNVizw2RlfHsOALbtM2wOWY/LuhqIlSRho3Kdw3OUUoCSx0/wSzNS7hw/m84OV/HRZ0fAuvU4y8cKl6+tWqKu/0EGA4WDuVgYaoEGG6IrFDfzu3RrkUzXEq/hxDnW8Dq+YVmVoUrz2CXcirEttxeHU8h4X+akWjVfzxvVVFhmclARhIyLxxGtd/moiVEiULNIb+hCHnqDQ4WpkqF4YbISumnjcO70Myq5ZoBaK5IQjflMYPbVfMcVqHzlqbo6v8EfNXJHHxMuaEm4VOIgx9DgoB7vlucpuQPNeEMNVQJMdwQVQYFZlY9nu2J+vcTIX33tMFpSkngZ8dpcF91H4Dg4GM7lZp5H8mXz6P23xtQ4+QXkCD0nTTFPdySoYZsAcMNUWVRaGZVYwhJYfBQTiEAT8WjhTELPtahq78aDrcucHyOjUq7loRffjuIyycP4C2HzVBKhdcSM0YrgB3OvdH6+VkID25g5iqJzI/hhqiy8giE9NSH0G2fAIXQQSMU+D9tTwx3iDE4TSkJrHF6H0d19VBj1V4ooOP4HFuSmYybV0/j2B+/ouvVTzBUEhAORffQ5M2+0woJq7S94dJpDDyzM1CTT+0mG8FwQ1SZtY6GIrQ7bl49g0s6P/T2cgVW7zYYfCwE0FhxBY0VV/T7lJLAuw6r0WVLC3T178DenEoo7VoSNAc+gf+Z1fCGQLd8Y2mKCjYaIeE9zXM4IULQsV17PN2tPXzcHIw+z4+osmK4IarsPALh7REI77ztAoOPF2mGoIHiKgYpfzN4mYOkw2KHj1Fj1WtQQLA3pzIo0EuT/7ZTSQYJr9L2wXptFP7TqR2WdgrWB1m1Wm3OqoksjuGGyNYUGHz8ZLYnQpxvQaxuazA+BwDClWf1f8+dbbUaT2xpjs71n4HidgpuXD6NGnUaw5eDS2WRNzDY8/4VKFXHUefoInhDZ9BLY0r+W0+rtX3g1vlVNA9tgO993Ng7RzaP4YbIFhUcfPxwOnne+BytUOCArjE6K08avEwp6fCZwwc4ufw7dFPvh68koBUSDjWfhfaDJiI18z4upt/l1HIzygs0qRdO4cThvfqBwaIEt53yztEIBfYFjUWd5h2R6VIbT9UJ5X8vsisMN0T2osD4nAZerkZ7c5opL6GZ5pJ+gTelJNDm+Cx8omyBLxOuoo6kwmXhhwkDu/L2VQUxFmjaSgL/cSjZOBogdyzNIs1zqN20I3o8EY7u7G0jO8ZwQ2RPjIzPyT/baonmGXTwuYtOmT8ZvEwpCQw7+izGOOXob3X8b+tIdK4/l7evSiEvxNRVqKDxDMHVjHtlDjT5bzudqPMitG1fxnD20BABYLghsm8FenNerBMKxe0UaL/42WCwqhCAm5Sj385dP+cL/LV0P5qLvwvdvkq7lsTA85Cp20w6AdQAoJBQ6kCTN1A8r5eGj0YgMsRwQ2TvCvbmeITiUPNZaH18Nhyk3B6dU0HPocW1jQYvkySgJc4Z3L5qe3wmDp7dicdzEoyO18nrtfAOapw7LsiG5A90AHDj8mkcu+ONk/u3YJ7DqkK9Mop8IaakgeZ9zRA0ad8VgXWbsJeGqAgMN0RUSPtBE5EW9hTSL5+FT52GaFHNBWLpV5CQb/0cSJBguAKuQgI6qP8oFHg2XLiIrFv/YozDttzBsVBA6vsh0mp2NOjhSc18gNSb/yLjVBx86zazugBk0CNVzQU3r57GRZ0f7pzajSfOzoWvJKATEgABXwloIgCUYtxMnrxAo4MCV9pMgcavBTJdamMYAw1RiTDcEJFRvrVCDW4pSX0/hNg+EZLQQkhKZHX6H6run2tw+0onDHskgNzt6LvrAMdH+yToILa9hhoC8H04bmRDjddxOvU25jmsgvLKowCUGvqMQY9PKrxwMf0uQp0zDR4OmrcNr1CkwqvErzFYwBAZ+sBScLtggNFJAt4AqotH7zP3z5KvPZNfwUBTLaQdvIMaIdjKAh5RZcBwQ0Ql0zoa0sP1cySvEHh4BOLQLaXB7avD9caj/fkPCwQeCWd1tdBYedXgchJg8ETzF28sMezlgA66beOxX/MdnlHuh0IS0EHCMvVICAALHFYBUu7DQfdrOyFM+TvwsFfogKYjBih/zx3bAgU+VI+AzsRrlFLuAoY/aDthoMMBeD98PMVebQv4OvwFbwhUF4b15g8wBcNccfQhRuT2e+XVyEBDVHEYboio5B6un5On4O2r8FqhOPR9dYPA83ujtzH9rxr4TTG+yAc5GuvlUEBgsMM+g+2FDl8YnK+UBJ5W/mYQigbl21ZAh/kOXxQKU/lfo5RE7mvwaLu7w7FH37eUASY/nci9medQIMRoPOviWsZ9BCtUDDREFYzhhojKpeDtq4KBp2utUEwIvYL/bR2Fdx1WwUHSQQcFIHQGoUErcsfw5N8njKzEaywEFXeOsXBSkuuWlEGAydcjkxfuqjWONBpifGsBQNOyf2MiMorhhogqXMHAM7hdbXSuPwd/XX5J/0v+0C/fGvTwfB/wJo5e+RfvOqzWB6CFmiF4y+Ergx6fkoSggtt5g3xL8xpj18gfYCDl9iRphAJva0aiaZcBaFXlX/jUaQgABuEuF0MMkaUw3BCRRfh7uMK/eVPk/ZIv2MMzuFYowtNvY9W2phjQ2h++dZsi9G8t/re1qkGPz/80I6GDwPyHIUgjFPhB2xEDlAdyz5EU2KLphP7K3/WvmV7MazRCga3aThjo8DsUML5dMMDkzpbKXR9ogpFZTPa+vg+RnBhuiEg2BXt4/D1c4O9dHV5NugGOjhjcDoV6fCbAC5fS7+Gm8xj4qlNw0zEAtbI9cdP5FnzVKVB4haAjvPDX5aQSvcbh1kVc0vmhY51QKJChDywFt40FGIP1gYjIajDcEJFVK9jj4/9wH+ANINTw4aAIfXROSV9TKzRfQCmwoGGhbSKqDBRyF0BERERUkRhuiIiIyKYw3BAREZFNYbghIiIim8JwQ0RERDaF4YaIiIhsCsMNERER2RSGGyIiIrIpDDdERERkUxhuiIiIyKYw3BAREZFNsctnSwkhAABZWVkyV1I0tVqNe/fuISsrC46OjnKXY1fY9vJgu8uD7S4Ptnvp5f3ezvs9bopdhpvbt28DAIKCgmSuhIiIiErr9u3b8PDwMHlcEsXFHxuk0+mQkpKCatWqQZIkucsxKSsrC0FBQbh69Src3d3lLseusO3lwXaXB9tdHmz30hNC4Pbt2wgICIBCYXpkjV323CgUCtSqVUvuMkrM3d2dH3yZsO3lwXaXB9tdHmz30imqxyYPBxQTERGRTWG4ISIiIpvCcGPFnJ2dMXPmTDg7O8tdit1h28uD7S4Ptrs82O7mY5cDiomIiMh2seeGiIiIbArDDREREdkUhhsiIiKyKQw3REREZFMYbqzMvHnz0KFDB7i5ucHT07NErxFCYMaMGfD394erqysiIiLwzz//mLdQG5ORkYGhQ4fC3d0dnp6eGDFiBO7cuVPka7p27QpJkgy+XnnlFQtVXHmtWLECwcHBcHFxQVhYGA4dOlTk+d9++y0aNmwIFxcXNGvWDDt27LBQpbalNO2+bt26Qp9tFxcXC1ZrG/bv34+nnnoKAQEBkCQJW7duLfY1e/fuRevWreHs7Ix69eph3bp1Zq/TFjHcWJmcnBw888wzGDNmTIlfs2jRInz00UdYuXIlEhISUKVKFURGRuLBgwdmrNS2DB06FKdOnUJsbCx++ukn7N+/H6NHjy72daNGjUJqaqr+a9GiRRaotvL6+uuvMWnSJMycOROJiYlo0aIFIiMjcf36daPnHzx4EM899xxGjBiBo0ePon///ujfvz9Onjxp4cort9K2O5C7am7+z/bly5ctWLFtuHv3Llq0aIEVK1aU6PyLFy+iT58+ePLJJ3Hs2DFMnDgRI0eOxK5du8xcqQ0SZJXWrl0rPDw8ij1Pp9MJPz8/8f777+v33bp1Szg7O4uvvvrKjBXajtOnTwsA4vDhw/p9O3fuFJIkieTkZJOv69Kli5gwYYIFKrQd7du3F6+++qp+W6vVioCAALFgwQKj5z/77LOiT58+BvvCwsLEyy+/bNY6bU1p272kP3+o5ACIH374ochzpkyZIpo0aWKwb/DgwSIyMtKMldkm9txUchcvXoRKpUJERIR+n4eHB8LCwhAfHy9jZZVHfHw8PD090bZtW/2+iIgIKBQKJCQkFPnajRs3wsfHB02bNsW0adNw7949c5dbaeXk5ODIkSMGn1WFQoGIiAiTn9X4+HiD8wEgMjKSn+1SKEu7A8CdO3dQp04dBAUFoV+/fjh16pQlyrVr/LxXHLt8cKYtUalUAABfX1+D/b6+vvpjVDSVSoWaNWsa7HNwcICXl1eRbfj888+jTp06CAgIwPHjx/HWW2/h3Llz2LJli7lLrpTS09Oh1WqNflbPnj1r9DUqlYqf7XIqS7s3aNAAa9asQfPmzZGZmYnFixejQ4cOOHXqVKV66HBlY+rznpWVhfv378PV1VWmyiof9txYwNSpUwsNziv4ZeqHDJWdudt99OjRiIyMRLNmzTB06FBs2LABP/zwA5KSkirwXRBZXnh4OKKjo9GyZUt06dIFW7ZsQY0aNfDZZ5/JXRpRibDnxgLeeOMNDBs2rMhzQkJCynRtPz8/AEBaWhr8/f31+9PS0tCyZcsyXdNWlLTd/fz8Cg2s1Gg0yMjI0LdvSYSFhQEAzp8/j9DQ0FLXa+t8fHygVCqRlpZmsD8tLc1kO/v5+ZXqfCqsLO1ekKOjI1q1aoXz58+bo0R6yNTn3d3dnb02pcRwYwE1atRAjRo1zHLtunXrws/PD3Fxcfowk5WVhYSEhFLNuLJFJW338PBw3Lp1C0eOHEGbNm0AAHv27IFOp9MHlpI4duwYABiETHrEyckJbdq0QVxcHPr37w8A0Ol0iIuLw7hx44y+Jjw8HHFxcZg4caJ+X2xsLMLDwy1QsW0oS7sXpNVqceLECfTu3duMlVJ4eHihpQ74eS8juUc0k6HLly+Lo0ePitmzZ4uqVauKo0ePiqNHj4rbt2/rz2nQoIHYsmWLfnvhwoXC09NT/Pjjj+L48eOiX79+om7duuL+/ftyvIVKKSoqSrRq1UokJCSI33//XTz22GPiueee0x+/du2aaNCggUhISBBCCHH+/HkxZ84c8eeff4qLFy+KH3/8UYSEhIjOnTvL9RYqhc2bNwtnZ2exbt06cfr0aTF69Gjh6ekpVCqVEEKIF198UUydOlV//oEDB4SDg4NYvHixOHPmjJg5c6ZwdHQUJ06ckOstVEqlbffZs2eLXbt2iaSkJHHkyBExZMgQ4eLiIk6dOiXXW6iUbt++rf8ZDkAsWbJEHD16VFy+fFkIIcTUqVPFiy++qD//woULws3NTUyePFmcOXNGrFixQiiVShETEyPXW6i0GG6szEsvvSQAFPr69ddf9ecAEGvXrtVv63Q68c477whfX1/h7OwsunfvLs6dO2f54iuxmzdviueee05UrVpVuLu7i+HDhxsEyosXLxr8d7hy5Yro3Lmz8PLyEs7OzqJevXpi8uTJIjMzU6Z3UHksX75c1K5dWzg5OYn27duLP/74Q3+sS5cu4qWXXjI4/5tvvhH169cXTk5OokmTJuLnn3+2cMW2oTTtPnHiRP25vr6+onfv3iIxMVGGqiu3X3/91ejP87y2fumll0SXLl0KvaZly5bCyclJhISEGPysp5KThBBCli4jIiIiIjPgbCkiIiKyKQw3REREZFMYboiIiMimMNwQERGRTWG4ISIiIpvCcENEREQ2heGGiIiIbArDDREREdkUhhsiIiKyKQw3REREZFMYboiIiMimMNwQERGRTfl/FKjO9NTok6oAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p_offres = (xc9+1j*yc9) + r09*np.exp(1j*(new_theta0+np.pi))\n", + "new_a = np.abs(p_offres)\n", + "new_alpha = np.angle(p_offres)\n", + "\n", + "linmag10 = linmag / new_a\n", + "phase10 = phase8 - new_alpha\n", + "data10 = linmag10 * np.exp(1j*phase10)\n", + "\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase5, '.-')\n", + "plt.plot(freq, phase10, '.-')\n", + "\n", + "plt.figure()\n", + "plt.plot(np.real(data5), np.imag(data5), '.-')\n", + "plt.plot(np.real(data10), np.imag(data10), '.-')\n", + "plt.axis('equal')\n", + "plt.grid()\n", + "\n", + "print(a, alpha)\n", + "print(new_a, new_alpha)\n", + "norm(data5-data10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Impedence mismatch and Q_ext" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circle fit: xc = 0.1082367697470622, yc = -0.007897708155741062, r0 = 0.8917982017391981\n", + "0.009885742546844512 (375.48504155892454+3.7120693760859074j) 3020.7122145551966 -0.22501111973535037\n", + "0.008856052161850097 (423.861932594991+3.7538415225015953j) 3494.7326181410813 -0.07977920910893826\n" + ] + } + ], + "source": [ + "xc11, yc11, r011 = fit_circle_algebraic(data10)\n", + "new_phi0 = -np.arcsin(yc11/r011)\n", + "\n", + "# FIXME: where does this come from?\n", + "new_Q_ext = new_Q_tot/(r011*np.exp(-1j*new_phi0)) # REFLECTION ONLY\n", + "new_Q_int = 1/(1/new_Q_tot-1/np.real(new_Q_ext))\n", + "\n", + "refl11 = S11_reflection(freq, new_a, new_alpha, new_tau, new_Q_tot, new_Q_ext, new_fr, new_phi0)\n", + "new_theta0 = phase[0] - np.unwrap(np.angle(refl11))[0]\n", + "\n", + "print(phi0, Q_ext, Q_int, theta0)\n", + "print(new_phi0, new_Q_ext, new_Q_int, new_theta0)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------\n", + "Q_total : 378.0141329369699\n", + "Q_external : (423.861932594991+3.7538415225015953j)\n", + "Q_internal : 3494.7326181410813\n", + "resonance freq [Hz] : 7720564877.30637\n", + "kappa_tot/2pi [Hz] : 20424011.180009764\n", + "kappa_external/2pi [Hz] : 18214810.728670772\n", + "kappa_internal/2pi [Hz] : 2209200.4513389906\n", + "Phi (Impedance mismatch) : 0.008856052161850097\n", + "\n" + ] + } + ], + "source": [ + "print(\n", + "\"-----------------------------------------\\n\" \\\n", + "+f\"Q_total : {new_Q_tot}\\n\" \\\n", + "+f\"Q_external : {new_Q_ext}\\n\" \\\n", + "+f\"Q_internal : {new_Q_int}\\n\" \\\n", + "+f\"resonance freq [Hz] : {new_fr}\\n\" \\\n", + "+f\"kappa_tot/2pi [Hz] : {new_fr/new_Q_tot}\\n\" \\\n", + "+f\"kappa_external/2pi [Hz] : {new_fr/np.real(new_Q_ext)}\\n\" \\\n", + "+f\"kappa_internal/2pi [Hz] : {new_fr/new_Q_int}\\n\" \\\n", + "+f\"Phi (Impedance mismatch) : {new_phi0}\\n\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(0.9937643817223956),\n", + " np.float64(0.13155076584920644),\n", + " np.float64(-3.1467292451105774e-10),\n", + " np.float64(378.0141329369699),\n", + " np.complex128(423.861932594991+3.7538415225015953j),\n", + " np.float64(7720564877.30637),\n", + " np.float64(0.008856052161850097))" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_a, new_alpha, new_tau, new_Q_tot, new_Q_ext, new_fr, new_phi0" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Fix 2n*pi phase offset\n", + "S11 = S11_reflection(freq, new_a, new_alpha, new_tau, new_Q_tot, new_Q_ext, new_fr, new_phi0)\n", + "\n", + "n = compute_global_2pi_shift(phase, np.unwrap(np.angle(S11)))\n", + "phase_fit = 2*n*np.pi + np.unwrap(np.angle(S11))\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, linmag, '.-')\n", + "plt.plot(freq, np.abs(S11))\n", + "\n", + "plt.figure()\n", + "plt.plot(freq, phase, '.-')\n", + "plt.plot(freq, phase_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Blushitting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vectorized S11" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t = np.linspace(1e-11, 1e-9, 10)\n", + "Q = np.linspace(1, 1e6, 10)\n", + "\n", + "# plt.plot(freq, S11_reflection_mesh(freq,a,alpha,tau,Q_tot,Q_ext,fr,phi0)[0])\n", + "\n", + "res = S11_reflection_mesh(freq,a,alpha,t,Q_tot,Q_ext,fr,phi0)\n", + "plt.imshow(np.angle(res), aspect='auto', extent=[freq[0], freq[-1], t[0], t[-1]],\n", + " origin='lower', cmap='viridis', interpolation='none')\n", + "\n", + "\n", + "# res = S11_reflection_mesh(freq,a,alpha,t[None,:],Q[None,:],Q_ext,fr,phi0)\n", + "# s11_magnitude = np.mean(np.abs(res), axis=2)\n", + "\n", + "# X, Y = np.meshgrid(t, Q)\n", + "# fig = plt.figure(figsize=(10, 7))\n", + "# ax = fig.add_subplot(111, projection='3d')\n", + "# ax.plot_surface(X, Y, s11_magnitude.T, cmap='viridis')\n", + "\n", + "# ax.set_xlabel('Tau (s)')\n", + "# ax.set_ylabel('Q_tot')\n", + "# ax.set_zlabel('Average |S11|')\n", + "# ax.set_title('3D surface of |S11| as a function of Tau and Q_tot')\n", + "# plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TODO:\n", + "- check phase_fit_kit with skewed lorenzian guess\n", + "- check kit's rotation to the canonical position" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/sqil_core/utils/analysis.py b/sqil_core/utils/analysis.py index f4373b9..e02f92b 100644 --- a/sqil_core/utils/analysis.py +++ b/sqil_core/utils/analysis.py @@ -25,7 +25,27 @@ def remove_offset(data: np.ndarray, avg: int = 3) -> np.ndarray: return data - np.mean(data[:, 0:avg], axis=1).reshape(data.shape[0], 1) -def remove_linear_background(data: np.ndarray) -> np.ndarray: +def estimate_linear_background(x: np.ndarray, data: np.ndarray, points_cut=0.1) -> list: + is1D = len(data.shape) == 1 + points = data.shape[0] if is1D else data.shape[1] + cut = int(points * points_cut) + + # Consider just the cut points + x_data = x[0:cut] if is1D else x[0:cut, :] + X = np.vstack([np.ones_like(x_data), x_data]).T + y_data = data[0:cut] if is1D else data[0:cut, :] + + # Linear fit + coefficients, residuals, _, _ = np.linalg.lstsq( + X, y_data if is1D else y_data.T, rcond=None + ) + + return coefficients + + +def remove_linear_background( + x: np.ndarray, data: np.ndarray, points_cut=0.1 +) -> np.ndarray: """Removes a linear background from the input data (e.g. the phase background of a spectroscopy). @@ -41,11 +61,8 @@ def remove_linear_background(data: np.ndarray) -> np.ndarray: The input data with the linear background removed. The shape of the returned array matches the input `data`. """ - is1D = len(data.shape) == 1 - points = data.shape[0] if is1D else data.shape[1] - - x_data = np.linspace(0, points - 1, points) - X = np.vstack([np.ones_like(x_data), x_data]).T + coefficients = estimate_linear_background(x, data, points_cut) - coefficients, _, _, _ = np.linalg.lstsq(X, data if is1D else data.T, rcond=None) + # Remove background over the whole array + X = np.vstack([np.ones_like(x), x]).T return data - (X @ coefficients).T diff --git a/tests/utils/test_analysis.py b/tests/utils/test_analysis.py new file mode 100644 index 0000000..d8fc696 --- /dev/null +++ b/tests/utils/test_analysis.py @@ -0,0 +1,16 @@ +import pytest + +from sqil_core.utils.analysis import * + + +def test_estimate_linear_background(): + a = 5 + b = 2 + + x = np.linspace(0, 10, 100) + y = a * x + b + + [c, m] = estimate_linear_background(x, y, 1) + + assert m == pytest.approx(a) + assert c == pytest.approx(b)