save_parameters.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:49:41.098110Z",
     "start_time": "2021-09-30T11:49:39.859827Z"
    }
   },
   "outputs": [],
   "source": [
    "import qcodes as qc\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from qcodes.data.data_set import load_data\n",
    "import scipy.signal as signal\n",
    "import scipy\n",
    "#from qcodes.plots.qcmatplotlib import MatPlot\n",
    "from qcodes.plots.pyqtgraph import QtPlot\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from scipy.interpolate import interp1d\n",
    "from scipy import integrate \n",
    "\n",
    "import math\n",
    "from lmfit import Model\n",
    "import qcodes.dataset.experiment_container as exc\n",
    "#from qcodes.dataset.plotting import plot_by_id, get_data_by_id, plot_dataset\n",
    "from qcodes.dataset.data_set import load_by_run_spec, load_by_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:49:41.145815Z",
     "start_time": "2021-09-30T11:49:41.099103Z"
    },
    "code_folding": [
     0,
     27,
     44,
     147,
     177,
     242,
     259,
     269,
     316,
     338,
     365,
     370,
     421
    ]
   },
   "outputs": [],
   "source": [
    "def charge_data(id_1): # opens the data \n",
    "\t'''\n",
    "    Opens database experiment\n",
    "    Parameters\n",
    "    ----------\n",
    "    id_1: int.\n",
    "        database id.\n",
    "    Returns\n",
    "    -------\n",
    "    integer: 1d array.\n",
    "        number of trace\n",
    "    X: 2d array.\n",
    "         reflectometry traces in I.\n",
    "    Y: 2d array.\n",
    "         reflectometry traces in Q.\n",
    "    sweep: 1d array.\n",
    "        Trace time in us.\n",
    "    '''\n",
    "\n",
    "\tdataset=load_by_id(id_1)\n",
    "\n",
    "\tinteger=np.unique(dataset.get_parameter_data()[\"Distance\"][\"integer\"])\n",
    "\tX=(dataset.get_parameter_data()[\"I\"][\"I\"])\n",
    "\tY=(dataset.get_parameter_data()[\"Q\"][\"Q\"])\n",
    "\tsweep=(dataset.get_parameter_data()[\"RF_sweep\"][\"RF_sweep\"] )[0]\t \n",
    "\n",
    "\treturn integer,X, Y, sweep\n",
    "def moving_average(a, n=20) :\n",
    "\t'''\n",
    "    Moving average on array a\n",
    "    Parameters\n",
    "    ----------\n",
    "    a: 1d array.\n",
    "        array with data.\n",
    "    n: int.\n",
    "        length of the moving average. When n=20 a moving average is perform on array a every 20 points\n",
    "    Returns\n",
    "    -------\n",
    "    1d array.\n",
    "        moving average of array a\n",
    "    '''\n",
    "\tret = np.cumsum(a, dtype=float)\n",
    "\tret[n:] = ret[n:] - ret[:-n]\n",
    "\treturn ret[n - 1:] / n \n",
    "def IQ_plot(id_1,jupyter_name,sweep, X,Y,signal_start,signal_end, bg_start,bg_end):\n",
    "\t'''\n",
    "    Plots maximums over two different time intervals in the IQ plane from the traces taken.\n",
    "    Calculate the center of the signal and std for the maximums over both time intervals.\n",
    "    The first interval si a mixture between signal and background.\n",
    "    The second interval corresponds to only background since the bleep (spin up) has already happened.\n",
    "    Parameters\n",
    "    ----------\n",
    "    id_1: int.\n",
    "        database id.\n",
    "    integer: 1d array.\n",
    "        number of trace\n",
    "    jupyter_name: string.\n",
    "         title of the plot.\n",
    "    X: 2d array.\n",
    "         reflectometry traces in I.\n",
    "    Y: 2d array.\n",
    "         reflectometry traces in Q.\n",
    "    sweep: 1d array.\n",
    "        Trace time in us.\n",
    "    signal_start: float.\n",
    "        start of the first interval in us.\n",
    "    signal_end: float.\n",
    "        end of the first interval in us.\n",
    "    bg_start: float.\n",
    "        start of the second interval in us.\n",
    "    bg_end: float.\n",
    "        end of the second interval in us.\n",
    "    Returns\n",
    "    -------\n",
    "    maximum_X: float.\n",
    "        mean in I of the maximums during first interval.\n",
    "    maximum_Y: float.\n",
    "        mean in Q of the maximums during first interval.\n",
    "    background_X: float.\n",
    "        mean in I of the maximums during second interval.\n",
    "    background_Y: float.\n",
    "        mean in I of the maximums during second interval.\n",
    "    '''\n",
    "\tmaximum_X=np.zeros(len(X))\n",
    "\tmaximum_Y=np.zeros(len(X))\n",
    "\n",
    "\tbackground_X=np.zeros(len(X))\n",
    "\tbackground_Y=np.zeros(len(X))\n",
    "\n",
    "\tfor a in range(len(X)):\n",
    "\t\tminim= np.where(sweep>= signal_start)[0][0]\n",
    "\t\tmaxim= np.where(sweep>= signal_end)[0][0]\n",
    "\t\tmaximum_X[a]=X[a][minim:maxim].min()\n",
    "\t\tmaximum_Y[a]=Y[a][minim:maxim].max()\n",
    "\n",
    "\t\tminim= np.where(sweep>= bg_start)[0][0]\n",
    "\t\tmaxim= np.where(sweep>= bg_end)[0][0]\n",
    "\t\tbackground_X[a]=X[a][minim:maxim].min()\n",
    "\t\tbackground_Y[a]=Y[a][minim:maxim].max()\n",
    "\t\t\n",
    "\tfig_width_pt = 320.0  # Get this from LaTeX using \\showthe\\columnwidth\n",
    "\tinches_per_pt = 1.0/72.27\t\t\t\t# Convert pt to inch\n",
    "\tgolden_mean = (math.sqrt(5)-1.0)/2.0\t\t # Aesthetic ratio\n",
    "\tfig_width = fig_width_pt*inches_per_pt\t# width in inches\n",
    "\tfig_height = fig_width\t\t# height in inches\n",
    "\tfig_size =\t[fig_width,fig_height]\n",
    "\tplt.rcParams['legend.fontsize'] = 8\n",
    "\tplt.rcParams['figure.figsize'] = fig_size\n",
    "\t\t\n",
    "\tplt.axis(\"Equal\")\n",
    "\tplt.scatter(maximum_X,maximum_Y ,label=\"signal.max\",alpha=0.9,s=19)\n",
    "\tplt.scatter(background_X,background_Y,label=\"background.max\",alpha=0.3,s=10)\n",
    "\t\n",
    "\n",
    "\tplt.xlabel(\"I_max (V)\")\n",
    "\tplt.ylabel(\"Q_max (V)\")\n",
    "\tplt.title(str(id_1)+\" \"+str(jupyter_name))\n",
    "\n",
    "\tplt.legend()\n",
    "\n",
    "\t\t\n",
    "\ttheta = np.linspace(0, 2*np.pi, 100)\n",
    "\n",
    "\t\n",
    "\tstand_dev_maximum=0\n",
    "\t\n",
    "\tfor b in range(len(maximum_X)):\n",
    "\t\tstand_dev_maximum=stand_dev_maximum+np.sqrt((maximum_X[b]-np.mean(maximum_X))**2+(maximum_Y[b]-np.mean(maximum_Y))**2)\n",
    "\t\n",
    "\t\n",
    "\tr = stand_dev_maximum/len(maximum_X)\n",
    "\n",
    "\tcirclex = r*np.cos(theta)+np.mean(maximum_X)\n",
    "\tcircley= r*np.sin(theta)+np.mean(maximum_Y)\n",
    "\tplt.plot(circlex,circley,'k')\n",
    "\n",
    "\tstand_dev_off=0\n",
    "\tfor b in range(len(maximum_X)):\n",
    "\t\tstand_dev_off=stand_dev_off+np.sqrt((background_X[b]-np.mean(background_X))**2+(background_Y[b]-np.mean(background_Y))**2)\n",
    "\n",
    "\tr = stand_dev_off/len(maximum_X)\n",
    "\n",
    "\tcirclex = r*np.cos(theta)+np.mean(background_X)\n",
    "\tcircley= r*np.sin(theta)+np.mean(background_Y)\n",
    "\tplt.plot(circlex,circley,'k')\n",
    "\tplt.show()\n",
    "\treturn maximum_X,maximum_Y,background_X,background_Y \n",
    "def projection(integer,X, Y, sweep,angle):\n",
    "\t'''\n",
    "    projects IQ data into an axis\n",
    "    Parameters\n",
    "    ----------\n",
    "    integer: 1d array.\n",
    "        number of trace\n",
    "    X: 2d array.\n",
    "         reflectometry traces in I.\n",
    "    Y: 2d array.\n",
    "         reflectometry traces in Q.\n",
    "    sweep: 1d array.\n",
    "        Trace time in us.\n",
    "    angle: float.\n",
    "        angle in radians between I axis and axis in which the signal is going to be projected onto.\n",
    "    Returns\n",
    "    -------\n",
    "    projected: 2d array.\n",
    "        IQ traces projected to best angle.\n",
    "    projected1: 2d array.\n",
    "        IQ traces projected perpendicularly to best angle. \n",
    "    '''\n",
    "\tX=np.resize(X, (len(integer),len(sweep))) \n",
    "\tY=np.resize(Y, (len(integer),len(sweep)))\n",
    "\tprojected=np.zeros((len(integer),len(sweep)))\n",
    "\tprojected1=np.zeros((len(integer),len(sweep)))\n",
    "\tfor a in range(int(len(integer))):\n",
    "\t\tprojected[a]=X[a]*np.cos(angle)+Y[a]*np.sin(angle)\n",
    "\t\tprojected1[a]=-X[a]*np.sin(angle)+Y[a]*np.cos(angle)\n",
    "\treturn projected, projected1 # \n",
    "def model_fit1( datax, datay, function, title,xlabel,ylabel,plot, init={}, bounds={},**kwargs):\n",
    "\t'''\n",
    "    Fits data to any function\n",
    "    Parameters\n",
    "    ----------\n",
    "    datax: 1d array.\n",
    "        x- axis from the data to be fitted\n",
    "    datay: 1d array.\n",
    "        y- axis from the data to be fitted\n",
    "    function: python function\n",
    "         function to be fitted\n",
    "    title: string.\n",
    "        title of the plot.\n",
    "    xlabel: string.\n",
    "        xlabel of the plot.\n",
    "    ylabel: string.\n",
    "        ylabel of the plot.\n",
    "    plot: bool.\n",
    "        True to plot, False to dont plot\n",
    "    Returns\n",
    "    -------\n",
    "    out.best_values: 1d array.\n",
    "        value of the fitted parameters.\n",
    "    errors: 1d array.\n",
    "        std of the parameters fitted\n",
    "    '''\n",
    "\tfrom lmfit import Model\n",
    "\tgmodel = Model(function)\n",
    "\tparams = gmodel.make_params()\n",
    "\t\n",
    "\tfor param in init.keys():\n",
    "\t\tif param in params:\n",
    "\t\t\tparams[param].value = init[param]\n",
    "\n",
    "\tfor param in bounds.keys():\n",
    "\t\tif param in params:\n",
    "\t\t\tparams[param].min = init[param][0]\n",
    "\t\t\tparams[param].max = init[param][1]\n",
    "\t\n",
    "\tout = gmodel.fit(datay,params, x=datax,sigma=2, **kwargs)\n",
    "\tdely = out.eval_uncertainty(x=datax,sigma=2)\n",
    "  \n",
    "\n",
    "\tif plot:\n",
    "\t\tplt.xlabel(xlabel, {'color': 'k', 'fontsize': 15}, )\n",
    "\t\tplt.ylabel(ylabel, {'color': 'k', 'fontsize': 15})\n",
    "\t\tplt.xticks( color='k', size=12)\n",
    "\t\tplt.yticks( color='k', size=12)\n",
    "\t\tplt.title(\"Model \"+title,size=16)\n",
    "\t\tplt.plot(datax, out.best_fit, 'r-', label='best fit')\n",
    "\t\tplt.scatter(datax , datay)\n",
    "\t\t#plt.fill_between(datax , out.best_fit-dely, out.best_fit+dely,color=\"#ABABAB\",label='$\\sigma$ uncertainty band')\n",
    "\t\tplt.legend(loc='best')\n",
    "\n",
    "\t\tplt.show()\n",
    "  \n",
    "\tkeys=list(params.valuesdict().keys() )\n",
    "\n",
    "\terror = {}\n",
    "\tfor i in range(len(keys)):\n",
    "\t\ttry:\n",
    "\t\t  error[keys[i]+\"_std\"] = np.absolute(out.covar[i][i])**0.5\n",
    "\t\texcept:\n",
    "\t\t  error[keys[i]+\"_std\"] = 0\n",
    "\treturn out.best_values, error\n",
    "def gaussian_function(x, mu, sigma):\n",
    "\t'''\n",
    "    Gaussian function\n",
    "    Parameters\n",
    "    ----------\n",
    "    datax: 1d array.\n",
    "        x- axis from the data to be fitted\n",
    "    mu: float.\n",
    "        median of the gaussian\n",
    "    sigma: float.\n",
    "         standard deviation of the gaussian\n",
    "    Returns\n",
    "    -------\n",
    "    1d array.\n",
    "        Gaussian fucntion\n",
    "    '''\n",
    "\treturn 1/sigma/np.sqrt(2*np.pi)*np.exp(-1/2*((x-mu)/sigma)**2)\n",
    "def fourier_transf(I,acqtime ):\n",
    "    I=I-np.mean(I)\n",
    "    #plt.plot(I)\n",
    "    fourier = np.fft.fft(I)\n",
    "    n = I.size\n",
    "    timestep = 1/n*acqtime\n",
    "    freq = np.fft.fftfreq(n, d=timestep)\n",
    "    #plt.scatter(freq, fourier)\n",
    "    plt.xlabel(\"Frequency (Hz)\")\n",
    "    return freq[0:int(n/2)], fourier[0:int(n/2)]\n",
    "def simulate_ss_out(A,std_down,std_up ,signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time, plot_trace = 0):\n",
    "    #v2 + add T_out\n",
    "    \n",
    "    # time list \n",
    "    #n_points_time = 1952 #number of points\n",
    "    #t_max = 2000 #mus\n",
    "    t = np.array(np.linspace(0,t_max,n_points_time))\n",
    "    # Indexes of time during which we will take the max of the trace + for the bg\n",
    "    list_t = moving_average(t,t_int)\n",
    "    #minim_time= np.where(list_t>= 0)[0][0]\n",
    "    #maxim_time= np.where(list_t>= list_t.max())[0][0]\n",
    "    minim_time_bg= np.where(list_t>= 1460)[0][0]\n",
    "    maxim_time_bg= np.where(list_t>= 1860)[0][0]\n",
    "        \n",
    "    # assign spin\n",
    "    choose_spin = np.random.binomial(1,A,1) #create 1 with proba A and 0 with proba (1-A)\n",
    "    \n",
    "    if choose_spin == 1 : # spin down because A = <P_down>\n",
    "    # create a blip of spin down i.e. noise centred at signal_low and take the max\n",
    "        line_spindown = moving_average(np.random.normal(signal_low,std_down,n_points_time),t_int) \n",
    "        \n",
    "        \n",
    "        max_ss = np.max(line_spindown)\n",
    "        max_ss_bg = np.max(line_spindown[minim_time_bg:maxim_time_bg])\n",
    "        \n",
    "        if plot_trace == 1 :\n",
    "            plt.title('Spin down with Tint = %f, T_in = %f'%(t_int,t_in))\n",
    "            plt.plot(list_t,line_spindown)\n",
    "            plt.legend()\n",
    "            #plt.ylim((-0.05,0.25))\n",
    "            plt.grid()\n",
    "    \n",
    "    if choose_spin == 0 : #spin up\n",
    "    # create a blip of spin up and take the max\n",
    "        line_spinup =simple_ss_n_in_out(t, t_in, t_out,std_down, std_up,t_int,signal_low, signal_high)\n",
    "        #line_spinup = ss_n_in_out_scaled_2std(t,t_in,t_out,t_bw,std_down,std_up,t_int,signal_low,signal_high)\n",
    "        max_ss = np.max(line_spinup)\n",
    "        max_ss_bg = np.max(line_spinup[minim_time_bg:maxim_time_bg])\n",
    "        \n",
    "        if plot_trace == 1 :\n",
    "            plt.title('Spin up with Tint = %f, T_in = %f'%(t_int,t_in))\n",
    "            plt.plot(t_list,line_spinup)\n",
    "            plt.legend()\n",
    "            #plt.ylim((-0.05,0.25))\n",
    "            plt.grid()\n",
    "            \n",
    "    return(max_ss,max_ss_bg,choose_spin)  \n",
    "def simple_ss_n_in_out(t, t_in, t_out, std_low,std_high,t_int,signal_low =0, signal_high = 1):\n",
    "    ss_x=np.zeros(len(t))\n",
    "    \n",
    "    t_leave=np.random.exponential(t_out) #random t_out time\n",
    "    t_enter=np.random.exponential(t_in) #random t_in time\n",
    "    \n",
    "    i_leave = np.where(t<=t_leave)[0][-1]    \n",
    "    i_enter = np.where(t<=t_enter+t_leave)[0][-1]\n",
    "    \n",
    "    \n",
    "    ss_x[0:i_leave] = signal_low + np.random.normal(0,std_low,len(t[0:i_leave])) \n",
    "\n",
    "    if i_enter == i_leave : #means T_enter = 0\n",
    "        ss_x[i_leave:] =  signal_low + np.random.normal(0,std_low,len(t[i_leave:]))\n",
    "\n",
    "    else : \n",
    "        ss_x[i_leave:i_enter] = signal_high + np.random.normal(0,std_high,len(t[i_leave:i_enter]))\n",
    "        ss_x[i_enter:] = signal_low + np.random.normal(0,std_high,len(t[i_enter:])) #+1 to make it continuous]\n",
    "\n",
    "    # test another type of rolling avergae\n",
    "    ss_x = moving_average(ss_x,t_int)\n",
    "    return ss_x\n",
    "def histogram_data (data,Tint, number_bins =60, range_min = 0, range_max = 0.3):\n",
    "    x = np.array(data.maximum_distance)\n",
    "    y = np.array(data.maximum_bg)\n",
    "    \n",
    "    #make histogram\n",
    "    hist_max, bin_edges_max = np.histogram(x, bins=number_bins, range=(range_min,range_max))    \n",
    "    hist_max_bg, bin_edges_max_bg = np.histogram(y, bins=number_bins,range=(range_min,range_max) ) \n",
    "    \n",
    "    plt.figure()\n",
    "    plt.hist(x, bins=number_bins, range=(range_min,range_max),alpha = 0.7, label='signal')\n",
    "    #plt.hist(y, bins=number_bins, range=(range_min,range_max), alpha = 0.7,label='background' )\n",
    "    plt.title(\"histogram at Tint = %f us\" %Tint) \n",
    "    plt.show()\n",
    "    plt.legend()\n",
    "    #plt.savefig('1histogram.png')\n",
    "    \n",
    "    \n",
    "    #plt.figure()\n",
    "    plt.plot(get_inter_bins(bin_edges_max),hist_max, label='signal')\n",
    "    #plt.plot(get_inter_bins(bin_edges_max_bg),hist_max_bg,label ='background')\n",
    "    plt.legend()\n",
    "    plt.xlabel('Distance(V)')\n",
    "    plt.grid()\n",
    "    #plt.title('Tint = 2.5us')\n",
    "\n",
    "    return(get_inter_bins(bin_edges_max),hist_max,get_inter_bins(bin_edges_max_bg),hist_max_bg)\n",
    "# Create list with center of bin_edges so that we can plot the histogram as a curve \n",
    "def get_inter_bins(bins):\n",
    "    res = []\n",
    "    for i in range (len(bins)-1):\n",
    "        res.append( 1/2*(bins[i]+bins[i+1]))\n",
    "    return(res)\n",
    "def simulate_histogram_updown_Virginia(A,range_min,range_max,std_down,std_up, signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time,n_traces,num_bins = 60,plot_histo = 1):\n",
    "    #returns the histograms of spin up and down\n",
    "    \n",
    "    max_ss_up = []\n",
    "    max_ss_down = []\n",
    "    max_ss_bg = []\n",
    "\n",
    "    # Do many traces and get max\n",
    "    for i in range(n_traces):\n",
    "        ss_readout = simulate_ss_out(A,std_down,std_up,signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time, 0)\n",
    "\n",
    "        if ss_readout[2] == 1 : #choose_spin = 1 so spin is down\n",
    "            max_ss_down.append(ss_readout[0])\n",
    "            max_ss_bg.append(ss_readout[1])\n",
    "\n",
    "        if ss_readout[2] == 0 : #choose_spin = 0 so spin is up\n",
    "            max_ss_up.append(ss_readout[0])\n",
    "            max_ss_bg.append(ss_readout[1])\n",
    "        \n",
    "        #if i==np.int(n_traces/2):\n",
    "        #    print('Progress>50%')\n",
    "    \n",
    "    max_ss_up = np.array(max_ss_up)\n",
    "    max_ss_down = np.array(max_ss_down)\n",
    "    \n",
    "    ma = np.append(max_ss_up,max_ss_down)\n",
    "    max_ss_bg =np.array(max_ss_bg)\n",
    "    \n",
    "\n",
    "    hist_max_ss_up, bin_edges_max_ss_up = np.histogram(max_ss_up,bins=num_bins,range = (range_min,range_max))    \n",
    "    hist_max_ss_down, bin_edges_max_ss_down = np.histogram(max_ss_down, bins=num_bins,range=(range_min,range_max) )\n",
    "\n",
    "    print('number of traces for bg =',len(max_ss_bg),'number of up traces =',len(max_ss_up))\n",
    "    if plot_histo == 1:\n",
    "        # Plot the histogram \n",
    "        plt.hist(max_ss_up,bins=num_bins,range = (range_min,range_max), label = 'spin up', alpha = 0.5)  \n",
    "        plt.hist(max_ss_down,bins=num_bins,range = (range_min,range_max), label = 'spin down', alpha = 0.5)\n",
    "        plt.xlabel(\"Signal\")\n",
    "        plt.ylabel(\"Probability\")\n",
    "        plt.title('Simulated histogram')\n",
    "        print('Parameters for the simulation :')\n",
    "        print('T_int = %f us, T_in = %f us, T_out = %f us, T_bw = %f us' %(t_int,t_in,t_out,t_bw))\n",
    "        print('A = %f, std = %f'%(A,std))\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "        #plt.savefig('1histogram.png')\n",
    "\n",
    "\n",
    "    #return(get_inter_bins(bin_edges_max_ss),hist_max_ss,ma)\n",
    "    return(get_inter_bins(bin_edges_max_ss_up),hist_max_ss_up,get_inter_bins(bin_edges_max_ss_down),hist_max_ss_down)\n",
    "\n",
    "def fidelity_Virginia(threshold_signal, A, range_min,range_max,std_down,std_up, signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time,n_traces,num_bins = 60,plot_histo = 1, plot_distrib=0):\n",
    "    print(t_int)\n",
    "    res = simulate_histogram_updown_Virginia(A,range_min,range_max,std_bg,std_up, signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time,n_traces,num_bins , plot_histo)\n",
    "    \n",
    "    histo_up = (res[0],res[1])\n",
    "    histo_down = (res[2],res[3])\n",
    "    \n",
    "    #plot_distrib = 0\n",
    "    if plot_distrib == 1:\n",
    "        # -----------------------\n",
    "        plt.plot(histo_up[0], histo_up[1],label='spin up signal')\n",
    "        plt.plot(histo_down[0], histo_down[1],label='spin down signal')\n",
    "\n",
    "\n",
    "        # Caption\n",
    "        #------------------------\n",
    "        plt.legend()\n",
    "        plt.xlabel(\"Signal\")\n",
    "        plt.ylabel(\"Probability\")\n",
    "        plt.title('Simulated histogram Tin=%f'%t_in)\n",
    "        #plt.savefig('2_histogram_Tin=%f.png'%t_in)\n",
    "\n",
    "    f_hist_up = interp1d(histo_up[0], histo_up[1],kind='cubic')\n",
    "    f_hist_down = interp1d(histo_down[0], histo_down[1],kind='cubic')\n",
    "    \n",
    "    def f_total(x):\n",
    "        return(f_hist_up(x)+f_hist_down(x))\n",
    "    \n",
    "    fidelity_up = []\n",
    "    fidelity_down = []\n",
    "    fidelity_error = []\n",
    "    \n",
    "    if type(threshold_signal)==np.ndarray or type(threshold_signal)==list:\n",
    "        for signal in threshold_signal:\n",
    "            integ_up = integrate.quad(f_hist_up, np.min(histo_up[0]), signal)\n",
    "            integ_down = integrate.quad(f_hist_down, signal, np.max(histo_down[0]))\n",
    "\n",
    "            #integ_total = integrate.quad(f_total, range_min, range_max)\n",
    "            integ_total = np.array(integrate.quad(f_hist_up, np.min(histo_up[0]), np.max(histo_up[0]))) + np.array(integrate.quad(f_hist_down,  np.min(histo_down[0]),  np.max(histo_down[0])))\n",
    "\n",
    "            #print(integ_total)\n",
    "            error_total_integral = np.abs((histo_up[0][2]-histo_up[0][1])*n_traces - integ_total[0])\n",
    "            \n",
    "            fidelity_up.append(1-integ_up[0]/integ_total[0])\n",
    "            fidelity_down.append(1-integ_down[0]/integ_total[0])\n",
    "            fidelity_error.append(error_total_integral)\n",
    "            \n",
    "        return(fidelity_down,fidelity_up,fidelity_error)\n",
    "\n",
    "    \n",
    "    elif type(threshold_signal)==float or type(threshold_signal)==int:\n",
    "        integ_up = integrate.quad(f_hist_up, np.min(histo_up[0]), signal)\n",
    "        integ_down = integrate.quad(f_hist_down, signal, np.max(histo_down[0]))\n",
    "\n",
    "        #integ_total = integrate.quad(f_total, range_min, range_max)\n",
    "        integ_total = np.array(integrate.quad(f_hist_up, np.min(histo_up[0]), np.max(histo_up[0]))) + np.array(integrate.quad(f_hist_down,  np.min(histo_down[0]),  np.max(histo_down[0])))\n",
    "\n",
    "        #print(integ_total)\n",
    "        error_total_integral = np.abs((histo_up[0][2]-histo_up[0][1])*n_traces - integ_total[0])\n",
    "           \n",
    "        return(1-integ_down[0]/integ_total[0],1-integ_up[0]/integ_total[0],error_total_integral)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:49:41.161760Z",
     "start_time": "2021-09-30T11:49:41.146811Z"
    },
    "code_folding": [
     1,
     27,
     92
    ]
   },
   "outputs": [],
   "source": [
    "# perform a fit using lmfit given inital values and bounds\n",
    "def fit(x, y, func, init={}, bounds={}, fixed = {}, steps = {}, step_size = 1e-7):\n",
    "    \n",
    "    gmodel = Model(func)\n",
    "    params = gmodel.make_params()\n",
    "    \n",
    "    for param in fixed.keys():\n",
    "        if param in params:\n",
    "            params[param].set(fixed[param],vary=False)\n",
    "    \n",
    "    for param in init.keys():\n",
    "        if param in params:\n",
    "            params[param].value = init[param]\n",
    "\n",
    "    for param in bounds.keys():\n",
    "        if param in params:\n",
    "            params[param].min = bounds[param][0]\n",
    "            params[param].max = bounds[param][1]\n",
    "    \n",
    "    for param in steps.keys():\n",
    "        if param in params:\n",
    "            params[param].set(brute_step=steps[param])\n",
    "    \n",
    "            \n",
    "    #return gmodel.fit(y, params, x=x,method='brute')\n",
    "    return (gmodel.fit(y, params, x=x, fit_kws = {'epsfcn':step_size}))\n",
    "\n",
    "def simulate_histogram_out(A,range_min,range_max,std_down,std_up, signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time,n_traces,num_bins = 60,plot_histo = 1): \n",
    "    max_ss_up = []\n",
    "    max_ss_down = []\n",
    "    max_ss_bg = []\n",
    "\n",
    "    # Do many traces and get max\n",
    "    for i in range(n_traces):\n",
    "        \n",
    "        # Plot the traces for the first 5 traces \n",
    "        #if i<5 :\n",
    "        #    ss_readout = simulate_ss_out(A,std_down,signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time, 1)\n",
    "\n",
    "        #else :\n",
    "        ss_readout = simulate_ss_out(A,std_down,std_up,signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time, 0)\n",
    "            \n",
    "        if ss_readout[2] == 1 : #choose_spin = 1 so spin is down\n",
    "            max_ss_down.append(ss_readout[0])\n",
    "            max_ss_bg.append(ss_readout[1])\n",
    "\n",
    "        if ss_readout[2] == 0 : #choose_spin = 0 so spin is up\n",
    "            max_ss_up.append(ss_readout[0])\n",
    "            max_ss_bg.append(ss_readout[1])\n",
    "        \n",
    "        #if i==np.int(n_traces/2):\n",
    "        #    print('Progress>50%')\n",
    "    \n",
    "    ma = np.append(np.array(max_ss_up),np.array(max_ss_down))\n",
    "    max_ss_bg = np.array(max_ss_bg)\n",
    "\n",
    "\n",
    "    hist_max_ss, bin_edges_max_ss = np.histogram(ma,bins=num_bins,range = (range_min,range_max))    \n",
    "    hist_max_ss_bg, bin_edges_max_ss_bg = np.histogram(max_ss_bg, bins=num_bins,range=(range_min,range_max) )\n",
    "    \n",
    "    bin_axis_ss= bin_edges_max_ss[0:-1]+( bin_edges_max_ss[1]- bin_edges_max_ss[0])/2\n",
    "    normalisation=( bin_edges_max_ss[1]- bin_edges_max_ss[0])*n_traces\n",
    "    \n",
    "    \n",
    "    #print('number of traces for bg =',len(max_ss_bg),'number of up traces =',len(max_ss_up))\n",
    "    if plot_histo == 1:\n",
    "        # Plot the histogram \n",
    "        plt.figure()\n",
    "        plt.hist(ma,bins=num_bins,label='total', alpha = 0.6,range = (range_min,range_max))\n",
    "        plt.hist(max_ss_bg,bins=num_bins ,label='background', alpha = 0.5,range = (range_min,range_max))\n",
    "        plt.xlabel(\"Signal\")\n",
    "        plt.ylabel(\"Probability\")\n",
    "        plt.title('Simulated histogram')\n",
    "        print('Parameters for the simulation :')\n",
    "        print('T_int = %f us, T_in = %f us, T_out = %f us' %(t_int,t_in,t_out))\n",
    "        print('A = %f, std = %f'%(A,std_down))\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "        #plt.savefig('1histogram.png')\n",
    "\n",
    "        #Plot the histogram as lines \n",
    "        plt.title('Simulated histogram as lines')\n",
    "        plt.plot(get_inter_bins(bin_edges_max_ss),hist_max_ss, label='signal')\n",
    "        plt.plot(get_inter_bins(bin_edges_max_ss_bg),hist_max_ss_bg,label ='background')\n",
    "        plt.legend()\n",
    "        plt.xlabel('Distance(V)')\n",
    "        plt.grid()\n",
    "        #plt.title('Tint = 2.5us')\n",
    "\n",
    "    return(bin_axis_ss,hist_max_ss/normalisation)\n",
    "\n",
    "\n",
    "def fit_histogram_v2(x,A,range_min,range_max,std_low, std_up,signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time,n_traces,num_bins = 60, plot_histo = 0):\n",
    "    #interpolate the histogram after generating it\n",
    "    \n",
    "    #print('x=',x)\n",
    "    #print('signal_high=',signal_high)\n",
    "    #print(\"std_up\",std_up)\n",
    "    #print(\"A\",A)\n",
    "    (inter_bin_simu, hist_max_simu) =  simulate_histogram_out(A,range_min,range_max,std_low,std_up, signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time,n_traces,num_bins ,plot_histo  )\n",
    "    f_hist_inter = interp1d(inter_bin_simu, hist_max_simu, kind='cubic')\n",
    "    \n",
    "    return(f_hist_inter(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:49:41.177708Z",
     "start_time": "2021-09-30T11:49:41.162752Z"
    },
    "code_folding": [
     0,
     25
    ]
   },
   "outputs": [],
   "source": [
    "def simple_ss_n_in_out_sim(t, t_in, t_out, std_low, std_up, signal_low =0, signal_high = 1):\n",
    "    ss_x=np.zeros(len(t))\n",
    "    \n",
    "    t_leave=np.random.exponential(t_out) #random t_out time\n",
    "    t_enter=np.random.exponential(t_in) #random t_in time\n",
    "    \n",
    "    i_leave = np.where(t<=t_leave)[0][-1]    \n",
    "    i_enter = np.where(t<=t_enter+t_leave)[0][-1]\n",
    "    \n",
    "    \n",
    "    ss_x[0:i_leave] = signal_low + np.random.normal(0,std_low,len(t[0:i_leave])) \n",
    "\n",
    "    if i_enter == i_leave : #means T_enter = 0\n",
    "        ss_x[i_leave:] =  signal_low + np.random.normal(0,std_low,len(t[i_leave:]))\n",
    "\n",
    "    else : \n",
    "        ss_x[i_leave:i_enter] = signal_high + np.random.normal(0,std_low,len(t[i_leave:i_enter]))\n",
    "        ss_x[i_enter:] = signal_low + np.random.normal(0,std_low,len(t[i_enter:])) #+1 to make it continuous]\n",
    "\n",
    "    # test another type of rolling avergae\n",
    "   # ss_x = moving_average(ss_x,t_int)\n",
    "    return ss_x\n",
    "\n",
    "\n",
    "\n",
    "def simulate_distance(A,std_down,std_up ,signal_low,signal_high,t_out,t_in,n_points_time, n_traces,sweep):\n",
    "    ss = []\n",
    "    spin_number=np.empty(0)\n",
    "    \n",
    "    for i in range(n_traces):\n",
    "        choose_spin = np.random.binomial(1,A,1) #create 1 with proba A and 0 with proba (1-A)\n",
    "        spin_number = np.append(spin_number, choose_spin)\n",
    "        \n",
    "        if choose_spin == 1 : # spin down because A = <P_down>\n",
    "        # create a blip of spin down i.e. noise centred at signal_low and take the max\n",
    "            line_spin_down = signal_low + np.random.normal(0,std_down,n_points_time)\n",
    "            ss.append(line_spin_down )\n",
    "            \n",
    "            \n",
    "        if choose_spin == 0 : #spin up\n",
    "        # create a blip of spin up and take the max\n",
    "            line_spin_up =simple_ss_n_in_out_sim(sweep, t_in, t_out,std_down, std_up,signal_low, signal_high)\n",
    "            \n",
    "            ss.append( line_spin_up )\n",
    "            \n",
    "    ss=np.array(ss)\n",
    "    return(ss,spin_number)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Open data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:49:44.288200Z",
     "start_time": "2021-09-30T11:49:44.271306Z"
    }
   },
   "outputs": [],
   "source": [
    "# load database\n",
    "qc.config.core.db_location = './fidelity_vs_power_readout-0.01112.db' \n",
    "#qc.config.core.db_location = './fidelity_vs_readout_pos.db' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:09.300890Z",
     "start_time": "2021-09-30T11:49:47.433030Z"
    }
   },
   "outputs": [],
   "source": [
    "# open data\n",
    "id_1=2\n",
    "integer,X, Y,  sweep=charge_data(id_1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:09.316785Z",
     "start_time": "2021-09-30T11:50:09.301814Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10001"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## project on IQ plane"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:09.601828Z",
     "start_time": "2021-09-30T11:50:09.317777Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1952\n"
     ]
    }
   ],
   "source": [
    "## Increase integration time to better determine the angle in the IQ plane\n",
    "# create new arrays\n",
    "factor = 41 # factor*T_int_original=Tint\n",
    "\n",
    "X_40=np.zeros((len(X),len(moving_average(Y[0], factor))))\n",
    "Y_40=np.zeros((len(X),len(moving_average(Y[0], factor))))\n",
    "\n",
    "acquisition_time=2000 # time of the trace in us\n",
    "number_points=len(sweep) # number of points in the trace\n",
    "print(number_points)\n",
    "T_int_original=acquisition_time/number_points # original integration time (1us)\n",
    "T_int=factor*T_int_original # new integration time\n",
    "\n",
    "\n",
    "# new I and Q with moving averaged\n",
    "X_40=np.zeros((len(X),len(moving_average(Y[0], factor))))\n",
    "Y_40=np.zeros((len(X),len(moving_average(Y[0],factor))))\n",
    "sweep_40=np.zeros(len(moving_average(Y[0], factor)))\n",
    "\n",
    "\n",
    "for a in range(len(X)):\n",
    "    X_40[a]=moving_average(X[a], factor)\n",
    "    Y_40[a]=moving_average(Y[a], factor)\n",
    "sweep_40=moving_average(sweep, factor)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:10.326324Z",
     "start_time": "2021-09-30T11:50:09.602822Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 318.804x318.804 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot of the maximums IQ plane for different traces during the time segment between\n",
    "#signal_start-signal end (blue)- mixture of signal and background maximums,\n",
    "#and bg_start-bg_end(orange)- mostly only the maximum of the background since the bleep should already have ocurred\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "title=\"B_voltage=0.123\"\n",
    "signal_start=0  # in us\n",
    "signal_end=400  # \n",
    "\n",
    "bg_start=1460\n",
    "bg_end=1860\n",
    "\n",
    "# IQ_plot: get the max of X and Y for signal and bg time window. The circles are centred at the mean and radius = std\n",
    "\n",
    "X_signal, Y_signal, X_bg, Y_bg=IQ_plot(str(id_1),title, sweep_40,X_40,Y_40,signal_start,signal_end, bg_start,bg_end) # maximum of the signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:10.595391Z",
     "start_time": "2021-09-30T11:50:10.327211Z"
    }
   },
   "outputs": [],
   "source": [
    "# finds the angle called theta between the X axis and the line between the center of the orange and blue circles.\n",
    "#In our case is not between 90 and -90 so we have to add np.pi\n",
    "\n",
    "angle=np.arctan((np.mean(Y_signal)-np.mean(Y_bg) )/(np.mean(X_signal)-np.mean(X_bg) ) )+np.pi\n",
    "\n",
    "distance, rubbish=projection(integer,X_40, Y_40,  sweep_40, angle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:10.611409Z",
     "start_time": "2021-09-30T11:50:10.596384Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7231561940480011"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "angle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-08-22T10:23:31.810816Z",
     "start_time": "2021-08-22T10:23:31.798895Z"
    }
   },
   "source": [
    "# distance integration time 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:10.911528Z",
     "start_time": "2021-09-30T11:50:10.612405Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "distance, rubbish=projection(integer,X, Y,  sweep, angle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:10.926655Z",
     "start_time": "2021-09-30T11:50:10.912521Z"
    }
   },
   "outputs": [],
   "source": [
    "#np.savez('./compressed-traces-JPA-off-2.npz', distance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:10.942162Z",
     "start_time": "2021-09-30T11:50:10.927662Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "#distance=np.load('./JPA_off_traces_simulated-2.npz')['sim_distance']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:10.957731Z",
     "start_time": "2021-09-30T11:50:10.944154Z"
    }
   },
   "outputs": [],
   "source": [
    "#plt.plot(file['arr_0'][5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  calculate parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:10.972992Z",
     "start_time": "2021-09-30T11:50:10.958667Z"
    }
   },
   "outputs": [],
   "source": [
    "# parameters to be extracted\n",
    "signal_parameters={\n",
    "  \"mean_bg\": 0,\n",
    "  \"std_bg\": 0,\n",
    "  \"mean_up\": 0,\n",
    "  \"std_up\": 0,\n",
    "  \"t_int\": 0,\n",
    "  \"t_out\": 0,\n",
    "}\n",
    "\n",
    "signal_parameters_fit={\n",
    "  \"mean_bg\": 0,\n",
    "  \"std_bg\": 0,\n",
    "  \"mean_up\": 0,\n",
    "  \"std_up\": 0,\n",
    "  \"t_int\": 0,\n",
    "  \"t_out\": 0,\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  on t_int and t_out\n",
    "\n",
    "where t_out is the time that it takes for the electron to leave the dot (time before the bleep)\n",
    "\n",
    "t_in time that the electron takes to come back to the dot (bleep duration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:11.115649Z",
     "start_time": "2021-09-30T11:50:10.974066Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1952\n"
     ]
    }
   ],
   "source": [
    "## Increase integration time to better determine the angle in the IQ plane\n",
    "# create new arrays\n",
    "factor = 20 # factor*T_int_original=Tint\n",
    "#sweep=np.linspace(0,2000,len(distance[0]))\n",
    "\n",
    "distance_40=np.zeros((len(distance),len( moving_average(distance[0], factor))))\n",
    "\n",
    "\n",
    "acquisition_time=2000 # time of the trace in us\n",
    "number_points=len(sweep) # number of points in the trace\n",
    "print(number_points)\n",
    "T_int_original=acquisition_time/number_points # original integration time (1us)\n",
    "T_int=factor*T_int_original # new integration time\n",
    "\n",
    "# new I and Q with moving averaged\n",
    "distance_40=np.zeros((len(distance),len(moving_average(distance[0], factor))))\n",
    "sweep_40=np.zeros(len(moving_average(distance[0], factor)))\n",
    "\n",
    "\n",
    "for a in range(len(distance)):\n",
    "    distance_40[a]=moving_average(distance[a], factor)\n",
    "sweep_40=moving_average(sweep, factor)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  histogram of the maximums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:47.036723Z",
     "start_time": "2021-09-30T11:50:46.835779Z"
    }
   },
   "outputs": [],
   "source": [
    "maximum=np.zeros(len(distance)) # trace maximum during first 400 us\n",
    "max_background_distance=np.zeros(len(distance)) # trace maximum during last 400 us\n",
    "\n",
    "for a in range(len(distance)):\n",
    "    minim= np.where(sweep_40>= 0)[0][0]\n",
    "    maxim= np.where(sweep_40>= sweep_40.max())[0][0]\n",
    "\n",
    "    \n",
    "    \n",
    "    maximum[a]=distance_40[a][minim:maxim].max()\n",
    "    \n",
    "    minim= np.where(sweep_40>= 1460)[0][0]\n",
    "    maxim= np.where(sweep_40>= 1860)[0][0]\n",
    "\n",
    "    \n",
    "    max_background_distance[a]=(distance_40[a][minim:maxim]).max()\n",
    "    \n",
    "# create histogram for the maximums  \n",
    "hist_max, bin_edges_max = np.histogram(maximum, bins=60,range=(maximum.min(),maximum.max()))    \n",
    "hist_max_bg, bin_edges_max_bg = np.histogram(max_background_distance, bins=60,range=(maximum.min(),maximum.max()))   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:50:47.551377Z",
     "start_time": "2021-09-30T11:50:47.399369Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'histogram')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline \n",
    "\n",
    "\n",
    "bin_axis=bin_edges_max[0:-1]+(bin_edges_max[1]-bin_edges_max[0])/2\n",
    "normalisation=10000*(bin_edges_max[1]-bin_edges_max[0])\n",
    "plt.bar(bin_axis, hist_max/normalisation, width=bin_edges_max[1]-bin_edges_max[0],label=\"background\",alpha=0.5)\n",
    "plt.plot(bin_axis, hist_max/normalisation)\n",
    "#Tin=factor*2.5\n",
    "Tin = T_int\n",
    "plt.title(\"maximum\"+str(id_1)+\" Tin=\"+str(Tin)+\" us\" +\" 14_long_tunneling\")\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel(\"distance (V)\")\n",
    "plt.ylabel(\"histogram\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### JPA  plot traces 10us Tint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:42:16.683477Z",
     "start_time": "2021-09-30T11:42:16.403490Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\virgi\\AppData\\Local\\Temp/ipykernel_15324/3104885129.py:29: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"rasterized\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  plt.savefig(\"JPA_OFF_TRACES.pdf\",dpi=600, bbox_inches = \"tight\", rasterized='True')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 239.103x147.774 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plots 2 traces to compare spin up and down already projected\n",
    "fig_width_pt = 240.0  # Get this from LaTeX using \\showthe\\columnwidth\n",
    "inches_per_pt = 1.0/72.27\t\t\t\t# Convert pt to inch\n",
    "golden_mean = (math.sqrt(5)-1.0)/2.0\t\t # Aesthetic ratio\n",
    "fig_width = fig_width_pt*inches_per_pt\t# width in inches\n",
    "fig_height = fig_width*golden_mean\t\t# height in inches\n",
    "fig_size =\t[fig_width,fig_height]\n",
    "plt.rcParams['legend.fontsize'] = 8\n",
    "plt.rcParams['figure.figsize'] = fig_size\n",
    "plt.xlim((sweep_40.min(), sweep_40.max()))\n",
    "\n",
    "#plt.ylim((y.min(), y.max())) \n",
    "plt.xlabel(\"Time ($\\mu s$) \", {'color': 'k', 'fontsize': 14})\n",
    "plt.ylabel(\"rf signal (V)\", {'color': 'k', 'fontsize': 14})\n",
    "plt.xticks( color='k', size=12)\n",
    "plt.yticks( color='k', size=12)\n",
    "#plt.ylim(0,30)\n",
    "\n",
    "\n",
    "plt.title(\"Single shot traces\",size=16)\n",
    "#plt.plot(datax, out.best_fit, 'r-', label='best fit')\n",
    "plt.scatter(sweep_40,distance_40[107],color=(120/255,120/255,120/255), marker='.',s=7, label=r'$ \\uparrow$' )\n",
    "plt.scatter(sweep_40,distance_40[300],color= (255/255,66/255,66/255),marker='.',s=7, label=r'$ \\downarrow$' )\n",
    "#plt.legend(loc=1, fontsize=10)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "plt.savefig(\"JPA_OFF_TRACES.pdf\",dpi=600, bbox_inches = \"tight\", rasterized='True')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:42:17.353590Z",
     "start_time": "2021-09-30T11:42:17.266692Z"
    }
   },
   "outputs": [],
   "source": [
    "## choose a threshold above which it's consider a bleep\n",
    "t_thershold=-2.53\n",
    "\n",
    "# select window for t_int\n",
    "minim= np.where(sweep_40>= 40)[0][0]\n",
    "maxim= np.where(sweep_40>= 300)[0][0]\n",
    "\n",
    "t_in=np.zeros(len(distance)) # bleep duration\n",
    "t_out=np.zeros(len(distance)) # times at which bleep starts\n",
    "\n",
    "for a in range(len(distance)):\n",
    "    \n",
    "    if np.any(distance_40[a][minim:maxim]>= t_thershold):\n",
    "        out = np.where(distance_40[a][minim:maxim]>= t_thershold)[0][0] # smallest time at which the signal is above the threshold\n",
    "        t_out[a]=sweep_40[out+minim]\n",
    "        inside = np.where(distance_40[a][minim:maxim]>=t_thershold)[0][-1] # last time at which signal is above the threshold\n",
    "        t_in[a]=sweep_40[inside+minim]-t_out[a] # t_in= last point of the bllep- first point of the bleep\n",
    "        \n",
    "t_in = np.delete(t_in, np.where(t_in== 0)[0])\n",
    "t_out = np.delete(t_out, np.where(t_out== 0)[0])\n",
    "hist_in,bin_edges_in= np.histogram(t_in, bins=60,range=(t_in.min(),(t_in).max()))\n",
    "hist_out,bin_edges_out= np.histogram(t_out, bins=60,range=(t_out.min(),(t_out).max()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:42:18.022877Z",
     "start_time": "2021-09-30T11:42:17.931158Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\virgi\\anaconda3\\envs\\qcodes\\lib\\site-packages\\lmfit\\model.py:968: UserWarning: The keyword argument sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(\"The keyword argument %s does not \" % name +\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEiCAYAAAA4f++MAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAA4jElEQVR4nO3dd5hU9fXH8ffZAixNpAhKx4KKoAQsAQvEgmhQBLuoGBSMmqYhSmxESSCSmGJ+SSSRGLtREbuIAsbYMdgQUImgLqAgRdpWzu+Pexdnh5ndmdndmd3Zz+t57jM7t825jO7Zbzd3R0REJBU5mQ5AREQaLiURERFJmZKIiIikTElERERSpiQiIiIpUxIREZGUKYlIg2BmY83Mw22/GMePiTh+XC19Zo/wfmNTuHaBmS2o4vidEfFWtQ1J/QlSEz73ZDPrFbW/tZndYGavmNlXZrYx/HlkumOU+kNJRBqazcD5MfZfGB5rKG4Gvh2x3RHuPzJq/38zEFsP4EagV9T+bsBlwIvAGOAs4EPgUTO7PJ0BSv2Rl+kARJI0CxhjZjd4OFLWzAqA04FHgLEZjC1h7r4cWF7x3sxODH983d3LMhNVtT4Bern7toh9c8ysK3A18H+ZCUsySSURaWjuBroT/MVe4TSC/5YfiXWBmY0xs3fMrMjM1pnZ3Wa2Z9Q5zc3sz2E1zRYzexzoEud+x5jZC2a22cy2mtkcMzuodh4vNWa2p5ndFT5fsZm9a2Zjos6ZbGa7TFERVq2tCH8eAswPD82NrFZz961RCaTCQmCvWn0gaTCURKShWQn8m8pVWhcAjwJbok82s/EEiWcJMAq4BhgGvGhmLSNOvR24GLg1PG8ZcF+M+50MvBB+1hjgXKAV8FL4F3namVkLgiqm4cDPgZHAe8Dd4fMn479ARdXUD0msWu1oYGmSnyNZQtVZ0hDdBfzWzH4I7A4cR/ALtBIzyyVoe1jg7mdH7F8KvAR8D/ijmfUmSAbXuvu08LTnwiRzadRt/wC86O6nRtxvPvA/4Crgx7XyhMm5CNgXGOruC8J9z5hZR2CKmd3h7uWJ3MjdvzazD8K3S9z9tarOD5PUEQQJVRohlUSkIXoIaAqMAM4D1hCUDqL1BvYA7o3c6e7/ISjRHBPuOpzg/4V/RV3/QOQbM9sX2Bu418zyKjZgG/AqwV/kmXA0UBiRQCrcA3QADqyLDw2rvv4I3OXu91Z9tmQrlUSkwXH3zWY2m6BKqwdwr7vvMLPoU9uGr6tj3GZNxPGK9pEvos6Jfr9H+HoH3/SmivRplYHXnbbEf8aK47XKzA4FHgfmEVQDSiOlJCIN1V3AUwQliHPinLM+fO0U41gn4K3w54pfwB0JqqWIeB/pq/B1EvB8jHuWVBFvXVpPUOqK1iniOEARgJk1cffIWNsl82Fm1heYA7wNjHb30qSilayi6ixpqOYSVD/91d0XxzlnGUFp4uzInWY2iKCH14Jw1+vADuDMqOvPjnq/DFgB9HH3hTG2d1N9mBp6EehiZoOj9p8LfAlUtHGsDF939iQzszbAoKjrisPXgugPCqv05hIk2++6+/YaRS4Nnkoi0iCFDcXxSiA7zzGzG4DbzewegjaCzsAvgY+AmeF5y8zsPuAmM8sB3gROAE6Kup+Hg+oeM7MmBElsHUGJZRDwqbvfWouPmag7gR8Bs8zsWuBzgrai44EJEY3qzwCbgL+Z2Y0E7Uo/Y9debR8CZcD3zGw9QVJZRpBU5gJNCAYjHhhVhbjI3YuRRkVJRLKau88ws23AROAxgl+YTwM/c/etEadOCI/9lOCX5DyCv+T/E3W/p83saOBa4O8Ev1jXAK8BD9bt08Tm7lvN7BjgFmAaQZfjZcD57n5PxHkbzey7wO8IEuDnwE0EvduGRJz3lZldQTCA8EUgFxgaHu4evj4ZI5SeBCU1aURMy+OKiEiq1CYiIiIpU3WWSD0WDpjcpe9yhB3uviNd8YhEU0lEpH5bDpRWsd2QudBEVBIRqe9GEPSiimdVugIRiUUN6yIikrKsL4m0b9/ee/TokekwREQalLfeemudu3eo7rysTyI9evRg4cKFmQ5DRKRBMbOV1Z+lhnUREakBJREREUlZ1ldniYjU1MaNG1m9OtZs+9mhWbNmdOnShfz8/KSvVRIREanGunXr6NGjBwUFu0xs3OC5O1999RWff/45PXv2TPp6VWeJiFSjtLSUZs2aZTqMOmFmtGvXjqKiopSuVxIREUlAjJUza9WCBQu47rrrUrp25syZu+zbunUrgwcP5owzzuDOO+/krbfeYsWKFcybN2+Xc2vybEoiIiINXKwk8s4773DUUUfx0EMPMXbsWAYMGBA3idSE2kTiufFG2LgR/vCHTEciIo3EG2+8wfDhwykuLubhhx+mbdu23HTTTcybN4+cnBxmzpxJWVkZ559/Ps2aNeP444+nffv2vPfeewwZMoTbbruNvn37AvCzn/2Mzz77jLy8PPLy8jjyyCOZOXMmL7/8Mq+++iovvPBCrcSsJBLP6tVw//1wyy3QtKqpi0REaoe788wzz/Dggw8yY8YMTjrpJAoLC1mwYAFLlixh6tSpHHbYYUyYMIGxY8fi7pgZd911FwsWLKh0rylTpvD8888zZcoUJk+eDMD48ePp1asXU6ZMqbWYlUTiOfVU+NvfYP58OPHEGt9u9qJCps9ZxqqN29mrTQETh/VmZP/OtRCoiKTNj38Mb79ds3sccgj8/vcxD/Xv3z885RDmzp3L0qVLWbBgAUOGDAFgzz335IwzzmDy5Mmcd955jBkzhuHDh9csnhpSEonn2GOhRQt47LEaJ5HZiwqZNOs9tpcGS10XbtzOpFnvASiRiMhO77zzzs7Xvffem/32248TTjiB2267DQh6iZWVlXHrrbdSUlLC4MGDGT58eMIN4/n5+ZSXl9dqzEoi8TRrBsOGweOPw//9H+Sk3gdh+pxlOxNIhe2l5Uyfs0xJRKQhiVOCqC35+fmceOKJFBUV8cgjj9CuXTs6derEkCFDMDPOOeccdtttN/70pz+xbds2xowZA0DXrl0ZPXo0v/zlL9l///3j3v+ggw5i0qRJnHXWWTz44IO1EnPWTwU/cOBAT3kCxrvvhgsugNdfh8MOSzmGntc8Rax/ZQM+mXZyyvcVkfRYsmQJBxxwQKbDqFPRz2hmb7n7wOquUxffqpx8MuTmBlVaNbBXm9ijXOPtFxFpKJREYpi9qJDB0+bR85ZX+W/3g/j6wUdqdL+Jw3pTkJ9baV9Bfi4Th/Wu0X1FRDJNSSRKRSN44cbtOPBEz8NovXwZzz3+csr3HNm/M1NH9aVzmwIM6NymgKmj+qo9REQaPDWsR4luBJ+77xHc+MLfWHr7PZxwyuCU7zuyf2clDZEGrGJMRjaqSdu4SiJRVm3cXun957t1ZEmHHhzx7ksZikhEMi0/Pz/lCQrru4pZfFOdYFIlkSh7tSmgMCqRPLfvEVzx6r9g3Tpo3z5DkYlIprRv354VK1ZkOow6U7GeSCqURKJMHNa70sBAgH8fMJgfvfIAPPkkjB2bueBEJCPatGlDmzZtMh1GvaTqrCixGsHPv2wkdO1a466+IiLZRiWRGGI2gp9yCsycCdu2QfPmmQlMRKSeUUkkUaeeCtu3w/PPZzoSEZF6Q0kkUcccA7vtpiotEZEISiKJatIETjoJnngCankWTBGRhkpJJBmjRsHatfDvf2c6EhGRekFJJBknnRSsMVJLUyiLiDR0aU0iZtbUzO4ws5VmttnM3jaz4eGxHmbmZrYlYrs+6tqZZva1ma0xsyvTGTsQ9MoaMQIeeQTKytL+8SIi9U26SyJ5wGfAMcBuwHXAv8ysR8Q5bdy9ZbjdHLF/MrAv0B0YCvzMzGq+bm2yzjwzGLk+f37aP1pEpL5JaxJx963uPtndV7j7Dnd/EvgEGJDA5RcCN7v7BndfAvwNGFuH4cY2fDi0aqUqLRERMtwmYmYdgf2AxRG7V5rZ52b2DzNrH563O7An8E7Eee8AfdIWbIVmzYIxI7NmQWlp2j9eRKQ+yVgSMbN84F7gn+6+FFgHHEpQXTUAaBUeB2gZvm6KuMWm8JxY9x5vZgvNbOHatWtrP/gzz4QNGzTwUEQavYwkETPLAe4GSoArANx9i7svdPcyd/8i3H+CmbUCtoSXto64TWtgc6z7u/sMdx/o7gM7dOhQ+w9wwgnBwENVaYlII5f2JGLBqi53AB2B0e4er06oYpWUHHffAKwGDo44fjCVq8HSp2lTOO00mD0bioszEoKISH2QiZLIX4ADgBHuvnPhDjM73Mx6m1mOmbUD/ggscPeKKqy7gOvMbHcz2x+4BLgzzbF/48wzYdMmeO65jIUgIpJp6R4n0h2YABwCrIkYD3Ie0At4lqCK6n2gGDgn4vIbgeXASuBFYLq7P5vG8Cs77jho21ZVWiLSqKV1Knh3XwlUtUjx/VVcWwx8L9wyLz8/mAblgQeC2X0LCjIdkYhI2mnak5o480zYsgWezVyBSEQkk5REamLoUOjQQVVaItJoKYnURF4ejB4dTA+/dWumoxERSTslkZo666xgydwnnsh0JCIiaackUlNHHw1du8Jdd2U6EhGRtFMSqamcHDj/fJgzB1avznQ0IiJppSRSGy64AHbsgHvvrf5cEZEsoiRSG3r3hiOOgH/+E9yrP19EJEsoidSWCy6A99+HRYsyHYmISNooidSWs86CJk3UwC4ijYqSSIJmLypk8LR59LzmKQZPm8fsRYWVT2jbFk45Be67T4tViUijoSSSgNmLCpk06z0KN27HgcKN25k0671dE8mFF8LatfDMMxmJU0Qk3ZREEjB9zjK2l5ZX2re9tJzpc5ZVPnHYMNhjj6CBXUSkEVASScCqjdsT25+fD+eeG4xe/+qrNEQmIpJZSiIJ2KtN7GneY+6/8MKgTUSTMopII6AkkoCJw3pTkJ9baV9Bfi4Th/Xe9eRDDoF+/VSlJSKNgpJIAkb278zUUX3p3KYAAzq3KWDqqL6M7N859gUXXghvvAFLl6Y1ThGRdDPP8hHWAwcO9IULF6b3Q9esgS5d4Kqr4Ne/Tu9ni4jUAjN7y90HVneeSiJ1oVMnGDEC/vEPKCnJdDQiInVGSaSG4g5CnDAhGDPy6KOZDVBEpA4pidRAlYMQTzgBevSAv/4102GKiNQZJZEaqHIQYk5OUBpZsEAN7CKStZREaqDaQYgXXRQMQJwxI+Z51c7HJSJSzymJ1EC1gxA7doTTToM774TtlRNOwvNxiYjUY0oiNRBvEOLQ/TvsLGH8oPVhsGEDPPxwpfMSno9LRKQeS2sSMbOmZnaHma00s81m9raZDY84fqyZLTWzbWY238y6R10708y+NrM1ZnZlOmOPJdYgxNEDOvPIW4U7SxhPtO3NJ20789Vv/1jp2oTn4xIRqcfyMvB5nwHHAJ8CJwH/MrO+wBZgFnAx8ARwM/AgcER47WRgX6A70AmYb2YfuPuz6XyAaCP7d640cn3wtHmVSxhm3HPIcK6f93d4991gShSCKq/CGAkjXhWZiEh9lNaSiLtvdffJ7r7C3Xe4+5PAJ8AAYBSw2N0fcvcigqRxsJntH15+IXCzu29w9yXA34Cx6Yw/EbFKEg8fdCzFuflw++079yU1H5eISD2V0TYRM+sI7AcsBvoA71Qcc/etwHKgj5ntDuwZeTz8uU/6ok1MrJLEpoJWzOs3BO6+G7ZsAVKYj0tEpB5Kd3XWTmaWD9wL/NPdl5pZS2Bt1GmbgFZAy4j30cdi3Xs8MB6gW7dutRl2tSYO682kWe9VqtIqyM+lxQ8vh4vmwgMPwMUXA7tWhYmINDQZKYmYWQ5wN1ACXBHu3gK0jjq1NbA5PEbU8Ypju3D3Ge4+0N0HdujQodbiTkS8EsbRF54CffvCn/8MWT7ppYg0HmkviZiZAXcAHYGT3L00PLSYoN2j4rwWwN4E7SQbzGw1cDAwNzzl4PCaeiduCeMHP4Dx4+Hf/4Zjjkl/YCIitSwTJZG/AAcAI9w9shX6UeAgMxttZs2AG4B33b1izpC7gOvMbPewsf0S4M40xl1zY8ZA+/Zw662ZjkREpFake5xId2ACcAiwxsy2hNt57r4WGA38EtgAHA6cHXH5jQQN7SuBF4Hpme7em7SCAvj+94M12D/+ONPRiIjUmBalSrc1a6B796Ba67bbMh2NiEhMiS5KlVKbiJn1BjoDzaKPufvTqdyz0ejUCc49F2bOhJtugt13z3REIiIpS6o6y8z6mtn7wAfA88CTUdsTtR5hNvrxj2HbNvjb3zIdiYhIjSTbJjITKAW+C/QGekZtvWo1umx18MFw7LHwxz9CaWn154uI1FPJJpEDgGvc/Rl3/8jdV0ZvdRFkVvrJT6CwcJfZfUVEGpJkk8gbQHqHgGer4cOhd++gu2+Wd24QkeyVbBIZD4w3s/PMbC8zax691UWQWSknJ2gbWbgQXn4509GIiKQk2SSyDlhBMPDvM4JpR6I3SdQFF0Dbthp8KCINVrJdfO8Bvg38BviYYO4rSVXz5nDppTB1KixbFlRviYg0IEkNNjSzrcAl7n5f3YVUu+rdYMNoX34JPXrAWWfBP/6R6WhERIDEBxsmW521AtiWUkQS2x57BKPX774bVqzIdDQiIklJNolMBK41sx51EEvj9dOfQm4u/PrXAMxeVMjgafPoec1TDJ42j9mLCjMcoIhIbMm2ifyCoIvvh2a2AtgYfYK7H1bzsBqZLl3gootg5kyeHTmOSf9Zt3NRq8KN25k06z0ALWAlIvVOsiWR94GnCVYkfJlgPY/oTVJx9dVQXs6mm6dVWhURYHtpOdPnLMtQYCIi8SVVEnH3i+oqkEavZ08YM4ZT7n2AW/qfxlct2lQ6vGrj9tjXiYhkUEaWx5U4Jk2iaXkJ4xbO3uXQXm0KErqF2lNEJJ2Sngo+bFQfA+xH7Kngz6x5WI1U796sOn4EFy54itsPG82mglYAFOTnMnFY9WNIZi8qZNKs99SeIiJpk+xU8AMI2j3OC7d9gYHA6cARQPvaDrCx6TL9ZlqUbOeHi5/BgM5tCpg6qm9CSWD6nGVqTxGRtEq2JDIdeAgYRzAl/Dh3/6+ZDQLuB26p5fgan3794NRTGffi44ybdRu0bp3wpfHaTdSeIiJ1Jdk2kUMIksWO8H0zAHd/haD777Rai6wxu+462LgRfv/7pC6L126SaHuKiEiykk0iDpR4MFfKl0D3iGOfEVRvSU0NHAijRsFvfgNr1yZ82cRhvSnIz620L9H2FBGRVCSbRD4A9g5/fhX4iZnta2bdgZ8By2szuEZtyhTYujWYnDFBI/t3ZuqovnRuU5B0e4qISCqSnYDxfKCHu99sZgcAzwF7hYe3Aqe7+3O1H2bq6v0EjFX53vfg3nvho4+gm9YCE5H0qZMJGN39bne/Ofx5CcFyuScCpwH71LcE0uBNnhy8/uIXGQ1DRCSehJOImTUzs+fMbEjFPnff4u5z3f1xd/+yLgJs1Lp1g8svhzvvhCVLMh2NiMguEk4i7l4EHArkVneu1KJJk6BFi6DHlohIPZNsw/rjwMiafKCZXWFmC82s2MzujNjfw8zczLZEbNdHHG9qZjPN7GszW2NmV9YkjgajQwe46iqYNQvefDPT0YiIVJLsYMM5wHQz25NgNt8vCLr97uTuT1dzj1XAFGAYEGsAQxt3L4uxfzJBF+LuQCdgvpl94O7PJvUEDdGVV8Kf/hSUSp5/PtPRiIjslMoa6wCjwi2aU011l7vPAjCzgUCXJD77QmCsu28ANpjZ34CxQPYnkVatguqsH/8Y5s6F44/PdEQiIkDy1Vk9q9l61UJMK83sczP7h5m1BzCz3YE9gXciznsH6FMLn9cwXHppsBb7T38KZbEKaiIi6ZdsF9+V1W01iGUdQcN9d2AA0Ipg8SuAluHrpojzN4Xn7MLMxoftLgvXJjHiuz6b/cE6rh10Abz7LtNP/6mmeBeReiGp6iwzq2rE2w7ga3f/OpVA3H0LUDEq8AszuwJYbWatgC3h/tZAUcTPm+PcawYwA4LBhqnEU5/snOK9y6F8t1tfxj33D07aZzAwSKPRRSSjkm0TWUFUQ3o0M/sU+KO7/y7VoEIVn5Pj7hvMbDVwMDA33H8wjWQ53p1TvJvxi2PH89SdP2LCgruZ3Go3ps9ZxqqN29mrTQETh/VWUhGRtEq2TeRc4HOCxuzLgDPC1zlAIXA58AJwi5n9JNYNzCzPzJoRNMDnhoMY88zscDPrbWY5ZtYO+COwwN0rqrDuAq4zs93NbH/gEuDOJONvkCKncl+6R0/uO+REzv/vU3T49GMKN27H+WYBKlVziUg6JZtEjgMed/eT3f12d58Vvp4EPAYMcveLgf8DLo1zj+uA7cA1BCskbg/39SJITpuB94Fi4JyI624kmOBxJfAiML1RdO9l16ncbz3yPLY2KeD6eX+HiLnPtACViKRbsknkDIJkEcvjwKnhz89QeZr4ndx9srtb1DbZ3e93957u3sLd93T3C9x9TcR1xe7+PXdv7e4d3f3WJGNvsKKneN/QfDduPWoMR69YxHEfv1HpXC1AJSLplGwSKQIGxzk2mG8avY1gVl+pBbGmeH960Cl82K4b1837O03KSneeqwWoRCSdkm1YnwFcH7ZZPAGsBToQlEAuBX4VnjeIymM6pIZG9u9cqdF89qJCfv3xBO6471rGLZzNX444QwtQiUjaJZVE3P16M1sPTASuIOhBZcAaYGJEj6wHgZm1GahUNrJ/Z/jphbz49tP84JUHePOw4xkzaoh6Z4lIWiW1KNXOi8xygG5AR4IE8pm776j6qsxo0ItSJeKzz+DAA2HwYHjmGTDLdEQikgXqZFGqCu6+w91XAP8NR6rXywTSKHTtCr/6FcyZA/ffn+loRKSRSTqJmNkgM3vGzDYDRWa22cyeNrNv10F8kojLLoPDDw8maPzqq0xHIyKNSFJJxMyOBxYQzL47nWCg4fTw/QIzO662A5QE5ObCjBmwYUMwQaOISJokWxL5JcF4kH7uflM40PAmd+8HPMk3vbMk3fr1g4kTg6V0X3gh09GISCORbBLpC/zNY7fGzwiPS6Zcfz3ssw9MmADbNehQROpesklkI7B3nGN7h8clUwoK4PbbYflyuOmmTEcjIo1AsknkIWCqmY0JJ1EknEBxDEFV1r9qO0BJ0ne+A2PHwvTpWpNdROpcsknkaoK2j38CW81sE8H0Jv8M919du+FJSm69FfbcE84/H7Zty3Q0IpLFkl3ZcLu7n0ewLO1Ygob2sUAfdx/j7kVVXC7psvvuQQP7smVwzTWZjkZEsliyKxseTTDAcCmwNOpYC2CAu/+7FuOTVB17LPzoR/CHP8CIEXD88bucMntRoRa1EpEaSbY6az5wYJxj+4fHpb6YOhUOOCBoI1m/vtKhiiV3taiViNREskmkqomZWgKqgK9PCgrg7rvhyy/h8ssrHdq55G4ELWolIsmqtjorrMIaErHrYjM7Meq0ZsDJwHu1F5rUigEDYPJkuO46OOUUOCdYLDLe4lVa1EpEkpFIm8jhwA/Cn51gdcOyqHNKCNpIJtZeaFJrrr4annwymGPryCOha1f2alNAYYyEoUWtRCQZ1VZnuft0d+/g7h2AT4GhFe8jts7ufqy7/7fuQ5ak5eUF1VplZXD22VBausuSu4AWtRKRpCXbxbenu79dR7FIXdpnH/j73+GVV2DSpJhL7k4d1Ve9s0QkKcl28R0NtHH3O8L3PYF7CXpsvQCMc/eNtR2k1NzsRYVM/6QDE751Mhf89re81vlARv7ke0oaIlIjyfbOug5oHfH+NqA9MA34FsHgQ6lnIrvzThl6Me902pcDJ/2Q5554JdOhiUgDl2wS6UXYA8vMdgNOAH7i7tOAa4ERtRue1IbI7rwleflcfurVONDt0rFQVHmSgdmLChk8bR49r3mKwdPmadyIiFQpleVxK6aBPwYoB54P338OdKiNoKR2RXfb/bxNJ646+Ur2X/URXHXVzv0agCgiyUo2ibwDnBdOcXIxMN/di8Nj3YAvazM4qR2xuu0+v+/h3HfUmfDnP8N99wEagCgiyUs2ifwcOA34mqAkMjni2Ejg9epuYGZXmNlCMys2szujjh1rZkvNbJuZzTez7hHHmprZTDP72szWmNmVScbeaMXrztviN7+Go4+GcePgjTc0AFFEkpZsF9//EJQ4DgO6u/sbEYdnEjS8V2cVMCU8fyczaw/MAq4H2gILgQcjTpkM7At0B4YCP4sxcl5iiNed99TDesDDD0OnTjByJP1sS8zrNQBRROKx2CvdpuGDzaYAXdx9bPh+PDDW3QeF71sA64D+7r7UzFaFx58Lj98M7OvuZ1f1OQMHDvSFCxfW4ZNkgfffh29/mw1de/GdU37BBvJ3HirIz9X4EZFGyMzecveB1Z2XyNxZlwEPufva8OequLv/JdEgo/QhaHOpuNFWM1sO9DGzL4A9I4+HP49M8bMk0kEHwX33sfupp/JEl5mcNfRHrNpUpOnhRaRaiQw2/BNB1dLa8OeqOJBqEmkZfkakTUCr8FjF++hjuwhLNeMBunXrlmI4jcyIETBtGl2uvpqXjxwI025I6TZao0Skcak2ibh7Tqyf68AWKg9kJHy/OTxW8b4o6tgu3H0GMAOC6qxajzRbTZwIixfDjTcG65CccUZSl1d0Ea7o4VXRRRhQIhHJUklNe1LBzPYDuhBMAR/J3f2ZFGNZDFwY8RktgL2Bxe6+wcxWAwcDc8NTDg6vkdpiBrffDh9/HKzP3rFj0HsrQVV1EVYSEclOyc6ddSDwAEH7RawFqhzIjbE/8h554efmArlm1oxgavlHgenh/FxPATcA74ZL8QLcBVxnZguBjsAlwEXJxC8JaNYMHn88mDL+lFPgpZegb9+ELlUXYZHGJ9nqqduBpsAooDfQM2rrlcA9rgO2A9cAY8Kfr3P3tcBogvm3NhCsYxLZ8+pGYDmwEngRmO7uzyYZvySiXTuYMwdatoRhw2DFioQui9cVWF2ERbJXUl18zWwLcLa7P1l3IdUudfGtgcWLgxLJHnvAf/4DHaqe1Sa6TQTURVikoUq0i2+yJZHl7NoOItmqT59gRcRPP4WTT4YtsQcjVtAaJSKNT7IlkeOAW4DT3f1/dRZVLVJJpBY88QScdhoce2zQXtK0aaYjEpE6VpuDDd/km5l7AToDS81sBbAx+nx3PyzxMKVBGDEiWBXxootg9Gh45BElEhEBEuudtZjKSUTdahujsWOhpAQmTIDTTw/m3FIiEWn0EhlsODYNcUhDMH48uMOllwYDER9+GJo0yXRUIpJBdTkCXbLRhAnBGiRPPBEkkpKSTEckIhmkJCLJ+/734U9/ChrZzzxTiUSkEVMSkdRcfjn88Y/w2GPByPatWzMdkYhkgJKIpO4HPwh6bc2dC8cdB+vXZzoiEUkzJRGpmXHjggb2//43mKyxsDDTEYlIGimJSM2ddho8+2wwsn3wYPjoo0xHJCJpoiQitWPoUJg/P2gbGTwYNEuASKOQ0noi0rjEW60w5v7//CeY+ffoo+Gee2DUqEyHLyJ1SCURqVLFzLyFG7fjfLNa4XWz34u5f/a2lvD663DwwcEUKVOnBgMURSQrKYlIleKtVnj/65/FXcWQjh2Dqq1zzoGf/zyYMqW4OI1Ri0i6qDpLqhRvVcLyOKWLnec3awb33gv77x+s2f6//8GsWdWuSSIiDYtKIlKleKsS5lqs1ZGjzjeDG26ABx4IGtoHDoQ336yLMEUkQ5REpEoTh/WmID+30r6C/FzOObxrzP0Th/Xe5R6z9zuSceNu5fONRZR8ezBv/1ztJCLZQklEqhRvtcIpI/smtIphRcP8Cy278d2xv+fl7v04ZOrP+ezk0ZoqRSQLJLWyYUOklQ0za/C0eRRGtKuY7+DyV//Flf+5l5wDDwwWuOq9a+lFRDKrrtZYF0lKdMO8Ww5/GnQ2F55xE3zxBQwYADNnqnpLpIFSEpE6Fa9h/n/9B8GiRXDYYcH8W6efDuvWpTk6EakpJRGpU/Ea5ofu34HB93xIr0N/wp+GT2DH409Av34wZ06GIhWRVCiJSJ2K1TA/ekBnHnmrkMKN29lhOfym3whGXfR7vm7eGk48kYcGjeKAqx5h8LR5zF6kWYFF6jM1rEvaRTe2V+iYt4PL597BBW88xso2nZg07AoW7TsgZq8vEalbDbZh3cwWmFmRmW0Jt2URx841s5VmttXMZptZ20zGKqmJNwr+i7Icbhh6CWef8yvKLYf7HryOyY/dyl9n648Akfqq3iWR0BXu3jLcegOYWR/gduB8oCOwDfhzBmOUFMVrbK/wWrd+DL/oNv58xOmMfv8F7v7t2GDhq4hS8+xFhQyeNo+e1zylai+RDKqvSSSW84An3P3f7r4FuB4YZWatMhyXJCleY/vuzfN3vi/Ob8otx4zl1At/x1e7dYAzzoDvfhc++ijuzMJKJCLpV1+TyFQzW2dmL5vZkHBfH+CdihPcfTlQAuyX/vCkJuKNgr9xRJ9dksv/uuzHstlz4be/hZdegj592PyTn2Jbt1Q6b+cMwiKSVvVxFt+rgQ8IEsTZwBNmdgjQEtgUde4mYJeSiJmNB8YDdOvWrS5jlRSN7N85bmN59EJXDgwuOYSSC/7ML169m/NffIDj33qOXw39Ho8fcEww0SPx21pEpO7U+95ZZvYs8BRwHPCyu98ScWwzMMTd34p3vXpnNWwVVVeRa5d8q3AJk5+/nX5rPuatvfZn6tCLWNilD53bFPDyNd/JYLQi2aPB9s6KwQEDFgMHV+w0s15AU+DDDMUlaRBrUaz/dj6AkRfcys9O/CFdvv6Sh++9mpmzbuamvev3H0Qi2aheJREza2Nmw8ysmZnlmdl5wNHAs8C9wAgzO8rMWgA3AbPcfXMmY5a6Fa+Kaofl8PIxpzJk/Az+OmwcR61ewrFnHQ8XXQSffprmKEUar3qVRIB8YAqwFlgH/AAY6e4fuvti4FKCZPIlQVvIZZkKVNIjXnfgiqqrJb8dzaXP/p38Ff+DK6+E++6DffeFyy6DlSvTHK1I41Ovkoi7r3X3Q929lbu3cfcj3H1uxPH73L2bu7dw91PdfX0m45W6F6878C6LX7VrB7/5DXz0UVAa+fvfYZ994JJLgqV5RaRO1KskIhItXnfguNOgdOsGf/0rLF8OEybA3XfDfvvB2LGweHE6QxdpFOp976yaUu+sxu3Z595i001TOeX1JykoK2bN4KF0+sW18J3v7OwaLCK7yqbeWSIpmb2okJ+8tJarj7yIQd+fyW+PPI+8txfBccfBt74VlFJKSjIdpkiDpiQiWSuye/CG5rtx2+BzGHzpTKaOuipIHhdcEFR/XXutGuFFUqQkIlkrVvfg4rwmzNh3KLz/Pjz7LBx+OEybBr16wYgR8PTTUF4e424iEouSiGSteN2D92pTELSHDBsGjz0Gn3wCkybBm2/CyScHCeWGG4LGeRGpkpKIZK2Euwd36wZTpgSDFB94APbfP3i/zz5w9NEwcyZs1phWkViURCRrJds9ePbitQz+pAM9+/+QkVffz+IrroEvvoBx46BjRzjzTJg1C7ZrokeRCuriK1lj9qLCXWYATnRZ3VgTPRbk5zL1tIMYWfwZ3HsvPPQQfPkltGoFI0fCWWcFPb2aNq3x54vUN4l28VUSkawQNwkkuD57vHXfK80MXFYGCxYEVV6PPAIbNwYJ5aSTePOQY/j++j1Yl9Mspc8XqW8STSL1cT0RkaTFmu23YqGqRH6Jx5vosdL+vDw47jhmtzuA3/U4g17vvMppK99k2HPPc+iDD/JKTh6vdD+Y5/c5jAW9BvB5m04Jf75IQ6UkIlkhoSRQhb3aFMQsiUT38Ios8azc+1Dm730oLY6/jANWLuaED1/jhI9eY8rcvwDwcdsuLOg1AAbugKOO2lntJZJNlEQkKySaBCpEt18M3b8Dj7xVuEt1WHRPrlglnq3lsKjrQSzs0odfDf0ePTesYujyhQz530LOf/tpOP4xKCiAI48M2lCOPRYOOQRyK/ccE2mI1CYiWSGZNpF4544e0Jn5S9dW2TDe85qniPd/TEF+7i73vGX43oxYvwyefz7YKiaB3H13GDo0KKEcfTQcfLCSitQrahORRqXil30ivaPitZ/MX7q22uV145V4OoefF/35I/p3BvaF7343OHHNGpg3D154AebPD7oMQ9BAP2hQkFQGDYKBA4N9IvWcSiLS6MQrTRjwybSTK+1LtNor5V5Yn38OL730zfb++8H+nBw46CA+2acv99le/Hu37mzbez+uGn4gkFiyFKkJlURE4kilER2gcON2HnmrMKFqr8h7RP/Ch+gkcDQjzzknuGD9enjjDXjtNb54bgHtnprNtcVbuRbYlt+UJX/uxft77svhHfdmcce9WV7ehUmz3gNQIpGMUElEGp1E208SGjuS5Ofk5xgYlJZ/8/9dvJLM4GnzWLVhK72+KqTfmo/ou+ZjDvriYw76YjnNS4sBKM7N4+N23VjZZR9OGnMi9OsHffoEI+y1XorUgEoiInEk2n5S027DsdpeSnfs+kdbvPEsqzZuxy2H5e27srx9Vx49KEhcOTvK6bW+kD5fLOeALz/hwC8/4dBlb8CVz31zcdu2QTKp2Hr3DuYE69w5qCoTqSVKItIojezfudrqn2S7DUdLNNlAUFU2eNq8Skkt3ufvyMnl4/bd+Lh9Nx7rMxQIS0cX9YH33oMPPgh6gS1eHIyu37jxm4ubNw+WC95/f9h332CSyYqtQweVXiRpSiIicUwc1jtmtdcuswDHES8JxGKw89zCjduZNOs9Rg/ovEsjfrzqsInDegdVWB07BmNRKrgHPcKWLYOlS4PXZcvg9dfhX/+CHTt2nrqtSQEr2nRiXfs92euQA9nn8L7Qo0ewde8Ou+2W0LNI46I2EZEq1PakjrGSgEHM3mLxug1DLfXOKimBFSt45bnXmffkK3ReV0jXjWvouukLum76Yme7y06tW0PXrsHU+d26QZcuQfVY5GurVirNZAlNwBhSEpFMSqR3VrzSSqwuxzX5nIpkE33utpIyNmwrrXxDd/rkF/PUiC6wYgV89lmw3krk9tVXuwbSvDnsuWflrVOnb0pJkVuTJon+M0oGKImElESkvktnL7BYVWTxVJvEiopg1apgrEthYfC6enXlbdUq2LIl9vWtWwftMO3bB68dOkC7dsH7du0qb7vvHnQWaNYs9r0SpOn6E6ckElISkfqurqaxjyXXjPIE/59vU5BPi6Z5NR4Ps37tBvrkFvGDPq1oun4dC15aTP66L+lavpVvt95B040b2LhyFa02b6Bt0dc0LSuN+RkA5U2bsr5pS9Y3aUFxi1bs0bUjpa1a88aGHayhKdZmNwb170VZy1Y88OHXfFqaS0H7tpx3XB/KWrTimrmf8LV/M71MbUzXn2hiamgJLCuTiJm1Be4ATgDWAZPc/b6qrlESkYagJr9gqprPK1XJjGdJtCSU0D532lLGOfs059U3PqRg8ybabN/MbsVbaFu0hd2Kt9Bq22ZaF22hdfFWdiveSuvirbQq2krroi3k+TcdBeIpyclja5MCtjZpxrb8AoqaNae4WXM2Wj7eogX79epEj+57QIsW32zNm7PwyyIeWrqBVcVGy91bceZR+1HerICpC1ayiVyK8ppSlNeE/KZNGD2wS6UBqbU+00HEv31dtZllaxK5n2BJ33HAIcBTwCB3XxzvGiURyXa1URKJLnXEbCeJcV5Fw3+in5+oZEpMO7lTUFpMy5JtQWIp3kar4q20KNlOy5LtwWvxNlqWbKd56XZalBTRPOJY89IiCkqLaVFWRKvyEpoUbSMnhd+P5ZZDUV4TivOahK/5lOTmU5zXhOLcJpTk5VGSG+zzJk3xJk3YuCOH/OYFHLxPR/bt0pYl64t5ccUmvipxClq2YGi/znh+Ex5fso61RTto2bo5fbq348X/bWSL51Cak0dZbi7k5VGam0cRuZTm5PJFq3bkNWuWUrLKuiRiZi2ADcBB7v5huO9uoNDdr4l3nZKIZLuatonE+os40dJN9MzF2cIAd6dpWQnNykpoXlpMs7JiCkqLKSgtollZCQUR+5qVFdO0rISmZaU0KyvZeV2T8tJwfwlNd/5cSpPyb7amZaU0LS8hv7yM/PIymu0oI7e8rFae49hxf2F5+64Jt69V+jfIwhHr+wFlFQkk9A5wTIbiEakX4o3Aj7VvZP/ODOzettrqjkTHuGwvLU+t1FCNurhnm4J8ist2JJT0HMCM4vymFOc3ZVNB+mZUzjVjx45ymoRJJb+8lPzyMprsKKNJWSl5O8rI31FOfnlZ8HN5OfnlpeTtKCd/Rxl55eU7z/myVVsguYGvyWpIJZGjgIfcvVPEvkuA89x9SNS544HxAN26dRuwcuXKdIYq0uDFKt1UJbpEknKbCPFLTDW959RRfQGq796chFiJKd64n3j700ElkcAWoHXUvtbA5ugT3X0GMAOC6qy6D00ku8Qq3cT7hZvMoMhE98UrMdX0npHPBrGTZaJJoCA/l8mn9Nnls+I1okfP/hzv3zOZUlh0TFXOaFBHGlJJpKJNpI+7fxTuuwtYpTYRkbpX067I9VWia8bUdAmAZFbYTHS6m1gxgXpnxWVmDxAk3osJemc9jXpniaRNQxvrkKp0PWe8z6nLrruJytYk0haYCRwPfAVco3EiIiK1LxvbRHD39cDITMchIiIBrU4jIiIpUxIREZGUKYmIiEjKlERERCRlDap3VirMbC1Q20PW2xPMItzYNMbn1jM3DnrmXXV39w7V3STrk0hdMLOFiXR9yzaN8bn1zI2Dnjl1qs4SEZGUKYmIiEjKlERSMyPTAWRIY3xuPXPjoGdOkdpEREQkZSqJiIhIypREREQkZUoi1TCzBWZWZGZbwm1ZxLFzzWylmW01s9nhLMMNjpldYWYLzazYzO6MOnasmS01s21mNt/Mukcca2pmM83sazNbY2ZXpj34FMV7ZjPrYWYe8X1vMbPrI4435GduamZ3hP/Nbjazt81seMTxrPuuq3rmLP+u7zGz1WHsH5rZxRHHavd7dndtVWzAAuDiGPv7EKyqeDTQErgPeCDT8ab4jKMIZkf+C3BnxP72wCbgDKAZMB14LeL4VOAlYHfgAGANcGKmn6eGz9yDYM2avDjXNeRnbgFMDp8xB/hu+N9wj2z9rqt55mz+rvsATcOf9w9jH1AX33PGH7a+b1UkkV8B90W83xsoAVplOuYaPOuUqF+o44FXIt63ALYD+4fvVwEnRBy/mQaWSGM8c3W/WBr8M0c9z7vA6MbwXcd45kbxXQO9gdXAmXXxPas6KzFTzWydmb1sZkPCfX2AdypOcPflBElkv/SHV2ein3ErsBzoY2a7A3tGHg9/7pPWCOvOSjP73Mz+YWbtAbLtmc2sI8F/r4tpJN911DNXyMrv2sz+bGbbgKUESeRp6uB7VhKp3tVAL6AzQb/qJ8xsb4IqrE1R524CWqU3vDpV1TO2jHgffawhWwccCnQnKP63Au4Nj2XNM5tZPsFz/dPdl9IIvusYz5zV37W7X0YQ71HALKCYOvieG9TKhpng7q9HvP2nmZ0DnARsAVpHnd6aoL41W1T1jFsi3hdFHWuw3H0LULGe8hdmdgWw2sxakSXPbGY5wN0EJecrwt1Z/V3HeubG8F27eznwHzMbA3yfOvieVRJJngNGUBw+uGKnmfUCmgIfZiiuuhD9jC0I2n4Wu/sGgiLywRHnH0zlaoJsUDEaNycbntnMDLgD6AiMdvfS8FDWftdVPHO0rPquo+QRfp/U9vec6Uaf+rwBbYBhBL0Y8oDzgK0Edap9gK8JiootgHtogI1u4XPmhc84leCvtYrn7UBQnB0d7vs1lXtyTANeJOjJsX/4H2BD6b0S75kPJ2iIzAHaAQ8C87PhmcP4/wq8BrSM2p/N33W8Z87K7xrYAziboHoqN/wdthU4pS6+54w/cH3ewn/wNwmKcxvD/xCPjzh+LvBp+AU9BrTNdMwpPudkgr/CIrfJ4bHjCBrmthP0VOsRcV1TYCZBMv0CuDLTz1LTZwbOAT4Jv9PVwF1Apyx55u7hcxYRVF1UbOdl63dd1TNn63cd/t56Mfyd9TXwHnBJxPFa/Z41d5aIiKRMbSIiIpIyJREREUmZkoiIiKRMSURERFKmJCIiIilTEhERkZQpiUijEK4bUd02JI3x7GFmk82sRxLXPG5mN9ZyHKeb2TIzy63N+0rjoXEi0iiY2RERbwuAeQTTwD8Vsf8Dd/86TfEcRDAIbKi7L0jg/MOBF4Bu7r6+FuPIIRh49it3v7O27iuNhyZglEbB3V+r+NnMKmYrXR65v577IfBYbSYQAHffYWZ3AT8A7qzNe0vjoOoskSSYWW5YDfWpBUvrLjazc6POWWBmD0ftGxJWmR0UVmG9Fx6aX1GdVsVntgJOA6LvucLMfhO1b2x4v5bh+3wz+01EvKvM7FEzaxJx2SPAt8yswayVIfWHkohIcm4CriVYW+YU4GXg3nCJgEStJpi7CeBy4NvhFs8ggiq4V5KOFiaFn3U9cDzwY4IJ+Ha2gbj7EmADwZxKIklRdZZIgsysLcEv4SnuPiXcPcfMuhBM3nh/Ivdx92Izezd8+0ECVWoDgHXu/kXyUXMYwTLO/4zY968Y570bniuSFJVERBJ3ENAceChq/4PAfmbWoY4+txPBKnypeBsYa2Y/M7N+4doasawLP0ckKUoiIonbM3yNLhFUvG9bR5/bjGBp01RMAf4PuIxgvezPzOxHMc4rDj9HJClKIiKJWx2+7hG1v2P4WtFzqghoEnXO7jX43PUEC6RFq/Zz3L3I3W9w9x4Ei6k9CPzezE6Muq4N38QvkjAlEZHEvQ9sA86I2n8m8KG7rw3ff06wKlykE6Lel4Svifz1vwzYy8yaRu3/HDigms/Zyd0/An5KUOo4MOpwD7JraWdJEzWsiyTI3deb2e+B68ysDFgIjAJOIlglr8KjwDgz+x3BYMahQPRf/p8SrCx3oZltAkrdfWGcj34ZyAf6hp8Z+Tm3mdnPCVbgHE2wbPNOZvYo8BawKPy80wn+v/93xDktCJLe9dX/K4hUppKISHJuIFiX/fvAk8DRwBh3f6DiBHd/Cvg5wS/sRwmWaK3UDuHuRcAlBD2vXiRIAjG5+4cEpaDhUYdmAL8nGIj4L4ISxpSoc14BRgL3ESzhPAAYHZWwTiAoYc2p4rlFYtK0JyINgJn9BBjn7gfVwb3vB7a6+8W1fW/JfkoiIg1AWOX0P+A8d3++Fu/blaDNpZ+7f1xb95XGQ20iIqFwJtt44yjc3cvTGU/Uh281swuBFrV86y7ApUogkiqVRERCZraCoP0ilpVhN1kRiaCSiMg3RgDR3WgrpDrYTySrqSQiIiIpUxdfERFJmZKIiIikTElERERSpiQiIiIpUxIREZGU/T+jC2Gyzfc+vQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fit T_out to an exponential\n",
    "def exponential(x, A,T_out):\n",
    "    return A*np.exp(-x/T_out)\n",
    "%matplotlib inline\n",
    "\n",
    "time_out, time_out_error=model_fit1( bin_edges_out[1:-1], hist_out[1::],exponential, \"T_out\"+str(id_1),\"T_out (us)\",\"histogram\",1, init={\"A\":200,'T_out':18})\n",
    "\n",
    "signal_parameters[\"t_out\"]=time_out[\"T_out\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:42:18.831752Z",
     "start_time": "2021-09-30T11:42:18.724185Z"
    }
   },
   "outputs": [],
   "source": [
    "## choose a threshold above which it's consider a bleep\n",
    "\n",
    "\n",
    "# select window for t_int\n",
    "minim= np.where(sweep_40>= 20)[0][0]\n",
    "maxim= np.where(sweep_40>= 1900)[0][0]\n",
    "\n",
    "t_in=np.zeros(len(integer)) # bleep duration\n",
    "t_out=np.zeros(len(integer)) # times at which bleep starts\n",
    "\n",
    "for a in range(len(integer)):\n",
    "    \n",
    "    if np.any(distance_40[a][minim:maxim]>= t_thershold):\n",
    "        out = np.where(distance_40[a][minim:maxim]>= t_thershold)[0][0] # smallest time at which the signal is above the threshold\n",
    "        t_out[a]=sweep_40[out+minim]\n",
    "        inside = np.where(distance_40[a][minim:maxim]>=t_thershold)[0][-1] # last time at which signal is above the threshold\n",
    "        t_in[a]=sweep_40[inside+minim]-t_out[a] # t_in= last point of the bllep- first point of the bleep\n",
    "        \n",
    "t_in = np.delete(t_in, np.where(t_in== 0)[0])\n",
    "t_out = np.delete(t_out, np.where(t_out== 0)[0])\n",
    "hist_in,bin_edges_in= np.histogram(t_in, bins=100,range=(t_in.min(),(t_in).max()))\n",
    "hist_out,bin_edges_out= np.histogram(t_out, bins=100,range=(t_out.min(),(t_out).max()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:42:19.518860Z",
     "start_time": "2021-09-30T11:42:19.406781Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\virgi\\anaconda3\\envs\\qcodes\\lib\\site-packages\\lmfit\\model.py:968: UserWarning: The keyword argument sigma does not match any arguments of the model function. It will be ignored.\n",
      "  warnings.warn(\"The keyword argument %s does not \" % name +\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def exponential(x, A,T_in):\n",
    "    return A*np.exp(-x/T_in)\n",
    "%matplotlib inline\n",
    "\n",
    "time_in, time_in_error=model_fit1( bin_edges_in[2:-2], hist_in[2:-1],exponential, \"T_in\"+str(id_1),\"T_in (us)\",\"histogram\",1, init={\"A\":200,'T_in':40})\n",
    "signal_parameters[\"t_in\"]=time_in[\"T_in\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:42:20.144558Z",
     "start_time": "2021-09-30T11:42:20.139575Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'mean_bg': 0,\n",
       " 'std_bg': 0,\n",
       " 'mean_up': 0,\n",
       " 'std_up': 0,\n",
       " 't_int': 0,\n",
       " 't_out': 47.833033656780664,\n",
       " 't_in': 436.06703990665557}"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "signal_parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-08-22T10:23:33.324267Z",
     "start_time": "2021-08-22T10:23:32.562844Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting noise\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:42:25.161325Z",
     "start_time": "2021-09-30T11:42:25.111565Z"
    }
   },
   "outputs": [],
   "source": [
    "# GETTing std and mean from background for I and Q\n",
    "minim= np.where(sweep>= 1600)[0][0]\n",
    "maxim= np.where(sweep>= 2000)[0][0]\n",
    "\n",
    "std_distance=np.std(np.transpose(distance)[minim:maxim]) # mean of the background I\n",
    "signal_low_distance=np.mean(np.transpose(distance)[minim:maxim]) # std of the background I\n",
    "signal_parameters[\"mean_bg\"]=signal_low_distance\n",
    "signal_parameters[\"std_bg\"]=std_distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:43:18.327352Z",
     "start_time": "2021-09-30T11:43:18.237514Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD4CAYAAADvsV2wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAB0vUlEQVR4nO19ebwdRZn2U33OuUt2QkIghBAg7DuGTRFBFtkGxtEZcfRTBGUcHXdlYBjHZUbFZT6Vz9EZxNFRccER3BAIIMgaIECAsG+BELYEyEKSm3vO6fr+6K7ut6rfqq4+y13O7ef3yy/39FJV3V311lvPu5SQUqJEiRIlSvQ+gtFuQIkSJUqUGBmUAr9EiRIlJghKgV+iRIkSEwSlwC9RokSJCYJS4JcoUaLEBEF1tBvgwqxZs+SCBQtGuxklSpQoMW5w1113rZFSzubOjWmBv2DBAixdunS0m1GiRIkS4wZCiKdt50pKp0SJEiUmCEqBX6JEiRITBKXAL1GiRIkJglLglyhRosQEQSnwS5QoUWKCoBT4JUqUKDFBUAr8EiVKlJggKAV+CQDAS+uHcM2DL452M0qUKNFFlAK/BADg9IuW4AM/XopGMxztppQoMSbRaIZohuN7/5BS4JcAADz9yiYAwPjuziVKdA8Lz78SJ19402g3oy2UAr8EACAQ0f/jXYMpUaKbePiFDaPdhLZQCvwSAACBSOKXO16WKNG7KAV+iQhKwy8lfokSPYtS4JcAkMh7hKXALzHCWLe5js//7gFsaTRHuyk9j1LglwAABCIS+WHJ4Vux+IEX8PhL45vDHYv4xtWP4Ee3rsDld68a7ab0PMZ0PvwSI4dY3qOU93ac/ZO7AAArLjh5lFvSWxhuRK7AZdfrPtrS8IUQXxdCPCyEuE8IcbkQYobj2ooQ4h4hxB/aqbNEd6AondJLp8RIQ8aiXnmKlege2qV0rgGwj5RyPwCPAjjPce3HADzUZn09iXozhBxl7lwI5aVTCvwSIwulY6g+WKJ7aEvgSykXSykb8c8lAOZx1wkh5gE4GcDF7dTXixiqN7Hr+Vfi3xc/OqrtEKWXTtt4deMw/uvPT5STZkEoR4FS3HcfnTTangngSsu5bwE4B0Bu3L4Q4mwhxFIhxNLVq1d3sHljExu3RPPlJbdbt6EcEeRROt+4+hHs/4XFI9egcYhzfn0fvnLlw7jr6VdHuynjC3GXC0oNv+vIFfhCiGuFEMuZf6eRa84H0ABwCXP/KQBeklLe5dMgKeVFUspFUspFs2ezG6/3FBIqZay0w9KQ71z/ONZtro9gi8Yf1sfvp94c7a85vqA0/KD0Gew6cr10pJTHus4LIc4AcAqAYyS/ln0DgFOFECcBGAAwTQjxUynlu1tob89hrOg0ZWoFN3xomvLNtYaw1PBHDO166ZyAiKo5VUq5ibtGSnmelHKelHIBgNMB/KkU9mMPSsMvA694eM2DifGxq03pOZR9buTQ7iLqOwCmArhGCLFMCPGfACCEmCuE+GPbresR3LniFez3+auxbpOdEinS56WUWPzACx0NkiojbXkMN0Lc9NhqNML8tNEJNVFK/EJQPa700uk+2vXSWSil3EFKeUD874Px8eeklCcx198gpTylnTrHI/7fnx7H+qEG7lmZNeapzl7Es+M3y1bh7J/chR/ftqIzDUQZeGXD169+GP/nB3fgrhX5hthUcHW3Tb0GmUyUo9yQCYDSTDICUB2Zk+mtaNQvrt8CAHh+3VA7zTIQNbLk8HU8sXojAGD1a1tyr5U97F74m3tWYe2m4a6UrRZP5cqo+ygF/gggcPDj6lgrYraTolmURlsA0VaPFEqI+8zLvarhP7VmIz7+y2X46C+WdaV8FWnbY69tTKIU+COAwEWXtCBfuzEwXKuQiYJbHl+DQ758Ha5a/kJyTL0On4kwfXe9JbpUFssX1m3uSvllpO3IoRT4IwCXB0wiR0ZZ0KpVyESLtP3cb5fjt8uiLI33r1oHALjnmSxf7/NeelXD7zZKDn/kUAr8EYDqx5xhVi1nW6J0OiicJ6qXzv/c9jQ+ZlAV9A2o1+HlEdXDHH43IXtEw98wFOX1H6qP3bz+pcAfAaQcfvZcK5R5N8aF8MyH38t5YriJWf3lJe9VOS18oPueXcuuLMYCRJensF5RMi687jH86NYV+OWdK0e7KVaU+fBHACpknKV0QmUULN7puzFO8gSblL1LWQiHHaMI1dXK6zn1O7cAGNu59rsll1WfG++CX6XUGMuOD6WGPwIQDg2/pfK6oHH5eumM3a7cPpKN3MkxNRH7UDp58ioMZZIsbzyh2xN8K7EoYxljWSEqBf4IIHDkmm/HLbOTSLVbd0vGuxbmgmugennpKPdCSzlfX/wI9v7c1XjkhfG5TWK3vnwR19exjPEwYZUCfwSQcsPZc0qOtNJXOtm9fL10xkGfbhutBsglxkfLCuxXS58FALzlWzfid/c+51Fe51NotIJuf3P1bscwE1IIY1jBLwX+SCD1w2e8dFoYTV0x2sb/52myvazhK0gylarHLeaHz2O4kXpv3P/s2tzyfnXXszj7J3fhZ3c8k3ttN9FtTjrxhGqxbw3Vm3jwufUdbFEW3cyWunzVOqxa250YBxOlwPfEylc24a6nX2np3iDI99KRLXSXTsrevHz4EwHcO1DfpYgfvu1b0jz5Pp48L8apM57vUsCTLxLasUudo11a8zP/ex9OuvAmvLqxO6kfgGKrj6JeWqf8v5vxhgv+lPweboRdc+0sBb4n3vi16/G2793W0r1qic9rMGNDwvoabXtJwzcFmGuY+hlt3Vx0vZlm3PQRCS6voZFEt795Smu2Vs+SJ18GAAw38zOatoqR5Oc///sHcMRX/5R/YQsoBf4IIIkg7DiHP/KBV6MtfDoJc3LjFLOUbsgvT11ru7RBC/GQ+GNlN7Ruc+uJJ1SLnasRC/puescU+f4+eGn9EDYN8x5bketzdx6mFPgtIgylN2/YreRpnYTvBii9pOHbaBqqzYUFhFESNe1xbRHX2tF+5SPF4bf6nIoq89iyoGUU6fc+svqQL1+Hv/rurew5KWXX0kyUAr9FfPeGx3HShTfhPg/jWxp4lT3XSifvxuyfavju63pH3GcFhGMhVsgPv1PvKKF0Rvmtyy4rJe166SiqzGeTmlbhly212AM8bHHPDaXsWqroUuC3iGUr1wIAXiA56R94bh3+5bfLs9ywh4bfCjqp+SVumXmBV13UokYapobPGm0lfy2HNIAov26f8RykEn9U0W0Nv10OX7Wvm+0spOFbji849wp885pHPerq3t4ApcBvEdzGy2f88E78+LanM5tlpKmHObdM9Yd/3d3oCumOVzkCf7SlTwdh4/A1t8zk2iIl+1A6+RgrCe26nUG1yETJQdlGGl0U+J0q+dvXPZZ7TShl1+wRE1LgP/zCeqvBxBfJ/qXkDfZXox9b6rp0SL10suWkNMDYEKT5HP4INWQEkBH4jmu9/LALUBM+A3qseOm0opQUK789o63CaGv4rkuKrF5kqeF3DkP1Jk741k34h5/d01Y5qnPRDzNQqwBIN4xQcGn4rXRy7o5mKNtyHUspnZy6R1v6dBA2AaE9otSvdY3DQpSOh47P5fYZDXSf0umMjaDR7F47fajMpHamk9QLtC0sjbadgzLw3PFUa0FUCmpQU4GvNPwhU8NP0hZky0mDWvzr5gyIu/zTH/FPly/3L8SAL6XTSxp+5lkZN0gz8Mo5Dgtw0T4Deqxo+N2mlNqNtFXoZjvb5fCLGJRLDr8LaFVTNZefnIZvRsmpa6598MXMuVZaYUY+Kj/kn7cRgp8I/Nxsmb0j8W2UDptLh1nRmSjEfBQY0KP9zkcq8KpdZaKbHL7tHdz2xMtYcO4VeGHdkHNirjeKafjdSsgz4QS+mmhb7RpKSHAc/kAt5vAb+myutLnbnnwZX/7jQ9q5VlzeTCPaxuGmVk8rcNkZKLo59le+sgk3PPJS9yowYA+8IkZbw0vHKfALrNZ8PlXAeA2NBtodM3lIlK+2OfwuumVajv9kyQoAwF1Pv+q8v16kbaWG3zm063HQTDT86LdO6Vg0fCKJn1qzUTuX9vViRh0g7YSvxTnWJ/W1vp+NauJoZss8/ps34owf3tm9CgxkNfzsIFNXKH7Yi8P38dIpROn0tpdOp7JldpPDt2n4qZ3FXXe9gJtXyeF3EK1w5vRjJdoOU4DS8DcbAp9+O/O2Vjq5Kag2JgK/4nX/hy+5G396+EX9oCNnP0U3lver1m7Gv/3hwcx76zbskbbZYw0fo62D0zGpskKRtt5XdgfdTs/crh++QjeNy9amaXYWex9Rk1HFQ5KXgVcdRLKlYIFhRCkaJSRU56IdQWn4m4cNgU8+nikwW/FQMOveMFRM4F9x//M480dL9TYaZdvQ7pB65IUNWHDuFdpK5xO/WIaLb36qzZL98MTq1/DbZasA2AWZHnil20ncHL79W5o0X5HAq1GndDokkG0o4s7qwmhw+Fx0NjeZq8RuFY8PH8oxmktHCPF1IcTDQoj7hBCXCyFmWK5bIYS4XwixTAixlLtmpNBsQcOnFE3K4SP+Py1IafgmpVMhb9nsOK2MIdNwvLEApWMbtKmXjvv+drW9y+6ONgG5avkLybFC/GabOObf/4yP/WIZgKyGnwpswuHH/ycavqNsFxU9bAp8j7aOZGqFejPEYy/yof5dD7xixlIr6GY7bd1ekJWxK6ZGafhBoI9BPhhz7FI61wDYR0q5H4BHAZznuPZoKeUBUspFbdbZFhLtuMA9VICbm47TTppo+BlKJ/165vdtZXu3plG34vAn9+dr+NaOq87nafhdGFOt9u3v3/gklq9a13K9JufrEtjJgHUabeP/md5lTmpLnnoZh3/lOmcAYMisIruFf/3DgzjumzeyufdHKpdOK6ACs9lNP/wCbeSGUJ1o+PQ8l9J5zLplSikXSylVj10CYF77TeouWlEmWUqHWYb2Kw5/WK+ECoDVr23BJy9dltA+rSjM6h41eRUx2tooG+8tDtsc9uruTvTnL/3xIZzy/25u+f7saovTtqL/fTh88x4K02h3y+Mv4/l1Q879bTvlruiDmx9fAwDsJutFuPFrHnwRv/fYvpFCld6K4Kdjk6N0Lrv7WfzyzvZ3DLM1jXPl5fqR+v5BILTnNGN2gO4abVt368jiTAC/tJyTABYLISSA/5JSXmQrRAhxNoCzAWD+/PkdbF6EZqqGeYPT8NXEQTVipcmbGj79/k+u3ognV2/EwQtm4p2HzG9JgKo6lQx5baiIhp9H6bjb0ynhQ/tzt/jKPJiCLGS6RkrppAPWBleKgCJ+2Gl7Ro68V5RTrZLVAfO++X/9+QnUKgHOPGInfODHEWP7F/vP9a67HS8dqiFzE9MnL70XAPCOg9uTJXnjBiDUFNMONRlVDIG/hXFUCCU6oxExyNXwhRDXCiGWM/9OI9ecD6AB4BJLMUdIKQ8CcCKADwshjrTVJ6W8SEq5SEq5aPbs2QUfJx+pkdS/d3FaBJcnXZXpE1ylBlg7Xjomhz9Y8+Hw+eNJRs9cSqdNDd/jfp9rfG0JUkpc++CLrDCwGtCZopPUCq66jP8pWtmNKW1f9wW/2R+boUz7Wc67vuqBF3D1Ay84r6G4/pGXEiN4VH70fytdi7atm+mR89OGpxewlE4jpXToc5rGfGCUOXwp5bFSyn2Yf78FACHEGQBOAfAuaRmpUspV8f8vAbgcwCEde4KCaIUXrTeyWgSnlagyTS8dTjtQA6wVAWqjdHw6iY2y8c2H3zENXwB3Pf0KHn1xQ0aI+tTha6C7avkLeP+Pl+Lim57UjkspM3mD2P2F43rqya5K+Rw+J5+L+GErNJNVZOFbC0O1TwUvferSZfjkpcuiY3mrvlB6T2g3P7YG7/vhnbjwusfw0vohLDj3imQD71ZWNHQi765bpnvcSJn2G3aFpyK1M5ROVsOXY5XDF0KcAOAcAKdKKTdZrpkshJiq/gZwPIDWk760icRLp8A9NPGRKehpJ1OdIuNPzlSmBkhLWo1hR1D1hRJYvWFLssen614b8gdNuxp++vfbvncbjv/mjZnVq8/A9x3czycbgQ9px6XMaoRpxCc5ZtSnJtVF/3YtPvaLe/T7GS8fhVYEfiur0VahFBC1gl356mY8v3ZIb4elGU0pM15INry0ISrzmVc2YeWrrMjI4Iwf3oEr73/eWnfyd1fdMtO/qfCneyi4jP5FNPyxHHj1HQBTAVwTu1z+JwAIIeYKIf4YXzMHwM1CiHsB3AHgCinlVW3W2zJa6RTUw8LU8PXt8OJrMu5+WWxJltCtc7tqtaImJCkl3va9W3H6RUvs9xakbC6/51k8SwZm5zh8e4/upMBX11WNERRKmdGcXdWmBsGonDWvbcFvlz2HFSSewDngWxH4HfDSeTHWom99Yo3zOqWAKG+kRjPM9DMbmmHW7dQG9SyBEBkK0lbPDY+sxt9fcrel7pHX8Gk1XC/mVkRKuTA5fM7QHOXD747Eb8toK6VcaDn+HICT4r+fBLB/O/V0Eq5IWRsopWNqOxylM9wIMVRvJsnUuI6cUjrezUhg7vCj+NBQSjzziltrso2JRJM1NKZP/PJebDd9IL2uzTGlbndRAD51+AbZJMayij6AmlJmBiYXBJd46SSrPP2eo75xA1ZccLJ2hmv/cAtG21ZWoyaWrngVAPCT257G63eZZb1OKQ1NokRUAn01a1tpFKF0EmEngGrFnIS9itBAhXx3A6/o3xIVQ9RL6OdNDBM/fFpWw+qW2VZzrZhwkbbtUjoJr2rQKlGZ0d/XPPgi9vjsVeR4FsOd0PDj/1NDcnqNbUKz54DPlqG0EkqHdMpz5JWNw9ZzndXw+QhHKbMTMRdRmqRHdmjbZiyFRLTJzqvkGW0avkuTSzzC2njnRRVF9c3rzZClLTkUoXTSdZLIlMtNKHmrC7pK65SG/8rGYXzpigexYaie1kP7BK2GyXdEz6/bXEejGSaCPaJ0+EmKxviMSQ5/rONHtzyFA764WDvmGrg21BnXL47SsZXJDVi1SUpLfvih3pZ6Mzt55An27HFVtruMtjX8+P6XyTaQJr3jZbT19ItXn46jdGwCh9PwOa8shXTySvvECd+6CX/xnTRGoDUOXz1DGwJftcyziITSCSVRAvKErr/AVy9XCLtbLEWewbhpEZ7t4IZHXsL3b3oqcekE9PdH34cWVKnOk5X3/l9YjH+6/H7DDz8tiwb/UcWtFPgt4PO/fxBrN9VzQ5nzQJerKa8Z/eaMtib4Jb4qs/WlvuorqtPQkmyd35owTJ3PWSJ3SsN/ORaStUq2YxfR8PMGRqLhB0GGhzWfj+PgswI/W8cL64f0++Pjz76aRq26djyyrsaMFVwrKJqegSoRofHs1nsKafjqu2XLbWVHOJoS+erlL3iNxzwoKvbPj6xm20GLpfvMmzSv+m6/XfZc8v2jSNu0AJsyWe5p2wYaOVpr7v1N/f5bHl+TTAIajVKgTO5+X5jGNPV8ukCTGKo38czLm4x707/Pv/x+vLhe98SwaR+dxsuvRQJ/xqS+jOXLx8c+CYTKGRhpwEs2SCfjh8+taNQ5h/A7+cKb8YEfLyUcfvYaK6UDx8pQ2Wo68B28NXxN4Mf158jyZiixxZvDj/5nKR2mjXkuqbTaO1a8gh/ftiL5XWRbQb3MpJFs23QNX11A6D9jZRQIkVI6gV3gqz4dyjGaPG28QBPYTK9atXYzFpx7Ba59UE8Z/K9/eBDvvGiJ9lFufnwN3nXx7Vi9IaIkQkPIcnD54bfE4ZtGW9VRDD7zk5cuw5Ffv56NFAaAS25/JnHhVM3YMFTHgnOvwP/cuoINZOmUhr9uc8SPTh3I+g34TIKqaa6BsW5zHYvjb1oJAgyRlBeSoXRS4yRTn8HTm7iG9B3O1c5F6eT1m/aoiuy2jS6ob95oyszq5pXXhnHmj+7M2F8UpePSqIfqTazbVE+9dILsc3PvIZfSMd7NGkIVmntL+0K1QzDHAP5dSpDkaVIfn0Kkk08l0N0y64YyGRdQGm1bgXpp1K2S0xjujPe3/U2cNlfhBzc/hduefFkbrCsNLxgqQG1900XptCI/TfdPNaGZHP4N8ZKUDgpzUJnJ5J5Y/RoA4Bd3rnRy+P/3mkdx3UMvZs7nQWlBW4hfcjbwqjMa/kd+fg8efyl6nmogtPiIUNoFDkcB+hhQ1bVbmPwoboHPHzcdBFpB0X1xVV+iGr569o3DTfzp4Zfwk9ue1tsp1T32Sk77zi3Y/4uLCbUkssnrmPvyU33o5weqaXoRbuL1AZcoz6bY0fdr2nko7Vgnbpm0yVSpKjn8NlGN9x+sM8nPKJQ1ftpgjS2HUgFmZJzursW3g+NPhxlDqy+axkCsM/SQjboyDye/4zJfXB9pSLOn9rOUjmrvhdc9hrP+p/VM16nAFi0FXtHlsg2PksRkQSD0lQ5rtI3/56gFB6VjXjPEaJbDFmEoHWV2QsP3ERucL3td0/D16zcM1XHzY2vIPdH/LtfMR+LUy6pMIbJjkXsP+TEA+vnBvvYFfrqdZXqM1iJJsVRdMVOnaxp+Q/2tUzrDlij+UsNvAWp3Gc71iWJ9nHxs2gAv8KngM7Pb6Z3UT8gCrXdGgFA6hkDQUsValqAZGsPopMoAOXtKP6/hG7+Lep+oZtUdz+8zBybcvEPgU+2pGgjtnYehZIy2umZG4ePd5dTwLc8bSt2WYNphorpb7ysp5WVvOGeob4SEwzce+uKbn8K7f3A7XjLsPz6GW/V8Avpqu68SOHMY2WB+w/4aEfgt7qDGbVjPfRdAN9pSDf+l9UM4+hs3JOXQvmgLvKIafsnhtwAl8OuMlw3F+iE7n2zeb2pvVv9cZP2zKToZaduwuGWanKL5N73H9DffZlo/y+Gb9yvKpCjqRLBk3TLTCeyh59ez9yeTsGNcUAFUCYTRD7KTP5sQz3iHToEf/69WEnTM2iZGKaURP5H+nQbWta/hu9qd7TcS9abUvgMHJaBUO70Efvx/IEQykfzraXujWhFsPZy2bWs7APRXU5HWroZP+5bNOUOjdML078vuWZUokoEgK3oyLgE98EoZ58fyBihjGuqlmV42JtQWgbaOTZeqmcRoDn48PZUtNzHattAnVXNMDd9G6ai/Vr6yCcd980a9LIsgm1SrsFSCeZ3K1LluUz1zrQtpsi5mGR8funTpSpz47Ztw46OrmWuyWpgJ2v5qRuBzkbZ62YDd84JFfOqxeBKkqYZtAv/eles0LxyOK+6EodxVgm5EDMmKMTpm07JVbENYQOCra4VI/95n++kIjI1BzLbZNF6zbQO1fEpn1drNWPRv1+Lplzey5zkN3zXOk7aQFSIV2JGXTvotdS8dquGnilvJ4RfA/l9YjK9e9TCq8YDL0/CVsLJ1WJrLfMi4JpTRB178wAsZYch5zyhwC+2X1g/hwed4jZYipR7iehijLa1TcY5/ZgWn/n9yD3jNUj2vwnAjxM2PrcH+X1zMCmb7M8Rt5wR+fGz5quhdrGAGJs0vbgP97oEQmSR4dBB/+9rHMsY2rU3MZGBCnfldvAFILW7b4V+5Dt9Y/Ch7zxf/8CC+++fHM/UA6TfshB++C6aGb/Ynm6eMuRmQT3oFVZJA+p4rQbTGY7101ARha7vxbuh1tvH8m3tWYc1rW/CLO1cmx55buxnnXXYf6s2QDeqjtejtVF5QeqAaXbUK4pYZuQOnd/N++KXRthDqzRD1RkgoHYmfLnkaqzdsYX2KlZuZzZeYUhtDTOrji296Emf/5C780cjol3rA2Acs7TwnXXgzTrrwJseTxeWaRltmRmmEYSZdK9eHzC0babt4Lx2pddItzRB3Pf0qAGDpildy227W4/IEStudbbiZvZIDFfASMpODndb9zWsfxcPPb4jrzbbFZ6Nt89mUwmFm6jRx/7PrtHYqNB0TUB6eX7cZ9z27lqX1TJiccp34g0f32u6D1j4/Dj/6XxBKRxnuXRy+TQC6DL82t0xVFp0s/vHX9+Hnd6zEbU+8nAQ02rx0aJWU0qF2HqFp+PpKOp/DLwOvCqESdyZl0Hti9Wv4598sx4cuuYvVVpQAs2r4lNLJeOnIZEBvNCYDc2ls3hedS08qH2Lb8v9dFy/Bvp+7Ok2epigdTsPXaIkI3KCxe4jYIm11TW64EWY2QL/nmVfx0yVPZ+7l0AyzndsMAuOEeqqF+Y0Ms92hzBpt1TZ/3Lvziqg2fpu7R1F+mYKupGjRqY2muMB/09duwKnfuYXNHXXr42uw4NwrEvsIfQ2NZpiJEbF6fIV6vyuk4RNKpxIICMFz+Mkhy2e2RUsDuvH8Pf99R/K3+iycd1IlECntZCmX+/wSaeS7SclQuqoppfacnJdONGGUGr43gvijKQ1f8e53rngVH/35PZnr87wMaKbDrMB3aB+JIAZmTu7Dp47bLXMN13lo8AjFLY+/jA1bGpm8N4nRVgu8om20L4vN3EBpuywaPqQmgIYbYSKQlXb61u/ein/+Db/lgVkiJ/CfizfSVgODe78+Gr5Wr9QFp8ml0jJdlI75t1kHhZk2wirwLR4cpsD94S1P4R3/dVty/qdLnsa9K9eyZVIjodm2Py6PVqJ3xisyqul+/vcPYtG/XavdY+Wsc4y2Q/UmFpx7BX5917PJsdRLJ9Xwq4GIUy0wdTj6rtl2s62Uw7/x0dWZ1QJn86LuosKi4XORtlIalI6h4dPJUTPaMn74pdG2ICpxgqKE0smxjKoP76Phm374zVCC2QYUAPmAkBisVTCFeAGlgym9fmp/dP6l9bzAp3UCnNGWLg+zQoSbl9Ilv348lDoFQq+vZzT87ACKrs3XTLlVxN9+/3Y89Px6YpiNjr9GNtj2zaWjEBpUVGSLsF+rYAZe0WMmTOrOTP/bV+X3HNZXD+Q40QoB4Au/fxC3x0GCw40Q//yb5Xjrd2/hHyJGQssw9a3ZsAVhmJ340rZkn10vW2peRub4UYrLvy9+JDlGN4NPvmEgEAjBUp8mn/5/r3nUiAHgJ+2oLr09qn2qz9zy+Bqs3TScPAsQswMMh0+rUa7L9JowJFtCGkqgIGWGGQ6frjJC9v5OoicFvuLMlBdB3pJYdWzbkrQRhklZmf1qpbRubN0koy0I9IyNL20Yigy9pJNvPaUvPucW+Kbmx1FHYZgV5iwXziz5ozp4YSylPrCpEDXlBr9fp1F/KDNumQBw3UMv4tKlkWYoIHDrE2uwz+euTgZ7UYEvkaV0rHQWNXiT69N7varMUDp9TKI4gN9RLWqHfcWhPEz6jUnk+zc+iQXnXpH8/vDP7gagT1JqPFz4p8dx3mX3W58nNVTbzuvCa7hpjo3of9rvlBKhGW1jDp+rx1zlXXjdY3j3D27X2sDVyZ1TY1cpgo+8uAFn/PBO7RkppaMFXpGy/uq7t2ba2ZTQhDq9lz5bKPV2abl0CDVbcvgFEIjoowWJ0dZPw7ddN9wIE3cvM3zcNRtTNysBgUqQvu5XN9Vx9k/u0tw8Z03pB5BuA2dvr655semRZTqVJAPPUZav0dbUlIebYfL8poa2kWjkNtg2nqZeLU0pE0G/bOWr8X32VQuQ3VhCSpmhdGyKAOstYlnS63Xov2uBPrxqFkpHT32RbQfXL5Xr54JZk7XjF9/8JFuHrb5fLl1pXbHkeukYhm9Tw09WaOSx1fgJglTrTTl8vfwnV7+WuBHb5J+plNg81YBUAaEK2sMvrI+fRfUnQWgkGnillyWNa6TUcw/RSS4g0bVm0j69T6Z1lRp+AVTizqSMtnlubXleBkP1EAM1+2C1RXvSPDVCZHOym23banKk4a/ZYN8chJbrzqWTpXRYo63FsHztgy9i6dNZr5tI4OuD3JavZdMws0GzMSmEYb7r4HAjTCaPyTHtlafhm6uLMDQonTDf3TBucHQ9PWTpTuZhk9Lhvj9gTHqkEFfglQp4mz9zUDvukyHSHA82f/VEK7WMH1N4Zd55fIp+I/Ws1A0ziDl8c+K59Yl0b+Y8P/w9t5sGIDK8q70WzO+rvHboeDXtFFTD159FP7Z+cyNuV9qONFYDhtFWV6xsHD61AZQcfgGoKL6Ew89xF1Mfw9bxh+rNzNJZwUXpUKolEIK9jmpIIrnP3d6E2038tHU3uuSc0ZlZt0ylVRjHn1i9Ef9x/ROZ6yV0jXNLI9QMV0BqnHytDQ2fot4MEw+oyX2mwOfvySz1kUb3qvNWbppy6up/Y/XEwtTwDUqnGtiMtvzqwaXhq/xPZh02pUVKYMmTL+Omx1Zn2r9xmP9OeRugmKtAq4avUTpEk44vjxLoCfabKdiUAnXPF07dGwDwh/uex8/veEZrv4JKi0JfmbqCcvjU9pbWo9e7ZmM0qQhyPrQI7IBy+FJ/n9QhhLal1PALQGWkUxpW3TKwFdT7t2r4jSb6LRp+NJvz5WobGoDX8PQIPiTXu0Dd5lQYfPQcVMMnHYnRtMzrfDeLMP3wIy8dtayNjqkEVpsYQWJW48OHbyEa/qT+qGyafI2DWW4os3sT21Z+rLdIyL9bCnP1UjPSBdiCxEyqyWyHKfAlabup/VsFPiROv2gJ/s8P7sjk17fdk9IQ7GmY0cr/S7xxVDsBM8VEeizxww8Qa/hmo7PKkIlkRzOymlKedGa7lYbPjwNk2iVlpLR87aqHM955mRTRRIEwKRkaY9A07B6cc0UoS7fMQgiECm9WRls/Dd9mtB2qh1raVQrq729C24lK8AOe0+7yhOBQ0qH1zqNr+FmBz3vp+NVJy9IonWbWD38wtne8tsUveVWeUb3eDJPVQhLOzwiTh55fnwSBmdp7JCRNLx3+e3M+99p79pwoqGYHZCketj7mOGc3SrciNDxRPHzhTQ3fLvDjNlk5fH2VpDyIFFTftlI6mtE28qwbboSaNqxgE4CqDGov4ShOgGr41BqrlyMliAsl8KUrHsJ3b3gCix94QStL0UaJhxqhdJqh1GYo2g8ir6a0XabnmLqmpHQKIAh0SsdG1ZhL1uFGiPXxBiBX3JdGzW4eblo5/NBB6WheOkJYBH7WD5fT8J9fl26Xpwy9Ji+thWl7GBnpdb5b4IVSr6dO3DJVGUrgb2IoHa6WvE0uhhthYg8w00lQYXLit2/C2753a9xOU+BnvWHsGj4vgPPaawpGaVxr1fBz/PBNDb8RpvlufNMu0KaZK5RcDd9K6bijgNNvlB5T35EKwchoG72/3f75yuQb0vepzmfqUAK/KjLHzD7AafhmNHpEU6Vn1QZB043U6S9nNPzUSMwFXtHJgDaL89CKNPzMo3YEfHrIcY6K0AOvbCHWoQQqZLk13AixYk3k7vY9kt9kS6OpJWXSyiD1mNC9dCwaPk2eFPc0bnwd/pU/JX8nS1ZDaGluh6HMdGbXUtaT0YGUUo+0bVIOP/pfvSsz8tiGvJzn1GhrphvwpXQ2DTdx3cPphi3Ubzp7b3Z1RGGndIxyjDrsRlu+PtUOuqF4VG7aV3yjcHVDoSEIrZk8VTv4Mk1KxwSn4Svah/rhVxI//AjL4mAyWnLAePEAaX+gtgzqHkmhIm+pgkapFvVMVPA+FcsD8z2/8pou8JuSZhfVKSg6WYVSn7i0yVzT8Lsj8XtT4MdeOmqA2TSYZiysKaWj+gh1ydpSD61RktGkkeOlI/28dBqWjmqCUjoNg0836wbSgeOidHwFvsmF6146sYYfc/icWyZXD6elqm8I6JSOuRdAnjFP4ZvXPmqct2vH+ruza5UmaJXKM4OWlReRbZZB7zWzKtJ34wNqQDf7l93Q6+6PEaVjr1NRZhwdI5B+Q6Xhu3zq6fUUHKWTZGI1Lh9ivHTMciR4u5b5nk1OX2oThU7baEZbg4Y17TdHf+MGvLqpXgr8IlB+rxUPgQ+kGgzdl5PK5i2N0Oql84Obn7K2IzGmQtopHS3wIuttw4Hm0qeCgFJXutYYC0fG9FXUaAtI0NepGW3jY4OJhs95fzCDlql7Ul8lSVs93KSUjq+G734el5cOvZUrxmeT9WoQZCgPG4dft1E65D1T2qcZysQRwTex2v2r1rFlAfZJQxXtyqXj0vATAy13kgjBQAhWg5f65ew3VWXQd2vr01ucXjpI7qHulQqmbcSkjZohjbTVaZto/14k51wcvlpRlJROAagXrISBjcM3c5zXm2HaycgbH26G6LNo+C7c+NhqDNSC5GPnGW1Nd7DNw81MPhat/aHdLY52ulACtz/5crJxOAUxM3iBcvhCRHSAelU/u/0Z/Pi2p/G6HbcCkO4zoN1PPkWtEqUs5miJKf3VVOA3ZLJa+NSv7sX8rSeRsPwoZuCntz/NPpf9Oewcfp5NwYc3VytH+n0qNrfMnHz4gJ6iO/ru0YvM80DjUJTDt7tluic/+o1M0Pwydg0//S2EYFcT6h597wF+MuQjv/Vr6TO5NHxzT+pQUqGuP4sWeGUIfE4xU/d0A20ZbYUQXxdCPCyEuE8IcbkQYobluhlCiP+Nr31ICHF4O/XmQeXDqOYYbdMdZpBcp/42X3crAv97NzyBt3731pjS4TV8btmu2rDnv1yFf/jZPZkc/AqmAZXaKmi5Dz63Hu+4aAm+fvXDTBl6nXmQMu3sk/uqEaUTn1OdV230zuUEop1dcf2cQKEDeLgZau1798W3a2H5Z/9kabJhe1JPfP6vXzePfQ4zPbKtjTyHn0+jVCtZge/D4W8YauCCKx+OvFVI5VTDbIbpyi7PA42Dr8BPhZl9YrTaM2TqUJCX2lhtZJ/R8MlvG6WTGG01DZ9fKSsqlF21kXHAJdEzPaWofS66j1A6xspHy6Uj9fo5Lx3APylgUbTrpXMNgH2klPsBeBTAeZbrvg3gKinlHgD2B/BQm/U6EcTaleIObR3a/GiU0jH7aCsCX0G5WXGBN3XGaEsH2FUPvJDZZYuCTmZ6Iqb0bxWI4kqPnEeB0OtVPZP7K6gTu0fyHPEB6lmUtIvUM+gQ+Npga4SZGTgRkkJg/sxJbDsB4OCdZlqfw6rh5xhCfWRsFLHp56VD8bWrHsZ//vkJ/O7e5zTt2fTmcmX2zIOpANlcOanRmD3voHQoncVx+FSTtiVPo7/zKB1Nww/5Pq2emx5Vf6trr1r+An4VG5aHDFsVRb0hNS85k9IxhTedDHRKZxxp+FLKxVJKtW5fAiCjTgkhpgM4EsAP4nuGpZRr26k3D0rDTzaVtnjpmJQOFWbmC++rBC3zahJRh+U1fN4tkw52M2EbRepqZg8OUlkLVdCSXr9M2ugDiVQrURq+KXSUUZfb+IOOQWXc5fPu89qt2e5AADuwAj/636ZVR9o3L+jyaBIfIVvlKB0hcNYROznveyXefc1MF2xSOuobFN1EHshu05lH6bhyDrkyadYZt8wEMVeuxkTAUDa6EdyS8oDj8JUffobSyWr46m/1Gv/7lqfSckJ7H6yHIT5x6bIkwR/V3KO/yWQF3WVT+640+SApfzwEXp0J4Erm+E4AVgP4oRDiHiHExUKIycx1AAAhxNlCiKVCiKWrV/tvmUehEjNRzZ2DabSlA8l83ZVAWL1x8qDcrDiBT4VLGkGrdzBO4Jt0lRliT5OnqSqo0IBxzp/SSd/R5P5I4Ns0qefXbc4YzuggUsFs3EBuhBLTB2s4aP4MVqhRg9+8rQat521atZR2QaZnAHWvPmyIjLaGwK8IfPaUvZK8Lxw2x4buwVpFX+UYRtskz04LGv4Gw3sqL5eObVKh+WNMUGqEX1lGQlaNKU6Dp48mjN+nXxTtC5C4ZdLAK7X6McpTgVfcSiFvhWtSZ/WmxG+XPafdr2n4pLGUwzf5fW0XNo0GcjanZeQKfCHEtUKI5cy/08g15wNoALiEKaIK4CAA35NSHghgI4BzbfVJKS+SUi6SUi6aPXt24QcC0jBt9c5tHTqJhCUfgxoktYeo8LlwfBBKWFMrNBgOftOWBt59cZoC1nQBA4h23MwuaQFoK5wkORwzcG1bHNogJTRKJ3Jl1e9V9QzVQ6w1NjfXOfyozZzQaIZRithaJdDy9QDRt0l9vN3PbhP4psGbgrqdclf45P9RbqUch+/qRsobaaBWsXpzNMLU0K0ZfD2F/3rDeK8UjX8+eU+cd+Ie2jmVxoFzSzYnNPNcmv4ie15Cap50QmRz6ZhC9j+uT2Njljz5CoC0n9CxyeWWAoiGz7Q3bxLPaPhM3iBVr5S6SygNvAL076QHXtF7nM1pGbleOlLKY13nhRBnADgFwDGSlxrPAnhWSqkk2P/CIfA7gUogNI8bGyXCpTJQWoC5pKoGAtVAwJ3HkoeMCsw12iq3sRsfW6Pl6uA4fOW2qAaFWTZH73BJ5BKjk+ezhFTD76ti7aa6k9Net7meZAGl9QFAf8zhc5x5oxmiWgnQVw0s3j5qosoOVmpXiFz+soPfFTSUl57Ax96h8jnpXjopfWGD+tb91WiFUA2iZF50dUaFSyMMseTJl3Hp0pX4t7/cJ7ddgJ3D32WbKdq2gFFd0beY1FfJ3NcMwXrOAMARX/1Tcr2Nw280icAHMGz0A7r6fW7dEOsC3QyzqU1sgVdqbHNiKu+bmqtjc9KnFBZVOAA9Hz6g5xOyrSbHJIcvhDgBwDkATpVSbuKukVK+AGClEGL3+NAxAB5sp948BAaHz2nIAB+CrSaHLKUTtEnp8NomneFVYEifobGyGn5N57/NskON0rFr+E0p8eL6oYIafuSKOVBTRlv7vZmBQX4qrZGjJZphFJ3cVwlYSkGzdxj115shoRPsAseq4TfTvsM9mk90a+KlQwooouFLRO1L9mGgtp6mnjzt9IuW4LK7V2VWU76gO0GZq1AlyCb1pbrhBX+1b3LONmmueW04mahZDT+mNtS5IMhq9D4eSE2ZTW3C7Q9Bj3PIWx1l3DKNPtAM9XozbpmMAlarBNYo625x+O364X8HQD+Aa+IGLpFSflAIMRfAxVLKk+LrPgLgEiFEH4AnAbyvzXqdUD7Q6qVvsiTxChlNQAld833XgtYpHRlTOr5umTQvCMCvUAbjAagEqll2g/HY4QT+ZXevwmV3r3K2/1vvOACrN2zBl/74EEIpsWm4iUm1CqqVSPt0DRZTmFMBoYLZuAmjES/V+2sxpWO8OroyyWr46bdXGr75BkNp3wBFldFXdW+750I1ENjcDA0NP5rgXIN5M4miljKaFF/boq/OmpTSIeVzcRY+SAV+ZGegkDLqY5P6UoO/8nxyUToUnLaq9kymq55szqD8skOHhm9ORraJgLvWRCbwyrHBTrSyS88Fgd5n1JitBfoz65OEszktoy2BL6VcaDn+HICTyO9lABa1U1cRpF460W9bvm9ua8CE0jF0/EqFp2R8IBG5iPKpFbJC2OSkOQ1/ksHhm52eC+DxNcya+MsDt8ezr27Cl/74ECSitMeT+quoBgEaTd3rwIQpVOlKQqWc5oRGdExgoFbB5uFm5nukGRGzdA1ddQRCxPfqF+UJq7oj2C5POACRcA/DpiHwo/99lDflNsrttNaklA4RGKaGv/fcaXjgufW5dekaPtOOpsRUsh+z6mvUMcIFNqVH/BxOSsdHww+ztjEznkXBDJZS2LilkYx7G8y2mL+bYZpjitXwNUOtUuwCTZnTOfwxSOmMVahUqxxHT0Gt6qrjJZSOabSNfYVbwS2Pv2yldDgt06znvmfXZa7Jo3RsLpqtIsmIKSU2bmlicl8ljpQNWQGYbD7DDAwFRelw7VMa/qS+CjbXmxlNu5kYyLIrjMhzKPo7CPRv+baDIs/hULqNr6rdnDzz1fClNI220fP69CNlK1ETu+6lEyb9hvLc6zbrFiZTcbBBCSohsoqDlFHdg0TDV+130WIUtp3Wor1fU6Ot5rESuldgCs0wzKy8bTEKtm96+kVLcusxA6+yv3VNPRMlLLPjsVYJtGfUOfzcJrWEnhT4lUAFOLivo26ZiZujVeAH8Bw/LKI9bTkNP9tIU4D98JYVmWtMH/YMpUNWOJ0Q+Kp4KSONaHJ/1UnpKDuEChJSaWbppSmlY69zsFbBpuGG4aIntNWZOeE0QpPSiRp/yE4z8eGjd4nvc2v4w0yQjoLP+6zEKbp5o23u7QjDSKio70wpHcrh0/JNDd+0BdmgBD7nOqw0/MmEw1cekKHl25vgKCxFxdF3Qt2nh5uhn4Yvs9lqbdSNWkGYLaZ5hmwwXbtVRk8FatBuSn1cZ2Iq4sm7bxxy+GMSarDlGSKp4U+5/w2R5S1FtdK6Hz4AxwYodoOkCymlw3P43E5aRXH2kTvjfW9YACCluEIZUWST+yJKx2a07asG2FxvotGUuOmx1Tjjh3fiuk+9SffSSYy2/MAWEBjsq2KoHlptFBw1U2+GaRSnEMnk3V8Nku/aDO2RtoDbU8fn+0SBVzA0/FSbzYOibcyVXHKORHgqrDU4fNMWZAOldMw5QhltqYavvsU5v77Pq3xuglMGX6rh1w16yhY/Q9EMs2PV5qVTb/ATgQ/y2kIF/r0r1+JeY0LgjLZmMj2TBuoGelLDV1bxvO/a1AS+TumYqAZBy0bbqE18agVu2eqjQZqCwGxak1lCFsX0wRq2mz6olS8RUTqT+iNKp9HkPTWoMN8YG81fG2ponVpNWrY4CUXpcM9QJz7PHFerLle51lWblLDKoyOefnkTFpx7BVZvYPIBeWr4NPOiOgb4avgS9QahdIxcOtykYxptvSkdarQ1+qiivqjRtqjiwwmvTVuauOzuVdo7oTTJYV+5Dpfd43YmAGKjrfGYZkClQjKJtzAc8lx1bdH8AHDDI6vxZJwFE0jH/Al7b6tdp+ffKd5GH/SkwFcaft5MrlE6ca+xC/zWjbZAMUrHJ7BnkrGZt5PDb9Faqw3U+M9Ew++voloJ0AhDntJRAp9MCDSPOwBsN30AgN2YLJBObCZyNfy4UCFSF9u+apoeI89oe9sTL1vPDTkGt0K1kg288vHDVwhlxM+r70w1zIZF4JuUTlGBzzkWKO8T6pZZlG7gVtq/XLoSAPBMnGhPIOul44OmlBlFSikDNi8d393dFOgrOXr32Thi4azMNT6rEQXVJ07cdzvtOFX+Sg6/AJRVnBvPR+0+G5f+XZSsk2r4fYnA5w077aRWAOy5dDhfY59+n6V0stGmCjaNNO9xaHMTISUlNimjbRClN+baq94npVeGG/o32Xb6oLMNQgiNSqDQ8sNnBrZkKZ2+Skrp5HH4nFCY0h8JPS5HkIkKkw9f1e0j8BVtw+Ubigya2ZduRtAW5/CzbQtl9A1ppC3Xj799+gHW8n0WmDR6ugiaocykX06z4BocvsVLJw/UfnHxew/G3BkDmWtsq1QOakIyU583mL7SafSuwA95zSIyvsY8bszzS4kMpWNq2dU23DJVmzi3TNPaD/hxjFmjrX6eCkHbQLJpzwr0ealnRmq0tXPwfcQDJ837oq8GBmoBZk3pt9YvhL2NdaLhmxNao2lQOvFz9GkcfnEBs/2MiN5a9Wo2C6gJLnlaylfn16WegaN0zvqfpVg/1MgI9HWb65orqW3DFROaWybDKzdCqR3nFJ+F20zBQfNnsOX79OdACDYSPA9cpK1tc5jUmKuXYUuwp6Dch5XSxq2czAhlZ5vjvmt+PzqJj4fkaWMGlTjQgetmtUoqeJthmmc9oXQayr9Zv7saBG3NuhL83resS6KHip9w+MoP39TwPVzaJlm0ZwXa6dRfn/vdA9iwJTbaVpRnU7a9SiOsh4TSaeo0WzUIsO20rLaU1s+3UQh9d7BQSuw2ZwreeuD2AKDl9wkMSifxMMnT8JlTW02uob8aYNXafIEfpUfm6/DpR0oIq4mdowyUIFIYqkcrr6QNHvVUA2EYbbMCvxnqtIlgpEa0iQlfn6+vfh5PzoGLtLVx+HQHOoo825x69qqDklMc/mdP2Qt/f9QulnKi+9SEVDUFPmlwlxidXhX4dg6/Vkk1fCqA1MdQGr7JJ3LC2nfJDERudtwAtKUVyMMkU8N3GG05fOYtu2PHra1JSzNlmp18Un8lyVDIDdSUwyeUTjPUkkpVKwJzpjk0fAg7h5+4ZUo0ZRR5rFIPbxpukiR4qdG2r1LRKB12ZRJ/U+4TBEJg7oxBLw2/Vsl66ahX6LNQVP1wUq2q/aYYMN7NUKOpce0+TgbVikiElRBZbVdNBrUcDV9tYsLB11e/FQ6/0Qwz49DqlmmhdPImRqXYJHKD6TeK0pm31SB23WaKs5ymhdK54r7nne3oBHpS4CsvHc72SakZyvMrAaX88E1Ojttq0HfJrOriBmAzzKYN8KEa1LJSabqm4SrPk+TDRy/Mpai09hqXTuknGj5jxGSNtk3dVbYSCMwkidVMCAErh0+DaKLw+vSdfOiSu3HW/yyN6qBumbVAo6Y4QaRWJhwdKERkaH7OS8MPIj98mdXafDR81f+mDFSxzdR+/GTJ05lrBgwNf/Nw0wiQSs8dYtkIphYEiSCkHk0K6hzVRrl+EwTCSlX5cvhFKfxoAxKZGYdWt8ykz+jHbbm2FFS/UmOMo2G3kInRNq6UgqRW5eaYffD5NCq6FddRH/SuwLdp+ITDpwE6SrPZXEDDz+P+KGwfsNHMpp51aUTvWLQDTjtgLmZOiQRl4pZpfEmfSSOv+XSJbl47WKskQoCndNIViBp4ppdO9C3sXVAAmsZKjyd5S5BGSnMTcGS0FXF9InkOZVs4ds9tsO/20xN+XtEknEYdCIHJ/VVsyhEQAB9pm7S/AKXTVw3w90ftgheZ7SLVfgIKQ3XdfZIK76n9fMjN5noTz8VGaI7DH04Uiuj4EQtnsRNWJUlhkUWrwVl5aMbRyCannsbX6NerZ6GHfYawGvu26HEgVRRrlYB1vwZSBVG1z/XIXZL3vSnwVS5yDlTDp/l2qoaXjklTcB+xyLaHtj5fD8NEOCq4hPUB82fg26cfmGoLluRpvtGgzvOUwzd650At8tIBLJQOMeiq56H+8ap+FysWCDulQ7exi3KiC5Zio80OiAFXGSN3mDkJv//IEZg9NaKW1Lew5VYJhN9grDCBV1ybbEgzp9rfgUnpbGk0tWs1G4ylTjMi1OwTiYYfCDz55ZPwk7MOYYWkqy91QvngoDYsygh8FZRmc8skh3ebMzW3HjXZVV0Cv5GutK0afkVPJeLqB626UuehJwV+QHLpmC8/moFTga8079QtMxpoppGsWskuWacO1LzbZNPwm6EsNHGoYtT8kwZepY3rqwbsstNEHrWgu2Xq5/qrgVPDr8XP9NDz6/Gz26M9detNmezoBHhELzsonQaldGTkqcF5T6gAKEDPhyRjYWymLFarLc7XnqZpyEM1yPrhF+Hw1Tt1CRBzIhiqmzlv7OWfe+IeWPyJI7VjkR++/g4ppRPEhlmuPRUHpeNSPi770Oujuu1NtaIZUzom3RrGNJ/dLTM9butfFCaHP8zsHKfGYV9VaO15w8Ktk79V//zRrSsAuMdfJ9KhcOhJga+8dEKJDF1CB71G6RhumRmBz3TyrRn+eaHFYGPV8JsyblP23B7bZrUP5WGgBGXKB6YF9FcDr+CtXIFPyjSX6wO1StKxOQ5fvfef37ESj730GgDgK398CCteTrdNoC6THATsqygz8MpF6YTJJJm+Z6XhK0opMexW7ZSOEH6GUPVsgOF5UcAPP6FSKvxz0bYqDNWbekQs/X5GnQu2npTRbgORNWByRlshssKdU4gUlEb86eN3y5zbPW5DKx5wDYuGr86ZQlOtuNTh6YO15N7d5vDjFkg94GoVfVXNwZyg6XOZ39H1zL77UxRFTwr8gHjpmIOiVg2SF08TrCnNRi3lTQ3ZdKECoO3kpLBw9hSsuOBkzJika/+Kxzxp320Tvjhpr0Vr4ga66geUlqK/gYiW6MQymnZIs2/2V1Oukgs64QS1uZdqLWdTGSEEaywH0kEXafhKmHMCPx08FaKhN5OJIr4ufhlqotrMrFqKavgA72LrZbStpwm2bNebkxJNp2zWY5bA2U4CITL58L961cMAspSm2aZaEFg5/JSz5lcGtnN5CBMNP/ssVLBT0J3wbvzM0cnK3hWVrL6li8NXcHL4gSnwrcW0nP8qDz0p8CsiXsbLrOtkLRCa9qWEQV9V56N9NPzpg1lKR/VbW376777rdfibRTtk28wtk5lBoNobJM+QTfbWXw28fPlzOXzy6jICP94ABeB9xH1cVvP2GBCWNgpBs2VGE3sUJZotIwhSDZ96oSgf+VTDT58LsGj4cA9Seq6SuKy2xuGrVVPVIUBe25Ld54Fq+K56VH/+w0eOSI5xwYH3xqm5TeXD7Js1krbChC3Bn6oz+t/eVhuUhs/1tbol5cdwM0y1Z5E+F6fQKZgcvitts+mlo2n4xnd0TXKll04BqC0OOQ2/WgmMDRzi4yZ36eGlwwn8pANnAljSv83vHAQWX2BO4Kv2mJQOGZD9tcCLA8zTqmhnNTW6/mpAKJ0QO82ajL9ZNA/zZ04CwLuxmqjmUDqBEIlx2gTdAEVFW3IaZiBSDl/tfgWkKzgzmKbfcM+lEAbl8baD5mHB1pOS31S7Vt+D0waLuGW6Iry5vX4HqhViK7Cv0FSZ5gSRZ3BUMD9L1cHhKxrPZewt4uKsoIy23L3NJu+lR5WTQKTP1eeo3+Twv/b2/azX1iqB1h76zFlKx1qM94b0RdGbAj9QRtsstVCtpIYparTNSzRVq2QjCTmBr2ROZm9QRxSdAC/4uP5gUjqc0ba/WvE02rrPc5G2CgO1ikbp9FUCfO3t+2PRgq0y7bGhYrFdpPXbOXOaCCvKpyLYCFDqVVOtpBp+3dA6U4Fv99IRQu8Dpx0wN7Oyos8GABdc+bD2PKpNeUj8uh1G2wWzJmWO9ddShUbj8I0vmGi2RHIHgd2IbvbnjIZfsVM6SflCZGxqgUjPFUUzTuzGjd1//cODuP6R1ZnjemI9YaV0lOICpKs19T533HoyTjtgLtsmc4Km/cVcRbieuaR0CoBq8FlKJw2v1wV+Hr2RfVXTBrK+zQEz2AAj1zXD5fHUhb09ieHZ8JMGIsGzdMUr9ptj5K0C6KDmNHwaeKVOK43cx7iZx+G7QH2tpdT5eQq6vRxNpFY33ps6rqg9zkvHpHSyeyakfcQVo+Gn4Su/bj4H06V/dzg+eVzWCNpXqSTvnlaTMbKqdAGGNmr7bhkN3yjQ5aVD73nwiydgx3hVFIhUILaSp6rZjLYV5AS+LbVyvZG6Yguk455+u8N2nomzj9w5+a3cj/V3xbe3j3gBRtfRc/o9rvdVUjoFoL4dty+ppuFLqWl/LrAc/iSGw7dc7/qAtv1uOSQGSFPDJ/f3VQNsHOaDgyb3VXDf548HkJ/hL3AIjIjSiXnqRrpBiTL62R5H2xu1kuOl4xgRNGoyyqdi5/ATGix2KwxESumYGr7S+jYz78802pr16Rw+t2JL68hD4pZZ4TX8Q3aamfHDB3QNn7Z13la6o0BCpVj4ZhMZOsJiWzFBPc2UYmMGMpl/+6IRhrGXjmty1X8PE6OtEKmg7zOEOX0XaXtTWWJ7VdnvZX/GUsPvEFRnZDV88kGKUDrchHDwgpmZCMbEaGt8XCrvze/cZxnUHFIDZPQ/t4m5awAM1CqYFscP5GX409wyTQ2/Vkm3hSQCv2YIUBP0OasOCgFw+2Ynkbaxz7XNg6ZCNHwqCM0IUtWsWhB5Bnm5ZWYEvv5sNhSidCwaflQHEwxI+hK97dNv2R3fe9dBmfbp9EP0/37zpuPNe2zjrIuf0HQ89ZWTsOd20zL3cGmiW1nphTLaJMY1djPRto00YWIg0tgNWgZdCUaTgt63zbZT1Cp6LEMeZWlD6ZZZANTPPuOWSTi2KHmaOu5+FVwHnzZYww2fOUo7pq76i/11js+1fVl/LchE29KygCjIpq8S4Pi952hlcHva2rw6AF1w523k4dJAqIZPyzX92k1UDYHvNNpaHkMg9U5SKTRslALl8KnAofljaHsrQYC+apBkTdXL0m0O5jPqPtcOrw8PA2VK6WR3WnvjrrOs5fTXgswzAZFtgm64wXL48fW/+4cj8M5D5mvlmkoE9wTm+6eJ69Rveq+Phv/RY3Zl41GA2Esn5Dl8G2gmVSDV7PW+nApqQc7p3jd8+TVDefOhZTmUgVcFkHqwZGf/KM1x9HeT5FKngkhlXaSwaY8ZTT7+/6Nv3hXnnbhHcpxLoqUwUK1kEmEBunDebdupePRLJ2LeVhH/aWbuo+3wXeLmaviOzmp6I6g/84xw5lLZ7ZbJn5OgqW6R7I3K1SmEyAr8gBptg+S66LkirY/dwUhkPZc+SYKJaPWcxqoOcfmBTNg0/K+9fT98/z2LonO5Gr7AvZ87HvfHFB6FEvQVCy9tfhZzAuMoSu5r0dtMzb5i9AUOc6b1Y1dL+oNGU7ll+q8OKFUnBOwaPtK2KkOzD4dPI/ld1+WdK1MrFIDSiOqMhl+tpOHhT63ZyFI60wdr2GFmxHnuMjtKITypr8IEr3D5w9M20MAsGpyX4cNrAZsvxdWNkwAiRsN3ClEq8PM0/BzugWqHqTBVmjJ/j+nB4A684o/TSEeVFdVK6QTEaEsE4bNxiuNZcRI61axqhU/RAGTjAoQATtlvbmLg43hfioMXzAQATLYkMqOwpVaYt9Vgwt2bQVJARLWpo4EQmD5YY1OA8Bw+yN962Vz6AhMch0/llnqt6rLAo89GgWfsqdin3r2aUlBCe9NwI6FLBETK4Vf1tlBKJ3nfhkcTB1MmaIZzY0S7hle3kqfl97xxCNU3G4zRliYw+v29zyV+1LRD91eDRHv6yJt3xan7z2U/MBchq6X/JV9bahq+fs9ArcJqlK7loBn1p1E6npymLUGYQp43iRluH/2v/zZhvi9XFbZTtN0SSCJmuesDkY1dCITAvSvXAgD2mzdDa1c1pnQU/vyZo/Cmr9+Q3EfbS5f99Dega4NT+6tY+tljE9rOlrlSoa8SpJROVRf4dDKqMX2ynwRAuQSKGUwEuJOtme6UnJ84V5+eS0ho/9sClCj6qoGjH6S0Vx6m9FexpTGM17Y0CIefUjom707fRaLh51A66rxGDznUtnEXeCWE+LoQ4mEhxH1CiMuFEDOYa3YXQiwj/9YLIT7eTr15SPPdA/2M0Zbi/lXrMscpP00zLJrfh8sfLo3zCq7Aq4FahfW4oOBWFwDR8D0NhnSg5mn4+RtDEA2fMcSxZRptcxqrPQx5SfI0C4cvqNE2SOtshBKzp/YnG7CodkeUTlrQjME+TdvjOGn1ceg5Go1Zq+o2mjwNvxII4oevKxXVnIk9mqz01RYHM5goaj/I3/q9fRW9f/KUQ7a+ephVgOgKJGmPU8Pnz6UC3/6cyivsva9fACDaHEc1SRCjrWaLJ7YaAZGMTVcgIsC/U2jlWpuZwYxJ9n0i2kG7lM41APaRUu4H4FEA55kXSCkfkVIeIKU8AMDrAGwCcHmb9TpBZ84Mh290DjV70+sGahXUqkqA2esJRLajapo8ORXKrKaT1FflKR0XWjXa0naYGr75rHneJJrXQqDfY4sUNCcRl8DPrb+S7nuggqK4STnl8KNGqm8+f+akzMqkWtE1/CDQBRSnlQZGGYAeqW0KpMn9+XsJbyFZKun3pP2Ue3dUE3e6WRq2C/P6jMD32LOBq46m+Ej6SDLxptdZKZ2qZemGtP+6NPyZk/uw4oKTE4G/cUsjSUAowE+akYYf/xDZ1U10TbZR6UYp5FwLivrfHjof/3D0wuI3eqAtgS+lXCylVPHdSwDMy7nlGABPSCmfbqfePNDOk6F0DGGoNC+N0qmlg8w1aLhUsbaVmKbhG+cGahWvNK0U1NOI/gbcGk+T0fA5rw4gn8M3DV30f1s/L+KLnKcQ1SpBkubYtsKg1anmqj5BDeV0kxRTqFLvEp2T1f+nz0YpOnMCnpKj4Qci/U6RV1l6jios3HeuEc7b9flceW0AxnXYpHQ8KQd9n1ah/a8F9jkEvo0WUQZYl8BX40OlkNg03EwDrwT/jqg9SCDl8JvEdsR1W+UCTm0r/M7abvztIfMLpUwvgk6WeiaAK3OuOR3Az10XCCHOFkIsFUIsXb06GxrtA43eMAaF+VsN+qpG6aSpf12DIG6v9psOBDomdLdMvYz+asB76ThEXuKJZGj4Qri1ZjoA1Z9KAGUjgPXfj3/pRL3dtay2qd6Hza0sj9K5/tNHJYbyvAClvmqgpUcGspMEp7WqwURpliRnfiXITGSJYBdm4JWu2dNzlC4zBbNL4A/WKtp3qBq7glUtf2vtZdpjgqNQtMksR+CzGj5TD9Xw0zQgqg76nIJtl8toO9TIp3TSiTOIAxIbJPDKEp1tGF2Vhq9vFpO9L3V1JQLfIu8vfOeB1ja3EoTmi1yBL4S4VgixnPl3GrnmfAANAJc4yukDcCqAX7nqk1JeJKVcJKVcNHv2bP8nIXDlcTc7R6rhWzj8gu/eruE7KB0bh+8YgMkGKE09WyYNJuHAZfpTAigrLPXf1UqA7WcMJvvQUoGZ1h/9llLiXYfOx3bTB4wyDYFv/N5p1mRMib1K8l59NQggEb1zjlYx61MDSWliNCiP7ovQl9HwkZQdMN+Ei6ClLq/mROri8LedPpBRWKgAof2XE9qBoO2xVmPdO4D7G8hmP+W9dLLHqJBMEsk5jLZm3+1zZOFUlI5LG6b1T+6rYNOWJqSU2jc1oWv4IsmgSscOb7TN+uvbAi532nqytc1Ftk4tilwvHSnlsa7zQogzAJwC4BjpDg87EcDdUsoXC7WwBei+v/q5bF7v6H86kKLNPfIpHQ5S+5to08zOR2l9AZrS7ZZptiJjtE1oGbv2JmWUNlZh7vQBPLduKHn27KSSLeemc47WUhXUKgL1psxQOqEEvvTWfXHDIy/hjB/emdzvE6JfcQxGig1D9TS1guVajdKJC1QDmK5Q1GupBrrRNs3CKSO3TGbFx1EoNKjNbJpLw3/XofPxXzc+qdVv88CyeY5VmdWpCX51oJdDYSpK+82bjvvi1Mm2ewBdSNYT5ST6zbkSm3235mG0ddmsKA0zub+KjcMNTB+saas2ExqHj5TSoe7APIevniFtD5UBrmh7rf7R1PBdEEKcAOAcAKdKKTflXP5O5NA5nYLLX9bUIIaTNLmmhq8EV3YO23m2fXamcx71vde9dLIaPme0PXGfba31qA5XNwKvhMhuYgGk2+HRx7n8w2/Azz9wmOafztWhHTO8RpSWbwq9dHN4c4I168g+m0kP2bAlDpOnlE6mvYyG389o+E3S3ppFqAZCz5aZlM3YD1xBbVOYpHsA8MAX3oKzjthJe5fm++ZcMSkqQbpCcVEDeRy+edr8Ft9910GYa6zeeA0/fQ/KrqEu0+0ryXIp0067hp9P6egafjXS8CEzUb/md6UrRo7S4fpmlWEFbCqw89sUVDKLoF0O/zsApgK4Jna5/E8AEELMFUL8UV0khJgM4DgAl7VZnxcm0xzfxjmzcyhKRPfDT1P/cjtHfeOv98eKC05m67ZFRGuUjnGu3yLw//LA7fHzDxzGlpf44TcMDp+vnqWM5kwbwOG7bJ1xl0vq8Oh4yvZgCmm66YjZ7ovfswhfOHVv9jxA6BnjuJmHfGp/NfHSsWlFXHBPwuETDV9N1LWKSM6bQiiidLICPxUaab1v2j2lI03hYNPwJ/dXtWA0jiLICzISAl50ZD6H7/7287aahJ+frfdNzuakUzqKw4+u8wkWjC51a/g1B6VDbQ2T+isRhy+zCorpXZd8UxANn6xWuM+g3jt9d1Qc0FdadDLuFNr10lkopdxBuV1KKT8YH39OSnkSuW6jlHJrKeU6e2mdAw1dNzuuOWDqzaxr17TBatKJ6AYWNNzaBtpx6McOjQ5FMVANcNqBc7Fwmyk4dKeZWtuV8DGfo1YJMHNyH15YPwQgneS2kORQFJxrmYLa29T0/fVRNBIN31glSMKJU1QCgWP3mpO4ydmiY7n699puGt51aJTj5Wtv2w/vff2CZN8DnzFibmNIbRBKMFQrQaohM1ogtwtYyuWnOGW/uTj/pD0zx1X9p+7P51NX9QA8zZGXhydw9BkgUlZ2mT05N9ulz/vMCCZOw2coHc6obFM6zGA3is1K4DsoHVPD37ilgVBm7S6hTNtVISs5IYS30ZZL8WDT8Lso053oju/PKIP6OWc5fP1AonWQ43OmDSRLZ7qRCDewTdiEPKV3zM4yUKtgm6kDuPaTb0pyhav61O+/WZT1eKUbLy+YldJMnCnF5ef/rdMPwM3/eHSGQvKxXygt2TTapsFOhsA3jbYch5+sVvRzgRD47Cl74dd/fzj+5uAdNDuGz2pEXaMEIjX2qc8ccfgq6C46RgU7JxRNakdhqoW6EUJ4eWkkmTw1Ssc9ZCtBKvC57/f2183DdZ86ylmG7V4TJl03Z2pK8ajbqcKUCHzllslo+OYkNWtKv7X+5avWA/B3Qx7sq0RumZDJIKb9ldqh6Fjn3TKzdZ7J5OCyOSi73m+3omyBHk2tQDX8rPGJ1/Cp3KFGW5+9Yf/xhD3w5OrX8Ku7nvXz0jHO2TaeDoTArCn9VvpotzlTseTJaKOTnTSBn7223yHwa5UA87aaxAYt5cGMY6BGWyBfwNsSnkX/68eDIHpXr9txZua8j6ErEaQVPQALSI3qtUqQBN2lWmc6mbmyP5qoJkv83Kax7awwbn75Gj79FsXqpfBps/ktzzlhd4RS4ke3rkjaTAWu6ueJJs0K/LS8Kz56BGZO7rOOqWUr12JyXwV7zp3GX2DUXw3iqGuyIlTfUILYFgI6iRMO3+GlYxujmqGW9BS3wLeeahs9r+Gb71UNmGs/+SYAVOAbE0NVaOdd+Pujdkk4W212tvjhm22iP4ssq3cmQp5OclyH4fz8TZgDy0dgqHJVjn3VfKuGn/Ob1pvnwslRAi6Ydg6e0qEavi6EBPj0yLaVX+L9lOtgqkOVx+Wsz3PZ09IFtCHx/TT87Er17a+LVqJpNtfovZ5+8A54/xt3ituYrSMwvg0AbJVQjHYJeOoB2yd9Lw+BUFufygw9K4mGL4T+xVIvHTelw4G2/KPH7Jr87VKmtmI2VuoUel7D57hvIKVK1EfMTAzxcnWY8Vvnul8l6TjpsVlTSbZMy0wfXZcuW12ucSao1i4QGTEH+yrsknCAybefBx+BofhuRV8ExnvgOHz9d/r3f777dVoZlCmRMtse+isVGAI2AWHWrVM6qZeO6eWi7hJCLyM9zq9IXO6CLph70tJy8oypFcI5F3UpLgrOGywxyApdYfrQUQuJR5d9IuO8oFwMR5HUyEJEKzkp9b4FRJRrOhEROg/pxK2lifCsVtGrX3/7ftoq3Da2Lv27w7uWRwfoVQ2/z87hq4+nOqRyFTMHx4HzZwAAFm6T8uSub6w+IPW7PXr3bfCtdxyQuVZVtXCbKbjz/GNxwA4zSHtF5jprncbksPSzx+Lmf3wze62Php+hUDwEhppckmhdQ8PPbH5tCu24jvkzJ+GE2IZgfjNTiCTHA0Y4OLRBM+0DpXQkaW/ipUM0PnU/J5BsGn7VEt+g8LP3H4rPvGV3azvT9B7WR2LvTTl8//tM+PDIbOBX/EoTWsqgpwDdOKrArdBUWa6mFNn8RKXKpvSNEsL7bD9NW3lQo25C7+a4ZXJQd2TzMPHX56XdaBc9qeFH4fF6QBAQ+bUPEK8SIWi4t8C33nEA9tgu8lg57YDtsf+8GZox1IWEu9by3gsct9eczLWU+509VTdKFdHwtU4nUoqC1fALJmcD/GgStQJSOdeVEE4pHX1AZjh9RlCbaXQDATSRfR/0p8+4d2r4DKWT1EP+pkVQqoeDy5gIAK9fOItP3mUIS1/hEt2bjYptBZw7cqYuzv4Svwv1XP99xsG47O5nNZ/9xDhKAyQZSofrGyZcLplce9Wm96oNh+28Na7++JHYbc4UfOXKh5Pr6ApARUa/fpetM8/giyizLvltub/FRaE3elLgA5GAqzcbWgf6XkwZKFQDoRlt//LA7bXzvsIeSAWO2Tk5rs7VVWzZC9k6LXw/pxG1IvB9+nQ9XiEpSifjh59jtE1SWWteTHH9STsEAJkZDL5GsKQu4xo98Cr6v0Zy6SQpgInmx21uwXHSgB+lw2l6qlmthNjT1Bo+9icbbNlOKWypHYD0u+4yewo+85Y9MtfRa2hZ+iSuUzrbzxjEqrWbtTKKaPhCkH2sST27x1so6l466QQ0pb+K6z99lJYmxJ/SSevm9ohWdKVCN4OugB6ldIA0O55zz1SR7m1aRIuylQVkha1r2esqB3BPDGY5tP2chu/yw1fIGG09erUSKlMGdEpHUSQmz+vjpWO6eJpCJL3OXY4J1ZZkxyNyC93qUmnmSutPJx5+QqbnKXz2rrWlRwBaC8AJhEi0Xs7+5AufPVVZZcZCv1GYaTgA+h6yQlG15ANv3AmnH7yDVhbl8P/3g4fjq2/bV/sO1LGhIgTZ7SoLdSzyxtLbsNOsyZrSlPdt3nP4jvjCqXtraUi4qO/sqrUU+C1h0HAB41ANRCaDnwu7xHw+x7OZ2oh5nMLltcFRBvZreQ2fG6utCA+fO5TAnxYL/KN33wYA8LeH7Aggn8NPN6vJekAIQzC4KR0lfO2trhgChCJNnpbmw08EPpmAuEmGJtqi4CIvbW2iaEvgE0qH3ZfXEz4CXz3Xx4j3iW1y1u/LXpPaS9LrMhN8ILIKFdHwFy2YiXccPD+JVTh4wVb49d+/nrRNUTqS/SbJSi0Qzn4UXes+/8XT9sF7X78gmWACIVibhfmauhllC/Q4pQO4Nb9Ao3TyX/SX/nJfvPXA7TVDroKNb3R1LA6UJsjrVPpqgF6bHaw+ikMryoUKTJvSH3H4c2cMaj7JeRq9Gq+c26qp87ly/fisRlwrK5p/3vS7Tr+JYGk023vzoWRcgWdF6Iq0TWn72xH4vr7gpv+56rOu1Q1nhOdSg5ieb9x44N5RJTb67LP9dG1f6SCIaDoJXsGjbrgmrZh9BssJ6/V6xLBIgvoE6HjtsrzvYQ0/pnQEgKX/fCxuOTfrvVINRMJB+wj8wb4K3rgrn7I5NVby984kHc8lyG3arOvaqMz0+F8v2iFzrY8vuKk9+UwAWwwO34Qp9MzfHBWWdcvM13iLRNoqcDRYNQgSI91wEhmK5H/tu5hVGr+TXaUcbeKa7aMl29ApDv/QnWfib+M0FkXAbblpIpnAqYbvoD4TelCIjELFuWVyeemB6N1sqTex8pVNvCKm2iJE8sP2GN5++FJdz69obB5p3ULPCvyEwxdRtOr2MwYz11QCkfCc7b5nM4cMxcXvWYTff+SI5LdbAPAdgQOX1wUADpq/FVZccDJ+9v5DSfvyy2sFKkhkkmXHrsymKjaBrx1Tf+mC3zU4Nm5pIA/JgGMmZarhT+7TJy/qNUTfs0k9ma842UrP8e5dyeNaMdpWiMBvR8OvVQJ8+a37AgD23X66931mum4OHM9fSTTe9DqTguOK5DT8NGAtm6l1/VAD1z+yOtktyzyv/k/7Fv8c3kZbpO+DS7ynKNDkeJdV/J4V+IM15TViv6ZCKJ12ubPUSyeLY/eao004rjaZxiIX8jx6Xr9wVuJ/34oxyGdV8KMzD8GX37qvNVgky+HD+G3X8FOjbfYaeh4Anl83lNtWVdcxe0aDbI/YOwNIV2ZBIDKTVzL0hWk30dtpe8XOPtgmh//99yzCB9+0S1pXkLqbtqPhK9x5/rG49O8O977eT+Ajc00lWQ1l32/CgzNl8pROdCyr4ad/DzPvhipb9Jvzz5Ce4JRJhVTDN6K042Z/8x0H4M+fOSpte5c1/J7l8Af78jn8ahCg0WzkXucD0x3RBaddoYiGr3H47vK61Y+2nzHoXPqbA9+WH19PT6u3edpgFes21zOTKR10a17bkttW1Za/OmgejttrThI7AKSUTiBEZkcqusJgI21za7aDm4jTnD/5JR+31xzsuPUk/Oefn4jbKJJgonkzJ7lu9YIZJ5IHH4HPTZCc0ZZbDWaNtgylozxgHKtL1/gSQrBxAWZbgMgL6FcftE+IkigS9Fur5x2oVbAj2f2q2xx+7wr8RLO1XxMENEd3e/W5KB0TrqpMrdZZJw1csVxPPUgu/9DrnZF8qoiT9t0WAqLwYOeQtwFKouFr1yBpMwD89KxDcdXyFzQ7CG0vADZi1QSte6qRf4Vyz1l6Kn2HbkpHGHcpasa+kOa5a56SsIGWUBECJ+yzLX559mE4hKTaduHkfbfDNQ91ZiM6lcdqj23tCc24bJk0lYEJF6XDBZmp62z2ItoGDlGkrRuq6L23n46tHRk9FaXjy9V3m9LpWYGv8um45G81CJIdo9r1f1V3+2Q2dVWVl4GRu9ZVZmr4BA6cv5WzPNX2A3aYgbOP3MV5rS+ybmf8b94tM/q949aT8XdvyrZHcdRnvmEn7GBos1972344ab/tjLrsb1X54QcBMLlm1/A1ocGkT6bYa+40vO8NC/C+1+9krZendKL/fTl8rh8cuvPWlquz+I93HeR9bR52nj0Fl7z/ULxuR3tfS9IvkHYnBm7mfdDNdMzhxVE6NiM//emK3q0E2VWmCV8FT512pQXhyu0WelbgK7dMureoiUDoVvR2oL6TqyOl1+ZTOj4TkL6/Kn+9OtrtpaINZrs4QxpgcPiMAY+D2vGIyxPUXwsyqxkXP6qiaisODh/CzIdiaPiZyU3gc3+xt/MZOCXeTJ6WB3pZt/24ffCGhbOc55NMlRqH31pdrtQKGQ2f/Oap1zTuIpnELaqXr1xW1fgqlGWkbYtQgVdDjDVegS61251ZfTL7KfhQOkXqdF4T6EJptGEO7CQHEcvhu9s8FO8bq6WNcFBiruXym/eIDLlT+qtattWoHWnRtAhh/N8KXO1sRcPvtobYCSRGW892p5HRWQ7fla/IFQPi0sypl46tWd4TK0mt4APRZYncsxr+YF/05jY5BL6e26K9+tT9PkZb13KxSDt8+pwZ/u+Dovnbi8CaW4fJJ5LXCqXhc7t5FRV8XzxtH3zkzbtmuH1A97RwZ8ss/t44wdFv7qkL4IK/2hfTB/k86Zr3x9iX96k3DGlsSulkr0+0ZKYsntKJ/ndTOkw9ZLWfN5l7++GrVYPX1aWXTssYjLW0TXWXhk+XlO29aDXY2zXaFsuMmH9t0nELlOtDS7WKDKXjMtrmtHkzR+m0SNHVKgHmWtzr0mW5weEbgr6VscoJDjWB0f55+iF2Tyi9TWNf4qeBZeSYi8ZzdEdO4NviGKgw5YZpahym2TLbo3TS633puZLSaQmTPCidCqNhtIqEw/dxy/RMnpZbjse1ecankcBuc6bg2D2jNNEZo62L0skpl6V0kjJabCwDPVoyPZ64/7VRF3evcin29dIZb1CPzKdWyL4Q6jJrKiMcpTMjDgY035+30DWCpDh458MvSOl0+5P3Zo9COmhclI4m8AvsnMOhkNHWI3maT2t8DF1FyusWFn/iTfjoMQuj9mQMadH/rtQKNqRGW07gd/6JhUHpmHvWtlInt7LkNHwXuu3K12mk+fCpwpX/zblznFvm7NhN0mYvsiFNdOa8TL/H87xvkaWXTotQAn+zg9IpsldoHooYbV1fn0s1YC3Gx2irBtcoL/XV0tu2zNbdMtX/7jazHL7nvXn47Cl7Ec48TZHAlZtQOi3UwwnrJGjQUx0bX+IeSYP9jbbktozRNvuStpkWCXwzPbSvJ5CP0dYXXCruvLq7iZ4V+AfN3wrTB2v48NELrddwS8pWoW732RrO9VGLGW19KJ3i5XbDaKuW3l6BVzlRjgr/dPKeGG6GrBtgu0rvWUfslDkmIHijWgvvWIErT01gdc989qM9mReF6l99jEslT+HbhSa3Mlca/uoNevR1noJEA7zyxo3vGydEpdf1ZaRti5g+WMO9nzveeQ3tLO1y+OqDtu+W6f/FfSz6Rfz6FbphtK1a8pskm1ww6ZHzxsgus6fgJ2cdyp7rhhCMNHx7XS1p+JzA71MC3y8XzjhjdJKVGed1xPVTbUco42FZSmcqL/DzKZ20DbY9DoqiKIdfboDSRXSHw/e/lkORwVtMax9d1BhXQ/qb5fDbaTW5dfEnjsT337Oo5aI0dz2W0mkdnJ6hbBLe2S5H++MWxPqhOgBgGhH4rnFDteTzTtoT7z18x+QIR+kcG+8j/deL5mnHfSmdSiD8V8Y5A74oh99ttKXhCyG+DuAvAAwDeALA+6SUa5nrPgHg/Yie//74uvz0hl0GtwNNq1BaxTsOzuaiN5G3KYsvfGiosULpTB2oor8aZPKOcLtQpRx+6/XRd7zbnKnYbc5Ux9V+EBBsm9oy2jL3TCqs4Y8VceKH1+JU1tNIzAPlum8652i8snGYnENybubkPnzhtH3w09ufQTOUbKTtdtMHMxuzAP7vKSArOdsd3q+cBI2NBbSr4V8DYB8p5X4AHgVwnnmBEGJ7AB8FsEhKuQ+ACoDT26y3I0j3lWzf02HaQA1Pfvkk/N2RO+de66qpkB/+ODLaThuo4cZzjsZb9t5WO640XFcunVbQSZqD+uHz+7jG/7dQtssP33dP2rEhSvyxYSgS+JTSUdHNu20zFTvMnIT9d5hB7rAHLxVxtsjl8DXhXJwKZctUdbdVSufQlsCXUi6WUqqdJ5YAmGe5tApgUAhRBTAJwHPt1NspJGloO+T8aqZAtcJxSZGO4RdpW7zcbmHOtIEspcN4N9myTxZBdzh8/vu2M0FxioaidOqelM5oT+ZFsSGhdFKCYe6MQfz0rEPx73+zf+Z6bovDDx0VJdPjOHwb8lhbNvDKu3RLmd2LYWwJneTwzwRwpXlQSrkKwDcAPAPgeQDrpJSLbYUIIc4WQiwVQixdvXp1B5uXRZG8452ETz58r3I8JH4rwqibkbYm0v1b0wZ2QjvvbOBV6p89EgbSohuYjD+Bn6V0AOCIXWdl9iIAeC35U8fvjhUXnFxoZe57LU2q2C58dj0bSeQKfCHEtUKI5cy/08g15wNoALiEuX8rAKcB2AnAXACThRDvttUnpbxISrlISrlo9mx+/9hOQQmbkc4w6Kqt08nT2uGXRwJCCHzquN3w2w+nW0CmsQitj7pu2CEEbJSOIFe0D6W1eu9YNTY/rRUqGNKWG8hEUV92G/LGgNomM8qySp3/W0caQzA2PlKu0VZKeazrvBDiDACnADhG8olkjgXwlJRydXz9ZQBeD+CnhVvbYaSUzggLfAdlUWQjlWJumQXaN8Kd8yPH7Kr9budzqFu78Umpux5XZ6fmVOV5ssWb0ulMvSMN28b3JqgNpR3kjReV+HDW1H492MuBPKWkqFtmt9EWpSOEOAHAOQBOlVJuslz2DIDDhBCTRCTpjgHwUDv1dgq2zY67DdfH748TgXF7bhYpx7xmrGgYPkh981svo5PpBriAHK2uNkfznttNw7+elubN76tG5flq+GN19WZDkjrCk3/vlJbs2yVmT+nPzWPv25bPn7o39th2KhZuM8Wv8i6j3cCr7wDoB3BN/GKWSCk/KISYC+BiKeVJUsrbhRD/C+BuRLTPPQAuarPejmC0NHxXdcpbwSfKsgiHP560wCLpJUy4tsNrG0Lkeul88rjdCtuErvzYG7XfO249GYftPBOfPj5/20ZgfH1bALjq42/Ek6s3el+f9IM2n9N3Yp49tR9Pv7ypE1XikJ1m4qqPH9lmKZ1DWwJfSsnmLZBSPgfgJPL7cwA+105d3cBoGW1d3WhyZj9VO7pF6Yw2khT5bRnOOqjhk8CrPIP7Rw16qhXUKgF+cbZ9Y2yu3vGEHbeerG3cnYeEw2+zXt9VH03Gl/dqx5oXTh4mdKRtX6VYVsJOwdWJBgsIfJ9mq7rGk1Box2jbVQ6fBF5xaXnH0Ssel2iXuiqWBVNNMhZKZ5x+6wkt8BVfPtJeOi7ha26v50KRbJnjCZ1ociefm7plJrs1kfJHW8sbj9+4FbSt4RfJJzXGjK2dQs8mT/OBcn8bS26Z5gbaLvi0u8ietm/afTYuvvkpHLzTTO82dAPJwGzHaNul5GmKRqOrwtH2tR5vHH5RhB1yy8yjdG7/p2OSv0d7Eu8WJrbAjwNcfPah7SRcHbeIwPeidApc+8ZdZ+PxL53o7T3RLTDb3BZGN4RvROkou0/6jkbb13q8eem0im576cyZNpD8vfPsydhtzhR87i/2dtzROWw9uQ8vk/xB3cKEFvhqs+hwhCV+pygdPy+d6H/foTLawh5In8snFsGGjkbakjJVuazdp9Twu4KjdtsGtzz+MnaYye857Isiq76BWgWLP/GmturjcPaRO6PJyJsbPnOUc7OmTqEU+AAaI63iO6BtyJ0Dnw5cKUDpjBUkfvhtlNFZDj8tk4vOHu3eM56+bSt4/xt3wlsP2h6zjEyrRdENmq+oTvJPJ+3JHp86UMPUAb/I43Yw+urcKEJROtyM2024UhYXy5bpURfGox9+J8ro3AOrvPT9tSAR7hqH3yG3wRI8hBBtC3ugs2NgvH7rUuDDb1vCTqLQ/rce5biQpnkZP120E++nk4NbRT0PVCtoxgFxFdYtc/y844mITioBb9xtNg6aPwOffotfcNxYwQSndCID6Uhr+J1CkXz440kUdcZo2/kn7q8FaISR8OdSao+ndzwR0UlvvCn9VVz2oTd0rLyRwsTW8Cujo+ErtJ0MysstM/5/HGmf3D63xcvoVGtSDNQqyc5mZ5JNznvVha/XMI6GQNcwoTX80eLwFdqndHyuGY+pFVqndLoZWdxfDTB1oJbZPm+0/fBL+GE8KT3dwoQW+P2jLPBtWPYvx3m5XPrQFmlkaNvNGjF0wjO0G8+rKEATvql0S4wuRjrAcixiQgv80Qq8UrDJ6xmT+jpWR+qHP346eyc2QOmGNmdzmeW24Csx9lB+nonO4Y+Shj+SnG8i+MZRZ+9EPvxuwKrhx/+Po1c8IVFSOhNc4I93Lx0fBF3ktLuFTqRH7uQGKAp2Db/kdMYDSkpnwgv80fHSGUnZK8alW2YnKJ1OtSZFvoY/nt7yxEMp7ye4wE8onREW+CNL6UT/jyMFvyNis1teOi6Mp3c8EVHaWCa6wI/dQcYaV9xJpFscjp/OLjpA6XTjca00UQ/3n16Czw5xvY4JLfD7CyQqG68Yj374SsdvK9J2BOmVdHekEmMZ40np6RZ6X+I50DcGUgF3G+Oxj7ej4Y9Gsrhe3R2p11B+nwku8FXu9/kzJ41yS7qH8ajVtJN4WGnbo/HcpdF2bKP00pnggVcAcMn7D8Wuc6aMdjO6BtXHRytfUCvohHFtJAX++HmzExvjUfnpNCa8wH/Dwlmj3YSuQgnPOMnjuEJbRtsRXLuWlM74QKngT3BKZyJAjEcNP/6/PaPtyKFMnjY+0I1gvPGGCa/hjwbURuUjYTuojNE0BS6kRtvijU6Ntp0b3D8961BnrMaJ+2yH/7l1Bc4+cpeO1Vmi8ygpnVLgjwoWzJqM779nEQ7beWbX6xqXGn5HNkDpSFMAAEfs6qb9Zk7u68qG10Xwx4++ETMndy7pXi+iVPDbpHSEEF8XQjwshLhPCHG5EGKG5bqPCSGWCyEeEEJ8vJ06ewXH7TVnZDYtVhz++JH3pbdLC9hr7jRsO31gtJtRYoyjXQ7/GgD7SCn3A/AogPPMC4QQ+wD4AIBDAOwP4BQhxMI26y3hCcVbjicNX2EcNrlEiTGNtgS+lHKxlLIR/1wCYB5z2Z4AbpdSboqv/TOAv2qn3hL+SAyg40l6tkHp/Pzsw/CuQ+djsMYnOitRYiKjkxz+mQB+yRxfDuBLQoitAWwGcBKApbZChBBnAzgbAObPn9/B5k1MjE9KJ0Irk9QBO8zAATvM6Gh7SvQGxpPO0y3kCnwhxLUAtmVOnS+l/G18zfkAGgAuMS+SUj4khPgqgMUANgJYBqBpq09KeRGAiwBg0aJF5SdqE5VxSOmUWQ1LdAN0BMyaMjEN3LkCX0p5rOu8EOIMAKcAOEZaVDIp5Q8A/CC+/ssAni3c0hJtYTxq+CVKdANT+qu4/tNHjXYzRgVtUTpCiBMAnAPgTVLKTY7rtpFSviSEmI+Ivz+snXpL+CPZTGQcafgK47DJJcYwZk/tBwB8+vjdRsRDbiyiXQ7/OwD6AVwTL8OXSCk/KISYC+BiKeVJ8XW/jjn8OoAPSynXtllviRg/et/BmNRn/4zjM5dO9H87O16VKGFiSn8VKy44ebSbMapoS+BLKVn3Sinlc4iMs+r3G9upp4QdR+2+jfO8csscR/I+8cMfT20uUWI8oMyl0+NQ2vJIb+PYDjqx41WJEiWyKAV+jyMYj7l04v9LSqdEic6iFPg9jqCNRGSjhlLDL1GiKygFfo/jiIWzAQCH7rz1KLfEH6IDe9qWKFEiizJbZo/j8F22xmNfOhG1cbR/r0g5nRIlSnQQ40cKlGgZ40nYAyWHX6JEtzC+JEGJCYFqJRL5/dUyAVqJEp1ESemUGHM4cIet8JE3L8T/OWzH0W5KiRI9hVLglxhzCAKBTx2/+2g3o0SJnkNJ6ZQoUaLEBEEp8EuUKFFigqAU+CVKlCgxQVAK/BIlSpSYICgFfokSJUpMEJQCv0SJEiUmCEqBX6JEiRITBKXAL1GiRIkJAjGW0+YKIVYDeLrF22cBWNPB5owHlM88MVA+88RAq8+8o5RyNndiTAv8diCEWCqlXDTa7RhJlM88MVA+88RAN565pHRKlChRYoKgFPglSpQoMUHQywL/otFuwCigfOaJgfKZJwY6/sw9y+GXKFGiRAkdvazhlyhRokQJglLglyhRosQEQc8JfCHECUKIR4QQjwshzh3t9nQKQoj/FkK8JIRYTo7NFEJcI4R4LP5/q/i4EEJcGL+D+4QQB41ey1uHEGIHIcT1QogHhRAPCCE+Fh/v2ecWQgwIIe4QQtwbP/MX4uM7CSFuj5/tl0KIvvh4f/z78fj8glF9gDYghKgIIe4RQvwh/t3TzyyEWCGEuF8IsUwIsTQ+1tW+3VMCXwhRAfAfAE4EsBeAdwoh9hrdVnUMPwJwgnHsXADXSSl3BXBd/BuInn/X+N/ZAL43Qm3sNBoAPiWl3AvAYQA+HH/PXn7uLQDeLKXcH8ABAE4QQhwG4KsAvimlXAjgVQBnxdefBeDV+Pg34+vGKz4G4CHyeyI889FSygOIv313+7aUsmf+ATgcwNXk93kAzhvtdnXw+RYAWE5+PwJgu/jv7QA8Ev/9XwDeyV03nv8B+C2A4ybKcwOYBOBuAIciirisxseTfg7gagCHx39X4+vEaLe9hWedFwu4NwP4AwAxAZ55BYBZxrGu9u2e0vABbA9gJfn9bHysVzFHSvl8/PcLAObEf/fce4iX7QcCuB09/twxtbEMwEsArgHwBIC1UspGfAl9ruSZ4/PrAGw9og3uDL4F4BwAYfx7a/T+M0sAi4UQdwkhzo6PdbVvl5uY9wiklFII0ZM+tkKIKQB+DeDjUsr1QojkXC8+t5SyCeAAIcQMAJcD2GN0W9RdCCFOAfCSlPIuIcRRo9yckcQRUspVQohtAFwjhHiYnuxG3+41DX8VgB3I73nxsV7Fi0KI7QAg/v+l+HjPvAchRA2RsL9ESnlZfLjnnxsApJRrAVyPiM6YIYRQChp9ruSZ4/PTAbw8si1tG28AcKoQYgWAXyCidb6N3n5mSClXxf+/hGhiPwRd7tu9JvDvBLBrbN3vA3A6gN+Ncpu6id8BeG/893sRcdzq+Htiy/5hANaRZeK4gYhU+R8AeEhK+X/JqZ59biHE7FizhxBiEJHN4iFEgv/t8WXmM6t38XYAf5IxyTteIKU8T0o5T0q5ANGY/ZOU8l3o4WcWQkwWQkxVfwM4HsBydLtvj7bhoguGkJMAPIqI9zx/tNvTwef6OYDnAdQR8XdnIeItrwPwGIBrAcyMrxWIvJWeAHA/gEWj3f4Wn/kIRDznfQCWxf9O6uXnBrAfgHviZ14O4F/i4zsDuAPA4wB+BaA/Pj4Q/348Pr/zaD9Dm89/FIA/9Pozx892b/zvASWrut23y9QKJUqUKDFB0GuUTokSJUqUsKAU+CVKlCgxQVAK/BIlSpSYICgFfokSJUpMEJQCv0SJEiUmCEqBX6JEiRITBKXAL1GiRIkJgv8PrAnnQjFhNPQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# vs power\n",
    "# for 5    12\n",
    "# for 4    1\n",
    "# for 3    490\n",
    "# for 2    300\n",
    "# for 1    0\n",
    "\n",
    "# vs voltage\n",
    "\n",
    "# for 1   10\n",
    "# for 2   12\n",
    "# for 3   300\n",
    "# for 4   10\n",
    "# for 5   107\n",
    "\n",
    "id_number=300\n",
    "plt.plot(distance[id_number][0:500])\n",
    "signal_parameters[\"mean_up\"]=np.mean(distance[id_number][0:500])\n",
    "signal_parameters[\"std_up\"]=np.std(distance[id_number][100:300])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:28:46.562243Z",
     "start_time": "2021-09-30T11:28:43.582681Z"
    }
   },
   "outputs": [],
   "source": [
    "up_down=np.zeros(len(distance))\n",
    "maximum=np.zeros(len(distance))\n",
    "background_distance=np.zeros(len(distance))\n",
    "max_background_distance=np.zeros(len(distance))\n",
    "\n",
    "for a in range(len(distance)):\n",
    "    minim= np.where(sweep_40>= 0)[0][0]\n",
    "    maxim= np.where(sweep_40>= 399)[0][0]\n",
    "\n",
    "    \n",
    "    up_down[a]=np.mean(distance[a][minim:maxim])\n",
    "    maximum[a]=distance[a][minim:maxim].max()\n",
    "    \n",
    "    minim= np.where(sweep_40>= 1460)[0][0]\n",
    "    maxim= np.where(sweep_40>= 1860)[0][0]\n",
    "\n",
    "    background_distance[a]=np.mean(distance[a][minim:maxim])\n",
    "    max_background_distance[a]=(distance[a][minim:maxim]).max()\n",
    "    \n",
    "  \n",
    "hist_max, bin_edges_max = np.histogram(maximum, bins=60,range=(maximum.min(),maximum.max()))    \n",
    "hist_max_bg, bin_edges_max_bg = np.histogram(max_background_distance, bins=60,range=(maximum.min(),maximum.max()))   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:28:46.720657Z",
     "start_time": "2021-09-30T11:28:46.563279Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'histogram')"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline \n",
    "## 30 first us removed\n",
    "bin_axis_bg=bin_edges_max_bg[0:-1]+(bin_edges_max_bg[1]-bin_edges_max_bg[0])/2\n",
    "\n",
    "plt.bar(bin_axis_bg, hist_max_bg, width=bin_edges_max_bg[1]-bin_edges_max_bg[0],label=\"background\",alpha=0.5)\n",
    "plt.plot(bin_axis_bg, hist_max_bg)\n",
    "#Tin=factor*2.5\n",
    "Tin = T_int\n",
    "plt.title(\"maximum\"+str(id_1)+\" Tin=\"+str(Tin)+\" us\" +\" 14_long_tunneling\")\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel(\"distance (V)\")\n",
    "plt.ylabel(\"histogram\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:28:46.736600Z",
     "start_time": "2021-09-30T11:28:46.720657Z"
    }
   },
   "outputs": [],
   "source": [
    "def fmax_down(x, n_points, std, signal_low):\n",
    "    PDF_max=np.zeros(len(x))\n",
    "    for a in range(len(x)):\n",
    "        gaussian=1/std/np.sqrt(2*np.pi)*np.exp(-1/2*((x[a]-signal_low)/std)**2)\n",
    "        F_function=1/2*(1+math.erf((x[a]-signal_low)/std/np.sqrt(2)))\n",
    "        PDF_max[a]=n_points*F_function**(n_points-1)*gaussian\n",
    "    return PDF_max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:28:46.847130Z",
     "start_time": "2021-09-30T11:28:46.738593Z"
    }
   },
   "outputs": [],
   "source": [
    "delta_t=(maxim-minim)\n",
    "mean_bg=np.mean(background_distance)\n",
    "std_bg=np.std(distance[a][minim:maxim])\n",
    "normalisation=(bin_edges_max_bg[1]-bin_edges_max_bg[0])*10000\n",
    "\n",
    "fit_results=fit(bin_edges_max_bg[0:-1], hist_max_bg/normalisation, fmax_down, init={\"signal_low\":mean_bg,\"std\":std_bg},fixed = {'n_points':delta_t})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:28:46.987495Z",
     "start_time": "2021-09-30T11:28:46.848131Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 432x432 with 2 Axes>, GridSpec(2, 1, height_ratios=[1, 4]))"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fit_results.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:28:51.141440Z",
     "start_time": "2021-09-30T11:28:51.133461Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h2> Model</h2> Model(fmax_down) <h2>Fit Statistics</h2><table><tr><td>fitting method</td><td>leastsq</td><td></td></tr><tr><td># function evals</td><td>174</td><td></td></tr><tr><td># data points</td><td>60</td><td></td></tr><tr><td># variables</td><td>2</td><td></td></tr><tr><td>chi-square</td><td> 81609.1701</td><td></td></tr><tr><td>reduced chi-square</td><td> 1407.05466</td><td></td></tr><tr><td>Akaike info crit.</td><td> 436.921141</td><td></td></tr><tr><td>Bayesian info crit.</td><td> 441.109830</td><td></td></tr></table><h2>Variables</h2><table><tr><th> name </th><th> value </th><th> standard error </th><th> relative error </th><th> initial value </th><th> min </th><th> max </th><th> vary </th></tr><tr><td> n_points </td><td>  390.000000 </td><td>  0.00000000 </td><td> (0.00%) </td><td> 390 </td><td>        -inf </td><td>         inf </td><td> False </td></tr><tr><td> std </td><td>  0.03338962 </td><td>  0.03572266 </td><td> (106.99%) </td><td> 0.10520112256241161 </td><td>        -inf </td><td>         inf </td><td> True </td></tr><tr><td> signal_low </td><td> -2.45809003 </td><td>  0.10013666 </td><td> (4.07%) </td><td> -2.6424063231800567 </td><td>        -inf </td><td>         inf </td><td> True </td></tr></table><h2>Correlations (unreported correlations are < 0.100)</h2><table><tr><td>std</td><td>signal_low</td><td>-0.9948</td></tr></table>"
      ],
      "text/plain": [
       "<lmfit.model.ModelResult at 0x291f099e070>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fit_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JPA off Final parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:28:52.824346Z",
     "start_time": "2021-09-30T11:28:52.805407Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'mean_bg': -2.6427917615361505,\n",
       " 'std_bg': 0.10148564935088496,\n",
       " 'mean_up': -2.646304100938416,\n",
       " 'std_up': 0.09590352698577818,\n",
       " 't_int': 0,\n",
       " 't_out': 56.63873533617122,\n",
       " 't_in': 453.85162520899223}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "signal_parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fit to experiements tint=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:29:21.959617Z",
     "start_time": "2021-09-30T11:29:21.945693Z"
    }
   },
   "outputs": [],
   "source": [
    "signal_parameters\n",
    "signal_parameters[\"std_up\"]=signal_parameters[\"std_bg\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:29:24.134026Z",
     "start_time": "2021-09-30T11:29:23.228162Z"
    }
   },
   "outputs": [],
   "source": [
    "# REAL DATA HISTOGRAM\n",
    "maximum=np.zeros(len(distance))\n",
    "max_background_distance=np.zeros(len(distance))\n",
    "\n",
    "for a in range(len(distance)):\n",
    "    minim= np.where(sweep>= 0)[0][0]\n",
    "    maxim= np.where(sweep>= 2000)[0][0]\n",
    "\n",
    "    \n",
    "    maximum[a]=distance[a][minim:maxim].max()\n",
    "    \n",
    "    \n",
    "  \n",
    "hist_max, bin_edges_max = np.histogram(maximum, bins=60,range=(maximum.min(),maximum.max()))    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:29:32.868499Z",
     "start_time": "2021-09-30T11:29:32.067342Z"
    }
   },
   "outputs": [],
   "source": [
    "# SIMULATION- CREATE DATA\n",
    "\n",
    "signal_low=signal_parameters[\"mean_bg\"]\n",
    "signal_high=signal_parameters[\"mean_up\"]\n",
    "std_bg=signal_parameters[\"std_bg\"]\n",
    "std_up=signal_parameters[\"std_up\"]\n",
    "\n",
    "\n",
    "t_in=signal_parameters[\"t_in\"]\n",
    "t_out=signal_parameters[\"t_out\"]\n",
    "\n",
    "A=0.5\n",
    "\n",
    "n_traces=10000\n",
    "n_points_time=1952\n",
    "\n",
    "range_min=maximum.min()\n",
    "range_max=maximum.max()\n",
    "\n",
    "sim_distance, spin_sim= simulate_distance(A,std_bg,std_up ,signal_low,signal_high,t_out,t_in,n_points_time, n_traces,sweep)\n",
    "   \n",
    "\n",
    "# SIMULATION HISTOGRAM\n",
    "maximum_sim=np.zeros(len(sim_distance))\n",
    "\n",
    "for a in range(len(sim_distance)):\n",
    "    minim= np.where(sweep>= 0)[0][0]\n",
    "    maxim= np.where(sweep>= 2000)[0][0]\n",
    "\n",
    "    \n",
    "    maximum_sim[a]=sim_distance[a][minim:maxim].max()\n",
    "    \n",
    "    \n",
    "  \n",
    "hist_max_sim, bin_edges_max_sim = np.histogram(maximum_sim, bins=60,range=(maximum_sim.min(),maximum_sim.max()))    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:29:34.276650Z",
     "start_time": "2021-09-30T11:29:34.054159Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'histogram')"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline \n",
    "## 30 first us removed\n",
    "bin_axis=bin_edges_max[0:-1]+(bin_edges_max[1]-bin_edges_max[0])/2\n",
    "normalisation=10000*(bin_edges_max[1]-bin_edges_max[0])\n",
    "plt.bar(bin_axis, hist_max/normalisation, width=bin_edges_max[1]-bin_edges_max[0],alpha=0.5)\n",
    "plt.plot(bin_axis, hist_max/normalisation)\n",
    "\n",
    "\n",
    "bin_axis=bin_edges_max_sim[0:-1]+(bin_edges_max_sim[1]-bin_edges_max_sim[0])/2\n",
    "normalisation=10000*(bin_edges_max_sim[1]-bin_edges_max_sim[0])\n",
    "plt.bar(bin_axis, hist_max_sim/normalisation, width=bin_edges_max_sim[1]-bin_edges_max_sim[0],alpha=0.5)\n",
    "plt.plot(bin_axis, hist_max_sim/normalisation)\n",
    "\n",
    "#Tin=factor*2.5\n",
    "Tin = T_int\n",
    "plt.title(\"maximum\"+str(id_1)+\" Tin=\"+str(Tin)+\" us\" +\" 14_long_tunneling\")\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel(\"distance (V)\")\n",
    "plt.ylabel(\"histogram\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tint=20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:46:36.354361Z",
     "start_time": "2021-09-30T11:46:36.092606Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1952\n"
     ]
    }
   ],
   "source": [
    "## REAL DATA MOVING AVERAGE\n",
    "factor = 20 # factor*T_int_original=Tint\n",
    "num_bins=100\n",
    "distance_40=np.zeros((len(distance),len( moving_average(distance[0], factor))))\n",
    "\n",
    "\n",
    "acquisition_time=2000 # time of the trace in us\n",
    "number_points=len(sweep) # number of points in the trace\n",
    "print(number_points)\n",
    "T_int_original=acquisition_time/number_points # original integration time (1us)\n",
    "T_int=factor*T_int_original # new integration time\n",
    "\n",
    "\n",
    "# new I and Q with moving averaged\n",
    "distance_40=np.zeros((len(distance),len(moving_average(distance[0], factor))))\n",
    "sweep_40=np.zeros(len(moving_average(distance[0], factor)))\n",
    "\n",
    "\n",
    "for a in range(len(X)):\n",
    "    distance_40[a]=moving_average(distance[a], factor)\n",
    "sweep_40=moving_average(sweep, factor)\n",
    "\n",
    "# HISTOGRAM WITH REAL DATA\n",
    "maximum=np.zeros(len(distance_40))\n",
    "max_background_distance=np.zeros(len(distance_40))\n",
    "\n",
    "for a in range(len(distance)):\n",
    "    minim= np.where(sweep_40>= 0)[0][0]\n",
    "    maxim= np.where(sweep_40>= sweep_40.max())[0][0]\n",
    "\n",
    "    \n",
    "    maximum[a]=distance_40[a][minim:maxim].max()\n",
    "    \n",
    "range_min=maximum.min()\n",
    "range_max=maximum.max()\n",
    "  \n",
    "hist_max, bin_edges_max = np.histogram(maximum, bins=num_bins,range=(maximum.min(),maximum.max()))    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1038,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:05:52.168492Z",
     "start_time": "2021-09-07T16:05:51.909443Z"
    }
   },
   "outputs": [],
   "source": [
    "## SIMULATION MOVING AVERAGE\n",
    "\n",
    "sim_distance_40=np.zeros((len(sim_distance),len( moving_average(sim_distance[0], factor))))\n",
    "\n",
    "\n",
    "# new I and Q with moving averaged\n",
    "sim_distance_40=np.zeros((len(sim_distance),len(moving_average(sim_distance[0], factor))))\n",
    "\n",
    "\n",
    "for a in range(len(sim_distance)):\n",
    "    sim_distance_40[a]=moving_average(sim_distance[a], factor)\n",
    "\n",
    "# HISTOGRAM WITH SIMULATION\n",
    "maximum_sim=np.zeros(len(sim_distance_40))\n",
    "\n",
    "for a in range(len(sim_distance)):\n",
    "    minim= np.where(sweep>= 0)[0][0]\n",
    "    maxim= np.where(sweep>= sweep_40.max())[0][0]\n",
    "\n",
    "    \n",
    "    maximum_sim[a]=sim_distance_40[a][minim:maxim].max()\n",
    "    \n",
    "    \n",
    "  \n",
    "hist_max_sim, bin_edges_max_sim = np.histogram(maximum_sim, bins=num_bins,range=(maximum_sim.min(),maximum_sim.max()))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:46:39.680935Z",
     "start_time": "2021-09-30T11:46:39.505792Z"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'bin_edges_max_sim' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_900/906644973.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mbin_axis_sim\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mbin_edges_max_sim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbin_edges_max_sim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mbin_edges_max_sim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     10\u001b[0m \u001b[0mnormalisation_sim\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m10000\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbin_edges_max_sim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mbin_edges_max_sim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbar\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbin_axis_sim\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhist_max_sim\u001b[0m\u001b[1;33m/\u001b[0m\u001b[0mnormalisation_sim\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mwidth\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mbin_edges_max_sim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mbin_edges_max_sim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0malpha\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0.5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'bin_edges_max_sim' is not defined"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline \n",
    "## PLOT\n",
    "bin_axis=bin_edges_max[0:-1]+(bin_edges_max[1]-bin_edges_max[0])/2\n",
    "normalisation=10000*(bin_edges_max[1]-bin_edges_max[0])\n",
    "plt.bar(bin_axis, hist_max/normalisation, width=bin_edges_max[1]-bin_edges_max[0],alpha=0.5)\n",
    "plt.plot(bin_axis, hist_max/normalisation)\n",
    "\n",
    "\n",
    "bin_axis_sim=bin_edges_max_sim[0:-1]+(bin_edges_max_sim[1]-bin_edges_max_sim[0])/2\n",
    "normalisation_sim=10000*(bin_edges_max_sim[1]-bin_edges_max_sim[0])\n",
    "plt.bar(bin_axis_sim, hist_max_sim/normalisation_sim, width=bin_edges_max_sim[1]-bin_edges_max_sim[0],alpha=0.5)\n",
    "plt.plot(bin_axis_sim, hist_max_sim/normalisation_sim)\n",
    "\n",
    "\n",
    "Tin = T_int\n",
    "plt.title(\"maximum\"+str(id_1)+\" Tin=\"+str(Tin)+\" us\" +\" 14_long_tunneling\")\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel(\"distance (V)\")\n",
    "plt.ylabel(\"histogram\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1040,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:05:54.537714Z",
     "start_time": "2021-09-07T16:05:54.530738Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.3152444813454167"
      ]
     },
     "execution_count": 1040,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maximum.min()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## fit parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1045,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:07:05.718342Z",
     "start_time": "2021-09-07T16:06:34.040565Z"
    }
   },
   "outputs": [],
   "source": [
    "signal_low=signal_parameters[\"mean_bg\"]\n",
    "signal_high=signal_parameters[\"mean_up\"]\n",
    "std_bg=signal_parameters[\"std_bg\"]\n",
    "std_up=signal_parameters[\"std_up\"]\n",
    "\n",
    "\n",
    "t_in=signal_parameters[\"t_in\"]\n",
    "t_out=signal_parameters[\"t_out\"]\n",
    "\n",
    "A=0.5\n",
    "t_int=factor\n",
    "num_bins = num_bins\n",
    "n_traces=10000\n",
    "t_max = 2000\n",
    "n_points_time=1952\n",
    "\n",
    "range_min=maximum.min()\n",
    "range_max=maximum.max()\n",
    "\n",
    "\n",
    "\n",
    "fitresult= fit(bin_axis, hist_max/normalisation,fit_histogram_v2, fixed = {'range_min':range_min,'range_max':range_max,'t_int':t_int,'t_out':t_out, 't_in':t_in, 't_max':t_max, 'n_points_time': n_points_time, 'n_traces':n_traces, 'num_bins':num_bins, 'plot_histo':0, 'signal_low': signal_low , 'std_low': std_bg}, init = {'std_up':std_up, \"A\":A,\"signal_high\":signal_high,},bounds={'std_up':[0.09,0.12], \"A\":[0.45,0.55]}, step_size = 2e-2 )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1046,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:07:08.199242Z",
     "start_time": "2021-09-07T16:07:05.720237Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 239.103x239.103 with 2 Axes>,\n",
       " GridSpec(2, 1, height_ratios=[1, 4]))"
      ]
     },
     "execution_count": 1046,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 239.103x239.103 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fitresult.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1047,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:07:08.214236Z",
     "start_time": "2021-09-07T16:07:08.201223Z"
    }
   },
   "outputs": [],
   "source": [
    "factor_ntraces = 10\n",
    "\n",
    "A = fitresult.params['A'].value\n",
    "range_min = fitresult.params['range_min'].value\n",
    "range_max = fitresult.params['range_max'].value\n",
    "std_low = fitresult.params['std_low'].value \n",
    "std_up = fitresult.params['std_up'].value\n",
    "signal_low = fitresult.params['signal_low'].value \n",
    "signal_high = fitresult.params['signal_high'].value\n",
    "t_int = fitresult.params['t_int'].value\n",
    "t_out = fitresult.params['t_out'].value\n",
    "t_in = fitresult.params['t_in'].value\n",
    "t_max = fitresult.params['t_max'].value\n",
    "n_points_time = fitresult.params['n_points_time'].value \n",
    "n_traces = fitresult.params['n_traces'].value * factor_ntraces \n",
    "num_bins = fitresult.params['num_bins'].value\n",
    "num_bins = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  definitive parameters fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1048,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:07:08.230125Z",
     "start_time": "2021-09-07T16:07:08.216174Z"
    }
   },
   "outputs": [],
   "source": [
    "signal_parameters_fit={\n",
    "  \"mean_bg\": 0,\n",
    "  \"std_bg\": 0,\n",
    "  \"mean_up\": 0,\n",
    "  \"std_up\": 0,\n",
    "  \"t_int\": 0,\n",
    "  \"t_out\": 0,\n",
    "    \"A\":0,\n",
    "}\n",
    "\n",
    "signal_parameters_fit[\"A\"]=A\n",
    "signal_parameters_fit[\"std_bg\"]=std_low\n",
    "signal_parameters_fit[\"std_up\"]=std_up\n",
    "signal_parameters_fit[\"mean_bg\"]=signal_low\n",
    "signal_parameters_fit[\"mean_up\"]=signal_high\n",
    "signal_parameters_fit[\"t_int\"]=t_int\n",
    "signal_parameters_fit[\"t_in\"]=t_in\n",
    "signal_parameters_fit[\"t_out\"]=t_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1049,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:07:08.245075Z",
     "start_time": "2021-09-07T16:07:08.231118Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'mean_bg': -3.3493535124031806,\n",
       " 'std_bg': 0.10143317709914586,\n",
       " 'mean_up': -3.224155519095218,\n",
       " 'std_up': 0.10172068194686833,\n",
       " 't_int': 20,\n",
       " 't_out': 22.419067336281234,\n",
       " 'A': 0.500042687664294,\n",
       " 't_in': 313.81919653814515}"
      ]
     },
     "execution_count": 1049,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "signal_parameters_fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1050,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:07:08.261019Z",
     "start_time": "2021-09-07T16:07:08.246068Z"
    }
   },
   "outputs": [],
   "source": [
    "import json\n",
    "with open('JPA_off_vs_power_'+str(id_1)+'.json', 'w') as fp:\n",
    "    json.dump(signal_parameters_fit, fp)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-06T14:31:54.487777Z",
     "start_time": "2021-09-06T14:31:54.482776Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T15:42:30.349139Z",
     "start_time": "2021-09-07T15:42:30.335252Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:27:10.382036Z",
     "start_time": "2021-09-30T11:27:08.763487Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\virgi\\AppData\\Local\\Temp/ipykernel_3128/3013448970.py:42: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"rasterized\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  plt.savefig(\"histogram.png\",dpi=600, bbox_inches = \"tight\", rasterized='True')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 239.103x147.774 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Comparing data and simulation\n",
    "\n",
    "\n",
    "fig_width_pt = 240.0  # Get this from LaTeX using \\showthe\\columnwidth\n",
    "inches_per_pt = 1.0/72.27\t\t\t\t# Convert pt to inch\n",
    "golden_mean = (math.sqrt(5)-1.0)/2.0\t\t # Aesthetic ratio\n",
    "fig_width = fig_width_pt*inches_per_pt\t# width in inches\n",
    "fig_height = fig_width*golden_mean\t\t# height in inches\n",
    "fig_size =\t[fig_width,fig_height]\n",
    "plt.rcParams['legend.fontsize'] = 8\n",
    "plt.rcParams['figure.figsize'] = fig_size\n",
    "t_max=2000\n",
    "n_points_time=1952\n",
    "n_traces=10000\n",
    "# Plot data as histogram\n",
    "# -----------------------\n",
    "bin_axis=bin_edges_max[0:-1]+(bin_edges_max[1]-bin_edges_max[0])/2\n",
    "normalisation=10000*(bin_edges_max[1]-bin_edges_max[0])\n",
    "plt.bar(bin_axis, hist_max/normalisation, width=bin_edges_max[1]-bin_edges_max[0],label=\"data\",alpha=0.5)\n",
    "\n",
    "# Plot simulation as curve\n",
    "# -----------------------\n",
    "bins, histo=simulate_histogram_out(A,range_min,range_max,std_low,std_up, signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time,n_traces,num_bins , 0)\n",
    "#f_hist_inter = interp1d(bins,histo, kind='cubic')\n",
    "x=np.linspace(-3,0,1000)\n",
    "#plt.plot(x,f_hist_inter(x), label='best fit')\n",
    "plt.plot(bins, histo, label='best fit')\n",
    "\n",
    "# Caption\n",
    "#------------------------\n",
    "plt.legend()\n",
    "plt.xlabel(\"Signal\")\n",
    "plt.ylabel(\"Probability\")\n",
    "plt.title('Simulated histogram vs data_ Tint=%f'%t_int)\n",
    "\n",
    "plt.xlabel(\"RF signal (V) \", {'color': 'k', 'fontsize': 14})\n",
    "plt.ylabel(\"Probability\", {'color': 'k', 'fontsize': 14})\n",
    "plt.xticks( color='k', size=12)\n",
    "plt.yticks( color='k', size=12)\n",
    "#plt.ylim(0,30)\n",
    "plt.title(\"Simulated histogram fitted to data_1\",size=16)\n",
    "plt.savefig(\"histogram.png\",dpi=600, bbox_inches = \"tight\", rasterized='True')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:27:05.737520Z",
     "start_time": "2021-09-30T11:27:05.732602Z"
    }
   },
   "outputs": [],
   "source": [
    "import json\n",
    "with open('JPA_off_vs_power_2.json', 'r') as file:\n",
    "    signal_parameters_fit_read=json.load(file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:27:06.407295Z",
     "start_time": "2021-09-30T11:27:06.399323Z"
    }
   },
   "outputs": [],
   "source": [
    "A=signal_parameters_fit_read[\"A\"]\n",
    "std_low=signal_parameters_fit_read[\"std_bg\"]\n",
    "std_up=signal_parameters_fit_read[\"std_up\"]\n",
    "signal_low=signal_parameters_fit_read[\"mean_bg\"]\n",
    "signal_high=signal_parameters_fit_read[\"mean_up\"]\n",
    "t_int=20\n",
    "t_in=signal_parameters_fit_read[\"t_in\"]\n",
    "t_out=signal_parameters_fit_read[\"t_out\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-30T11:25:24.543789Z",
     "start_time": "2021-09-30T11:25:24.539802Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'mean_bg': -3.3493535124031806,\n",
       " 'std_bg': 0.10143317709914586,\n",
       " 'mean_up': -3.224155519095218,\n",
       " 'std_up': 0.10172068194686833,\n",
       " 't_int': 20,\n",
       " 't_out': 22.419067336281234,\n",
       " 'A': 0.500042687664294,\n",
       " 't_in': 313.81919653814515}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "signal_parameters_fit_read"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1136,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:21:52.364957Z",
     "start_time": "2021-09-07T16:21:34.456803Z"
    }
   },
   "outputs": [],
   "source": [
    "# Calculate fidelity as David\n",
    "\n",
    "# SIMULATION- CREATE DATA\n",
    "\n",
    "signal_low=signal_parameters_fit_read[\"mean_bg\"]\n",
    "signal_high=signal_parameters_fit_read[\"mean_up\"]\n",
    "std_bg=signal_parameters_fit_read[\"std_bg\"]\n",
    "std_up=signal_parameters_fit_read[\"std_up\"]\n",
    "\n",
    "\n",
    "t_in=signal_parameters_fit_read[\"t_in\"]\n",
    "t_out=signal_parameters_fit_read[\"t_out\"]\n",
    "\n",
    "A=signal_parameters_fit_read[\"A\"]\n",
    "\n",
    "n_traces=100000\n",
    "n_points_time=1952\n",
    "\n",
    "\n",
    "\n",
    "sim_distance, spin_sim= simulate_distance(A,std_bg,std_up ,signal_low,signal_high,t_out,t_in,n_points_time, n_traces,sweep)\n",
    "\n",
    "## SIMULATION MOVING AVERAGE\n",
    "\n",
    "sim_distance_40=np.zeros((len(sim_distance),len( moving_average(sim_distance[0], factor))))\n",
    "\n",
    "\n",
    "# new I and Q with moving averaged\n",
    "sim_distance_40=np.zeros((len(sim_distance),len(moving_average(sim_distance[0], factor))))\n",
    "\n",
    "\n",
    "for a in range(len(sim_distance)):\n",
    "    sim_distance_40[a]=moving_average(sim_distance[a], factor)\n",
    "\n",
    "# HISTOGRAM WITH SIMULATION\n",
    "maximum_sim=np.zeros(len(sim_distance_40))\n",
    "\n",
    "for a in range(len(sim_distance)):\n",
    "    minim= np.where(sweep>= 0)[0][0]\n",
    "    maxim= np.where(sweep>= sweep_40.max())[0][0]\n",
    "\n",
    "    \n",
    "    maximum_sim[a]=sim_distance_40[a][minim:maxim].max()\n",
    "range_min=maximum_sim.min()\n",
    "range_max=maximum_sim.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1137,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:21:52.380905Z",
     "start_time": "2021-09-07T16:21:52.365957Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"np.savez('./JPA_off_traces_simulated-2.npz', sim_distance=sim_distance, spin_sim=spin_sim)\\nnp.load('./JPA_off_traces.npz').files\""
      ]
     },
     "execution_count": 1137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"np.savez('./JPA_off_traces_simulated-2.npz', sim_distance=sim_distance, spin_sim=spin_sim)\n",
    "np.load('./JPA_off_traces.npz').files\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1138,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:21:52.396091Z",
     "start_time": "2021-09-07T16:21:52.381902Z"
    }
   },
   "outputs": [],
   "source": [
    "epsilon=0.005\n",
    "signal_threshold = np.linspace(range_min + epsilon, range_max - epsilon,50)\n",
    "\n",
    "fidelity_up = []\n",
    "fidelity_down = []\n",
    "\n",
    "spin_up_maximums=maximum_sim[np.where(spin_sim==0)[0]]\n",
    "spin_down_maximums=maximum_sim[np.where(spin_sim==1)[0]]\n",
    "for signal in signal_threshold:\n",
    "            \n",
    "            integ_up=len(np.where(spin_up_maximums<=signal)[0])\n",
    "            integ_down=len(np.where(spin_down_maximums>=signal)[0])\n",
    "            \n",
    "            fidelity_up.append(1-integ_up/n_traces)\n",
    "            fidelity_down.append(1-integ_down/n_traces)\n",
    "           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1139,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:21:52.458585Z",
     "start_time": "2021-09-07T16:21:52.398080Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1e590e3ab50>]"
      ]
     },
     "execution_count": 1139,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 239.103x147.774 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(signal_threshold,fidelity_up)\n",
    "plt.plot(signal_threshold,fidelity_down)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1140,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:21:52.474532Z",
     "start_time": "2021-09-07T16:21:52.459582Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9734500000000001"
      ]
     },
     "execution_count": 1140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visibility=np.array(fidelity_up)+np.array(fidelity_down)-1\n",
    "visibility.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1130,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:19:26.356118Z",
     "start_time": "2021-09-07T16:19:08.570902Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "number of traces for bg = 100000 number of up traces = 50103\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\virgi\\AppData\\Local\\Temp/ipykernel_19416/4279502438.py:457: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
      "  If increasing the limit yields no improvement it is advised to analyze \n",
      "  the integrand in order to determine the difficulties.  If the position of a \n",
      "  local difficulty can be determined (singularity, discontinuity) one will \n",
      "  probably gain from splitting up the interval and calling the integrator \n",
      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n",
      "  integ_down = integrate.quad(f_hist_down, signal, np.max(histo_down[0]))\n",
      "C:\\Users\\virgi\\AppData\\Local\\Temp/ipykernel_19416/4279502438.py:460: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
      "  If increasing the limit yields no improvement it is advised to analyze \n",
      "  the integrand in order to determine the difficulties.  If the position of a \n",
      "  local difficulty can be determined (singularity, discontinuity) one will \n",
      "  probably gain from splitting up the interval and calling the integrator \n",
      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n",
      "  integ_total = np.array(integrate.quad(f_hist_up, np.min(histo_up[0]), np.max(histo_up[0]))) + np.array(integrate.quad(f_hist_down,  np.min(histo_down[0]),  np.max(histo_down[0])))\n",
      "C:\\Users\\virgi\\AppData\\Local\\Temp/ipykernel_19416/4279502438.py:456: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
      "  If increasing the limit yields no improvement it is advised to analyze \n",
      "  the integrand in order to determine the difficulties.  If the position of a \n",
      "  local difficulty can be determined (singularity, discontinuity) one will \n",
      "  probably gain from splitting up the interval and calling the integrator \n",
      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n",
      "  integ_up = integrate.quad(f_hist_up, np.min(histo_up[0]), signal)\n"
     ]
    }
   ],
   "source": [
    "# CALCULATE FIDELITY AS CONSTANCE\n",
    "\n",
    "epsilon = 0.005 \n",
    "#epsilon is so that we make sure we don't integrate out of the boundaries of the interpolated function\n",
    "#n_traces = int(n_traces/factor_ntraces)\n",
    "\n",
    "signal_threshold = np.linspace(range_min + epsilon, range_max - epsilon,50)\n",
    "t_max=2000\n",
    "\n",
    "fidelity_down, fidelity_up, error = fidelity_Virginia(signal_threshold,A,range_min,range_max,std_low,std_up, signal_low,signal_high,t_int,t_out,t_in,t_max,n_points_time,n_traces,num_bins , 0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1131,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:19:26.595277Z",
     "start_time": "2021-09-07T16:19:26.357062Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max visibility = 0.9733414945702967 at -2.546989572545515\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\virgi\\AppData\\Local\\Temp/ipykernel_19416/3730769154.py:23: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"rasterized\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  plt.savefig(\"fidelity.png\",dpi=600, bbox_inches = \"tight\", rasterized='True')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 239.103x147.774 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "fig_width_pt = 240.0  # Get this from LaTeX using \\showthe\\columnwidth\n",
    "inches_per_pt = 1.0/72.27\t\t\t\t# Convert pt to inch\n",
    "golden_mean = (math.sqrt(5)-1.0)/2.0\t\t # Aesthetic ratio\n",
    "fig_width = fig_width_pt*inches_per_pt\t# width in inches\n",
    "fig_height = fig_width*golden_mean\t\t# height in inches\n",
    "fig_size =\t[fig_width,fig_height]\n",
    "plt.rcParams['legend.fontsize'] = 8\n",
    "plt.rcParams['figure.figsize'] = fig_size\n",
    "\n",
    "plt.plot(signal_threshold-signal_low,fidelity_down, color=(120/255,120/255,120/255), label=r' Spin down')#Fidelity$_{\\downarrow}$')\n",
    "\n",
    "\n",
    "plt.plot(signal_threshold-signal_low,fidelity_up, color= (255/255,66/255,66/255), label=r'Spin up')#Fidelity$_{\\uparrow}$' )\n",
    "plt.plot(signal_threshold-signal_low,np.array(fidelity_up)+np.array(fidelity_down)-1,'--',label='Visbility',c='k')\n",
    "\n",
    "plt.legend(loc=1, fontsize=8)\n",
    "plt.xlabel(\"Threshold voltage (V) \", {'color': 'k', 'fontsize': 14})\n",
    "plt.ylabel(\"Fidelity\", {'color': 'k', 'fontsize': 14})\n",
    "plt.xticks( color='k', size=12)\n",
    "plt.yticks( color='k', size=12)\n",
    "\n",
    "plt.savefig(\"fidelity.png\",dpi=600, bbox_inches = \"tight\", rasterized='True')\n",
    "print(\"max visibility =\", np.max(np.array(fidelity_up)+np.array(fidelity_down)-1),'at', signal_threshold[np.argmax(np.array(fidelity_up)+np.array(fidelity_down)-1)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1132,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-07T16:19:26.610230Z",
     "start_time": "2021-09-07T16:19:26.596272Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9733414945702967"
      ]
     },
     "execution_count": 1132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visibility=np.array(fidelity_up)+np.array(fidelity_down)-1\n",
    "visibility.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "549.588px",
    "left": "21px",
    "top": "145.284px",
    "width": "383.925px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}