diff --git a/README_SEMISPIN.md b/README_SEMISPIN.md new file mode 100644 index 00000000..3b3b868c --- /dev/null +++ b/README_SEMISPIN.md @@ -0,0 +1,3 @@ +### Added drivers by SemiSpin group: + * ADwin Pro II driver(s): + * \ No newline at end of file diff --git a/qkit/analysis/semiconductor/analyzers/AnalyzerPeakTracker.py b/qkit/analysis/semiconductor/analyzers/AnalyzerPeakTracker.py new file mode 100644 index 00000000..12c5f687 --- /dev/null +++ b/qkit/analysis/semiconductor/analyzers/AnalyzerPeakTracker.py @@ -0,0 +1,272 @@ +from typing import Any, Dict, List + +import numpy as np +from qkit.analysis.semiconductor.main.fit_functions import sech +from scipy.signal import find_peaks, peak_widths +from scipy.optimize import curve_fit + +class ItsAllDanielsFaultError(Exception): + pass + +class Peak_fit: + """Class for peak fits. Takes a callable argument f and assumes f(x, height, width, position) -> Peak. + width ist the full-width-half-maximum of Peak.""" + def __init__(self, fit_func): + self.fit_func = fit_func + self.min_peak_height = 0.002 + self.min_peak_width = 2 + self.min_peak_distance = 30 + self.fit_interval_peak_relheight = 0.5 + + @property + def fit_interval_peak_relheight(self): + return self._fit_interval_peak_relheight + @fit_interval_peak_relheight.setter + def fit_interval_peak_relheight(self, new_height): + self._fit_interval_peak_relheight = new_height + if new_height == 0.5: self.find_fit_interval = self._calc_fit_interval_peak_width + else: self.find_fit_interval = self._calc_fit_interval_rel_height + + def construct_guess(self, single_trace): + self.peak_pos, params = find_peaks(single_trace, height = self.min_peak_height,\ + width = self.min_peak_width,\ + distance = self.min_peak_distance) + self.peak_heights = params["peak_heights"] + self.peak_fwhms = peak_widths(single_trace, self.peak_pos, rel_height = 0.5) [0] + + def _calc_fit_interval_rel_height(self, single_trace): + self.fit_idxs_left, self.fit_idxs_right = np.rint(\ + peak_widths(single_trace, self.peak_pos, \ + rel_height = self.fit_interval_peak_relheight)\ + [2:]).astype(np.int_) + + def _calc_fit_interval_peak_width(self, single_trace): + self.fit_idxs_left = np.rint(self.peak_pos - self.peak_fwhms / 2).astype(np.int_) + self.fit_idxs_right = np.rint(self.peak_pos + self.peak_fwhms / 2).astype(np.int_) + + def fit(self, single_trace): + self.construct_guess(single_trace) + self.find_fit_interval(single_trace) + + x = range(len(single_trace)) + popts, covs = [], [] + + for i in range(len(self.peak_pos)): + guess = (self.peak_heights[i], self.peak_fwhms[i], self.peak_pos[i]) + try: + popt, cov = curve_fit(self.fit_func, x[self.fit_idxs_left[i] : self.fit_idxs_right[i]], + single_trace[self.fit_idxs_left[i] : self.fit_idxs_right[i]], + p0 = guess, maxfev = 10000) + except TypeError: + raise TypeError(f"{__name__}: Fit interval for peak {i} does not contain enough data points. Reconsider the min_peak_width.") + popts.append(popt) + covs.append(cov) + + return popts, covs + +def sech_fwhm(x, a, b, c): + return sech(x, a, b /2.634, c) + +class Analyzer: + def __init__(self, matrix_to_analyze, timestamps, gate_axis, peak_function = sech_fwhm) -> None: + self.pf = Peak_fit(peak_function) + + self.matrix_to_analyze = matrix_to_analyze + self.timestamps = timestamps + self.gate_axis = gate_axis + + self.rel_jump_height = 0.2 + self.f_clock = 1.8e9 + self.LR_offset = 0 + + @property + def matrix_to_analyze(self): + return self._matrix_to_analyze + @matrix_to_analyze.setter + def matrix_to_analyze(self, new_matrix): + if not isinstance(new_matrix, np.ndarray): + raise TypeError(f"{__name__}: Invalid data matrix. Must be a 2D numpy array.") + if new_matrix.ndim != 2: + raise ValueError(f"{__name__}: Invalid data matrix. Must be a 2D numpy array.") + self._matrix_to_analyze = new_matrix + + @property + def timestamps(self): + return self._timestamps + @timestamps.setter + def timestamps(self, new_stamps): + if not isinstance(new_stamps, np.ndarray): + raise TypeError(f"{__name__}: Invalid timestamps. Must be a 2D numpy array.") + if new_stamps.shape != self.matrix_to_analyze.shape: + raise ValueError(f"{__name__}: Invalid timestamps. Must have the same shape as matrix_to_analyze.") + self._timestamps = new_stamps + + @property + def gate_axis(self): + return self._gate_axis + + @gate_axis.setter + def gate_axis(self, new_axis): + if not isinstance(new_axis, np.ndarray): + raise TypeError(f"{__name__}: Invalid gate_axis. Must be a numpy array.") + if len(new_axis) != len(self.matrix_to_analyze[0]): + raise ValueError(f"{__name__}: Invalid gate_axis. Must have the same length as a trace from matrix_to_analyze.") + self._gate_axis = new_axis + + def _append_to_nearest(self, tracked_positions, position): + distances = [] + for last_positions in tracked_positions: + distances.append(abs(np.average(last_positions[-5:]) - position)) + + idx = distances.index(min(distances)) + tracked_positions[idx].append(position) + + def _append_to_nearest_2(self, tracked_positions, positions): + forbidden_tracks = [] + for position in positions: + distances = [] + for last_positions in tracked_positions: + distances.append(abs(np.average(last_positions[-5:]) - position)) + idx = distances.index(min(distances)) + if idx not in forbidden_tracks: + tracked_positions[idx].append(position) + forbidden_tracks.append(idx) + + def _find_nth_smallest(self, array, n): + nth_smallest = np.partition(array, n)[n] + idx = np.where(array == nth_smallest)[0][0] + return idx + + def _append_to_nearest_3(self, peak_tracks, positions): + forbidden_tracks = [] + for peak_track in peak_tracks: + #Calculate the distance of each newly found peak to the average of the + #last five positions. + distances = [] + peak_track_avg = np.average(peak_track[-5:]) + for position in positions: + distances.append(peak_track_avg - position) + + distances = np.array(distances) + abs_distances = abs(distances) + + #Append the value to one of the peak_tracks based on conditions: + + #Did the peak position change by more then self.rel_jump_height * 100 percent? + sub_cond11 = (abs_distances > (peak_track_avg * self.rel_jump_height)).all() + sub_cond12 = (distances < 0).any() + sub_cond13 = len(distances) >= 2 + condition1 = sub_cond11 and sub_cond12 and sub_cond13 + if condition1: + #If this is the case, the jump went up therefore append the closest position + #above the current one. + idx = self._find_nth_smallest(abs_distances, 1) + #elif condition2: + # ... + else: + idx = abs_distances.argmin() + + if idx not in forbidden_tracks: + peak_track.append(positions[idx]) + forbidden_tracks.append(idx) + + def _translate_samples(self, tracked_positions : List[List[float]]) -> List[List[float]]: + v_offset = self.gate_axis[0] + v_step = self.gate_axis[1] - v_offset + translated_tracks = [] + for track in tracked_positions: + trans_track = v_step * np.array(track) + v_offset + translated_tracks.append(trans_track) + return translated_tracks + + def _create_time_axis_avg(self): + durations = [] + for timestamps in self.timestamps: + duration_of_trace = timestamps[-1] - timestamps[0] + durations.append(duration_of_trace) + translated_durations = np.array(durations)/self.f_clock + avg_duration = np.average(translated_durations) + time_axis = np.arange(0, len(translated_durations)) * avg_duration + return time_axis + + def analyze(self) -> Dict[str, Any]: + raw = self.matrix_to_analyze + + tracked_positions = [] + trace = self.matrix_to_analyze[0] + peak_pars, _ = self.pf.fit(trace) + for peak_par in peak_pars: + peak_pos = peak_par[2] + tracked_positions.append([peak_pos]) + + for trace in raw[1:]: + peak_pars, _ = self.pf.fit(trace) + peak_pos = [peak_par[2] for peak_par in peak_pars] + self._append_to_nearest_3(tracked_positions, peak_pos) + + peak_pos = self._translate_samples(tracked_positions) + time_axis = self._create_time_axis_avg() + return {"tracked_peak_positions" : peak_pos, "time_axis" : time_axis} + +def main(): + pass +if __name__ == "__main__": + main() +# from scipy.signal import find_peaks, peak_widths +# from scipy.optimize import curve_fit +# from random import uniform + +# def sech(x, a, b, c): +# return a / np.cosh((x - c) / b) + +# def multi_sech(x, *params): +# y = np.zeros_like(x) +# for i in range(0, len(params), 3): +# a = params[i] +# b = params[i+1] +# c = params[i+2] +# y = y + sech(x, a, b, c) +# return y + +# def create_jitter(amplitude): +# return uniform(-amplitude, amplitude) + +# xdata = np.linspace(-40, 40, 1000) # create x_axis +# x_step = xdata[1] - xdata[0] +# rng = np.random.default_rng() +# y_noise = 0 +# y_noise = 0.1 * rng.normal(size=xdata.size) # create some noise + +# jitter_ampl = 0 +# y = multi_sech(xdata, 1, 1, 30 + create_jitter(jitter_ampl), +# 1, 1, 15 + create_jitter(jitter_ampl), +# 1, 3, -30 + create_jitter(jitter_ampl), +# 1, 1, -15 + create_jitter(jitter_ampl)) +# ydata = y + y_noise + +# peak_pos, params = find_peaks(ydata, height = 0.5, width = 6) +# results = peak_widths(ydata, peak_pos, rel_height=0.5) +# peak_widths = results[0] * x_step / 2.634 +# no_peaks = len(peak_pos) +# print(f"peak_widths: {peak_widths}") +# print(f"peak_pos: {xdata[peak_pos]}") +# lower_bounds = [0, 0, -np.inf] * no_peaks +# upper_bounds = [np.inf, np.inf, np.inf] * no_peaks +# bounds = (lower_bounds, upper_bounds) +# print(bounds) +# guess = [] +# for peak, height, width in zip(xdata[peak_pos], params["peak_heights"], peak_widths): +# guess.extend([height, width, peak]) +# print(guess) +# #guess = [1, 1, 0, 1, 1, 20, 1, 1, -8, 1, 1, -15] +# popt, pcov = curve_fit(multi_sech, xdata, ydata, p0 = guess, bounds = bounds, maxfev = 1000) + +# plt.figure() +# plt.plot(np.arange(len(ydata)) * x_step - 40, ydata) +# plt.plot(xdata, multi_sech(xdata, *popt), 'r-') +# for i in range(len(results[1:][0])): +# y = results[1:][0][i] +# x_min = results[1:][1][i] * x_step + xdata[0] +# x_max = results[1:][2][i] * x_step + xdata[0] +# plt.hlines(y, x_min, x_max, color ="C2") +# print(popt) diff --git a/qkit/analysis/semiconductor/analyzers/AnalyzerPeakTracker_Daniel.py b/qkit/analysis/semiconductor/analyzers/AnalyzerPeakTracker_Daniel.py new file mode 100644 index 00000000..3890a552 --- /dev/null +++ b/qkit/analysis/semiconductor/analyzers/AnalyzerPeakTracker_Daniel.py @@ -0,0 +1,92 @@ +import numpy as np +from scipy.optimize import curve_fit + +from qkit.analysis.semiconductor.main.find_index_of_value import map_array_to_index +from qkit.analysis.semiconductor.main.time_conversion import convert_secs_2D + + +class AnalyzerPeakTracker: + """Fits a sechans function to a plunger gate sweep in two iterations. + """ + def __init__(self) -> None: + self.init_params = None + self.intervall1 = 0.01 + self.intervall2 = 0.01 + self.max_iter = 10000 + self.peak_voltage = 0 + + def analyze(self, data:dict, nodes): + """self.peak_voltage is the Voltage of the peak eyeballed. + width and width2 are the intervalls of idices used to fit the data to. Better in Volts in future? + The sechans fit is NOT using Volt values as x values but instead indices of the array. + init_params: first values [a, b, d] of f(x) = a * (1 / np.cosh(b * (x - c))) + d + self.peak_voltage: first value of c + """ + def sech(x, a, b, c, d): + '''hyperbolic secans function''' + return a * (1 / np.cosh(b * (x - c))) + d # return is scaled in Volts + + if self.init_params is None: + # initial parameters for fit + a, b, d = 0.01, -0.1, 0.0 + else: + a, b, d = self.init_params[0], self.init_params[1], self.init_params[2] + + peak_index = map_array_to_index(data[nodes[1]], self.peak_voltage) + intervall1_half_index = map_array_to_index(data[nodes[1]], abs(self.intervall1 / 2) + data[nodes[1]][0]) + intervall2_half_index= map_array_to_index(data[nodes[1]], abs(self.intervall2 / 2) + data[nodes[1]][0]) + + p0 = [a, b, peak_index, d] #initatal guess of a, b, c, d + timestamps = convert_secs_2D(data[nodes[0]]) + length_sweep = len(timestamps) + data["timestamps_diff"] = np.diff(timestamps) + data["avg_sweep_time"] = np.average(np.diff(timestamps)) + data["peaks_plunger_V"] = np.array([None] * length_sweep) # initialize None array for peaks + data["peaks_value"] = np.array([None] * length_sweep) + data["peaks_plunger_V_cov"] = np.array([None] * length_sweep) + data["peaks_fit_popts"] = np.array([None] * length_sweep) + data["peaks_fit_intervall_half"] = intervall2_half_index # saves the index size of the fit intervall/2 + + for trace_num in range(len(timestamps)): + try: + # bigger intervall, first fit + popt, pcov = curve_fit(sech, np.arange(peak_index-intervall1_half_index, peak_index+intervall1_half_index, 1), + data[nodes[2]][trace_num][peak_index-intervall1_half_index : peak_index+intervall1_half_index], p0, maxfev=self.max_iter) + peak_fitted_index = int(round(popt[2])) + + try: + # smaller intervall, second fit around peak of first fit + if peak_fitted_index > intervall2_half_index and peak_fitted_index < (length_sweep-intervall2_half_index): + p1 = [a, b, peak_fitted_index, d] + + popt1, pcov1 = curve_fit(sech, np.arange(peak_fitted_index-intervall2_half_index, peak_fitted_index+intervall2_half_index, 1), + data[nodes[2]][trace_num][peak_fitted_index-intervall2_half_index : peak_fitted_index+intervall2_half_index], p1, maxfev=self.max_iter) + + data["peaks_plunger_V"][trace_num] = data[nodes[1]][int(round(popt1[2]))] # plunger gate voltage of peak + data["peaks_value"][trace_num] = sech(popt1[2], *popt1) # lock-in value of fitted peak + data["peaks_plunger_V_cov"][trace_num] = pcov1 # covariance on index of peak + data["peaks_fit_popts"][trace_num] = popt1 # values of [a, b, c, d] + + if pcov1[2][2] > 1: + print("COV TOO BIG ", trace_num) + data["peaks_plunger_V"][trace_num] = None + data["peaks_value"][trace_num] = None + data["peaks_plunger_V_cov"][trace_num] = None + data["peaks_fit_popts"][trace_num] = None + + else: + print("Peak not found in first fit") + data["peaks_plunger_V"][trace_num] = None + data["peaks_value"][trace_num] = None + data["peaks_plunger_V_cov"][trace_num] = None + data["peaks_fit_popts"][trace_num] = None + + + except RuntimeError: + print("RUNTIME ERROR second ", trace_num) + pass + + except RuntimeError: + print("RUNTIME ERROR first ", trace_num) + pass + diff --git a/qkit/analysis/semiconductor/analyzers/AnalyzerPlungerSweep.py b/qkit/analysis/semiconductor/analyzers/AnalyzerPlungerSweep.py new file mode 100644 index 00000000..b3d979ed --- /dev/null +++ b/qkit/analysis/semiconductor/analyzers/AnalyzerPlungerSweep.py @@ -0,0 +1,31 @@ +import numpy as np + +from qkit.analysis.semiconductor.main.find_index_of_value import map_array_to_index + + +class AnalyzerPlungerSweep: + """Fits a tangent to a point in a plunger gate sweep and returns the fit results. + Lock-in V used for calculations instead of conductance. + Slope coef[0] in Volt / Volt. + """ + def __init__(self): + self.voltage_fit = 0 + self.intervall_fit = 0 + + def analyze(self, data, nodes): + """Fits a linear function to values at voltage with intervall around it. + """ + self.data_x = data[nodes[0]] + self.data_y = data[nodes[1]] + index_begin = map_array_to_index(self.data_x, self.voltage_fit - abs(self.intervall_fit)) + index_end = map_array_to_index(self.data_x, self.voltage_fit + abs(self.intervall_fit)) + print(index_begin, index_end) + if index_begin > index_end: # array was in descending order + index_begin, index_end = index_end, index_begin + self.data_x_cut = self.data_x[index_begin : index_end] + self.data_y_cut = self.data_y[index_begin : index_end] + + coef = np.polyfit(self.data_x_cut, self.data_y_cut, 1) + + return {"fit_coef" : coef, "index_begin" : index_begin, "index_end" : index_end} + \ No newline at end of file diff --git a/qkit/analysis/semiconductor/analyzers/AnalyzerTimetraceJumps.py b/qkit/analysis/semiconductor/analyzers/AnalyzerTimetraceJumps.py new file mode 100644 index 00000000..0dbabacc --- /dev/null +++ b/qkit/analysis/semiconductor/analyzers/AnalyzerTimetraceJumps.py @@ -0,0 +1,36 @@ +import numpy as np +from scipy.optimize import curve_fit +from qkit.analysis.semiconductor.main.fit_functions import gauss_function + +class Analyzer: + def __init__(self, trace, time_axis): + self.trace = trace + self.time_axis = time_axis + self.bin_count = 50 + self.bin_range = None + self.big_jump_minimum_height = 2e-3 + self.hist = np.array([]) + self.guess = None + + def analyze(self): + """Analyzes a timetrace and counts jumps. + """ + difference = np.diff(self.trace) + (self.hist, self.bin_edges) = np.histogram(difference, bins=self.bin_count, range=self.bin_range) + + jumps = difference[abs(difference) >= self.big_jump_minimum_height] + jumps_idx = np.flatnonzero(abs(difference) >= self.big_jump_minimum_height) + 1 + jumps_time = self.time_axis[jumps_idx] + jumps_t_difference = np.diff(jumps_time) + + return {"jump_height" : self.bin_edges[:-1], "jumps_per_bin" : self.hist}, \ + {"number_of_big_jumps" : len(jumps), "height_of_big_jumps" : jumps, + "time_between_big_jumps" : jumps_t_difference, "time_of_big_jumps" : jumps_time, + "idx_of_big_jumps" : jumps_idx} + + def fit(self): + assert self.hist.any(), f"{__name__}: Analyze trace first. No histogram available." + popt, _ = curve_fit(gauss_function, self.bin_edges[:-1], self.hist, self.guess) + + return popt + diff --git a/qkit/analysis/semiconductor/analyzers/AnalyzerTimetraceSpectralNoiseDensity.py b/qkit/analysis/semiconductor/analyzers/AnalyzerTimetraceSpectralNoiseDensity.py new file mode 100644 index 00000000..ee113097 --- /dev/null +++ b/qkit/analysis/semiconductor/analyzers/AnalyzerTimetraceSpectralNoiseDensity.py @@ -0,0 +1,107 @@ +import numpy as np +import numbers +from scipy import signal +from scipy.optimize import curve_fit + +from qkit.analysis.semiconductor.main.find_index_of_value import map_array_to_index + +def func_linear(x, a, b): + return np.multiply(a, x) + b + +class AnalyzerTimetraceSpectralNoiseDensity: + + def __init__(self, trace_to_analyze, sampling_freq, fit_func = func_linear): + + self.guess = [-1, 1] + self.max_iter = 10000000 + self.welch_segment_length = 5e5 + self.sampling_freq = sampling_freq + self.trace_to_analyze = trace_to_analyze + + self.fit_func = fit_func + self._fit_interval = [] + + @property + def trace_to_analyze(self): + return self._trace_to_analyze + @trace_to_analyze.setter + def trace_to_analyze(self, new_trace): + if not isinstance(new_trace, np.ndarray): + raise TypeError(f"{__name__}: Invalid data trace. Must be a 1D numpy array.") + if new_trace.ndim != 1: + raise ValueError(f"{__name__}: Invalid data trace. Must be a 1D numpy array.") + self._trace_to_analyze = new_trace + + @property + def fit_interval(self): + return self._fit_interval + @fit_interval.setter + def fit_interval(self, new_interval): + if not isinstance(new_interval, list): + raise TypeError("Fit interval must be a list") + if len(new_interval) != 2: + raise ValueError("Invalid input for fit intervall. Must be a list of length 2.") + for element in new_interval: + if not isinstance(element, numbers.Number): + raise TypeError("Fit interval must be two numbers in ascending order. Duh.") + if new_interval[0] > new_interval[1]: + raise ValueError("Fit interval must be two numbers in ascending order. Duh.") + self._fit_interval = new_interval + + def analyze(self): + """Analyzes a single timetrace using consecutive Fourier transforms. + """ + + freqs, times, spectrogram = signal.spectrogram(self.trace_to_analyze, fs = self.sampling_freq, nperseg = len(self.trace_to_analyze)) + spectrogram = np.real(spectrogram.flatten().astype(complex)) # yes I know... tell me why data type is object and complex + self.freqs = freqs[1:] + self.spectrogram = spectrogram[1:] + self.times = times[1:] + + return {"freq" : self.freqs, "times" : self.times, "spectrogram": self.spectrogram} # freqs[0]=0 ; The 0Hz value is cut off: + + def analyze_welch(self): + """Analyzes a sigle timetrace using Welch's method. + Welch’s method [1] computes an estimate of the power spectral density by dividing + the data into overlapping segments, computing a modified periodogram for each segment + and averaging the periodograms. + segment_length is length of a segment. + """ + freqs, Pxx = signal.welch(self.trace_to_analyze, fs = self.sampling_freq, nperseg = self.welch_segment_length) + spectrogram = np.real(Pxx.flatten().astype(complex)) # yes I know... tell me why data type is object and complex + + self.freqs = freqs[1:] + self.spectrogram = spectrogram[1:] + return {"freq" : self.freqs, "spectrogram": self.spectrogram} # freqs[0]=0 ; The 0Hz value is cut off: + + def fit(self, freqs = np.array([]), spectrogram = np.array([])): + """Fits f(x)= a*x + b to log10(data) AROUND 1Hz. So the spectrum must include 1Hz... + Return is the parameters of the fit. + guess is an array or list of starting values for a, b. + """ + if not freqs.any(): + assert self.freqs.any(), "No spectrum data, yet. Analyze spectrum first." + freqs = self.freqs + spectrogram = self.spectrogram + + #slice data around the fit interval + if self._fit_interval: + index_begin = map_array_to_index(self.freqs, self.fit_interval[0]) + index_end = map_array_to_index(self.freqs, self.fit_interval[1]) + print(index_begin, index_end) + freqs = self.freqs[index_begin : index_end] + spectrogram = self.spectrogram[index_begin : index_end] + + #fitting of log10(spec) + popt_raw, cov = curve_fit(self.fit_func, np.log10(freqs), np.log10(spectrogram), p0=self.guess, maxfev=self.max_iter) + popt = [] + for i in range(0, len(popt_raw), 2): + popt.extend([popt_raw[i], 10**popt_raw[i+1]]) + print(popt_raw[i+1]) + + sigma_raw = np.sqrt(np.diagonal(cov)) + sigma = [] + for i in range(0, len(sigma_raw), 2): + sigma.extend([sigma_raw[i], np.log(10) * sigma_raw[i +1] * 10**popt_raw[i+1]]) + + return {"popt" : np.array(popt), "cov" : cov, "fit_range" : [min(freqs), max(freqs)], "sigma" : np.array(sigma)} # freqs[0]=0 ; The 0Hz value is cut off \ No newline at end of file diff --git a/qkit/analysis/semiconductor/analyzers/AnalyzerUnity.py b/qkit/analysis/semiconductor/analyzers/AnalyzerUnity.py new file mode 100644 index 00000000..bf91dc98 --- /dev/null +++ b/qkit/analysis/semiconductor/analyzers/AnalyzerUnity.py @@ -0,0 +1,12 @@ +from qkit.analysis.semiconductor.main.interfaces import AnalyzerInterface + +class Analyzer(AnalyzerInterface): + def load_data(self, data): + self.data_raw = data + + def validate_input(self): + if not isinstance(self.data_raw, dict): + raise TypeError("The loader returned an invalid data type. Type must be dictionary.") + + def analyze(self): + return self.data_raw \ No newline at end of file diff --git a/qkit/analysis/semiconductor/gui/analysis_main_nu.py b/qkit/analysis/semiconductor/gui/analysis_main_nu.py new file mode 100644 index 00000000..07ede8b3 --- /dev/null +++ b/qkit/analysis/semiconductor/gui/analysis_main_nu.py @@ -0,0 +1,296 @@ +#!/usr/bin/python python +import importlib.util +import json +import os +import sys +import traceback + +from PyQt5 import uic +from PyQt5.QtWidgets import ( + QApplication, + QFileDialog, + QMainWindow, + QMessageBox, + QTableWidgetItem, +) +from qkit.analysis.semiconductor.gui.windows.plot import Plot_window +from qkit.analysis.semiconductor.gui.windows.settings import Settings_window + +HOMEDIR = os.path.dirname(os.path.dirname(__file__)) + + +class Model: + def __init__(self) -> None: + self.settings = { + "files": [], + "plotter_path": "", + "analyzer_path": "", + "loader_path": "", + } + + self.data_raw = {} + self.data_analyzed = {} + + def save_settings(self): + with open( + os.path.join(HOMEDIR,"gui", "configuration.ini"), "w+" + ) as configfile: + configfile.write(json.dumps(self.settings, indent=2)) + + def load_settings(self): + try: + with open(os.path.join(HOMEDIR, "gui", "configuration.ini")) as configfile: + self.settings = json.load(configfile) + except FileNotFoundError: + pass + + +def do_monitored(func): + def wrapper(self): + try: + func(self) + except: + error_msg = traceback.format_exc() + self.view.show_error_msg(error_msg) + + return wrapper + + +class View(QMainWindow): + def __init__(self, model): + super().__init__() + self.model = model + path = os.path.join(HOMEDIR, "gui", "ui", "main_window.ui") + uic.loadUi(path, self) + + def add_to_file_browser(self, entry): + self.text_browser_file_display.append(entry) + + def clear_file_browser(self): + self.text_browser_file_display.clear() + + def enable_load_button(self, yesno): + self.button_load.setEnabled(yesno) + + def enable_analyze_button(self, yesno): + self.button_analyze.setEnabled(yesno) + + def enable_plot_button(self, yesno): + self.button_plot.setEnabled(yesno) + + def enable_settings_button(self, yesno): + self.button_settings.setEnabled(yesno) + + def enable_reanalyze_replot_button(self, yesno): + self.button_replot_reanalyze.setEnabled(yesno) + + def open_files_dialog(self, title="Choose files to load", *dir): + fnames, _ = QFileDialog.getOpenFileNames(self, title, os.path.join(*dir)) + return fnames + + def open_python_file_dialog(self, title, *dir): + fname, _ = QFileDialog.getOpenFileName( + self, f"Choose {title}", os.path.join(*dir), "Python files(*py)" + ) + return fname + + def display_loader_name(self, name): + item = QTableWidgetItem(os.path.basename(name)) + self.Table_LAP.setItem(0, 0, item) + + def display_analyzer_name(self, name): + item = QTableWidgetItem(os.path.basename(name)) + self.Table_LAP.setItem(1, 0, item) + + def display_plotter_name(self, name): + item = QTableWidgetItem(os.path.basename(name)) + self.Table_LAP.setItem(2, 0, item) + + def closeEvent(self, event): + event.accept() + self.model.save_settings() + + def show_error_msg(self, msg): + msgBox = QMessageBox(self) + msgBox.setIcon(QMessageBox.Critical) + msgBox.setText(msg) + msgBox.setWindowTitle("Error") + msgBox.show() + + def open_settings_window(self, *LAPs): + self.settings_window = Settings_window(HOMEDIR, *LAPs) + self.settings_window.show() + + def open_plot_window(self, figure): + self.plot_window = Plot_window(HOMEDIR, figure) + self.plot_window.show() + + def clear_plot_axis(self): + self.plot_window.plot_widget.canvas.axes.cla() + + def draw_additional_plot(self): + self.plot_window.plot_widget.canvas.draw() + + +class Controller: + def __init__(self, model: Model, view: View): + self.model = model + self.view = view + self.loader = None + self.analyzer = None + self.plotter = None + + self.view.button_load.clicked.connect(self.load_data) + self.view.button_add_files.clicked.connect(self.add_files) + self.view.button_reset_files.clicked.connect(self.reset_files) + + self.view.button_settings.clicked.connect(self.open_settings) + self.view.button_plot.clicked.connect(self.open_plot) + self.view.button_analyze.clicked.connect(self.analyze_data) + self.view.button_replot_reanalyze.clicked.connect(self.reanalyze_replot) + + self.view.action_Save_Settings.triggered.connect(self.save_settings) + self.view.action_Load_Settings.triggered.connect(self.load_settings) + self.view.action_Choose_Loader.triggered.connect(self.choose_loader) + self.view.action_Choose_Analyzer.triggered.connect(self.choose_analyzer) + self.view.action_Choose_Plotter.triggered.connect(self.choose_plotter) + self.view.action_Reload_Modules.triggered.connect(self.load_LAP) + + self.load_settings() + + @staticmethod + def load_module_from_filepath(fname): + module_name = os.path.splitext(os.path.basename(fname))[0] + module_spec = importlib.util.spec_from_file_location(module_name, fname) + module = importlib.util.module_from_spec(module_spec) # type: ignore + module_spec.loader.exec_module( + module + ) # pyright: reportOptionalMemberAccess=false + return module + + @do_monitored + def load_loader(self): + module = self.load_module_from_filepath(self.model.settings["loader_path"]) + self.loader = module.Loader() + self.view.display_loader_name(self.model.settings["loader_path"]) + + def choose_loader(self): + fname = self.view.open_python_file_dialog( + "loader", os.path.join(HOMEDIR, "loaders") + ) + self.model.settings["loader_path"] = fname + if fname: + self.load_loader() + + @do_monitored + def load_analyzer(self): + module = self.load_module_from_filepath(self.model.settings["analyzer_path"]) + self.analyzer = module.Analyzer() + self.view.display_analyzer_name(self.model.settings["analyzer_path"]) + + def choose_analyzer(self): + fname = self.view.open_python_file_dialog( + "analyzer", os.path.join(HOMEDIR, "analyzers") + ) + self.model.settings["analyzer_path"] = fname + if fname: + self.load_analyzer() + + @do_monitored + def load_plotter(self): + module = self.load_module_from_filepath(self.model.settings["plotter_path"]) + self.plotter = module.Plotter() + self.view.display_plotter_name(self.model.settings["plotter_path"]) + + def choose_plotter(self): + fname = self.view.open_python_file_dialog( + "plotter", os.path.join(HOMEDIR, "plotters") + ) + self.model.settings["plotter_path"] = fname + if fname: + self.load_plotter() + + def load_LAP(self): + self.load_loader() + self.load_analyzer() + self.load_plotter() + + def add_files(self): + fnames = self.view.open_files_dialog("Choose data to load", "") + for name in fnames: + self.view.add_to_file_browser(os.path.basename(name)) + self.model.settings["files"].extend(fnames) + + def reset_files(self): + self.model.settings["files"] = [] + self.view.clear_file_browser() + + @do_monitored + def load_data(self): + self.loader.set_filepath(self.model.settings["files"]) + self.model.data_raw.update(self.loader.load()) + if self.model.settings["files"]: + self.view.text_browser_file_display.append("---------LOADED---------") + self.model.settings["files"] = [] + # self.view.enable_analyze_button() + + @do_monitored + def analyze_data(self): + self.analyzer.load_data(self.model.data_raw) + self.analyzer.validate_input() + self.model.data_analyzed.update(self.analyzer.analyze()) + # self.view.enable_plot_button() + + def plot_data(self): + self.plotter.load_data(self.model.data_analyzed) + self.plotter.validate_input() + self.plotter.plot() + + @do_monitored + def open_plot(self): + self.plot_data() + self.view.open_plot_window(self.plotter.figure) + + @do_monitored + def reanalyze_replot(self): + self.analyzer.load_data(self.model.data_raw) + self.analyzer.validate_input() + self.model.data_analyzed.update(self.analyzer.analyze()) + self.view.clear_plot_axis() + self.plot_data() + self.view.draw_additional_plot() + + @do_monitored + def open_settings(self): + self.view.open_settings_window(self.loader, self.analyzer, self.plotter) + + def save_settings(self): + self.model.save_settings() + + def load_settings(self): + self.model.load_settings() + self.load_LAP() + + # self.view.enable_settings_button() + for file in self.model.settings["files"]: + self.view.add_to_textbrowser(os.path.basename(file)) + + +class App(QApplication): + def __init__(self, sys_argv): + super().__init__(sys_argv) + self.model = Model() + self.main_view = View(self.model) + self.main_controller = Controller(self.model, self.main_view) + + self.main_view.show() + + +def main(): + app = App(sys.argv) + sys.exit(app.exec_()) + pass + + +if __name__ == "__main__": + main() diff --git a/qkit/analysis/semiconductor/gui/ui/main_window.ui b/qkit/analysis/semiconductor/gui/ui/main_window.ui new file mode 100644 index 00000000..b66f1e36 --- /dev/null +++ b/qkit/analysis/semiconductor/gui/ui/main_window.ui @@ -0,0 +1,301 @@ + + + Spasma_Mode + + + + 0 + 0 + 655 + 434 + + + + + 0 + 0 + + + + Data Analysis Main + + + + Qt::LeftToRight + + + + + + + 0 + 0 + + + + + + + + + + 14 + + + + Choose data + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + 0 + 0 + + + + + + + + add files + + + + + + + reset files + + + + + + + true + + + load + + + + + + + + + + + + 14 + + + + Analyze data + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + 0 + 0 + + + + Qt::ScrollBarAlwaysOff + + + Qt::ScrollBarAlwaysOff + + + QAbstractScrollArea::AdjustToContents + + + true + + + 3 + + + 1 + + + false + + + false + + + true + + + true + + + false + + + false + + + + Loader + + + + + Analyzer + + + + + Plotter + + + + + + + + + true + + + + 0 + 0 + + + + open settings window + + + false + + + + + + + true + + + analyze + + + + + + + true + + + open plot window + + + + + + + true + + + re-analyze and re-plot + + + + + + + + + + + + + + 0 + 0 + 655 + 27 + + + + + &File + + + + + + + + + + + + + + + &Save Settings + + + + + &Load Settings + + + + + &Choose Loader + + + + + &Choose Analyzer + + + + + &Choose Plotter + + + + + &Reload Modules + + + + + + diff --git a/qkit/analysis/semiconductor/gui/ui/plot_window.ui b/qkit/analysis/semiconductor/gui/ui/plot_window.ui new file mode 100644 index 00000000..f4695bb8 --- /dev/null +++ b/qkit/analysis/semiconductor/gui/ui/plot_window.ui @@ -0,0 +1,20 @@ + + + plot_window + + + + 0 + 0 + 683 + 463 + + + + Plot + + + + + + diff --git a/qkit/analysis/semiconductor/gui/ui/settings_window.ui b/qkit/analysis/semiconductor/gui/ui/settings_window.ui new file mode 100644 index 00000000..2cc257ba --- /dev/null +++ b/qkit/analysis/semiconductor/gui/ui/settings_window.ui @@ -0,0 +1,24 @@ + + + Settings + + + + 0 + 0 + 638 + 540 + + + + Settings + + + + + + + + + + diff --git a/qkit/analysis/semiconductor/gui/windows/plot.py b/qkit/analysis/semiconductor/gui/windows/plot.py new file mode 100644 index 00000000..8297dd17 --- /dev/null +++ b/qkit/analysis/semiconductor/gui/windows/plot.py @@ -0,0 +1,35 @@ +import os +from PyQt5 import uic +from PyQt5.QtWidgets import QWidget, QVBoxLayout +from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg, NavigationToolbar2QT + +class Mpl_canvas(FigureCanvasQTAgg): + def __init__(self, figure) -> None: + self.axes = figure.gca() + super().__init__(figure) + + def update_canvas(self): + self.axes.cla() + self.draw() + +class Plot_widget(QWidget): + def __init__(self, figure): + super().__init__() + + self.canvas = Mpl_canvas(figure) + self.toolbar = NavigationToolbar2QT(self.canvas, self) + + self.vbox = QVBoxLayout(self) + self.vbox.addWidget(self.toolbar) + self.vbox.addWidget(self.canvas) + + self.canvas.draw() + +class Plot_window(QWidget): + def __init__(self, main_dir, figure): + super().__init__() + uic.loadUi(os.path.join(main_dir, "gui", "ui", "plot_window.ui"), self) + + self.plot_widget = Plot_widget(figure) + + self.layout().addWidget(self.plot_widget) \ No newline at end of file diff --git a/qkit/analysis/semiconductor/gui/windows/settings.py b/qkit/analysis/semiconductor/gui/windows/settings.py new file mode 100644 index 00000000..746a31ef --- /dev/null +++ b/qkit/analysis/semiconductor/gui/windows/settings.py @@ -0,0 +1,53 @@ +import os +from PyQt5 import uic +from PyQt5.QtWidgets import QWidget, QLineEdit, QGridLayout, QLabel + + +class Mask: + def __init__(self, mask): + self.mask = mask + + def postive_mask(self, obj): + if obj in self.mask: + return True + else: + return False + + def negative_mask(self, obj): + if obj in self.mask: + return False + else: + return True + +class Settings_tab(QWidget): + def __init__(self, obj): + super().__init__() + self.obj = obj + self.grid = QGridLayout(self) + self.masking = Mask([int, float, str]) + + for i, (name, value) in enumerate(obj.__dict__.items()): + + if self.masking.postive_mask(type(value)): + label = QLabel(f"{name}:") + entry = QLineEdit() + entry.setText(str(value)) + entry.textEdited.connect(self.create_setter(entry, name, value)) + + self.grid.addWidget(label, i, 1) + self.grid.addWidget(entry, i, 2) + + def create_setter(self, entry, name, value): + def setter(): + newval = entry.text() + setattr(self.obj, name, type(value)(newval)) + return setter + +class Settings_window(QWidget): + def __init__(self, main_dir, *objects): + super().__init__() + uic.loadUi(os.path.join(main_dir, "gui", "ui", "settings_window.ui"), self) + + for obj in objects: + new_tab = Settings_tab(obj) + self.tabWidget.addTab(new_tab, type(obj).__name__) \ No newline at end of file diff --git a/qkit/analysis/semiconductor/loaders/LoaderExcel.py b/qkit/analysis/semiconductor/loaders/LoaderExcel.py new file mode 100644 index 00000000..53e9f4bc --- /dev/null +++ b/qkit/analysis/semiconductor/loaders/LoaderExcel.py @@ -0,0 +1,28 @@ +import pandas as pd +import numpy as np + +class LoaderExcel(): + """Loads our special Excel file and packs each column in a dict. + """ + def load(self, path, ignored_rows, sample_name): + self.data = {sample_name : []} + df = pd.read_excel(path, skiprows=np.arange(ignored_rows)) + + for measurement in range(len(df["Biascooling (V)"].to_numpy())): + self.data[sample_name].append({ + "bias_V" : df["Biascooling (V)"].to_numpy()[measurement], + "cooldown_nr" : df["Cooldown"].to_numpy()[measurement], + "person" : df["Person"].to_numpy()[measurement], + "first_acc_V" : df["Left demod0. gates (V)"].to_numpy()[measurement], + "date" : df["Date Start"].to_numpy()[measurement], + "RT_cooldown" : df["RT cooldown"].to_numpy()[measurement], + "second_acc_V" : "", + "SET_left_TG" : df["Links demod0. TG G4 (V)"].to_numpy()[measurement], + "SET_left_G5" : df["G5"].to_numpy()[measurement], + "SET_left_G7" : df["G7"].to_numpy()[measurement], + "SET_right_TG" : df["Rechts demod4. G14 TG (V)"].to_numpy()[measurement], + "SET_right_G15" : df["G15"].to_numpy()[measurement], + "SET_right_G17" : df["G17"].to_numpy()[measurement], + "SET_other_gates" : df["Other gates (V)"].to_numpy()[measurement], + }) + return self.data \ No newline at end of file diff --git a/qkit/analysis/semiconductor/loaders/LoaderJSON.py b/qkit/analysis/semiconductor/loaders/LoaderJSON.py new file mode 100644 index 00000000..3ad9177a --- /dev/null +++ b/qkit/analysis/semiconductor/loaders/LoaderJSON.py @@ -0,0 +1,13 @@ +import json +from qkit.measure.json_handler import QkitJSONDecoder + +from pathlib import Path + +class LoaderJSON: + """Extracts all data from json files and returns it. + """ + def load(self, path): + with Path(path).open() as file: + data = json.load(file, cls = QkitJSONDecoder) + + return data \ No newline at end of file diff --git a/qkit/analysis/semiconductor/loaders/LoaderPickle.py b/qkit/analysis/semiconductor/loaders/LoaderPickle.py new file mode 100644 index 00000000..95deaac0 --- /dev/null +++ b/qkit/analysis/semiconductor/loaders/LoaderPickle.py @@ -0,0 +1,39 @@ +import pickle +import os +import urllib +from smb.SMBHandler import SMBHandler + + +class LoaderPickle: + """Extracts all data from pickle files and returns it. + """ + def load(self, settings): + + if isinstance(settings, str): + path = settings + else: + try: #Are we in the new data format? + path = settings["file_info"]["filepath"] + + if not os.path.isfile(path): + mod_path = path.replace("smb://nanospin@phi-ndus", "smb://nanospin:Hadamard_gate@phi-ndus") + opener = urllib.request.build_opener(SMBHandler) + fh = opener.open(mod_path) + data = pickle.load(fh)["entry"]["data0"] + return + except KeyError: #Or in the old? + path = (f"{settings['file_info']['absolute_path']}" + f"{settings['file_info']['date_stamp']}/" + f"{settings['file_info']['filename']}/" + f"{settings['file_info']['filename']}.p") + + if not os.path.isfile(path): + path = (f"{settings['file_info']['absolute_path']}" + f"{settings['file_info']['date_stamp']}/" + f"{settings['file_info']['filename']}/" + "data_pickle") + + with open(path, "rb") as file: + data = pickle.load(file) + + return data diff --git a/qkit/analysis/semiconductor/loaders/LoaderSamba.py b/qkit/analysis/semiconductor/loaders/LoaderSamba.py new file mode 100644 index 00000000..c736710e --- /dev/null +++ b/qkit/analysis/semiconductor/loaders/LoaderSamba.py @@ -0,0 +1,13 @@ +import urllib +from smb.SMBHandler import SMBHandler # pip install pysmb + +class LoaderSamba: + """Loads from a samba smb:// filepath. + """ + def load(self, filepath): + director = urllib.request.build_opener(SMBHandler) + fh = director.open(filepath) + data = fh.read() + fh.close() + + return data \ No newline at end of file diff --git a/qkit/analysis/semiconductor/loaders/Loader_spectrum_np.py b/qkit/analysis/semiconductor/loaders/Loader_spectrum_np.py new file mode 100644 index 00000000..c5e9b089 --- /dev/null +++ b/qkit/analysis/semiconductor/loaders/Loader_spectrum_np.py @@ -0,0 +1,28 @@ +import numpy as np +from qkit.analysis.semiconductor.main.saving import create_saving_path + +class Loader_spectrum_np(): + """Loads spectrum of folder given in settings. + """ + def load(self, settings:dict, ending=""): + """Return is a touple of the data dict, fit params of the plunger gate sweep potentially used for + calibration, and data of the power fit. + """ + data = {} + fit_params_plunger = {} + power_fit_params = {} + + data["freq"] = np.loadtxt(create_saving_path(settings, "frequency_data"+ending, filetype=".txt")) + data["spectrogram"] = np.loadtxt(create_saving_path(settings, "spectrum_data"+ending, filetype=".txt")) + try: + fit_params_plunger['fit_coef'] = np.loadtxt(create_saving_path(settings, "plunger_fit_data"+ending, filetype=".txt")) + except FileNotFoundError: + print("No plunger data found.") + fit_params_plunger = None + try: + power_fit_params["popt"] = np.loadtxt(create_saving_path(settings, "power_fit_data"+ending, filetype=".txt")) + except FileNotFoundError: + print("No power fit data found.") + power_fit_params = None + + return (data, fit_params_plunger, power_fit_params) diff --git a/qkit/analysis/semiconductor/loaders/Loaderh5.py b/qkit/analysis/semiconductor/loaders/Loaderh5.py new file mode 100644 index 00000000..354d44eb --- /dev/null +++ b/qkit/analysis/semiconductor/loaders/Loaderh5.py @@ -0,0 +1,96 @@ +import h5py +import numpy as np +from pathlib import Path +import urllib +from smb.SMBHandler import SMBHandler +import paramiko +from qkit.analysis.semiconductor.main.interfaces import LoaderInterface +import base64 + +def deobfuscate(obfuscatedText): + obfuscatedBytes = obfuscatedText.encode('ascii') + decodedBytes = base64.b64decode(obfuscatedBytes) + decodedText = decodedBytes.decode('ascii') + return decodedText + +class Loaderh5: + """Extracts all data from .h5 files in this folder and returns it as a dict. + """ + def load(self, Pathobj): + """Loads the data of a .h5 file. Analysis and views are not loaded. Is able to interprete smb connection to nanospin@phi-ndus" + """ + if type(Pathobj) is dict: + path = str(Pathobj['file_info']['filepath']) + elif type(Pathobj) is str: + path = Pathobj + else: + raise ValueError("Unknown data type of given path object.") + + if path.startswith("smb:"): + mod_path = path.replace("smb://nanospin@phi-ndus", "smb://nanospin:Hadamard_gate@phi-ndus") + opener = urllib.request.build_opener(SMBHandler) + fh = opener.open(mod_path) + data = h5py.File(fh,"r")["entry"]["data0"] + + elif path.startswith("sftp:"): + if type(Pathobj) is not dict or 'authentication' not in Pathobj: + raise ValueError("Could not find authentication data in you path object. Please make sure your pathobject is a dictionary containing an 'authentication' key.") + + host = "os-login.lsdf.kit.edu" #hard-coded + port = 22 + transport = paramiko.Transport((host, port)) + try: + f=open(Pathobj['authentication']['configpath'],"r") + except KeyError: + raise AuthorizationError("sftp connection needs authorization infos. Missing authorization key in settings or wrong configpath.") + lines=f.readlines() + username=deobfuscate(deobfuscate(lines[0][:-1])) + password=deobfuscate(deobfuscate(lines[1][:-1])) + f.close() + + transport.connect(username = username, password = password) + sftp = paramiko.SFTPClient.from_transport(transport) + mod_path = path.split(".lsdf.kit.edu")[1] + fh = sftp.open(mod_path) + data = h5py.File(fh,"r")["entry"]["data0"] + + else: + data = h5py.File(path,'r')["entry"]["data0"] + + self.data_dict = {} + for key in data.keys(): + self.data_dict[key] = np.array(data.get(u'/entry/data0/' + key)[()]) + return self.data_dict , data + + def _decrypt_string(self, string): + """Decodes a twofold encoded base64 string""" + return base64.b64decode(base64.b64decode(string)).decode("ascii") + + +class H5filemerger(): + """Sonjas first class -whoop-whoop- merges data from several .h5 files with the same nodes and returns them as dict + See accumulation_many_files.py in the scripts folder for an application + """ + def __init__(self): + self.paths = [] + + def add_paths(self, paths): + if type(paths) != list: + raise TypeError("Your input type is dumb. Must be list, silly human.") + self.paths.extend(paths) + + def merge(self): + data1 = h5py.File(Path(self.paths[0]),'r')["entry"]["data0"] + dictmerged = {key : np.array([]) for key in data1.keys()} + for element in self.paths: + data = h5py.File(Path(element),'r')["entry"]["data0"] + for key in dictmerged.keys(): + data_dict = {} + data_dict[key] = np.array(data[key]) + dictmerged[key] = np.concatenate( (dictmerged[key], data_dict[key])) + + return dictmerged + +class AuthorizationError(Exception): + """Exception raised for errors for missing authorization info. + """ diff --git a/qkit/analysis/semiconductor/main/GUI_file_dialog_qt.py b/qkit/analysis/semiconductor/main/GUI_file_dialog_qt.py new file mode 100644 index 00000000..45949b91 --- /dev/null +++ b/qkit/analysis/semiconductor/main/GUI_file_dialog_qt.py @@ -0,0 +1,18 @@ +from PyQt5.QtWidgets import QFileDialog +from PyQt5 import QtCore, QtWidgets + +import sys + +app = QtCore.QCoreApplication.instance() +if app is None: + app = QtWidgets.QApplication(sys.argv) + +name = [] +def gui_fname(dir=None): + """Select a file via a dialog and return the file name.""" + if dir is None: dir ='./' + fname = QFileDialog.getOpenFileNames(None, "Select data file...", dir, filter="All files (*);; SM Files (*.sm)") + name.extend(fname[0]) + return name + +gui_fname() diff --git a/qkit/analysis/semiconductor/main/GUI_file_dialog_tk.py b/qkit/analysis/semiconductor/main/GUI_file_dialog_tk.py new file mode 100644 index 00000000..22d87edc --- /dev/null +++ b/qkit/analysis/semiconductor/main/GUI_file_dialog_tk.py @@ -0,0 +1,21 @@ +from tkinter import * +# import filedialog module +from tkinter import filedialog + +# Function for opening the file explorer +def browseFiles(): + filenames = filedialog.askopenfilenames(initialdir = "/", + title = "Select a File", + filetypes = (("Text files","*.txt*"),("all files","*.*"))) + return filenames + + + +def print_nodes(file): + print("\nData nodes:\n" + str([key for key in file.keys()])) + +def main(): + browseFiles() + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/main/SlicerPlungerTimetrace.py b/qkit/analysis/semiconductor/main/SlicerPlungerTimetrace.py new file mode 100644 index 00000000..6b92ff15 --- /dev/null +++ b/qkit/analysis/semiconductor/main/SlicerPlungerTimetrace.py @@ -0,0 +1,27 @@ +import numpy as np +import copy + +from qkit.analysis.semiconductor.main.find_index_of_value import map_array_to_index +from qkit.analysis.semiconductor.main.time_conversion import convert_secs_2D + + + +class SlicerPlungerTimetrace(): + """Slices the nodes which are given in a slice that is given by "begin" and "end" in hours. + First node needs to be timestamps, second is gate, third and following can be x, y, and/or R. + """ + def __init__(self): + self.beginning = 0 + self.ending = 0 + + def slice(self, data, nodes): + timestamps = convert_secs_2D(data[nodes[0]]) + index_begin = map_array_to_index(timestamps, self.beginning*3600) + index_end = map_array_to_index(timestamps, self.ending*3600) + data_sliced = {} + data_sliced[nodes[0]] = copy.deepcopy(data[nodes[0]][index_begin : index_end]) + data_sliced[nodes[1]] = copy.deepcopy(data[nodes[1]]) + for index in np.arange(2, len(nodes)): # could be x, y, R + data_sliced[nodes[index]] = copy.deepcopy(data[nodes[index]][index_begin : index_end, : ]) + + return data_sliced \ No newline at end of file diff --git a/qkit/analysis/semiconductor/main/SlicerTimetrace.py b/qkit/analysis/semiconductor/main/SlicerTimetrace.py new file mode 100644 index 00000000..2a7b268b --- /dev/null +++ b/qkit/analysis/semiconductor/main/SlicerTimetrace.py @@ -0,0 +1,26 @@ +import copy + +from qkit.analysis.semiconductor.main.find_index_of_value import map_array_to_index + + + +class SlicerTimetrace: + """Slices data by beginning and ending values of the time (first node entry) in seconds. + """ + def __init__(self, begin, end): + """initialize with beginning and ending. + """ + self.begin = begin + self.end = end + + def make_slice_timetrace(self, data, nodes, f=1.8*1e9): + begin_x = data[nodes[0]][0] + self.begin * f + end_x = data[nodes[0]][0] + self.end * f + index_begin = map_array_to_index(data[nodes[0]], begin_x) + index_end = map_array_to_index(data[nodes[0]], end_x) + data_sliced = {} + for key in nodes: + data_sliced[key] = copy.deepcopy(data[key][index_begin : index_end]) + + return data_sliced + \ No newline at end of file diff --git a/qkit/analysis/semiconductor/main/conversion_lockin_conductance.py b/qkit/analysis/semiconductor/main/conversion_lockin_conductance.py new file mode 100644 index 00000000..6a092fcc --- /dev/null +++ b/qkit/analysis/semiconductor/main/conversion_lockin_conductance.py @@ -0,0 +1,14 @@ +import numpy as np + +def convert_conductance(amplitudes, settings, multiplier): + """Converts Lock-in amplitude in conductance in Siemens. + measurement_amp: amplitude of lock-in signal + voltage_divider: used before the input of the lock-in + IVgain: of IV converter + in_line_R: sum of resistances of the line without QD + multiplier: multiplies values by factor of e.g. 1e6 to get micro Siemens + """ + return multiplier / (settings["meas_params"]["measurement_amp"] * settings["meas_params"]["IVgain"] / (settings["meas_params"]["voltage_divider"] + * amplitudes * np.sqrt(2)) - settings["meas_params"]["in_line_R"]) + + diff --git a/qkit/analysis/semiconductor/main/equalize_length.py b/qkit/analysis/semiconductor/main/equalize_length.py new file mode 100644 index 00000000..1513850d --- /dev/null +++ b/qkit/analysis/semiconductor/main/equalize_length.py @@ -0,0 +1,16 @@ +import copy + + +def make_len_eq(data:dict, keys:list): + """Takes a data dict and looks at two entries. Cuts away the end of data of the longer one to make + both equal length. + """ + len1 = len(data[keys[0]]) + len2 = len(data[keys[1]]) + if len1 != len2: + if len1 < len2: + data[keys[1]] = copy.deepcopy(data[keys[1]][:len1]) + else: + data[keys[0]] = copy.deepcopy(data[keys[0]][:len2]) + + return data \ No newline at end of file diff --git a/qkit/analysis/semiconductor/main/find_index_of_value.py b/qkit/analysis/semiconductor/main/find_index_of_value.py new file mode 100644 index 00000000..59491d53 --- /dev/null +++ b/qkit/analysis/semiconductor/main/find_index_of_value.py @@ -0,0 +1,23 @@ +import numpy as np + + +# def map_array_to_index(array, value): +# """Takes an array of SORTED values and returns the nearest index where the value is found. +# """ +# if array[0] 0 and (idx == len(array) or math.fabs(value - array[idx-1]) < math.fabs(value - array[idx])): +# # return idx-1 +# #else: +# return idx +# else: # array in descending order +# idx = np.searchsorted(array[::-1], value, side="left") +# #if idx > 0 and (idx == len(array) or math.fabs(value - array[idx-1]) < math.fabs(value - array[idx])): +# # return len(array) - idx - 1 +# #else: +# return len(array) - idx + +def map_array_to_index(array, value): + array = np.asarray(array) + idx = (np.abs(array - value)).argmin() + return idx \ No newline at end of file diff --git a/qkit/analysis/semiconductor/main/fit_functions.py b/qkit/analysis/semiconductor/main/fit_functions.py new file mode 100644 index 00000000..01e54a28 --- /dev/null +++ b/qkit/analysis/semiconductor/main/fit_functions.py @@ -0,0 +1,31 @@ +import numpy as np + + +def sech(x, a, b, c): + """Returns the hyperbolic secant of the given x values""" + return a / np.cosh((x - c) / b) + +def multi_sech(x, *params): + """Returns the sum of multiple hyperbolic secants + according to the number of given parameters""" + y = np.zeros_like(x) + for i in range(0, len(params), 3): + a = params[i] + b = params[i + 1] + c = params[i + 2] + y = y + sech(x, a, b, c) + return y + +def gauss_function(x, a, x0, sigma): + """prefactor "a" takes non-normalized data into account. + """ + return a * np.exp(-1 * ((x-x0)**2/(2*sigma**2))) + +def linear(x, a, b): + return a * x + b + +def bilinear2(x, a, b, c, switch_point): + x = np.array(x) + part1 = a * x[x <= switch_point] + b + part2 = c * x[x > switch_point] + (a - c) * switch_point + b + return np.concatenate((part1, part2)) \ No newline at end of file diff --git a/qkit/analysis/semiconductor/main/interfaces.py b/qkit/analysis/semiconductor/main/interfaces.py new file mode 100644 index 00000000..91f7b2e8 --- /dev/null +++ b/qkit/analysis/semiconductor/main/interfaces.py @@ -0,0 +1,40 @@ +from abc import ABC, abstractmethod +from typing import Any, Dict, List + + +class PlotterInterface(ABC): + @abstractmethod + def load_data(self, data: Dict[str, Any]): + pass + + @abstractmethod + def validate_input(self): + pass + + @abstractmethod + def plot(self): + pass + + +class AnalyzerInterface(ABC): + @abstractmethod + def load_data(self, data: Dict[str, Any]): + pass + + @abstractmethod + def validate_input(self): + pass + + @abstractmethod + def analyze(self) -> Dict[str, Dict[str, Any]]: + pass + + +class LoaderInterface(ABC): + @abstractmethod + def set_filepath(self, path: List[str]): + pass + + @abstractmethod + def load(self): + pass diff --git a/qkit/analysis/semiconductor/main/pre_formatted_figures.py b/qkit/analysis/semiconductor/main/pre_formatted_figures.py new file mode 100644 index 00000000..8dff8127 --- /dev/null +++ b/qkit/analysis/semiconductor/main/pre_formatted_figures.py @@ -0,0 +1,53 @@ +import matplotlib.pyplot as plt +import gc + + +class SemiFigure(): + """Standard class for plots of semiconducting people. + """ + def __init__(self, jumbo_data = False): + self.fig, self.ax = plt.subplots() + self.set_dpi = 400 + self.set_bbox_inches = "tight" + self.save_as = ".png" + self.ax.set_axisbelow(True) # pushes grid to background + self.fig.set_facecolor("White") + self.ax.title.set_size(fontsize=14) + self.ax.xaxis.label.set_size(fontsize=12) + self.ax.yaxis.label.set_size(fontsize=12) + self.jumbo_data = jumbo_data + + + @property + def jumbo_data(self): + return self._jumbo_data + + @jumbo_data.setter + def jumbo_data(self, yesno:bool): + if yesno: + plt.rcParams['agg.path.chunksize'] = 10000 # makes saving too big data sets possible. + else: + plt.rcParams['agg.path.chunksize'] = 0 + self._jumbo_data = yesno + + + def close_delete(self): + """Closes fig and deletes instance to free RAM. + """ + self.fig.clear() + plt.close(self.fig) + del self + gc.collect() + + + +if __name__ == "__main__": + print(plt.rcParams['agg.path.chunksize']) + sf = SemiFigure(True) + print(plt.rcParams['agg.path.chunksize']) + sf.jumbo_data = False + print(sf.jumbo_data) + print(plt.rcParams['agg.path.chunksize']) + sf.jumbo_data = True + print(plt.rcParams['agg.path.chunksize']) + print(sf.jumbo_data) \ No newline at end of file diff --git a/qkit/analysis/semiconductor/main/rotate_phase.py b/qkit/analysis/semiconductor/main/rotate_phase.py new file mode 100644 index 00000000..4b6741b9 --- /dev/null +++ b/qkit/analysis/semiconductor/main/rotate_phase.py @@ -0,0 +1,15 @@ +import numpy as np +import copy + + +def rotate_phase(data, nodes, phase_offset_deg): + """Gives phase offset to x and y data (given in nodes). + """ + R = np.sqrt(np.add(np.power(data[nodes[0]], 2), np.power(data[nodes[1]], 2))) + phi = np.arctan2(data[nodes[1]], data[nodes[0]]) + phi = phi + phase_offset_deg*np.pi/180 + data_rotated = copy.deepcopy(data) + data_rotated[nodes[0]] = R * np.cos(phi) + data_rotated[nodes[1]] = R * np.sin(phi) + + return data_rotated \ No newline at end of file diff --git a/qkit/analysis/semiconductor/main/saving.py b/qkit/analysis/semiconductor/main/saving.py new file mode 100644 index 00000000..8adea118 --- /dev/null +++ b/qkit/analysis/semiconductor/main/saving.py @@ -0,0 +1,15 @@ +import pathlib +import os + + +def create_saving_path(settings, name, filetype=".png"): + """Creats a folder with the name of settings["file_info"]["savepath"] if it's not existent and returns path to it. + """ + path = os.path.join(pathlib.Path(settings['file_info']['filepath']).parents[0], + settings['file_info']['savepath']) + + pathlib.Path(path).mkdir(parents=True, exist_ok=True) + path = os.path.join(path, name) + filetype + + return path + diff --git a/qkit/analysis/semiconductor/main/time_conversion.py b/qkit/analysis/semiconductor/main/time_conversion.py new file mode 100644 index 00000000..e469e536 --- /dev/null +++ b/qkit/analysis/semiconductor/main/time_conversion.py @@ -0,0 +1,21 @@ + +def convert_secs(timestamps, f=1.8*1e9): + """Sets the starting point to 0 and adjusts with the clock speed of 1.8 GHz. Not really accurate. + Timestamps need to be numpy arrays. + """ + time_stamps = timestamps - timestamps[0] + time_stamps = time_stamps / f + + return time_stamps + + + + +def convert_secs_2D(timestamps, f=1.8*1e9): + """Sets the starting point to 0 and adjusts with the clock speed of 1.8 GHz. Not really accurate. + Converts 2D timestamps in 1D arrays with each point in 1D being the beginning of a 2D array. + """ + time_stamps = timestamps[:,0] - timestamps[0,0] + time_stamps = time_stamps / f + + return time_stamps \ No newline at end of file diff --git a/qkit/analysis/semiconductor/main/wrapper_functions.py b/qkit/analysis/semiconductor/main/wrapper_functions.py new file mode 100644 index 00000000..0f171b3e --- /dev/null +++ b/qkit/analysis/semiconductor/main/wrapper_functions.py @@ -0,0 +1,11 @@ +import traceback + +def do_monitored(func): + def wrapper(self): + try: + func(self) + except: + error_msg = traceback.format_exc() + self.view.show_error_msg(error_msg) + + return wrapper \ No newline at end of file diff --git a/qkit/analysis/semiconductor/plotters/Plotter3D.py b/qkit/analysis/semiconductor/plotters/Plotter3D.py new file mode 100644 index 00000000..e06858d3 --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/Plotter3D.py @@ -0,0 +1,67 @@ +import numpy as np +import matplotlib.pyplot as plt +from matplotlib.colors import BoundaryNorm +from matplotlib.ticker import MaxNLocator + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.analysis.semiconductor.main.conversion_lockin_conductance import convert_conductance + + +class Plotter3D(SemiFigure): + """Plots 3D data of 2D sweeps. + """ + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.colorcode = "viridis" + self.savename = "plot3D" + self.conductance = True + self.min = None + self.max = None + self.y_axis_in_mV = False + + + + def plot(self, settings:dict, data:dict, nodes, axis_labels=["x_gate", "y_gate"]): + """Nodes in format [x, y, R]. + good color codes might be viridis, PiYG, plasma, gist_rainbow... + """ + data_x = data[nodes[0]] + plt.xlabel(axis_labels[0] + " (V)") + + if self.y_axis_in_mV == True: + data_y = 1e3 * data[nodes[1]] + plt.ylabel(axis_labels[1] + " (mV)") + else: + data_y = data[nodes[1]] + plt.ylabel(axis_labels[1] + " (V)") + + if self.conductance == True: + data_z = np.transpose(convert_conductance(data[nodes[2]], settings, 1e6)) + else: + data_z = np.transpose(1e3 * data[nodes[2]]) + + + + + if self.min is None: + min = data_z.min() + else: + min = self.min + if self.max is None: + max = data_z.max() + else: + max = self.max + + levels = MaxNLocator(nbins=100).tick_values(min, max) + cmap = plt.get_cmap(self.colorcode) + norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True) + plt.pcolormesh(data_x, data_y, data_z, cmap=cmap, norm=norm) + if self.conductance == True: + plt.colorbar(label='Conductance ($\mu$S)') + else: + plt.colorbar(label='Lock-in Amplitude (mV)') + + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() diff --git a/qkit/analysis/semiconductor/plotters/Plotter3D_y_axis_in_mV.py b/qkit/analysis/semiconductor/plotters/Plotter3D_y_axis_in_mV.py new file mode 100644 index 00000000..44558d85 --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/Plotter3D_y_axis_in_mV.py @@ -0,0 +1,58 @@ +import numpy as np +import matplotlib.pyplot as plt +from matplotlib.colors import BoundaryNorm +from matplotlib.ticker import MaxNLocator + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.analysis.semiconductor.main.conversion_lockin_conductance import convert_conductance + + +class Plotter3D(SemiFigure): + """Plots 3D data of 2D sweeps. + """ + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.colorcode = "viridis" + self.savename = "plot3D" + self.conductance = True + self.min = None + self.max = None + + + + def plot(self, settings:dict, data:dict, nodes, axis_labels=["x_gate", "y_gate"]): + """Nodes in format [x, y, R]. + good color codes might be viridis, PiYG, plasma, gist_rainbow... + """ + data_x = data[nodes[0]] + data_y = 1e3 * data[nodes[1]] + if self.conductance == True: + data_z = np.transpose(convert_conductance(data[nodes[2]], settings, 1e6)) + else: + data_z = np.transpose(1e3 * data[nodes[2]]) + + plt.xlabel(axis_labels[0] + " (V)") + plt.ylabel(axis_labels[1] + " (mV)") + + if self.min is None: + min = data_z.min() + else: + min = self.min + if self.max is None: + max = data_z.max() + else: + max = self.max + + levels = MaxNLocator(nbins=100).tick_values(min, max) + cmap = plt.get_cmap(self.colorcode) + norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True) + plt.pcolormesh(data_x, data_y, data_z, cmap=cmap, norm=norm) + if self.conductance == True: + plt.colorbar(label='Conductance ($\mu$S)') + else: + plt.colorbar(label='Lock-in Amplitude (mV)') + + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() diff --git a/qkit/analysis/semiconductor/plotters/PlotterAccumulation.py b/qkit/analysis/semiconductor/plotters/PlotterAccumulation.py new file mode 100644 index 00000000..2850c669 --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterAccumulation.py @@ -0,0 +1,49 @@ +import matplotlib.pyplot as plt + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.analysis.semiconductor.main.conversion_lockin_conductance import convert_conductance +from qkit.analysis.semiconductor.main.equalize_length import make_len_eq + + +class PlotterAccumulation(SemiFigure): + """Plots Accumulation Traces over gate voltage. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.gatename:str = "" + self.savename = "accumulation" + self.title = "Accumulation" + self.marker = "." + + def plot_one_trace(self, settings, data_in, nodes): + """Plot only one trace. + """ + data = make_len_eq(data_in, nodes) + self.ax.set_title(self.title) + if len(self.gatename) == 0: + gatename = nodes[0] + self.ax.set_xlabel(self.gatename) + self.ax.set_ylabel("Conductance ($\mu$S)") + self.ax.plot(data[nodes[0]], convert_conductance(data[nodes[1]], settings, multiplier=1e6), marker=self.marker) + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() + + def add_trace(self, settings, data_in, nodes, label_id=""): + """Adds a trace to the plotter object which can be plotted by plot_all(). + """ + data = make_len_eq(data_in, nodes) + self.ax.plot(data[nodes[0]], convert_conductance(data[nodes[1]], settings, multiplier=1e6), label=label_id, marker=self.marker) + + def plot_all(self, settings): + """Plots the traces that have been added by add_trace(). + """ + self.ax.set_title(self.title) + self.ax.set_xlabel(self.gatename) + self.ax.set_ylabel("Conductance ($\mu$S)") + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches, marker=self.marker) + plt.legend() + plt.show() + self.close_delete() diff --git a/qkit/analysis/semiconductor/plotters/PlotterBiascoolingAccumulation.py b/qkit/analysis/semiconductor/plotters/PlotterBiascoolingAccumulation.py new file mode 100644 index 00000000..c3c25b79 --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterBiascoolingAccumulation.py @@ -0,0 +1,74 @@ +import matplotlib.pyplot as plt +import matplotlib.patches as mpatches + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure + +class PlotterBiascoolingAccumulation(SemiFigure): + """Plots Accumulation voltages over bias cooling voltage. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.savename = "accumulations_biascooling" + self.shape = "*" + self.size = 500 + self.transparency = 1 + + def plot(self, data): + self.ax.set_title("Accumulation Voltages depending on Bias Cooling") + self.ax.set_xlabel("Bias Cooling Voltage (V)") + self.ax.set_ylabel("Accumulation Voltage (V)") + for sample in data: + for cooldown in data[sample]: + self.ax.scatter(cooldown["bias_V"], cooldown["first_acc_V"], marker=self.shape, s=self.size, alpha=self.transparency) + + plt.grid() + savepath = self.savename + self.save_as + plt.savefig(savepath, dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() + + +class PlotterBiascoolingAccumulationColors(SemiFigure): + """Plots Accumulation voltages over bias cooling voltage. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.savename = "accumulations_biascooling_color" + self.shape = "*" + self.size = 500 + self.transparency = 1 + self.cooldown_perfect = "False" + + def plot(self, data, savename="accumulations_biascooling"): + self.ax.set_title("Accumulation Voltages depending on Bias Cooling") + self.ax.set_xlabel("Bias Cooling Voltage (V)") + self.ax.set_ylabel("Accumulation Voltage (V)") + + color_palette = ["r", "b", "g", "k"] + i = 0 + + for sample in data: + color_plot = color_palette[i] + for cooldown in data[sample]: + if cooldown["RT_cooldown"] == "y" or cooldown["RT_cooldown"] == "new": + self.ax.scatter(cooldown["bias_V"], cooldown["first_acc_V"], marker=self.shape, s=self.size, alpha=self.transparency, color=color_plot) + elif cooldown["RT_cooldown"] == "n": + if self.cooldown_perfect == False: + self.ax.scatter(cooldown["bias_V"], cooldown["first_acc_V"], marker="3", s=self.size, alpha=self.transparency, color=color_plot) + else: + # Plot what is not labled + self.ax.scatter(cooldown["bias_V"], cooldown["first_acc_V"], marker="s", s=self.size, alpha=self.transparency, color=color_plot) + i+=1 + + red_patch = mpatches.Patch(color='red', label='Sample B1') + blue_patch = mpatches.Patch(color='blue', label='Sample B4') + black_patch = mpatches.Patch(color='green', label='Sample B3') + + + plt.grid() + plt.legend(handles=[ red_patch, blue_patch, black_patch]) + plt.savefig(f"{savename}.png", dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/plotters/PlotterDifferenceTimetraceSpectralNoiseDensity.py b/qkit/analysis/semiconductor/plotters/PlotterDifferenceTimetraceSpectralNoiseDensity.py new file mode 100644 index 00000000..26e7ac0a --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterDifferenceTimetraceSpectralNoiseDensity.py @@ -0,0 +1,66 @@ +import numpy as np +import matplotlib.pyplot as plt + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path + + +class PlotterDifferenceTimetraceSpectralNoiseDensity(SemiFigure): + """Plots the spectral noise density difference of two SNDs using the equivalent gate voltage found in fit_params['fit_coef'][0] if provided. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.fit_params_plunger = None, + self.fit_vals = None + self.savename = None + self.xlim = None + self.ylim = None + self.dotsize = 0.5 + self.fiftyHz = False + + + def plot(self, settings:dict, data_calib:dict, data_no_calib:dict): + """Plots the sqrt of a spectrum (data["spectrogram"]). Respecting scaling with the slope of a plunger gate sweep (fit_params_plunger). + data: spectral data in dictionary with keys "freq", "times", "spectorgram" + fit_params_plunger_in: dict including key "fit_coef" + fit_vals: dict with keys "popt" and "SND1Hz" that is used to plot a linear fit to the data + fifyHz: bool that overlays the first 30 50Hz multiples + """ + self.ax.set_title("Power Spectral Noise Density") + self.ax.set_xscale("log") + self.ax.set_yscale("log") + self.ax.set_xlabel("Frequency (Hz)") + self.ax.set_ylabel("PSD (V²/Hz)") + if self.xlim != None: + self.ax.set_xlim(self.xlim) + if self.ylim != None: + self.ax.set_ylim(self.ylim) + if self.fit_params_plunger is None: # for reference measurements without plunger gate sweeps the slope is 1 + fit_params_plunger = {} + fit_params_plunger["fit_coef"] = [1] + else: + fit_params_plunger = self.fit_params_plunger + if self.savename == None: + self.savename = f"PSD_without_background_slope_{fit_params_plunger['fit_coef'][0]:.3f}" + + if self.fiftyHz == True: # plotting 50Hz multiples + self.savename += "_50Hz" + freqs = [] + signals = [] + for f in [i*50 for i in range(13)]: + freqs.extend([f]*1000 ) + signals.extend(np.logspace(-11, -4, 1000)) + self.ax.plot(freqs, signals, "yo", markersize=self.dotsize) + + if np.array_equal(data_calib["freq"], data_no_calib["freq"]): + self.spectrum = (data_calib["spectrogram"] - data_no_calib["spectrogram"] ) / (fit_params_plunger['fit_coef'][0])**2 + + self.ax.plot(data_calib["freq"], self.spectrum, "ok", markersize=self.dotsize) + + plt.grid() + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + else: + print("Error: Frequency arrays of both data inputs not equal!") + self.close_delete() diff --git a/qkit/analysis/semiconductor/plotters/PlotterExcel.py b/qkit/analysis/semiconductor/plotters/PlotterExcel.py new file mode 100644 index 00000000..d9239a1d --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterExcel.py @@ -0,0 +1,176 @@ +import matplotlib.pyplot as plt +import matplotlib.patches as mpatches + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure + + +class PlotterBiascoolingAccumulation(SemiFigure): + """Plots Accumulation voltages over bias cooling voltage. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def plot(self, data, savename="accumulations_biascooling", shape="^", size=100, transparency=1): + self.ax.set_title("Accumulation Voltages depending on Bias Cooling") + self.ax.set_xlabel("Bias Cooling Voltage (V)") + self.ax.set_ylabel("Accumulation Voltage (V)") + for cooldown in data: + if cooldown["RT_cooldown"] == "y": + self.ax.scatter(cooldown["bias_V"], cooldown["first_acc_V"], marker=shape, s=size, alpha=transparency, color="r") + elif cooldown["RT_cooldown"] == "n": + self.ax.scatter(cooldown["bias_V"], cooldown["first_acc_V"], marker=shape, s=size, alpha=transparency, color="b") + else: + self.ax.scatter(cooldown["bias_V"], cooldown["first_acc_V"], marker=shape, s=size, alpha=transparency, color="c") + plt.grid() + red_patch = mpatches.Patch(color='red', label='Cooldown from room temperature') + blue_patch = mpatches.Patch(color='blue', label='Fast thermal cycle to 197 Kelvin') + plt.legend(handles=[ red_patch, blue_patch]) + plt.savefig(f"{savename}.png", dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() + + +class PlotterBiascoolingMinimalTopgate(SemiFigure): + """Plots the minimal topgate voltages over bias cooling voltage. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def plot(self, data, savename="min_TG_biascooling", shape="^", size=100, transparency=1, RT="both"): + self.ax.set_title("Minimal SET Topgate Voltages depending on Bias Cooling") + self.ax.set_xlabel("Bias Cooling Voltage (V)") + self.ax.set_ylabel("TG (V)") + for cooldown in data: + if RT == "yes": + if cooldown["RT_cooldown"] == "y": + self.ax.scatter(cooldown["bias_V"], cooldown["SET_left_TG"], marker=shape, s=size, alpha=transparency, color="r") + self.ax.scatter(cooldown["bias_V"], cooldown["SET_right_TG"], marker=shape, s=size, alpha=transparency, color="b") + else: + self.ax.scatter(cooldown["bias_V"], cooldown["SET_left_TG"], marker=shape, s=size, alpha=transparency, color="r") + self.ax.scatter(cooldown["bias_V"], cooldown["SET_right_TG"], marker=shape, s=size, alpha=transparency, color="b") + + plt.grid() + red_patch = mpatches.Patch(color='red', label='left SET') + blue_patch = mpatches.Patch(color='blue', label='right SET') + plt.legend(handles=[ red_patch, blue_patch]) + plt.savefig(f"{savename}.png", dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() + + +class PlotterBiascoolingDifferenceTopgateGates(SemiFigure): + """Plots difference of topgate and the middle gates over bias cooling voltage. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def plot(self, data, savename="Dif_TG_middle_gates_biascooling", shape="^", size=100, transparency=1, RT="both"): + self.ax.set_title("Difference between TG and middle gates depending on Bias Cooling") + self.ax.set_xlabel("Bias Cooling Voltage (V)") + self.ax.set_ylabel("TG - middle gates (V)") + for cooldown in data: + if RT == "yes": + if cooldown["RT_cooldown"] == "y": + self.ax.scatter(cooldown["bias_V"], cooldown["SET_left_TG"] - cooldown["SET_other_gates"], marker=shape, s=size, alpha=transparency, color="r") + self.ax.scatter(cooldown["bias_V"], cooldown["SET_right_TG"] - cooldown["SET_other_gates"], marker=shape, s=size, alpha=transparency, color="b") + else: + self.ax.scatter(cooldown["bias_V"], cooldown["SET_left_TG"] - cooldown["SET_other_gates"], marker=shape, s=size, alpha=transparency, color="r") + self.ax.scatter(cooldown["bias_V"], cooldown["SET_right_TG"] - cooldown["SET_other_gates"], marker=shape, s=size, alpha=transparency, color="b") + + plt.grid() + red_patch = mpatches.Patch(color='red', label='left SET') + blue_patch = mpatches.Patch(color='blue', label='right SET') + plt.legend(handles=[ red_patch, blue_patch]) + plt.savefig(f"{savename}.png", dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() + + +class PlotterBiascoolingDifferenceTopgateBarriers(SemiFigure): + """Plots difference of topgate and the mean of barrier gates over bias cooling voltage. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def plot(self, data, savename="Dif_TG_barrier_gates_biascooling", shape="^", size=100, transparency=1, RT="both"): + self.ax.set_title("Difference between TG and the mean of barrier gates depending on Bias Cooling") + self.ax.set_xlabel("Bias Cooling Voltage (V)") + self.ax.set_ylabel("TG - barrier gates (V)") + for cooldown in data: + if RT == "yes": + if cooldown["RT_cooldown"] == "y": + self.ax.scatter(cooldown["bias_V"], cooldown["SET_left_TG"] - 0.5*(cooldown["SET_left_G5"] + cooldown["SET_left_G7"]), marker=shape, s=size, alpha=transparency, color="r") + self.ax.scatter(cooldown["bias_V"], cooldown["SET_right_TG"] - 0.5*(cooldown["SET_right_G15"] + cooldown["SET_right_G17"]), marker=shape, s=size, alpha=transparency, color="b") + else: + self.ax.scatter(cooldown["bias_V"], cooldown["SET_left_TG"] - 0.5*(cooldown["SET_left_G5"] + cooldown["SET_left_G7"]), marker=shape, s=size, alpha=transparency, color="r") + self.ax.scatter(cooldown["bias_V"], cooldown["SET_right_TG"] - 0.5*(cooldown["SET_right_G15"] + cooldown["SET_right_G17"]), marker=shape, s=size, alpha=transparency, color="b") + + plt.grid() + red_patch = mpatches.Patch(color='red', label='left SET') + blue_patch = mpatches.Patch(color='blue', label='right SET') + plt.legend(handles=[ red_patch, blue_patch]) + plt.savefig(f"{savename}.png", dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() + + +class PlotterBiascoolingDifferenceBarrierGates(SemiFigure): + """Plots difference of both barrier gates over bias cooling voltage. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def plot(self, data, savename="Dif_barrier_gates_biascooling", shape="^", size=100, transparency=1, RT="both"): + self.ax.set_title("Difference between both Barrier Gates depending on Bias Cooling") + self.ax.set_xlabel("Bias Cooling Voltage (V)") + self.ax.set_ylabel("Difference Barriers (V)") + for cooldown in data: + if RT == "yes": + if cooldown["RT_cooldown"] == "y": + self.ax.scatter(cooldown["bias_V"], cooldown["SET_left_G5"] - cooldown["SET_left_G7"], marker=shape, s=size, alpha=transparency, color="r") + self.ax.scatter(cooldown["bias_V"], cooldown["SET_right_G15"] - cooldown["SET_right_G17"], marker=shape, s=size, alpha=transparency, color="b") + else: + self.ax.scatter(cooldown["bias_V"], cooldown["SET_left_G5"] - cooldown["SET_left_G7"], marker=shape, s=size, alpha=transparency, color="r") + self.ax.scatter(cooldown["bias_V"], cooldown["SET_right_G15"] - cooldown["SET_right_G17"], marker=shape, s=size, alpha=transparency, color="b") + + plt.grid() + red_patch = mpatches.Patch(color='red', label='left SET') + blue_patch = mpatches.Patch(color='blue', label='right SET') + plt.legend(handles=[ red_patch, blue_patch]) + plt.savefig(f"{savename}.png", dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() + + +class PlotterBiascoolingDifferenceTopgateAccumulation(SemiFigure): + """Plots difference of topgate and first accumulation voltage over bias cooling voltage. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def plot(self, data, savename="Dif_TG_accumulation_biascooling", shape="^", size=100, transparency=1, RT="both"): + self.ax.set_title("Difference between TG and Accumulation Voltage depending on Bias Cooling") + self.ax.set_xlabel("Bias Cooling Voltage (V)") + self.ax.set_ylabel("TG - firs accumulation (V)") + for cooldown in data: + if RT == "yes": + if cooldown["RT_cooldown"] == "y": + self.ax.scatter(cooldown["bias_V"], cooldown["SET_left_TG"] - cooldown["first_acc_V"], marker=shape, s=size, alpha=transparency, color="r") + self.ax.scatter(cooldown["bias_V"], cooldown["SET_right_TG"] - cooldown["first_acc_V"], marker=shape, s=size, alpha=transparency, color="b") + else: + self.ax.scatter(cooldown["bias_V"], cooldown["SET_left_TG"] - cooldown["first_acc_V"], marker=shape, s=size, alpha=transparency, color="r") + self.ax.scatter(cooldown["bias_V"], cooldown["SET_right_TG"] - cooldown["first_acc_V"], marker=shape, s=size, alpha=transparency, color="b") + + plt.grid() + red_patch = mpatches.Patch(color='red', label='left SET') + blue_patch = mpatches.Patch(color='blue', label='right SET') + plt.legend(handles=[ red_patch, blue_patch]) + plt.savefig(f"{savename}.png", dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() diff --git a/qkit/analysis/semiconductor/plotters/PlotterPlungerSweep.py b/qkit/analysis/semiconductor/plotters/PlotterPlungerSweep.py new file mode 100644 index 00000000..47d21d1c --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterPlungerSweep.py @@ -0,0 +1,41 @@ +import numpy as np +import matplotlib.pyplot as plt + + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.analysis.semiconductor.main.equalize_length import make_len_eq + + +class PlotterPlungerSweep(SemiFigure): + """Plots plunger gate sweeps and (if given) overlays tangent. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.fit_params = None + self.savename = "plunger_sweep" + self.color = "r" + self.x_limits = [] + + def plot(self, settings, settings_plunger, data_in, nodes): + data = make_len_eq(data_in, nodes) + y_axis_factor = 1000 #scales y axis to mV + self.ax.set_title("Plunger Gate Sweep") + self.ax.set_xlabel("Voltage (V)") + self.ax.set_ylabel("Lock-in Voltage (mV)") + self.data_x = data[nodes[0]] + self.data_y = data[nodes[1]]*y_axis_factor + if len(self.x_limits) == 2: + self.ax.set_xlim(self.x_limits) + self.ax.plot(self.data_x, self.data_y) + if self.fit_params != None: + poly1d_fn = np.poly1d(self.fit_params["fit_coef"]) + self.data_x_fit = self.data_x[self.fit_params["index_begin"] : self.fit_params["index_end"]] + self.ax.plot(self.data_x_fit, poly1d_fn(self.data_x_fit)*y_axis_factor, self.color, + label=f"slope: {self.fit_params['fit_coef'][0]*y_axis_factor:.0f} mV/V") + self.ax.legend() + plt.savefig(create_saving_path(settings_plunger, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/plotters/PlotterPlungerTimetrace3D.py b/qkit/analysis/semiconductor/plotters/PlotterPlungerTimetrace3D.py new file mode 100644 index 00000000..6c648524 --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterPlungerTimetrace3D.py @@ -0,0 +1,52 @@ +import numpy as np +import matplotlib.pyplot as plt +from matplotlib.colors import BoundaryNorm +from matplotlib.ticker import MaxNLocator + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.analysis.semiconductor.main.conversion_lockin_conductance import convert_conductance +from qkit.analysis.semiconductor.main.time_conversion import convert_secs_2D + + +class PlotterPlungerTimetrace3D(SemiFigure): + """Plots 3D data of plunger gate sweeps. + """ + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.colorcode = "viridis" + self.savename = "plunger_timetrace" + self.min_cond = None + self.max_cond = None + self.point_size = 3 + self.marker_shape = "ro" + + + def plot(self, settings:dict, data:dict, nodes): + """Nodes in format [timestamps, plunger_gate, R]. + good color codes might be viridis, PiYG, plasma, gist_rainbow... + """ + data_z = np.transpose(convert_conductance(data[nodes[2]], settings, 1e6)) + data_time = convert_secs_2D(data[nodes[0]])/3600 + plt.xlabel("Time (h)", fontsize=12) + plt.ylabel("Voltage plunger gate (V)", fontsize=12) + if self.min_cond is None: + min = data_z.min() + else: + min = self.min_cond + if self.max_cond is None: + max = data_z.max() + else: + max = self.max_cond + levels = MaxNLocator(nbins=100).tick_values(min, max) + cmap = plt.get_cmap(self.colorcode) + norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True) + plt.pcolormesh(data_time, data[nodes[1]], data_z, cmap=cmap, norm=norm) + plt.colorbar(label='Conductance ($\mu$S)') + + if "peaks_plunger_V" in data: # plotting fit + plt.plot(data_time, data["peaks_plunger_V"], self.marker_shape, markersize=self.point_size) + + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/plotters/PlotterPlungerTraceFit.py b/qkit/analysis/semiconductor/plotters/PlotterPlungerTraceFit.py new file mode 100644 index 00000000..839afbd0 --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterPlungerTraceFit.py @@ -0,0 +1,42 @@ +import numpy as np +import matplotlib.pyplot as plt + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path + + +class PlotterPlungerTraceFit(SemiFigure): + """Plots a single plunger gate sweep trace and overlays the analyzed fit to see how shitty the fit is. + The sechans function uses as x values not voltages but indices of the voltages of the plunger gate array. + """ + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.plot_fit = True + self.savename = "one_plunger_fit" + self.trace_num = 0 + + def plot(self, settings:dict, data:dict, nodes): + def sech(x, a, b, c, d): + '''hyperbolic secans function''' + return a * (1 / np.cosh(b * (x - c))) + d + + self.ax.set_title("One Plunger Sweep") + self.ax.set_xlabel("Plunger Voltage (V)") + self.ax.set_ylabel("Lock-in (mV)") + + self.ax.plot(data[nodes[0]], data[nodes[1]][self.trace_num]*1000,"+" ,markersize = 1) + + if self.plot_fit: + #plotting the fit only in the used intervall + fit_peak_index = int(round(data["peaks_fit_popts"][self.trace_num][2])) # value of c in sech(x, *[a, b, c, d]) as an INDEX of the array + fit_intervall_half_index = data["peaks_fit_intervall_half"] + fit_x_indices = np.arange(fit_peak_index - fit_intervall_half_index, fit_peak_index + fit_intervall_half_index+1) + fit_x = data[nodes[0]][fit_x_indices[0] : fit_x_indices[-1]+1] + fit_y = 1000 * sech(fit_x_indices, *data["peaks_fit_popts"][self.trace_num]) + self.ax.plot(fit_x, fit_y, "r", label="fit") + + + plt.legend() + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/plotters/PlotterPlungerTraceTimestampsDifference.py b/qkit/analysis/semiconductor/plotters/PlotterPlungerTraceTimestampsDifference.py new file mode 100644 index 00000000..f0eb0446 --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterPlungerTraceTimestampsDifference.py @@ -0,0 +1,25 @@ +import numpy as np +import matplotlib.pyplot as plt + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path + + +class PlotterPlungerTraceTimestampsDifference(SemiFigure): + """Plots the time difference between consecutive plunger traces. + """ + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.savename = "timestamps_diff" + + def plot(self, settings, data ): + self.ax.set_title("Length of Plunger Sweeps") + self.ax.set_xlabel("Sweep Number") + self.ax.set_ylabel("Difference between Sweeps (s)") + x_vals = np.arange(1, len(data["timestamps_diff"])+1) + self.ax.plot(x_vals, data["timestamps_diff"]) + self.ax.plot(x_vals, [data["avg_sweep_time"]]*len(x_vals), "-r", label="average") + plt.legend() + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/plotters/PlotterTest.py b/qkit/analysis/semiconductor/plotters/PlotterTest.py new file mode 100644 index 00000000..273c6844 --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterTest.py @@ -0,0 +1,30 @@ +import matplotlib.pyplot as plt + +from itertools import cycle +from qkit.analysis.semiconductor.main.interfaces import PlotterInterface + +class Plotter(PlotterInterface): + def __init__(self) -> None: + self.cycler = cycle("rgb") + self.figure = plt.Figure() + self.figure.subplots() + self.ax = self.figure.gca() + self.mode = 0 + + def load_data(self, data): + self.data_analyzed = data + print(f"Data is in plotter: {self.data_analyzed['x']}") + + def validate_input(self): + if "x" not in self.data_analyzed.keys(): + raise KeyError + if "y" not in self.data_analyzed.keys(): + raise KeyError + + def plot(self): + x = self.data_analyzed["x"] + if self.mode: + y = self.data_analyzed["x"] **4 + else: + y = self.data_analyzed["y"] + self.ax.plot(x, y, next(self.cycler)) \ No newline at end of file diff --git a/qkit/analysis/semiconductor/plotters/PlotterTimetrace.py b/qkit/analysis/semiconductor/plotters/PlotterTimetrace.py new file mode 100644 index 00000000..dc2a56fa --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterTimetrace.py @@ -0,0 +1,30 @@ +import matplotlib.pyplot as plt + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.analysis.semiconductor.main.time_conversion import convert_secs +from qkit.analysis.semiconductor.main.equalize_length import make_len_eq + + +class PlotterTimetrace(SemiFigure): + """Plots a timetrace of the lock-in amplitude over time. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.savename = "timetrace" + self.label = "-" + self.title = "Timetrace" + self.jumbo_data = True + + def plot(self, settings, data_in, nodes): + """nodes are time and x,y,R of lock-in like ["demod0.timestamp0", "demod0.x0"]. + """ + data = make_len_eq(data_in, nodes) + self.ax.set_title(self.title) + self.ax.set_xlabel("Time (s)") + self.ax.set_ylabel("Lock-in R (mV)") + self.ax.plot(convert_secs(data[nodes[0]]), data[nodes[1]]*1000, self.label) + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/plotters/PlotterTimetraceConductance.py b/qkit/analysis/semiconductor/plotters/PlotterTimetraceConductance.py new file mode 100644 index 00000000..c2d3102c --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterTimetraceConductance.py @@ -0,0 +1,31 @@ +import matplotlib.pyplot as plt + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.analysis.semiconductor.main.conversion_lockin_conductance import convert_conductance +from qkit.analysis.semiconductor.main.equalize_length import make_len_eq +from qkit.analysis.semiconductor.main.time_conversion import convert_secs + + +class PlotterTimetraceConductance(SemiFigure): + """Plots a timetrace of the conductance over time. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.savename = "timetrace" + self.label = "-" + self.title = "Timetrace" + self.jumbo_data = True + + def plot(self, settings, data_in, nodes): + """nodes are time and x,y,R of lock-in like ["demod0.timestamp0", "demod0.x0"]. + """ + data = make_len_eq(data_in, nodes) + self.ax.set_title(self.title) + self.ax.set_xlabel("Time (s)") + self.ax.set_ylabel("Conductance ($\mu$S)") + self.ax.plot(convert_secs(data[nodes[0]]), convert_conductance(data[nodes[1]], settings, multiplier=1e6), self.label) + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/plotters/PlotterTimetraceJumpsHistogram.py b/qkit/analysis/semiconductor/plotters/PlotterTimetraceJumpsHistogram.py new file mode 100644 index 00000000..28b3091b --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterTimetraceJumpsHistogram.py @@ -0,0 +1,47 @@ +import numpy as np +import matplotlib.pyplot as plt +from scipy.optimize import curve_fit + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.analysis.semiconductor.main.fit_functions import gauss_function + + +class PlotterTimetraceJumpsHistogram(SemiFigure): + """Plots a Histogramm of the amount of Jumps in a Timetrace analyzed with AnalyzerTimetraceJumps. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.savename = "Jumps_Histogram" + self.label = "-" + self.title = "Jumps Histogram" + self.marker_size = 5 + self.init_guess_0 = [20, 0, 0.2] # inital guess for a and sigma for a gauss around x=0 + + + def plot(self, settings, hist): + """hist is the output of AnalyzerTimetraceJumps. + """ + self.title = self.title + f" ({hist['time_analyzed']/3600:.1f} hours)" + self.ax.set_title(self.title) + self.ax.set_xlabel("Jump value (mV)") + self.ax.set_ylabel("Count") + + data_x = np.array(1e3 * hist["jump_height"][:-1], dtype=np.float32) + data_y = hist["jumps_per_bin"] + + self.ax.plot(data_x, data_y, "-ok", markersize=self.marker_size) + + popt, pcov = curve_fit(gauss_function, data_x, data_y) + x_linspace = np.linspace(data_x[0], data_x[-1], num = 1000) + self.ax.plot(x_linspace, gauss_function(x_linspace, *popt), label=f"Gaussian fit\nsigma : {abs(popt[2]):.3f} mV") + self.ax.legend() + self.popt = popt + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + + # counting jumps bigger than 3 sigma: + + + self.close_delete() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/plotters/PlotterTimetracePeakTrackingSND.py b/qkit/analysis/semiconductor/plotters/PlotterTimetracePeakTrackingSND.py new file mode 100644 index 00000000..c283d17c --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterTimetracePeakTrackingSND.py @@ -0,0 +1,86 @@ +import numpy as np +import matplotlib.pyplot as plt + + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.analysis.semiconductor.main.find_index_of_value import map_array_to_index + + +class PlotterTimetracePeakTrackingSND(SemiFigure): + """Plots the spectral noise density using the equivalent gate voltage found in fit_params['fit_coef'][0] if provided. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.fit_params_plunger = None + self.fit_vals = None + self.savename = None + self.xlim = None + self.ylim = None + self.dotsize = 0.5 + self.fiftyHz = False + self.legend_loc = "lower left" + + + def plot(self, settings:dict, data:dict, data_peak_tracking): + """Plots the sqrt of a spectrum (data["spectrogram"]). Respecting scaling with the slope of a plunger gate sweep (fit_params_plunger). + data: spectral data in dictionary with keys "freq", "times", "spectorgram" + data_peak_tracking: spectral data of a peak tracking that won't need division by equivalent gate voltage + fit_params_plunger: dict including key "fit_coef" + fit_vals: dict with keys "popt" and "SND1Hz" that is used to plot a linear fit to the data + fifyHz: bool that overlays the first 30 50Hz multiples + """ + self.ax.set_title("Power Spectral Noise Density") + self.ax.set_xscale("log") + self.ax.set_yscale("log") + self.ax.set_xlabel("Frequency (Hz)") + self.ax.set_ylabel("PSD (V²/Hz)") + if self.xlim != None: + self.ax.set_xlim(self.xlim) + if self.ylim != None: + self.ax.set_ylim(self.ylim) + if self.fit_params_plunger is None: # for reference measurements without plunger gate sweeps the slope is 1 + fit_params_plunger = {} + fit_params_plunger["fit_coef"] = [1] + else: + fit_params_plunger = self.fit_params_plunger + + plunger_calib = fit_params_plunger['fit_coef'][0] + + if self.savename == None: + self.savename = f"PSD_slope_{plunger_calib:.3f}" + + if self.fiftyHz == True: # plotting 50Hz multiples + self.savename += "_50Hz" + freqs = [] + signals = [] + for f in [i*50 for i in range(6)]: + freqs.extend([f]*1000 ) + signals.extend(np.logspace(-11, -4, 1000)) + self.ax.plot(freqs, signals, "yo", markersize=self.dotsize) + + + + self.ax.plot(data_peak_tracking["freq"], data_peak_tracking["spectrogram"], "or", markersize=self.dotsize, label="peak tracking") + self.ax.plot(data["freq"], data["spectrogram"] / plunger_calib, "ok", markersize=self.dotsize, label="timetrace") + + if self.fit_vals is not None: + def func(x, a, b): + return a * np.power(x, b) + index_begin = map_array_to_index(data["freq"], 1e-1) + index_end = map_array_to_index(data["freq"], 1e1) + freqs = data["freq"][index_begin : index_end] + SND_1Hz = func([1], *self.fit_vals["popt"]) / np.abs(plunger_calib) + exponent_1Hz = self.fit_vals["popt"][1] + text = f"PSD(1Hz): {1e9 * SND_1Hz[0]:.1f} " + "nV²/Hz" + text = text + f"\nexponent(1Hz) : {exponent_1Hz:.3f} " + fit_spectrum = func(freqs, *self.fit_vals["popt"]) / np.abs(plunger_calib) + self.ax.plot(freqs, fit_spectrum, label=text) + self.ax.legend(loc="lower left") + + plt.grid() + plt.legend(loc=self.legend_loc) + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() diff --git a/qkit/analysis/semiconductor/plotters/PlotterTimetracePhase.py b/qkit/analysis/semiconductor/plotters/PlotterTimetracePhase.py new file mode 100644 index 00000000..35a78a2c --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterTimetracePhase.py @@ -0,0 +1,38 @@ +import numpy as np +import matplotlib.pyplot as plt + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.analysis.semiconductor.main.time_conversion import convert_secs +from qkit.analysis.semiconductor.main.equalize_length import make_len_eq + + +class PlotterTimetracePhase(SemiFigure): + """Plots the phase of the conductance of a timetrace over time. + phi = np.arctan2(data_y, data_x) + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.savename = "timetrace_phase" + self.label = "-" + self.x_limits = [] + self.y_limits = [] + self.jumbo_data = True + + def plot(self, settings, data_in, nodes): + """nodes are t, x, y of lock-in like ["demod0.timestamp0", "demod0.x0", "demod0.y0"]. + """ + data = make_len_eq(data_in, nodes) + if len(self.x_limits) == 2: + self.ax.set_xlim(self.x_limits) + if len(self.y_limits) == 2: + self.ax.set_ylim(self.y_limits) + self.ax.set_title("Timetrace") + self.ax.set_xlabel("Time (s)") + self.ax.set_ylabel("Phase (deg)") + self.phase = np.arctan2(data[nodes[2]], data[nodes[1]]) * 180 / np.pi + self.ax.plot(convert_secs(data[nodes[0]]), self.phase, self.label) + plt.savefig(create_saving_path(settings, self.savename, self.save_as), dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/plotters/PlotterTimetraceSpectralNoiseDensity.py b/qkit/analysis/semiconductor/plotters/PlotterTimetraceSpectralNoiseDensity.py new file mode 100644 index 00000000..3f4f5264 --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/PlotterTimetraceSpectralNoiseDensity.py @@ -0,0 +1,138 @@ +import numpy as np +import matplotlib.pyplot as plt + +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.analysis.semiconductor.main.find_index_of_value import map_array_to_index + +def func_power(x, a, b): + return b * x ** a +def func_power2(x, *params): + if len(params) == 2: + return params[1] * x ** params[0] + else: + part1 = params[1] * x[x <= params[3]] ** params[0] + part2 = params[1]/(params[3] ** (params[2]-params[0])) * x[x > params[3]] ** params[2] + return np.concatenate((part1, part2)) + +class PlotterTimetraceSpectralNoiseDensity(SemiFigure): + """Plots the spectral noise density using the equivalent gate voltage found in fit_params['fit_coef'][0] if provided. + """ + + def __init__(self, saving_path, spectrogram, fit = {"popt": [], "fit_range" : []}, *args, **kwargs): + super().__init__(*args, **kwargs) + self.fit_params_plunger = None + self.fit_vals = None + self.savename = "" + self.xlim = None + self.ylim = None + self.dotsize = 0.5 + self.fiftyHz = False + self.alpha = 1.0 # Transparency of plotted line + + + self.spectrogram = spectrogram + self.fit = fit + self.saving_path = saving_path + + self.ax.set_title("Power Spectral Noise Density") + self.ax.set_xscale("log") + self.ax.set_yscale("log") + self.ax.set_xlabel("Frequency (Hz)") + self.ax.set_ylabel("PSD (V²/Hz)") + + @property + def spectrogram(self): + return self._spectrogram + @spectrogram.setter + def spectrogram(self, new_spec): + if len(new_spec) != 2: + raise TypeError(f"{__name__}: Invalid spectrogram data. Must be of form [freqs, spectrum].") + if len(new_spec[0]) != len(new_spec[1]): + raise TypeError(f"{__name__}: Invalid spectrogram data. Freqs and spectrum have to be arrays of same length.") + self._spectrogram = new_spec + + @property + def fit(self): + return self._fit + @fit.setter + def fit(self, new_pars): + if not isinstance(new_pars, dict): + raise TypeError(f"{__name__}: Invalid fit data. Must be a dictionary containing keys 'popt' and 'fit_range'.") + if not "popt" in new_pars.keys() or not "fit_range" in new_pars.keys(): + raise TypeError(f"{__name__}: Invalid fit data. Must be a dictionary containing keys 'popt' and 'fit_range'.") + self._fit = new_pars + + def _plot_50Hz_multiples(self): + self.savename += "_50Hz" + freqs = [] + signals = [] + for f in [i*50 for i in range(6)]: + freqs.extend([f]*1000 ) + signals.extend(np.logspace(-11, -4, 1000)) + self.ax.plot(freqs, signals, "yo", markersize=self.dotsize) + + def _plot_fit(self): + index_begin = map_array_to_index(self.spectrogram[0], self.fit["fit_range"][0]) + index_end = map_array_to_index(self.spectrogram[0], self.fit["fit_range"][1]) + freqs = self.spectrogram[0][index_begin : index_end] + + SND_1Hz = float(func_power2(np.array([1]), *self.fit["popt"]) / (self.plunger_calib)**2) + exponent_1Hz = self.fit["popt"][-2] + text = f"PSD(1Hz) : {1e9 * SND_1Hz:.1f} * e-9 V²/Hz" + text = text + f"\nexponent(1Hz) : {exponent_1Hz:.3f} " + fit_spectrum = func_power2(freqs, *self.fit["popt"]) / (self.plunger_calib)**2 + self.ax.plot(freqs, fit_spectrum, label=text, alpha=self.alpha) + self.ax.legend(loc="lower left") + + def _plot_error(self): + + index_begin = map_array_to_index(self.spectrogram[0], self.fit["fit_range"][0]) + index_end = map_array_to_index(self.spectrogram[0], self.fit["fit_range"][1]) + freqs = self.spectrogram[0][index_begin : index_end] + + bound_upper = func_power2(freqs, *(self.fit["popt"] + self.fit["sigma"])) + bound_lower = func_power2(freqs, *(self.fit["popt"] - self.fit["sigma"])) + # plotting the confidence intervals + self.ax.fill_between(freqs, bound_lower, bound_upper, + color = 'black', alpha = 0.15) + + def plot(self, save = True): + """Plots the sqrt of a spectrum (data["spectrogram"]). Respecting scaling with the slope of a plunger gate sweep (fit_params_plunger). + data: spectral data in dictionary with keys "freq", "times", "spectorgram" + fit_params_plunger_in: dict including key "fit_coef" + fit_vals: dict with keys "popt" and "SND1Hz" that is used to plot a linear fit to the data + fifyHz: bool that overlays the first 30 50Hz multiples. + """ + if self.xlim: + self.ax.set_xlim(self.xlim) + if self.ylim: + self.ax.set_ylim(self.ylim) + if not self.fit_params_plunger: # for reference measurements without plunger gate sweeps the slope is 1 + fit_params_plunger = {"fit_coef" : [1]} + else: + fit_params_plunger = self.fit_params_plunger + + self.plunger_calib = fit_params_plunger['fit_coef'][0] + + if not self.savename: + self.savename = f"PSD_slope_{self.plunger_calib:.3f}" + if self.fiftyHz: # plotting 50Hz multiples + self._plot_50Hz_multiples() + + self.ax.plot(self.spectrogram[0], self.spectrogram[1] / (self.plunger_calib)**2, "ok", markersize=self.dotsize) + + if self.fit["popt"].any() and self.fit["fit_range"]: + '''self.fit_vals are the parameters of f(x)=a*x+b to the data_x=log10(freqencies), data_y=log10(PSD) + so plotting of f_power(x)=b'*x**a' leads to + b' = 10^b + a'= a + ''' + self._plot_fit() + #self._plot_error() + + plt.grid() + if save: + plt.savefig(f"{self.saving_path}.png", dpi=self.set_dpi, bbox_inches=self.set_bbox_inches) + plt.show() + self.close_delete() diff --git a/qkit/analysis/semiconductor/plotters/plotterPeakTrack.py b/qkit/analysis/semiconductor/plotters/plotterPeakTrack.py new file mode 100644 index 00000000..35fb8cb6 --- /dev/null +++ b/qkit/analysis/semiconductor/plotters/plotterPeakTrack.py @@ -0,0 +1,76 @@ +from typing import Any, Dict + +import numpy as np +from qkit.analysis.semiconductor.main.interfaces import PlotterInterface +from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure + + +class Plotter(PlotterInterface): + def __init__(self): + super().__init__() + self.figure = SemiFigure() + self.ax = self.figure.ax + self.plot_index = 0 + self.data_analyzed = {} + self.node_to_plot = "demod0.r0" + + def load_data(self, data: Dict[str, Any]): + self.data_analyzed = data + + def validate_input(self): + for file in self.data_analyzed.values(): + keys = file.keys() + missing_entries = "" + + if self.node_to_plot not in keys: + missing_entries += self.node_to_plot + if "peak_positions" not in keys: + missing_entries += "\npeak_pos" + if "gates_6_16" not in keys: + missing_entries += "\ngates_6_16" + if "number" not in keys: + missing_entries += "\nnumber" + + if missing_entries: + raise TypeError( + f"{__name__}: Invalid input data. The following nodes are missing: {missing_entries}" + ) + + def plot_measurement(self): + for file in self.data_analyzed.values(): + (x_len, y_len) = np.shape(file[self.node_to_plot]) + self.ax.pcolor( + file["number"][:x_len], + file["gates_6_16"][:y_len], + np.transpose(file[self.node_to_plot]), + ) + + def plot_peaks(self): + for file in self.data_analyzed.values(): + self.ax.scatter( + file["peak_positions"]["x"], file["peak_positions"]["y"], s=0.5, c="r" + ) + + def plot_peak_1D(self): + for file in self.data_analyzed.values(): + self.ax.plot(file["gates_6_16"], file[self.node_to_plot][self.plot_index]) + self.ax.scatter( + file["peak_positions"]["y"][self.plot_index], + file[self.node_to_plot][self.plot_index][ + file["peak_positions"]["index"][self.plot_index] + ], + ) + + def plot(self): + self.plot_measurement() + self.plot_peaks() + # self.plot_peak_1D() + + +def main(): + plotter = Plotter() + plotter.plot() + + +if __name__ == "__main__": + pass diff --git a/qkit/analysis/semiconductor/savers/SaverPickle.py b/qkit/analysis/semiconductor/savers/SaverPickle.py new file mode 100644 index 00000000..07c44e57 --- /dev/null +++ b/qkit/analysis/semiconductor/savers/SaverPickle.py @@ -0,0 +1,11 @@ +import pickle + +class SaverPickle: + """Saves data to Pickle. + """ + def save(self, settings, data): + path = f"{settings['file_info']['absolute_path']}{settings['file_info']['date_stamp']}/{settings['file_info']['filename']}/data_pickle" + file = open(path, "wb") + pickle.dump(data, file, pickle.HIGHEST_PROTOCOL) + file.close() + diff --git a/qkit/analysis/semiconductor/savers/SaverSamba.py b/qkit/analysis/semiconductor/savers/SaverSamba.py new file mode 100644 index 00000000..c6fbb10a --- /dev/null +++ b/qkit/analysis/semiconductor/savers/SaverSamba.py @@ -0,0 +1,10 @@ +import urllib +from smb.SMBHandler import SMBHandler # pip install pysmb + +class SaverSamba: + """Saves data to Pickle with a samba smb:// filepath. + """ + def save(self, filepath, data_in): + director = urllib.request.build_opener(SMBHandler) + fh = director.open(filepath, data=data_in) + fh.close() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/savers/Saver_json.py b/qkit/analysis/semiconductor/savers/Saver_json.py new file mode 100644 index 00000000..de59af8d --- /dev/null +++ b/qkit/analysis/semiconductor/savers/Saver_json.py @@ -0,0 +1,96 @@ +import os +import json +import collections.abc +from qkit.analysis.semiconductor.main.saving import create_saving_path +from qkit.measure.json_handler import QkitJSONEncoder, QkitJSONDecoder + +def update(d, u): + for k, v in u.items(): + if isinstance(v, collections.abc.Mapping): + d[k] = update(d.get(k, {}), v) + else: + d[k] = v + return d + +class Saver_json(): + """Saves data in a folder that is set by "save_path". + """ + def __init__(self, save_path) -> None: + self.additional_info = {} + self.fname = "analyzed_data" + self.saving_path = save_path + self.single_file = True + self.append_to_file = True + + def add_info(self, fname, info): + new_info = {fname : info} + update(self.additional_info, new_info) + + def remove_info(self, fname): + self.additional_info.pop(fname, None) + + def _overwrite(self, fpath, data): + #full_path = os.path.join(self.saving_path, fname + ".json") + with open(fpath, "w") as file: + json.dump(data, file, cls = QkitJSONEncoder, indent = 4) + + def _append(self, fpath, data): + #full_path = os.path.join(self.saving_path, fname + ".json") + with open(fpath, "r") as file: + data_total= json.load(file, cls = QkitJSONDecoder) + update(data_total, data) + with open(fpath, "w") as file: + json.dump(data_total, file, cls = QkitJSONEncoder, indent = 4) + + def _save(self, fname, data): + if not os.path.exists(self.saving_path): + os.makedirs(self.saving_path) + full_path = os.path.join(self.saving_path, fname + ".json") + file_exists = os.path.isfile(full_path) + file_has_content = False + if file_exists: + file_has_content = os.stat(full_path).st_size != 0 + + if file_has_content and self.append_to_file: + return self._append(full_path, data) + if not file_exists: + return self._overwrite(full_path, data) + if not self.append_to_file: + return self._overwrite(full_path, data) + + def save(self): + if self.single_file: + self._save(self.fname, self.additional_info) + else: + for fname, info in self.additional_info.items(): + self._save(fname, info) + +if __name__ == "__main__": + import numpy as np + settings = {"file_info" : { + "absolute_path" : "/home/ws/lr1740/Dokumente/Doktorarbeit/Messungen/SAVERTEST", + "filetype" : ".h5", + "date_stamp" : "20220216", + "filename" : "bananaasd", + "savepath" : "analysis/", + "analysis" : "noise_timetrace"}, + "meas_params" : { + "measurement_amp" : 100e-3, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3} + } + a = np.int64(10) + b = complex(1,2) + # + + print(type(b)) + print(b) + print(type(a)) + if type(a) == np.integer: + print("Yass") + data = {"ads" : [12,3], "das" : a} + plunger = {'fit_coef': np.array([-2.87297491, 2.60734095]), 'index_begin': 158, 'index_end': 204} + saver = Saver_json(settings) + saver.add_info("data", data) + saver.save() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/savers/Saver_pickle.py b/qkit/analysis/semiconductor/savers/Saver_pickle.py new file mode 100644 index 00000000..1cac281a --- /dev/null +++ b/qkit/analysis/semiconductor/savers/Saver_pickle.py @@ -0,0 +1,63 @@ +import os +import pickle +from qkit.analysis.semiconductor.main.saving import create_saving_path + +class Saver_pickle(): + """Saves data in a folder that is set by "settings". + """ + def __init__(self, settings:dict) -> None: + self.settings = settings + self.additional_info = {} + self.saving_path = os.path.join(settings["file_info"]["absolute_path"], + settings["file_info"]["date_stamp"], + settings["file_info"]["filename"]) + self.single_file = True + + def add_info(self, fname, info): + self.additional_info[fname] = info + + def remove_info(self, fname): + self.additional_info.pop(fname, None) + + def _save(self, fname, data): + full_path = os.path.join(self.saving_path, fname + ".p") + with open(full_path, "wb") as file: + pickle.dump(data, file, pickle.HIGHEST_PROTOCOL) + + def save(self): + if self.single_file: + fname = f'{self.settings["file_info"]["filename"]}_pickle' + self._save(fname, self.additional_info) + else: + for fname, info in self.additional_info.items(): + self._save(fname, info) + +if __name__ == "__main__": + import numpy as np + settings = {"file_info" : { + "absolute_path" : "/home/ws/lr1740/Dokumente/Doktorarbeit/Messungen/SAVERTEST", + "filetype" : ".h5", + "date_stamp" : "20220216", + "filename" : "bananaasd", + "savepath" : "", + "analysis" : "noise_timetrace"}, + "meas_params" : { + "measurement_amp" : 100e-3, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3} + } + a = np.int64(10) + b = complex(1,2) + # + + print(type(b)) + print(b) + print(type(a)) + if type(a) == np.integer: + print("Yass") + data = {"ads" : [12,3], "das" : a} + plunger = {'fit_coef': np.array([-2.87297491, 2.60734095]), 'index_begin': 158, 'index_end': 204} + saver = Saver_pickle(settings) + saver.add_info("data", data) + saver.save() \ No newline at end of file diff --git a/qkit/analysis/semiconductor/savers/Saver_spectrum_np.py b/qkit/analysis/semiconductor/savers/Saver_spectrum_np.py new file mode 100644 index 00000000..36d41ef5 --- /dev/null +++ b/qkit/analysis/semiconductor/savers/Saver_spectrum_np.py @@ -0,0 +1,14 @@ +import numpy as np +from qkit.analysis.semiconductor.main.saving import create_saving_path + +class Saver_spectrum_np(): + """Saves data in a folder that is set by "settings". + """ + def save(self, settings:dict, data:dict, fit_params_plunger=None, power_fit_params=None, ending=""): + np.savetxt(create_saving_path(settings, "frequency_data"+ending, filetype=".txt"), data["freq"]) + np.savetxt(create_saving_path(settings, "spectrum_data"+ending, filetype=".txt"), data["spectrogram"]) + if fit_params_plunger != None: + np.savetxt(create_saving_path(settings, "plunger_fit_data"+ending, filetype=".txt"), fit_params_plunger['fit_coef']) + if power_fit_params != None: + np.savetxt(create_saving_path(settings, "power_fit_data"+ending, filetype=".txt"), power_fit_params['popt']) + diff --git a/qkit/analysis/semiconductor/scripts/Excel_plots.py b/qkit/analysis/semiconductor/scripts/Excel_plots.py new file mode 100644 index 00000000..693c9f9d --- /dev/null +++ b/qkit/analysis/semiconductor/scripts/Excel_plots.py @@ -0,0 +1,82 @@ +#%% +from qkit.analysis.semiconductor.loaders.LoaderExcel import LoaderExcel +from qkit.analysis.semiconductor.plotters.PlotterBiascoolingAccumulation import PlotterBiascoolingAccumulation, PlotterBiascoolingAccumulationColors +from qkit.analysis.semiconductor.plotters.PlotterExcel import PlotterBiascoolingDifferenceBarrierGates, PlotterBiascoolingDifferenceTopgateGates, PlotterBiascoolingMinimalTopgate, PlotterBiascoolingDifferenceTopgateBarriers, PlotterBiascoolingDifferenceTopgateAccumulation + + +#%% +path = "/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Data_overview_P35_B1.xlsx" +ignored_rows = 4 +sample_name = "P35_B1" +loader = LoaderExcel() +data_B1 = loader.load(path, ignored_rows, sample_name) + + +#%% +path = "/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Data_overview_P35_B4.xlsx" +ignored_rows = 4 +sample_name = "P35_B4" +loader = LoaderExcel() +data_B4 = loader.load(path, ignored_rows, sample_name) + + +#%% +path = "/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Data_overview_P35_B3.xlsx" +ignored_rows = 4 +sample_name = "P35_B3" +loader = LoaderExcel() +data_B3 = loader.load(path, ignored_rows, sample_name) + + + + +#%% +data = dict(**data_B1, **data_B4, **data_B3) + +#plotter = PlotterBiascoolingAccumulation() +plotter = PlotterBiascoolingAccumulationColors() +plotter.cooldown_perfect = True +plotter.shape = "*" +plotter.size = 200 +plotter.transparency = 1 +plotter.plot(data) + + + + + + + + + + + +##################################################### + +#%% +plotter = PlotterBiascoolingMinimalTopgate() +plotter.plot(data, shape="*", size=300, transparency=0.8, RT=room_temp_cooldown) + + +#%% +plotter = PlotterBiascoolingDifferenceTopgateGates() +plotter.plot(data, shape="*", size=300, transparency=0.8, RT=room_temp_cooldown) + + +#%% +plotter = PlotterBiascoolingDifferenceBarrierGates() +plotter.plot(data, shape="*", size=300, transparency=0.8, RT=room_temp_cooldown) + + +# %% +plotter = PlotterBiascoolingDifferenceTopgateBarriers() +plotter.plot(data, shape="*", size=300, transparency=0.8, RT=room_temp_cooldown) + + + +# %% +plotter = PlotterBiascoolingDifferenceTopgateAccumulation() +plotter.plot(data, shape="*", size=300, transparency=0.8, RT=room_temp_cooldown) +# %% + +# %% diff --git a/qkit/analysis/semiconductor/scripts/Peaktacking_postanalysis.ipynb b/qkit/analysis/semiconductor/scripts/Peaktacking_postanalysis.ipynb new file mode 100644 index 00000000..16da569a --- /dev/null +++ b/qkit/analysis/semiconductor/scripts/Peaktacking_postanalysis.ipynb @@ -0,0 +1,3695 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T10:04:01.330308Z", + "start_time": "2022-09-15T10:04:01.315513Z" + }, + "init_cell": true + }, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T10:04:06.636226Z", + "start_time": "2022-09-15T10:04:01.332361Z" + }, + "init_cell": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QKIT configuration initialized -> available as qkit.cfg[...]\n" + ] + } + ], + "source": [ + "from qkit.analysis.semiconductor.loaders.Loaderh5 import Loaderh5\n", + "from qkit.analysis.semiconductor.analyzers.AnalyzerTimetraceSpectralNoiseDensity import AnalyzerTimetraceSpectralNoiseDensity\n", + "from qkit.analysis.semiconductor.plotters.PlotterTimetraceSpectralNoiseDensity import PlotterTimetraceSpectralNoiseDensity\n", + "from qkit.analysis.semiconductor.analyzers.AnalyzerPeakTracker_Daniel import AnalyzerPeakTracker\n", + "from qkit.analysis.semiconductor.plotters.PlotterPlungerTimetrace3D import PlotterPlungerTimetrace3D\n", + "from qkit.analysis.semiconductor.plotters.PlotterPlungerTraceFit import PlotterPlungerTraceFit\n", + "from qkit.analysis.semiconductor.plotters.PlotterPlungerTraceTimestampsDifference import PlotterPlungerTraceTimestampsDifference\n", + "from qkit.analysis.semiconductor.plotters.PlotterTimetraceJumpsHistogram import PlotterTimetraceJumpsHistogram\n", + "from qkit.analysis.semiconductor.main.SlicerPlungerTimetrace import SlicerPlungerTimetrace\n", + "from qkit.analysis.semiconductor.loaders.Loader_spectrum_np import Loader_spectrum_np\n", + "from qkit.analysis.semiconductor.savers.Saver_spectrum_np import Saver_spectrum_np\n", + "from qkit.analysis.semiconductor.savers.Saver_json import Saver_json\n", + "from qkit.analysis.semiconductor.main.pre_formatted_figures import SemiFigure\n", + "from qkit.analysis.semiconductor.loaders.LoaderJSON import LoaderJSON\n", + "\n", + "\n", + "import os\n", + "import matplotlib.pyplot as plt\n", + "import pathlib\n", + "from scipy.stats import sem\n", + "from scipy import mean\n", + "\n", + "from qkit.analysis.semiconductor.analyzers.AnalyzerPeakTracker import Analyzer as Peak_hunt\n", + "from qkit.analysis.semiconductor.analyzers.AnalyzerTimetraceJumps import Analyzer as jump_count\n", + "from qkit.analysis.semiconductor.main.fit_functions import gauss_function" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T10:04:06.683218Z", + "start_time": "2022-09-15T10:04:06.641856Z" + }, + "init_cell": true + }, + "outputs": [], + "source": [ + "def linear(x, a, b):\n", + " return a * x + b\n", + "\n", + "def bilinear2(x, a, b, c, switch_point):\n", + " x = np.array(x)\n", + " part1 = a * x[x <= switch_point] + b\n", + " part2 = c * x[x > switch_point] + (a - c) * switch_point + b\n", + " return np.concatenate((part1, part2))\n", + "\n", + "def func_power2(x, *params):\n", + " x = np.array(x)\n", + " if len(params) == 2:\n", + " return params[1] * x ** params[0]\n", + " else:\n", + " part1 = params[1] * x[x <= params[3]] ** params[0]\n", + " part2 = params[1]/(params[3] ** (params[2]-params[0])) * x[x > params[3]] ** params[2]\n", + " return np.concatenate((part1, part2))\n", + "\n", + "def get_bcv(key):\n", + " return float(key.split(\"tg\")[0])\n", + "\n", + "def get_tgv(key):\n", + " return float(key.split(\"tg\")[1].split(\"vr\")[0])\n", + "\n", + "def get_vref(key):\n", + " return float(key.split(\"vr\")[1].split(\"side\")[0])\n", + "\n", + "def get_side(key):\n", + " return key.split(\"side\")[1].split(\"num\")[0]\n", + "\n", + "def extract_lowest_tgv(wanted_bcv, wanted_side, data_dict):\n", + " tgvs = []\n", + " matching_key = []\n", + " for key in data_dict.keys():\n", + " bcv = get_bcv(key)\n", + " tgv = get_tgv(key)\n", + " side = get_side(key)\n", + " if bcv == wanted_bcv and side == wanted_side:\n", + " tgvs.append(tgv)\n", + " matching_key.append(key)\n", + " \n", + " val = min(tgvs)\n", + " idx = tgvs.index(val)\n", + " return val, matching_key[idx]\n", + "\n", + "def find_nearest_idx(array, value):\n", + " array = np.asarray(array)\n", + " idx = (np.abs(array - value)).argmin()\n", + " return idx\n", + "\n", + "def remove_jumps(peak_track, jump_min_height):\n", + " difference = np.diff(peak_track)\n", + " jumps_height = difference[abs(difference) >= jump_min_height]\n", + " jumps_idx = np.flatnonzero(abs(difference) >= jump_min_height) + 1\n", + " \n", + " prev_idx = 0\n", + " jumped = 0\n", + " baseline = np.array([])\n", + " \n", + " for idx, height in zip(jumps_idx, jumps_height):\n", + " len_x = idx - prev_idx\n", + " prev_idx = idx \n", + " baseline = np.concatenate((baseline, np.full(len_x, jumped)))\n", + " jumped += height\n", + "\n", + " baseline = np.concatenate((baseline, np.full(len(peak_track) - len(baseline), jumped)))\n", + " return peak_track - baseline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Choose the Data" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T13:50:02.006736Z", + "start_time": "2022-09-15T13:49:56.804749Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Specify current bias cooling voltage in V: -0.8\n", + "Savepath: /V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/20220913/143347_2D_Peak_tracking\n" + ] + } + ], + "source": [ + "date_time_string = \"20220913/143347\"\n", + "date = date_time_string.split(\"/\")[0]\n", + "time = date_time_string.split(\"/\")[1]\n", + "filepath = f\"smb://nanospin@phi-ndus/o/data/{date}/{time}_2D_Peak_tracking/{time}_2D_Peak_tracking.h5\"\n", + "savepath = os.path.join(\"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\",\n", + " str(pathlib.Path(filepath).parents[1]).split(\"/\")[-1],\n", + " str(pathlib.Path(filepath).parents[0]).split(\"/\")[-1])\n", + "overview_path = \"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\"\n", + "\n", + "configpath = \"/home/ws/lr1740/Dokumente/Doktorarbeit/Sonstiges/sftp_config.txt\"\n", + "\n", + "saver = Saver_json(savepath)\n", + "saver.append_to_file = True\n", + "saver_overview = Saver_json(overview_path)\n", + "bcv = input(\"Specify current bias cooling voltage in V: \")\n", + "\n", + "saver_overview.fname = \"P35B3\"\n", + "saver_overview.append_to_file = True\n", + "\n", + "print(\"Savepath: \" + savepath)\n", + "\n", + "settings = {\"file_info\" : {\n", + " \"filepath\" : filepath,\n", + " \"savepath\" : savepath,\n", + " \"analysis\" : \"plunger_sweep_timetrace\"},\n", + " \"meas_params\" : {\n", + " \"measurement_amp\" : 100e-6,\n", + " \"voltage_divider\" : 3,\n", + " \"IVgain\" : 1e8,\n", + " \"in_line_R\": 40e3},\n", + " \"authentication\" : {\n", + " \"configpath\" : configpath}\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T13:55:18.913562Z", + "start_time": "2022-09-15T13:50:03.171534Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done loading file, formatting now...\n", + "dict_keys(['demod0.r0', 'demod0.timestamp0', 'demod0.x0', 'demod0.y0', 'gate_6', 'measurement', 'number', 'settings', 'static_voltages'])\n", + "\n", + "\n", + "['{\\n \"gate10_out\": -0.42755126953125,\\n \"gate11_out\": -0.42755126953125,\\n \"gate12_out\": -0.42755126953125,\\n \"gate13_out\": -0.42755126953125,\\n \"gate14_out\": -0.42755126953125,\\n \"gate15_out\": -0.42755126953125,\\n \"gate16_out\": -0.42755126953125,\\n \"gate17_out\": -0.42755126953125,\\n \"gate18_out\": -0.42755126953125,\\n \"gate19_out\": -0.42755126953125,\\n \"gate20_out\": -0.42755126953125,\\n \"gate21_out\": -0.42755126953125,\\n \"gate22_out\": -0.42755126953125,\\n \"gate23_out\": -0.42755126953125,\\n \"gate4_out\": 1.3661,\\n \"gate5_out\": 0.9625244140625,\\n \"gate6_out\": -0.36773681640625,\\n \"gate7_out\": 1.09283447265625,\\n \"gate9_out\": -0.42755126953125\\n}']\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "Interrupted by user", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"\\n\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"static_voltages\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mvr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Specify reference voltage in V: \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mraw_input\u001b[0;34m(self, prompt)\u001b[0m\n\u001b[1;32m 846\u001b[0m \u001b[0;34m\"raw_input was called, but this frontend does not support input requests.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 847\u001b[0m )\n\u001b[0;32m--> 848\u001b[0;31m return self._input_request(str(prompt),\n\u001b[0m\u001b[1;32m 849\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_ident\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 850\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_header\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36m_input_request\u001b[0;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[1;32m 890\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 891\u001b[0m \u001b[0;31m# re-raise KeyboardInterrupt, to truncate traceback\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 892\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Interrupted by user\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 893\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 894\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarning\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Invalid Message:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexc_info\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: Interrupted by user" + ] + } + ], + "source": [ + "loader = Loaderh5()\n", + "data, _ = loader.load(settings)\n", + "print(data.keys())\n", + "print(\"\\n\")\n", + "print(data[\"static_voltages\"])\n", + "vr = input(\"Specify reference voltage in V: \")" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:14:07.386734Z", + "start_time": "2022-09-15T12:13:59.631479Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Specify side of SET (l/r): l\n", + "Specify current top gate voltage in V: 1.429\n" + ] + } + ], + "source": [ + "side = input(\"Specify side of SET (l/r): \")\n", + "tgv = input(\"Specify current top gate voltage in V: \")\n", + "while side != \"l\" and side != \"r\":\n", + " side = input(\"Specify side of SET (l/r): \")\n", + " \n", + "analysis_key = f\"{bcv}tg{tgv}vr{vr}side{side}\"\n", + "\n", + "demod_prefix = \"demod0&4\"\n", + "if side == \"l\":\n", + " demod_idx = 0\n", + "else:\n", + " demod_idx = 4\n", + " \n", + "node_timestamp = f\"{demod_prefix}.timestamp{demod_idx}\"\n", + "node_x = f\"{demod_prefix}.x{demod_idx}\"\n", + "node_y = f\"{demod_prefix}.y{demod_idx}\"\n", + "node_r = f\"{demod_prefix}.r{demod_idx}\"\n", + "\n", + "gates = \"gates_6_16\"" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:10:23.048172Z", + "start_time": "2022-09-15T12:10:23.028987Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.25tg1.927vr0.699sidel\n" + ] + } + ], + "source": [ + "print(analysis_key)" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:14:12.073034Z", + "start_time": "2022-09-15T12:14:11.035038Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotter = PlotterPlungerTimetrace3D()\n", + "plotter.max_cond = None\n", + "plotter.plot(settings, data, [node_timestamp, gates , node_r])" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:10:45.403278Z", + "start_time": "2022-09-15T12:10:45.028219Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(data[node_r][3])" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:14:15.066221Z", + "start_time": "2022-09-15T12:14:14.156597Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#%% Slice Data and Plot\n", + "slicer = SlicerPlungerTimetrace()\n", + "slicer.beginning, slicer.ending = 2.4, 4 # in hours\n", + "data_sliced = slicer.slice(data, [node_timestamp, gates , node_r])\n", + "\n", + "plotter = PlotterPlungerTimetrace3D()\n", + "plotter.max_cond = None\n", + "plotter.savename = \"plunger_timetrace_sliced\"\n", + "plotter.plot(settings, data_sliced, [node_timestamp, gates , node_r])" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-29T16:27:16.898538Z", + "start_time": "2022-07-29T16:27:15.042993Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Do you wish to continue to work with the sliced data? [y/n]y\n", + "You are now working with the sliced data\n" + ] + } + ], + "source": [ + "yeno = input(\"Do you wish to continue to work with the sliced data? [y/n]\")\n", + "if yeno == \"y\":\n", + " data_raw = data.copy()\n", + " data = data_sliced\n", + " print(\"You are now working with the sliced data\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Let the peak hunt begin!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The bloodmoon has risen over the city of Yharnam..." + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:17:06.899675Z", + "start_time": "2022-09-15T12:17:04.642593Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of tracked peaks: 2\n", + "Length of chosen peak track: 700\n", + "Length of samples: 700\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "peak_hunter = Peak_hunt(data[node_r], data[node_timestamp], data[gates])\n", + "peak_hunter.pf.min_peak_height = 0.001\n", + "peak_hunter.pf.min_peak_width = 5\n", + "peak_hunter.pf.min_peak_distance = None #Can also be None, for no min distance\n", + "peak_hunter.pf.fit_interval_peak_relheight = 0.8\n", + "peak_hunter.rel_jump_height = 2\n", + "tracked_peaks = peak_hunter.analyze()\n", + "\n", + "print(f\"Number of tracked peaks: {len(tracked_peaks['tracked_peak_positions'])}\")\n", + "index_of_peak = 0\n", + "print(f\"Length of chosen peak track: {len(tracked_peaks['tracked_peak_positions'][index_of_peak])}\")\n", + "print(f\"Length of samples: {len(data[node_r])}\")\n", + "\n", + "saver.add_info(f\"{node_r}_tracked_peaks\", tracked_peaks)\n", + "\n", + "fig, ax1 = plt.subplots()\n", + "ax1.set_title(\"Peak tracking\", fontsize = 14)\n", + "ax1.set_xlabel(\"Measurement Time (hrs)\", fontsize = 12)\n", + "ax1.set_ylabel(\"Plunger Gate Voltage (V)\", fontsize = 12)\n", + "ax1.set_axisbelow(True) # pushes grid to background\n", + "fig.set_facecolor(\"White\")\n", + "\n", + "ax1.pcolor(tracked_peaks[\"time_axis\"]/3600, data[gates], np.transpose(data[node_r]))\n", + "for tracked_peak in tracked_peaks[\"tracked_peak_positions\"]:\n", + " length = min([len(tracked_peaks[\"time_axis\"]), len(tracked_peak)])\n", + " ax1.plot(tracked_peaks[\"time_axis\"][:length]/3600, tracked_peak[:length], color = \"r\")\n", + "fig.savefig(os.path.join(savepath, \"peak_tracking.png\"), dpi = 400)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Spectral noise density Calculation" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:23:17.393369Z", + "start_time": "2022-09-15T12:23:17.155186Z" + }, + "init_cell": true + }, + "outputs": [], + "source": [ + "def linear(x, a, b):\n", + " return a * x + b\n", + "\n", + "def bilinear2(x, a, b, c, switch_point):\n", + " x = np.array(x)\n", + " part1 = a * x[x <= switch_point] + b\n", + " part2 = c * x[x > switch_point] + (a - c) * switch_point + b\n", + " return np.concatenate((part1, part2))" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:23:20.202696Z", + "start_time": "2022-09-15T12:23:18.687966Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-8.012508550030827\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "type_of_fit = \"lin\"\n", + "if type_of_fit == \"lin\":\n", + " fit_func = linear\n", + " guess = [-1, 1]\n", + "elif type_of_fit == \"bilin\":\n", + " fit_func = bilinear2\n", + " guess = [-2, 1, -1, -3]\n", + " \n", + "sampling_f = tracked_peaks[\"time_axis\"][1]**-1\n", + "peak_no = 0\n", + "noise_calculator = AnalyzerTimetraceSpectralNoiseDensity(tracked_peaks[\"tracked_peak_positions\"][peak_no],\\\n", + " sampling_f, fit_func = fit_func)\n", + "\n", + "noise_calculator.welch_segment_length = 300\n", + "noise_calculator.guess = guess\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_welch_segment_length\", noise_calculator.welch_segment_length)\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_fit_interval\", noise_calculator.fit_interval)\n", + "\n", + "spectral_result = noise_calculator.analyze()\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_spectrum\", spectral_result)\n", + "saver_overview.add_info(f\"{node_r}_peak{peak_no}_spectrum\", spectral_result)\n", + "\n", + "fit = noise_calculator.fit()\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_SNDfit_parameters\", fit)\n", + "saver_overview.add_info(f\"{node_r}_peak{peak_no}_SNDfit_parameters\", fit)\n", + "\n", + "f, s = spectral_result[\"freq\"], spectral_result[\"spectrogram\"]\n", + "saving_path = os.path.join(settings[\"file_info\"][\"savepath\"], node_r)\n", + "\n", + "plotter_SND = PlotterTimetraceSpectralNoiseDensity(saving_path, [f,s], fit)\n", + "plotter_SND.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Jump analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:23:28.968103Z", + "start_time": "2022-09-15T12:23:27.899930Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#peak_no = 0\n", + "jump_analysis = jump_count(tracked_peaks[\"tracked_peak_positions\"][peak_no], tracked_peaks[\"time_axis\"])\n", + "jump_analysis.big_jump_minimum_height = 2e-3\n", + "jump_analysis.bin_count = 100\n", + "jump_analysis.range = (-0.01, 0.01)\n", + "jump_analysis.guess = [20, 0, 0.0002]\n", + "jump_hist, big_jumps = jump_analysis.analyze()\n", + "popt = jump_analysis.fit()\n", + "\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_jumphist\", jump_hist)\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_big_jumps\", big_jumps)\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_jumpfit_parameters\", popt)\n", + "\n", + "saver_overview.add_info(f\"{node_r}_peak{peak_no}_big_jumps\", big_jumps)\n", + "saver_overview.add_info(f\"{node_r}_peak{peak_no}_jumpfit_parameters\", fit)\n", + "\n", + "plt.pcolor(tracked_peaks[\"time_axis\"], data[gates], np.transpose(data[node_r]))\n", + "for tracked_peak in tracked_peaks[\"tracked_peak_positions\"]:\n", + " length = min([len(tracked_peaks[\"time_axis\"]), len(tracked_peak)])\n", + " plt.plot(tracked_peaks[\"time_axis\"][:length], tracked_peak[:length], color = \"r\")\n", + "for jump_time in big_jumps[\"time_of_big_jumps\"]:\n", + " plt.axvline(jump_time, color = \"r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:23:33.634594Z", + "start_time": "2022-09-15T12:23:33.504575Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FHWM of the guassian distribution: 0.6954538933146511 mV\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(f\"FHWM of the guassian distribution: {2.35482e3 * popt[-1]} mV\")\n", + "x = np.linspace(min(jump_hist[\"jump_height\"]), max(jump_hist[\"jump_height\"]), 1000)\n", + "y = gauss_function(x, *popt)\n", + "plt.plot(x, y)\n", + "plt.plot(jump_hist[\"jump_height\"], jump_hist[\"jumps_per_bin\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Save your analysis!" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:23:38.304993Z", + "start_time": "2022-09-15T12:23:38.207287Z" + } + }, + "outputs": [], + "source": [ + "saver.save()\n", + "\n", + "ovw = saver_overview.additional_info\n", + "\n", + "saver_saver_overview = Saver_json(overview_path) #Save your saved data to be safe\n", + "\n", + "\n", + "saver_saver_overview.fname = saver_overview.fname\n", + "saver_saver_overview.append_to_file = True\n", + "\n", + "saver_saver_overview.additional_info = {analysis_key : ovw}\n", + "saver_saver_overview.save()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Look at the big picture!" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-31T13:45:36.328398Z", + "start_time": "2022-08-31T13:45:36.084399Z" + } + }, + "outputs": [], + "source": [ + "from qkit.analysis.semiconductor.loaders.LoaderJSON import LoaderJSON\n", + "overview_path = \"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\"\n", + "sample = \"P35B3\"#_post_analysis\"\n", + "fname = f\"{sample}.json\"\n", + "\n", + "loader = LoaderJSON()\n", + "ovw_data = loader.load(os.path.join(overview_path, fname))\n", + "ovw_data.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-31T13:45:38.461554Z", + "start_time": "2022-08-31T13:45:38.439320Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['0tg0.957vr0.17sidel', '0tg1.106vr0.17sider', '0.75tg1.239vr0.604sidel', '0.75tg1.413vr0.604sider', '-0.5tg1.878vr-0.446sider', '-0.5tg0.38vr-0.446sidel', '1.5tg3.31vr0.655sidel', '0.75tg1.414vr0.604sidel'])" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-14T14:57:53.257498Z", + "start_time": "2022-09-14T14:57:52.988342Z" + } + }, + "outputs": [], + "source": [ + "def get_bcv(key):\n", + " return float(key.split(\"tg\")[0])\n", + "\n", + "def get_tgv(key):\n", + " return float(key.split(\"tg\")[1].split(\"vr\")[0])\n", + "\n", + "def get_vref(key):\n", + " return float(key.split(\"vr\")[1].split(\"side\")[0])\n", + "\n", + "def get_side(key):\n", + " return key.split(\"side\")[1].split(\"num\")[0]\n", + "\n", + "def extract_lowest_tgv(wanted_bcv, wanted_side, data_dict):\n", + " tgvs = []\n", + " matching_key = []\n", + " for key in data_dict.keys():\n", + " bcv = get_bcv(key)\n", + " tgv = get_tgv(key)\n", + " side = get_side(key)\n", + " if bcv == wanted_bcv and side == wanted_side:\n", + " tgvs.append(tgv)\n", + " matching_key.append(key)\n", + " \n", + " if tgvs:\n", + " val = min(tgvs)\n", + " idx = tgvs.index(val)\n", + " return val, matching_key[idx]\n", + " else:\n", + " return None, None\n", + " \n", + "\n", + "def find_nearest_idx(array, value):\n", + " array = np.asarray(array)\n", + " idx = (np.abs(array - value)).argmin()\n", + " return idx" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-31T12:15:57.171412Z", + "start_time": "2022-08-31T12:15:57.135402Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.75tg1.602vr1.104\n", + "0.75\n", + "1.602\n", + "1.104\n" + ] + }, + { + "ename": "IndexError", + "evalue": "list index out of range", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mget_tgv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mget_vref\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mget_side\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36mget_side\u001b[0;34m(key)\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_side\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"side\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"num\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m: list index out of range" + ] + } + ], + "source": [ + "key1 = list(ovw_data.keys())[0]\n", + "print(key1)\n", + "print(get_bcv(key1))\n", + "print(get_tgv(key1))\n", + "print(get_vref(key1))\n", + "print(get_side(key1))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-12T14:43:24.197600Z", + "start_time": "2022-09-12T14:43:23.954119Z" + }, + "scrolled": false + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'ovw_data' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 140\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfreqs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 141\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 142\u001b[0;31m \u001b[0mbcp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbias_cool_plotter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0movw_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mintegrated_noise_power_fit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'ovw_data' is not defined" + ] + } + ], + "source": [ + "class bias_cool_plotter():\n", + " def __init__(self, data_dict, y_maker, sample, y_scale = \"log\"):\n", + " self.data_dict = data_dict\n", + " self.y_maker = y_maker\n", + " self._build_x_axis()\n", + " self._build_y_axis()\n", + " print(self.x_axis)\n", + " print(self.y_axis)\n", + " self.fig, self.ax1 = plt.subplots()\n", + " self.ax1.set_title(\"Total noise power vs bias cooling\")\n", + " self.ax1.set_xlabel(\"Bias Cooling Voltage (V)\")\n", + " self.ax1.set_ylabel(\"Integrated Noise Power (V²)\")\n", + " self.ax1.set_yscale(y_scale)\n", + " self.ax1.set_ylim(min(self.y_axis), max(self.y_axis))\n", + " self.ax1.plot(self.x_axis, self.y_axis)\n", + " \n", + " self.set_dpi = 400\n", + " #self.fig.set_bbox_inches = \"tight\"\n", + " self.fig.save_as = \".png\"\n", + " self.fig.set_facecolor(\"White\")\n", + " self.ax1.set_axisbelow(True) # pushes grid to background\n", + " self.ax1.title.set_size(fontsize=14)\n", + " self.ax1.xaxis.label.set_size(fontsize=12)\n", + " self.ax1.yaxis.label.set_size(fontsize=12)\n", + " self.ax1.grid()\n", + " self.fig.savefig(os.path.join(overview_path, f\"{sample}_integrated_noise.png\"), dpi = self.set_dpi)\n", + " \n", + " def _build_x_axis(self):\n", + " x_vals = set()\n", + " for key in self.data_dict.keys():\n", + " bcv = get_bcv(key)\n", + " x_vals.add(bcv)\n", + " self.x_axis = sorted(list(x_vals))\n", + " \n", + " def _build_y_axis(self):\n", + " self.y_axis = []\n", + " for x_value in self.x_axis:\n", + " y_value = self.y_maker(self.data_dict, x_value)\n", + " self.y_axis.append(y_value)\n", + " \n", + "def test_y_maker(data_dict, x_value): \n", + " return extract_lowest_tgv(x_value)\n", + "\n", + "def format_float(float_no):\n", + " if float_no.is_integer():\n", + " key = f'{float_no:.0f}'\n", + " else:\n", + " key = f'{float_no}'\n", + " return key\n", + "\n", + "def find_key(data_dict, part_key):\n", + " keys = data_dict.keys()\n", + " #print(keys)\n", + " #print(part_key)\n", + " for key in keys:\n", + " if part_key in key:\n", + " return key\n", + " return \"not_found\"\n", + "\n", + "def one_mHz_value(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value)\n", + " #key = f\"{format_float(x_value)}tg{tgv}\"\n", + " \n", + " spectrum_key = find_key(data_dict[key], \"spectrum\")\n", + " freqs = data_dict[key][spectrum_key][\"freq\"]\n", + " spec = data_dict[key][spectrum_key][\"spectrogram\"]\n", + " one_mHz_idx = find_nearest_idx(freqs, 1e-3)\n", + " return spec[one_mHz_idx]\n", + "\n", + "def func_power2(x, *params):\n", + " x = np.array(x)\n", + " if len(params) == 2:\n", + " return params[1] * x ** params[0]\n", + " else:\n", + " part1 = params[1] * x[x <= params[3]] ** params[0]\n", + " part2 = params[1]/(params[3] ** (params[2]-params[0])) * x[x > params[3]] ** params[2]\n", + " return np.concatenate((part1, part2))\n", + "\n", + "def one_mHz_value_fit(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value)\n", + " #key = f\"{format_float(x_value)}tg{tgv}\"\n", + " \n", + " fit_key = find_key(data_dict[key], \"SNDfit\")\n", + " fit_pars = data_dict[key][fit_key][\"popt\"]\n", + " \n", + " return func_power2(1e-3, *fit_pars)\n", + "\n", + "def integrated_noise_power(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value)\n", + " #key = f\"{format_float(x_value)}tg{tgv}\"\n", + " \n", + " spectrum_key = find_key(data_dict[key], \"spectrum\")\n", + " freqs = data_dict[key][spectrum_key][\"freq\"]\n", + " spec = data_dict[key][spectrum_key][\"spectrogram\"]\n", + " integral = np.sum(np.diff(freqs) * spec[:-1])\n", + " return integral\n", + "\n", + "def integrated_noise_power_fit(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value, \"l\", data_dict)\n", + " #key = find_key(data_dict, str(tgv))\n", + " print(tgv)\n", + " print(key)\n", + " sub_key = \"r0_peak0\"\n", + " fit_key = find_key(data_dict[key], sub_key + \"_SNDfit\")\n", + " print(fit_key)\n", + " if fit_key != \"not_found\":\n", + " fit_pars = data_dict[key][fit_key][\"popt\"]\n", + "\n", + " f_min = 1e-4\n", + " f_max = 1e-2\n", + "\n", + " band = np.linspace(f_min, f_max, 100000)\n", + " spec = func_power2(band, *fit_pars)\n", + "\n", + " integral = np.sum(np.diff(band) * spec[:-1])\n", + " return integral\n", + " else:\n", + " return np.nan\n", + "\n", + "def fwhm(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value)\n", + " #key = f\"{format_float(x_value)}tg{tgv}\"\n", + " \n", + " jumpfit_key = find_key(data_dict[key], \"jumpfit\")\n", + " popt = data_dict[key][jumpfit_key][\"popt\"]\n", + " if len(popt) == 4:\n", + " fwhm = data_dict[key][jumpfit_key][\"popt\"][-1]\n", + " else:\n", + " fwhm = 0\n", + " return fwhm\n", + "\n", + "def length_plot(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value)\n", + " #key = f\"{format_float(x_value)}tg{tgv}\"\n", + " spectrum_key = find_key(data_dict[key], \"r4_peak0_spectrum\")\n", + " freqs = data_dict[key][spectrum_key][\"freq\"]\n", + " print(len(freqs))\n", + " print(min(freqs))\n", + " print(max(freqs))\n", + " return len(freqs)\n", + "\n", + "bcp = bias_cool_plotter(ovw_data, integrated_noise_power_fit, sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-31T13:46:25.846421Z", + "start_time": "2022-08-31T13:46:25.811941Z" + } + }, + "outputs": [ + { + "ename": "KeyError", + "evalue": "'0.75tg1.104vr1.104sidel'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0movw_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"0.75tg1.104vr1.104sidel\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m: '0.75tg1.104vr1.104sidel'" + ] + } + ], + "source": [ + "ovw_data[\"0.75tg1.104vr1.104sidel\"].keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-31T13:46:26.308845Z", + "start_time": "2022-08-31T13:46:26.295022Z" + } + }, + "outputs": [], + "source": [ + "p35_b3_x_axis = bcp.x_axis[:]\n", + "p35_b3_y_axis = bcp.y_axis[:]" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-31T13:10:52.683399Z", + "start_time": "2022-08-31T13:10:52.654123Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.00020310787652103387,\n", + " 2.3523320996339547e-05,\n", + " 0.0003767679261758867,\n", + " 1.0901465928507918e-05,\n", + " 5.0115537164900075e-06,\n", + " 4.2162141374273204e-07,\n", + " 9.399752489652295e-07,\n", + " 3.977015929895646e-05,\n", + " 9.603997936154829e-05,\n", + " 4.5053375116834815e-05,\n", + " 2.378668328994797e-06]" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Done Samples:\n", + "p35_b4_x_axis\n", + "p35_b4_y_axis\n", + "\n", + "p35_b3_x_axis\n", + "p35_b3_y_axis\n", + "\n", + "p35_b1_y_axis\n", + "p35_b1_y_axis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bias cooling results vs. min integration freq" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-23T12:28:29.190066Z", + "start_time": "2022-08-23T12:28:26.253971Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.38\n", + "-0.5tg0.38vr-0.446sidel\n", + "1.106\n", + "0tg1.106vr0.17sidel\n", + "1.239\n", + "0.75tg1.239vr0.604sidel\n", + "3.31\n", + "1.5tg3.31vr0.655sidel\n", + "[-0.5, 0.0, 0.75, 1.5]\n", + "[2.7906591219636985e-08, 6.819744002666638e-07, 5.252054358886223e-08, 3.411788358516969e-05]\n", + "0.38\n", + "-0.5tg0.38vr-0.446sidel\n", + "1.106\n", + "0tg1.106vr0.17sidel\n", + "1.239\n", + "0.75tg1.239vr0.604sidel\n", + "3.31\n", + "1.5tg3.31vr0.655sidel\n", + "[-0.5, 0.0, 0.75, 1.5]\n", + "[1.8560690302086095e-08, 3.619782015393523e-07, 3.670130394303255e-08, 1.6738160095794387e-05]\n", + "0.38\n", + "-0.5tg0.38vr-0.446sidel\n", + "1.106\n", + "0tg1.106vr0.17sidel\n", + "1.239\n", + "0.75tg1.239vr0.604sidel\n", + "3.31\n", + "1.5tg3.31vr0.655sidel\n", + "[-0.5, 0.0, 0.75, 1.5]\n", + "[1.34918102773828e-08, 2.3225676359368754e-07, 2.7451265084726622e-08, 1.029397752051534e-05]\n", + "0.38\n", + "-0.5tg0.38vr-0.446sidel\n", + "1.106\n", + "0tg1.106vr0.17sidel\n", + "1.239\n", + "0.75tg1.239vr0.604sidel\n", + "3.31\n", + "1.5tg3.31vr0.655sidel\n", + "[-0.5, 0.0, 0.75, 1.5]\n", + "[1.0062591111061684e-08, 1.5907400657915902e-07, 2.0889856201836133e-08, 6.853572572709006e-06]\n", + "0.38\n", + "-0.5tg0.38vr-0.446sidel\n", + "1.106\n", + "0tg1.106vr0.17sidel\n", + "1.239\n", + "0.75tg1.239vr0.604sidel\n", + "3.31\n", + "1.5tg3.31vr0.655sidel\n", + "[-0.5, 0.0, 0.75, 1.5]\n", + "[7.494330954766171e-09, 1.1110956106046927e-07, 1.5801340021718126e-08, 4.68796724261691e-06]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEaCAYAAADtxAsqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdd1hT59sH8G9ENgoIokAQBRQZggqIo+5aKgLuURfWgdZdW622zqq1raOutorV9ge1rrYOUHGCE0UUFdmylCGoyN7J8/7hSyoyPAjhJOH+XBfXZU5ycr6cxNzkPOc8t4AxxkAIIYRw0IzvAIQQQuQHFQ1CCCGcUdEghBDCGRUNQgghnFHRIIQQwhkVDUIIIZxR0SCc7dmzB/r6+lLfzvLly+Ho6Cj17ZDXAgICIBAIkJ+fX6/HyLro6GgIBAI8evSo2tuEGyoackQgENT6M23aNE7PM2HCBIwZM0a6Yeth5cqVOHfuHN8xyBsGDRqE9PR0aGpq8h2lwXTs2BHp6eno3Lkz31HkSnO+AxDu0tPTJf/29/fHrFmzKi1TV1fnI1aD09LSgpaWFt8xeFdaWgoVFRW+YwAAVFRU0LZtW75jNCglJSWF+50aA33TkCNt27aV/Ojo6FRZpq2tDQAICwvDgAEDoK6uDj09PcycORN5eXkAXh/6OXLkCP755x/JN5Rbt24BAJYsWYKOHTtCXV0dHTp0wDfffIPS0lLO+YqLiyEQCPD7779j5MiR0NDQgLm5OY4ePVrpcbXlq8j45uGpise3aNECLVq0QLdu3XD9+nXJ/eHh4fj444+hpaWFNm3aYPLkyXj+/HmNOSsOSxw5cgS9evWCmpoabGxsEBgYWOlxly5dgpOTE1RVVWFoaIhly5ahrKwMAHD8+HHo6elBLBZLMggEAnz++eeS9b/44gu4u7tzzlnxDXD9+vUwMjKCubl5lewvX76EiooKLly4UGn5qVOnoKamhuzsbDDGsGrVKrRr1w6qqqowMjLCzJkza9wfFa5duwY7OzuoqanB2dkZDx48kNz39uGpjIwMjB8/HsbGxtDQ0ICtrS0OHjxYZf/16NEDmpqa0NHRQc+ePRETE1Pj9ouLi7Fs2TKYmJhAVVUVFhYW2LNnT6Xnq+n1AICioiLMnz8frVu3hpqaGvr06SN5b1fn7cNTFb9jUFAQHB0doaGhAWdnZ4SHh1dab+/evTAxMYGGhgZGjhyJHTt2QE1N7Z37V2EwIpeOHTvGqnv5cnJyWOvWrdnYsWNZeHg4u3TpEuvQoQObOHEiY4yxvLw8Nnz4cObm5sbS09NZeno6Ky0tZYwxtnbtWnbz5k2WmJjITp06xQwNDdmGDRskz/3rr78yPT29GjMVFRUxAMzExIQdOnSIxcXFsc8//5ypqqqytLQ0TvkYY+yrr75iDg4OktsWFhZs2rRpLDo6msXFxbG///6bhYSEMMYYe/LkCdPR0WErV65k0dHRLCwsjLm4uLAPPvigxpxRUVEMAGvXrh37559/WGRkJPPy8mKamposIyODMcZYYmIiU1VVZfPnz2dRUVHs+PHjTF9fn3399deMMcZevnzJBAIBCwsLY4wxtnPnTqavr8/s7e0l2+nevTvbsmUL55zjx49nWlpabNq0aezRo0csPDy82vxubm7M09Oz0rJx48axUaNGMcYY+/PPP5muri4LCAhgycnJLCQkhP3yyy817o+zZ88yAMzGxoZdvHiRPXz4kHl4eDATExNWXFxc6TF5eXmS/bNt2zYWFhbG4uPj2e7du5mSkhK7du0aY4yx4uJipqWlxVasWMHi4+NZZGQk8/HxYbGxsTXmGDFiBGvXrh07fvw4i4+PZxcvXmR//vknp9eDMca8vLyYsbExO3v2LIuIiGCenp5MW1ubPX/+vNLrXrFf375d8Tv26tWLXblyhUVGRrIBAwYwOzs7yTYCAwNZs2bN2NatW1lMTAz7+eefWatWrZiqqmqNv5eioaIhp2oqGjt37mR6enqssLBQsuzs2bNMIBCwJ0+eMMZefziNHj36ndv46aefmI2NjeQ216Kxdu1aybLi4mLWvHlzduzYMc753iwaYrGYqaqqssOHD1e7zaVLlzJXV9dKy9LT0xkA9uDBg2rXqfiwqPhAZ4yx8vJyZmpqytavX88YY2zJkiXM2tqaicXiSr+/urq6pMja2dmxbdu2McYYGzVqFNuwYQNTVlZmL1++ZNnZ2UxJSYmFhoZyzjl+/HhmZGQkef6aHD58mLVo0UKyD3Nzc5m6ujr7999/GWOMbdy4kdna2rLy8vJan6dCxYfl33//LVn26tUrpqmpyXx9fSs9pqJoVGf48OFs3rx5jDHGUlNTGQB269YtThkePnzIALDAwMBq73/X65GVlcWUlJTYkSNHJPeXlpYyoVAoeU25Fo2goCDJc1y8eJEBkBSeESNGsOHDh1fKNmXKlCZVNOjwlIKJiopCt27dKo1vfPDBB2CMISoqqtZ1Dx06hN69e6Nt27bQ0tLC8uXL8eTJkzpnsLOzk/xbVVUVrVq1QmZm5nvlqzjkM3nyZAwZMgSbNm1CXFyc5P67d+/iwoULknEQLS0tWFhYAADi4+NrzdmrVy/Jv5WUlODk5ITIyEhJzt69e0MgEFTKWVRUhMTERADAgAEDEBQUBMYYrl69Cnd3d3Tr1g1XrlzB1atXoaWlha5du9Ypp52dHZSVlWvNPXz4cAgEAvj5+QEA/v33X6ipqWHYsGEAXh/mysrKQocOHTBr1iz8888/lQ7jcNkfOjo6sLKykuyPt5WXl2PdunXo0qULWrVqBS0tLZw+fVryfjEyMsKECRMwYMAAuLu7Y/v27UhNTa1x22FhYVBWVkbfvn2rvf9dr0dcXBxEIhH69OkjuV9ZWRnOzs41/g41efP9a2RkBACS9290dDR69OhR6fHOzs51en55R0VDwTDGKv3HelNNywHgypUrmDJlCjw8PODv74+wsDCsXr26TmMaFd7+0BMIBJJj/++Tb9OmTXj06BFcXV1x9epV2NjYSI6fi8VijBgxAvfv36/0ExcXhyFDhtQ5ewUuOQcMGICrV6/i4cOHYIyhS5cuGDBgAAIDAxEUFIS+fftCSUmpTjm5nJ2kpqaGUaNGSfbBwYMHMXbsWMmguZmZGR4/fozdu3dDQ0MDCxcuhLOzM4qLi997f7xt48aN+Pnnn7FixQoEBgbi/v37cHV1rfR+OXToEG7cuIHevXvjn3/+QceOHauMG1Vg75hs+12vR8X61T2mtvd9dd58/1asy+X921RQ0VAw1tbWuHfvHoqKiiTLrl+/DoFAIDm1UEVFBSKRqNJ6169fh7m5uWQQumPHjkhKSuIlX3UsLS3x+eef4+zZs5g0aRL2798PAOjevTsiIiLQoUMHWFhYVPp51xlYbw6SikQihIaGwsrKSpLzxo0blT7Mrl+/DnV1dbRv3x4A0L9/f+Tk5OCnn35C//79IRAIKhWNAQMGSNatT87qTJ48GWfPnkVkZCQuX76MyZMnV7pfXV0dHh4e2LFjB27evImwsDCEhIRw3h85OTmIioqS7I+3Xb9+HSNHjsTEiRNhb28PMzMzxMbGVnlc9+7dsWLFCly7dg3Ozs7w9fWt9vm6d++OsrIyXLt2rdr73/V6dOrUCUpKSpVOkCgrK8Pt27dhbW1d6+9dF1ZWVlX247v2q8Lh5aAYqbd3DYSPGzeOhYeHs8uXLzMzM7NKA82rVq1iHTp0YLGxsez58+esrKyMHT16lCkrK7MjR46wx48fsx07dlQZ4OM6puHn51dpeZs2bdiuXbs453tzTCM7O5stWLCABQUFsaSkJHbjxg1maWkpOXaenJzMdHV12bhx41hISAiLj49n586dY9OnT2clJSXV5qw4lm1qasqOHz/OoqKi2Jw5c5iGhgZ79uwZY+y/gdcFCxawqKgoduLEiSoDr4y9HtdQUlKS/H55eXlMWVmZNWvWTDKewTUn17EmxhgTiUTM2NiY2dvbM1NT00rH+r29vdmBAwdYeHg4S0hIYOvWrWMqKiosJSWl2ueqOJZva2vLLl26xMLDw9mIESOYsbExKyoqqvSYijGNuXPnMlNTU3bz5k0WGRnJZs6cyVq2bMlcXFwYY4xFR0ezr7/+mt28eZMlJSWxCxcuMAMDA7Z58+YafycPDw/JQHhCQgILCgpiBw8e5Px6zJ49mwmFQhYQEFCvgfA3x23efkxgYCBTUlJiP/30E4uNjWV79uxhenp6TE1NjdPrpgioaMipmooGY4zdu3eP9e/fn6mpqbFWrVqxGTNmsNzcXMn9aWlpbNCgQUxTU5MBYMHBwUwsFrMlS5YwPT09pqWlxcaOHct27NjR4EWDS743i0ZBQQEbP348MzExYSoqKszIyIjNmTOH5efnSx4fFRXFhg8fzrS1tZm6ujqztLRkCxcurHEguOKD4NChQ8zJyYmpqKgwKysrdvHixUqPu3jxInNwcGAqKiqsTZs2bOnSpVUGqRctWlTpQ4UxxpydnZm2tnaV7b8rZ12KBmOvB9cBVClkR48eZT169GAtW7ZkmpqarEePHuzs2bM1Pk/Fh6W/vz+ztrZmKioqzNHRUXJm2JuPqfhAff78OXN3d2eamprMwMCAff3112z69OmSopGSksKGDx/ODA0NmYqKCjM1NWVff/11rYPzhYWFbPHixZJ1LCws2J49eyT3v+v1KCwsZHPnzmX6+vpMVVWV9erViwUHB0vub4iiwdjr/wfGxsZMXV2djRgxgm3atInp6OjU+HspGgFj1LmPNC3R0dGwsrJCeHg4bG1t+Y5D5Nxnn32G0NBQ3Llzh+8ojYKuCCeEkDr44Ycf8PHHH0NTUxMBAQE4cOAAtm/fznesRkNFgxBC6iA4OBhbt25FXl4eOnTogG3btmHOnDl8x2o0cnV4KigoCKtWrYKNjY3kHHBCCCGNp9FOuZ0+fToMDAyqHEMOCAiApaUlLCws8P3339f6HAKBAFpaWiguLoZQKJRmXEIIIdVotG8aFVfITp06VTJBmEgkQqdOnXDhwgUIhUI4OTnh0KFDEIlEWLFiRaX1Dxw4AH19fTRr1gwZGRlYsmRJlQnSqqOvry85r76uCgoKZHIqaMpVN5SrbihX3chirsy8EmTkFqODvia0VN9vFCIpKQkvXryosrzRxjT69etX5WKxkJAQWFhYwMzMDMDr6Q9OnjyJFStWwN/fv8bn0tXVRUlJSY33e3t7w9vbGwDQvHlzbNmy5b0y5+fny+QU3ZSrbihX3VCuupG1XC+LxFhxvQgf6zB87vT+ub788stql/M6EJ6amgoTExPJbaFQiNu3b9f4+H///Rfnzp1DdnY25s+fX+PjvLy84OXlBQBwdHR877GPt6/qlRWUq24oV91QrrqRtVzz/7oHgaAEk21UpZKL16JR3ZGx2uZ1GTVqFEaNGiXNSIQQIrduJbyE/8N0LBrcEa2V06SyDV7nnhIKhXj69KnkdkpKimRWSUIIIdyVi8RYeyoCxjrqmNO/agOvhsJr0XByckJcXBwSExNRWlqKw4cPw8PDo0Ge28/PD15eXsjJyWmQ5yOEEFn2V8gTRD/Lw8phVlBXUZLadhqtaHzyySfo1asXYmJiIBQKsX//fjRv3hy7d++Gi4sLrKysMG7cONjY2DTI9tzd3eHt7S1pgUoIIYoqq6AUW8/Hore5Hj62lW7f80Yb0zh06FC1y11dXeHq6tpYMQghROFsOR+D/JJyrPWwkXq/D+qnQQghcuxRag4OhTzB1F6m6NSmhdS3p7BzT/n5+cHPz4/GNAghCosxhjWnItBKQwWLP+zUKNtU2G8aNKZBCFF0J+6n4m7yKyz72BLa6rX3lm8oCls0CCFEkeWXlGPTmWjYCbUx1sHk3Ss0EIU9PEUIIYps1+U4ZOaVYO8UBzRrJt3B7zcpbNGgMQ1CiKJKeJ6PA9cTMcZBiG7tdBt12wp7eIrGNAghiogxhm/9I6HaXAnLPrZs9O0rbNEghBBFdDk6E0Exz7H4w44waKHW6NunokEIIXKiuEyEb/0jYd5aE1N7teclg8KOaRBCiKLZfz0RyS8L4TujB1Sa8/M3v8IWDRoIJ4QokvScIuy+/BgfWbdB346tecuhsIenaCCcEKJINp2JhogxrHKz5jWHwhYNQghRFLcTXuLUgzTM6WcGk1YavGahokEIITKsXCTGmlMRMNJWw2cDLPiOQ0WDEEJk2aE7TxH9LA/fDLOWanMlrqhoEEKIjHpVUIqt52PQy0wPrl2k21yJKzp7ihBCZNTWCzHIKy7HGg9rqTdX4kphv2nQ2VOEEHkWkZaDv24/wZSepujctiXfcSQUtmgQQoi8Yoxh7akI6Gio4PNGaq7EFRUNQgiRMacepOFO0issdbGEtkbjNFfiqtYxjfLycpw6dQqnT5/GgwcPkJ2dDR0dHdjb22Po0KEYMWIEmjdX2GERQghpdAUl5fjuTBS6GGtjnGPjNVfiqsZvGnv37oWZmRn27t0Lc3NzfPPNN9izZw+++eYbmJubY9++fTAzM8OePXsaMy8hhCi03YGPkZFbgrUeNlBqxOZKXNX4NSE2NhYhISFo27bqaV4jR47E119/jfT0dGzdulWqAQkhpKlIfFGA/dcSMaq7MRxMG7e5Elc1Fg0uxcDQ0BBbtmxp0EANhU65JYTIm/X+kVBp3gzLP+7Md5Qa1ToQHh8fj59//hl5eXkAAF9f30YJ1RDolFtCiDy5HJ2By9GZWDjYAgYtG7+5Ele1Fo1PP/0UhYWF8PDwQGpqKo4dO9ZYuQghpMkoKRfhW79ImLXWxLTeHfiOU6taT31q3bo1li5dirFjx2LmzJnIz89vrFyEENJkHLiehKSXhfjjUyfemitxVWu6li1fX4XYvn17bN++HUlJSY2RiRBCmoxnOcXYdTkOH1q1wQBLA77jvFOtRWPp0qWSf1taWuLp06dSD0QIIU3J92ejUC5mWM1zcyWuai0a3bp1g5OTE37++We8fPmysTIRQkiTcCcpCyfup8Grrxna6fHbXImrWotGWloaPD094ePjA2NjY4wcORInT55EeXl5Y+UjhBCFJBIzrDkZAUNtNcwdaM53HM5qLRp6enqYP38+bt++jQcPHsDGxgaLFy+GoaEhFixYgDt37jRWTkIIUSiHQp4gMj0XX7taQUNFfqZj4jxMb2lpiQ0bNiAxMRF//fUX/P390bNnT2lmI4QQhZRdWIot52Pg3KEV3OwM+Y5TJ3Uqb7du3YKPjw+OHj0KbW1trF69Wlq56o2uCCeEyKqt52ORW1SGtR42MtNciat3Fo3k5GT4+vrC19cXGRkZGDNmDI4fP46+ffs2Rr735u7uDnd3dzg6OvIdhRBCJCLTcnHwdjKm9DSFlaHsNFfiqtai0b9/fwQHB2PgwIFYs2YNRo4cCXV19cbKRgghCoUxhrV+EdBWV8bnQ2SruRJXtRaNoUOH4q+//oKxsXFj5SGEEIXl9zAdIYlZ+G5kF+hoqPAd573UWDQyMzOxfPnydz5BRkYG2rRp06ChCCFE0RSWluO701GwMWqJ8U6y11yJqxrPnho4cCDmzp2L4OBgiMXiSveJxWLcunULc+fOxeDBg6UekhBC5N3PgY/xLLcY62S0uRJXNRaNsLAwWFtbw8vLCy1atECXLl3Qu3dvdOnSBS1atMCcOXPQpUsX3Lt3rzHzEkKI3El+WYB9VxMxspsxHNu34jtOvdR4eEpFRQXz58/H/Pnz8fTpU4SHhyM7Oxu6urqws7OjcQ5CCOFovX8klJUEWD5UdpsrccXpOg0TExOYmMjvMThCCOFLYEwmLkZlYvnQzmgjw82VuJLtidsJIUSOlZaLsd4vEh30NfFpn/Z8x2kQVDQIIURKfr+RiIQXBVjtbg3V5kp8x2kQVDQIIUQKMnKLsfNSHAZ3NsBAOWiuxNU7i4ZIJMKAAQNQUlLSGHkIIUQh/HA2GmUihlVy0lyJq3cOhCspKSExMbHKtRqyjiYsJITw5W5yFv4NS8XcAeZor6/Jd5wGxenw1Jo1a/DZZ58hOTkZIpEIYrFY8iOr3N3d4e3tDW1tbb6jEEKaEJGYYc2pCLRtqYZ5Ay34jtPgOJ1yO3PmTACAr6+vZBljDAKBACKRSDrJCCFEDh258xSPUnOxY0JXaKrKT3Mlrjj9RomJidLOQQghci+nsAybz0WjR/tW8LA34juOVHAqGqampgBezzmVkZEBQ0P56jRFCCGNYduFGOTIaXMlrjiNaWRnZ2PixIlQU1ODhcXrY3SnTp3CypUrpRqOEELkRfSzXPjeSsYkZ1NYG8lfcyWuOBWNOXPmQFtbG8nJyVBReT0HfK9evXDkyBGphiOEEHnAGMOakxFoqa6MJXLaXIkrToenLl26hLS0NCgrK0u+crVu3RqZmZlSDUcIIfLgdHg6bidmYcMIW+hqymdzJa44fdPQ1tbGixcvKi178uQJjW0QQpq8knKGjaejYG3YEp/0aMd3HKnjVDRmzpyJ0aNHIzAwEGKxGMHBwfD09MScOXOknY8QQmSaf2IZ0nOKsW64fDdX4orT4amvvvoKampqmDdvHsrKyjB9+nTMnj0bixYtknY+QgiRWU9eFuJsYhmGdzWCk5w3V+KKU9EQCARYvHgxFi9eLO08hBAiN9afjoSSAFgx1IrvKI2G0+GpkSNHYseOHXjw4IG08xBCiFy4EvscFyIz4G6ujLba8t9ciStORcPNzQ337t3D8OHD0apVK3h4eGDr1q24c+eOtPMRQojMKS0XY51fBNrracClvTLfcRoVp8NTM2bMwIwZMwAAycnJ8Pb2xrfffov8/Hyae4oQ0uT872YSEp4X4MA0RzR7FsV3nEbFqWhER0fjypUruHLlCq5fv462bdti9uzZ6N+/v7TzEUKITMnMLcaOS3EY1NkAgzq3QRAVjaqsra1hbm6OFStWYN++fdDUVKz54QkhhKsfAmJQUi5SuOZKXHEa0/Dx8cGgQYOwZcsWODg4wMvLCwcPHsTTp0+lnY8QQmTG3eRX+OdeCmZ8YIYOCtZciStO3zQmT56MyZMnAwAyMjKwc+dOzJ07l8Y0CCFNhljMsPZUBNq0VMWCQYrXXIkrTkUjLCwMQUFBuHLlCq5duwZ1dXW4ubk1+piGWCzGqlWrkJubC0dHR3h6ejbq9gkhTdfR0KcIT83B9vGK2VyJK87Xady/fx8eHh4ICQlBSkoKDh48CC8vL84bmj59OgwMDGBra1tpeUBAACwtLWFhYYHvv/++1uc4efIkUlNToaysDKFQyHnbhBBSHzlFZfjxXAwcTXUxvKtiNlfiilO5TEpKqveGpk2bhvnz52Pq1KmSZSKRCPPmzcOFCxcgFArh5OQEDw8PiEQirFixotL6Bw4cQExMDHr16oXZs2djzJgxGDx4cL1zEULIu/x0IRavCkux1qOHwjZX4orzd6zff/8dvr6+SE1NhbGxMaZMmYJPP/2U84b69etXpfiEhITAwsICZmZmAIAJEybg5MmTWLFiBfz9/as8h1AolPTzUFJS4rxtQgh5XzHP8uB7KxkTe7SDrbE233F4x6lobNy4ET4+Pvjiiy9gamqK5ORk/Pjjj0hLS8M333zz3htPTU2FiYmJ5LZQKMTt27drfPyoUaOwYMECXLt2Df369avxcd7e3vD29gYApKSkICgo6L3y5efnv/e60kS56oZy1Q3l+g9jDD/eKYaaEkMvzRfVbr/J7S/GQfv27VlSUlKlZUlJSaxdu3ZcVpdITExkNjY2kttHjx5lM2bMkNz28fFh8+fPr9NzvouDg8N7rxsYGNhwQRoQ5aobylU3lOs/px+mMdOv/JnPzcQaH6Oo+6umz05OA+EFBQVo3bp1pWV6enooKiqqV8ESCoWVrvVISUmBkVHTHmQihMiGolIRNp6OQue2LZpEcyWuOBWNjz/+GJMmTUJMTAyKiooQHR0NT09PuLi41GvjTk5OiIuLQ2JiIkpLS3H48GF4eHjU6zkr+Pn5wcvLCzk5OQ3yfISQpuXXK/FIzS7COg8bNFfi9FHZJHDaE7t370aLFi1gb28PLS0tdO3aFZqamti1axfnDX3yySfo1asXYmJiIBQKsX//fjRv3hy7d++Gi4sLrKysMG7cONjY2Lz3L/Mmd3d3eHt7Q1ubBq4IIXXzNKsQe67Ew93eCM5menzHkSmcBsJbtmwJHx8f/PHHH3jx4gX09fXRrFndKu+hQ4eqXe7q6gpXV9c6PRchhEjThtORUBII8LVrZ76jyJxaP/kzMjIwceJE2NnZYdq0aXj16hUMDAzqXDAIIUReXIt7jnMRGZg/yAKG2up8x5E5tX76z507FxkZGZgzZw6ePn0qV+1eaUyDEFJXZSIx1p6KgKmeBmZ80IHvODKp1sNT165dQ2xsLHR0dDBu3Dh069atsXLVm7u7O9zd3eHo6Mh3FEKInPjfzSTEPy/Ab1MdoaZMFxBXp9ZvGsXFxdDR0QEA6Ovro6CgoFFCEUJIY3ueV4IdF+MwwLI1BlsZ8B1HZtX6TaOsrAy///47GGMAgJKSEhw4cKDSY6ZPny69dIQQ0kh+DIhGcbkIq92sm/z8UrWptWg4OzvDx8dHcrtHjx7w9fWV3BYIBDJbNPz8/ODn50djGoSQdwp78grH7qZgdn8zmLXW4juOTKu1aMjifCpc0ZgGIYSLiuZKBi1UsWBQR77jyDw6d5YQ0qT9fTcFD1JysMK1M7SacHMlrqhoEEKarJyiMvwQEA0HU12M6GrMdxy5QGWVENJk7bgYh6zCUvyPmitxprBFgwbCCSG1icvIw/+CkzDBiZor1QXnw1NRUVFYv3495s2bBwCIjo7Gw4cPpRasvmjCQkJITRhjWOsXAU0VJSx1seQ7jlzhVDSOHTuG/v37IzU1VXLKbX5+PpYsWSLVcIQQIg3nIp7hxuOX+OIjS7TSVOE7jlzhVDRWr16N8+fPY8+ePZLe3Pb29njw4IFUwxFCSEMrKhVhvf/r5kqTnKm5Ul1xGtPIzMyEvb09AEgGiwQCAQ0cEULkzt6rr5srHZrVk5orvQdOe8zBwaHSleAAcPjwYfTo0UMqoQghRBqeZhXi19+LGKcAACAASURBVKB4DLMzRC9zaq70Pjh909i5cyc++ugj7N+/HwUFBXBxcUFsbCzOnz8v7Xzvjc6eIoS87bszURAIgG9crfiOIrc4FY3OnTsjOjoa/v7+cHNzg4mJCdzc3KClJbtztNA0IoSQN914/AJnHz3DF0M6wUiHmiu9L87XaWhoaGDcuHEAgISEBLx8+VKmiwYhhFSoaK5k0kods/qZ8R1HrnEa0/jkk09w8+ZNAMDvv/8OGxsbWFtbY//+/VINRwghDcEnOBlxmflYNcyamivVE6eicenSJclhnm3btuHixYsICQnB999/L9VwhBBSXy/yS7D9Qiz6dWqNIdZt+I4j9zgdniotLYWKigpSU1ORlZWFPn36AAAyMjKkGo4QQurrx4BoFJVRc6WGwqlodO3aFZs2bUJycjKGDRsGAEhNTUXLli2lGo4QQurj/tNsHA1NgVc/M1gY0BhsQ+B0eGr//v0IDw9HUVERNmzYAAAIDg7GpEmTpBqOEELeV0VzpdYtVLFgkAXfcRQGp28a5ubm+OuvvyotGzNmDMaMGSOVUA2BrtMgpGn7514K7j/Nxtax9mihpsx3HIVRY9Hw9fXFlClTAAAHDhyo8QlktUc4XadBSNOVW1yGHwJi0K2dDkZ2o+ZKDanGonHo0CFJ0Xh7CpEKAoFAZosGIaTp2nkxDi8LSnBgmiOaNaPB74ZUY9E4c+aM5N+BgYGNEoYQQurrcWYe/riZhPGOJrAT6vAdR+FwviL81atX8PPzQ2pqKoyNjeHu7g5dXV1pZiOEkDphjGGdXyTUqbmS1HA6eyo4OBjm5ubYs2cPHj58iL1798Lc3BzBwcHSzkcIIZydj8zAtbgXWDKkE/S0VPmOo5A4fdNYvHgxfvnlF0yYMEGy7MiRI1i4cCHu3LkjtXCEEMJVcZkI6/0j0amNFqb0NOU7jsLi9E0jNjZWMllhhTFjxuDx48dSCUUIIXXlfTUBKa+KsNbDhporSRGnPduxY0ccPny40rJjx47B3NxcKqEIIaQuUl4V4pegxxjWxRC9zfX5jqPQOB2e2r59O9zc3LBz506YmpoiKSkJcXFx8Pf3l3a+90YX9xHSdGw6Ew0A+HoYNVeSNk5Fo3fv3oiPj8fp06eRlpYGd3d3uLq6olWrVtLO997o4j5Cmoabj1/gdHg6lgzpBGNqriR1nE+51dXVxeTJk6WZhRBC6qRcJMZavwgIddXhRc2VGkWtRWPgwIG1TiUsEAhw6dKlBg9FCCFc+N5KRmxGPvZOcaDmSo2k1qJR0zeL1NRU7Ny5E4WFhVIJRQgh7/IyvwTbLsSib0d9fETNlRpNrUVjxowZlW6/fPkSmzZtwr59+zB+/HisXr1aquEIIaQmm8/FoKhUhDXu1FypMXE65TY3NxerVq2ChYUFMjIycO/ePXh7e0MoFEo7HyGEVPEwJRtHQp9iWu/2sDBowXecJqXWolFUVIRNmzbBzMwMUVFRuH79Onx9fen6DFJFuUiMvFLGdwzSBIjFDGtORUBPUxULP+zId5wmp9bDUx06dIBIJMKyZcvg6OiIjIyMKn3BBw0aJNWARPaJxAyzfe8iKKYQ0Swa8wd2hLoKDUoS6TgeloqwJ9nYPMYOLam5UqOrtWioqalBIBDg119/rfZ+gUCAhIQEqQQj8mPL+Rhcis5EJ91m+DkwHifvp+Hb4TYY1JkGJ0nDyisuw6az0ehqooPR3enwOB9qLRpJSUmNFIPIq5P3U/FrUDw+6dEOH+m+gGq7Llh14hGm/xEKF5s2WONuAyO64Io0kF2XH+NFfgn2e1JzJb7QrF7kvYWn5GDZ3w/h1F4X6zxsIBAI0NtcH2cX9cNSF0tciX2OD7ddgffVeJSJxHzHJXIuLV+MA9cTMc5RCHsTaq7EFyoa5L1k5hXDyzcUepoq+HWyA1Sa//dWUmneDPMGWuDC5/3Ry0wP352JhtvO6whNyuIxMZFnjDH8FV0KdWUlLPu4M99xmjSFLRp+fn7w8vKiCQuloKRchM/+vIdXhaXwnuoI/Rqa3Zi00sBvno7YO8UBecVlGLMnGEuPPUBWQWkjJyby7mJUJh69EGHxkE41vt9I41DYouHu7g5vb29oa2vzHUWhMMaw+kQE7ia/wuYx9rA1rn3/CgQCuNi0xYUl/TG7nxmOh6Vi0NYgHA55ArGYTtEl71bRXMlIS4Cpvai5Et9qLBpisZjTD2la/nczCUdCn2LeQHO42xtxXk9TtTlWuFrh9MK+6GTQAsv/DcfYvcGISs+VYlqiCH67loAnWYWYbKUKZWquxLsaX4HmzZtDWVn5nT+k6bjx+AXWn47Ch1YG+GKI5Xs9h2XbFjgyuyc2j7FD4osCuO26jg3+kcgvKW/gtEQRpGUX4efAeAy1bQtrPbr2RxbUWDQSExORkJCAhIQE7Nq1C/3790dAQACioqIQEBCAgQMHYvfu3Y2ZlfDoyctCzPvrHsz0NfHT+K71Ot1RIBBgrKMJLi3pj3GOQvx2PREfbr2Cs+HpYIwOWZH/fHcmCmLG8LUrNVeSFTVep2Fq+t+xw23btiE0NBQ6Oq9Pc+vUqRMcHR3h6OiIzz77TPopCa/yS8oxyycUjAH7pjqiRQNdhaurqYJNo+wwxsEEK088wmcH72GAZWt862GLdnoaDbINIr+C41/C/2E6Fn/YESatNBDPdyACgONAeE5OTpVp0AsLC+nMpCZALGZYcuQ+4jLzsHtiN7TX12zwbTiY6sJvfh+sHGaFO4lZGPLTFey8FIeSclGDb4vIh3KRGOv8ImCso445/WmuO1nCqXOfp6cnPvzwQyxevBgmJiZ4+vQpdu7cCU9PT2nnIzzbfikO5yMzsMrNGn07tpbadporNcPMvmYYZmeI9f6R2HYhFifCUrF+hC36WOhLbbtENh28/QTRz/KwZ3J3aq4kYzgVjR9//BEWFhY4cuQI0tLSYGhoiPnz52PWrFnSzkd4dDY8HTsvxWGMgxDT+7RvlG0aaqvjl0kOCIrJxOqTEZj022142BthpZsVDFqoNUoGwq+sglJsPR+DPhZ6cLFpy3cc8hZORaNZs2aYM2cO5syZI+08REZEpuViydEH6NZOBxtH2jZ6k5sBlgY4/7kefgmKx56geARGZ+JLF0tM7mkKJZpzSKFtPheDglIR1rrbUHMlGcRpTIMxhn379mHw4MGws7MDAFy9ehVHjx6VajjCj5f5JZjlEwptdWXsnewA1eb8HB5QU1bCkiGdELC4L+xMtLHmVARG/HwDD1OyeclDpO9Rag4O33kCz17t0bENNVeSRZyKxurVq7F//37MmjULT548AQAIhUL88MMPUg1HGl+ZSIy5B+/heX4J9k5xgEFL/g8JmbXWwp8znLHzk254lluM4T/fwKoTj5BTVMZ3NNKAGKtorqSCxUOouZKs4lQ0/vjjD/j7+2PChAmSr4sdOnSgXhoKaJ1fBG4nZuHH0XYyNZOoQCCAh70RLn3RH5692uPg7WQM3noFJ8JS6doOBXHifiruJr/CMpfO1FxJhnEqGiKRCFpaWgAgKRr5+fmSZUQxHLydjD9vPcHsfmYY0c2Y7zjVaqmmjLUeNjg57wMY66hh8ZH7mPTbbTzOzOc7GqmH/JJybDoTDXuhNsY4UHMlWcapaLi6umLJkiUoKSkB8Ppr5KpVq+Du7i7VcKTx3E54iTUnIzDAsrVcTD3dRaiNf+f2wfoRtghPzcHQHVex+Vw0ikrp2g55tOtyHDLzSrDWw4aaK8k4TkVj27ZtSEtLg7a2NnJycqClpYXk5GR8//330s5HGkHKq0J8dvAe2ulpYMeEbnJzdpJSMwGm9DTF5S8GwM3OCD8HxmPIT1dwOTrj3SsTmRH/PB8HridirIMQ3drp8h2HvAOnU25btmyJEydOIDMzE8nJyTAxMUHbtnT+tCIoLC3HLJ+7KCsXY99UR2iry9+x5NYtVPHT+K4Y6yikVrNyhjGGb/0iodacmivJC07fNLp16wYAMDAwgJOTk6RgODo6Si8ZkTrGGJYee4joZ7nY+Uk3mLeW7zGqmlrNllPfDpl1KSoTV2KfY9GHHdG6BTVXkgecvmk8fvy4yjLGGJ09Jed2X36M0+HpWD60MwZ2NuA7ToOoaDXrYW+Etaci8N2ZaAi1BNAxy4Jj+1Z8xyNvKC4T4Vv/SFgYaMGzd3u+4xCOai0aU6dOBQCUlpZK/l0hKSkJNjY20ktGpOp8xDNsvRCLEV2NMLufGd9xGlxFq9nzkRlYcewexuwJxjhHIZYPtUIrTRW+4xEA+68n4klWIXxn9KDmSnKk1qJhbm5e7b8FAgH69OmDsWPHSi9ZNa5du4aDBw+ivLwckZGRuHnzZqNuX1HEZuTh8yP3YSfUxvej7RR2qoaKVrMsXR1hpW2x/3ri6yIytDPGOpjQWTo8Ss8pwu7Lj+Fi00aqE2GShldr0VizZg0AoGfPnnBxcanXhqZPnw5/f38YGBjg0aNHkuUBAQFYtGgRRCIRZs6cieXLl9f4HH379kXfvn1x4sQJODk51StPU5VdWIpZPqFQV2mOvVMcmsQMomrNBVjxoRVGdRdi5YlwfPVPOI6GpmDDCFtYGbbkO16TtOlMNMSMYeUwa76jkDriNKbh4uKC0tJSxMTE4MWLF5WuwB00aBCnDU2bNg3z58+vdJhLJBJh3rx5uHDhAoRCIZycnODh4QGRSIQVK1ZUWv/AgQMwMHh93P2vv/7Cb7/9xmm75D/lIjHm/xWG9OxiHPLqCUPtpnVmkWXbFjji1Qt/30vBpjNRcNt1HZ/2bo/FQzpBS5XTfwXSAG4nvMSpB2lYOPh1cyUiXwSMwxwM169fx9ixY1FSUoLc3Fy0bNkSeXl5MDExqdNgeFJSEtzc3CTfNIKDg7F27VqcO3cOALBp0yYAqFIw3vTkyROsX78e+/btq/Ex3t7e8Pb2BgCkpKTg8OHDnDO+SVaven/fXAejSnAhuRwzbFXQV9jwp9bK0/7KL2U4FluKKynl0FUVYKKVChzbKDXqoTp52l8NRSRmWBtcjMIyhu/6qkNVifv+bor7qz7qm+vLL79EaGho1TsYB46Ojmzbtm2MMcZ0dHQYY4ytW7eObd68mcvqEomJiczGxkZy+9ixY2zGjBmS2z4+PmzevHm1Psfq1avZjRs3OG/TwcGhThnfFBgY+N7rStP75Dpy5wkz/cqfrT31qOED/T953F+hSVns4+1XmelX/mzagdss+UWBTOTikzRz+dxMZKZf+bPTD9PqvG5T3F/1Ud9cNX12cjplITY2FosWLaq0bPny5fjpp5/eu4r9f8Gqsuxdf+mtW7cOvXv3rtd2m5q7ya+w8vgjfGChj29crfiOI1PebDUb8v+tZndRq1mpeFVQii3nY9HLTA9DbeniYHnFqWhoa2sjNzcXAGBoaIjIyEi8evUK+fn1myROKBTi6dOnktspKSkwMjKq13OSytJzijDb9y4MddSwe2I3NKdTG6uoaDV78Yv+GGxlgK0XYjF0xzXcfPyC72gKZcv5GOSXlGOtBzVXkmecPkFGjRqFM2fOAABmzJiBgQMHwsHBod6n3Do5OSEuLg6JiYkoLS3F4cOH4eHhUa/nrODn5wcvLy/k5OQ0yPPJo+IyEbx87qKotBz7pjpCR4OuT6hNRavZPz51QrmIYeJvt7HocBgy84r5jib3HqXm4K+QJ5jS0xSWbam5kjzjdMrI9u3bJf/+4osv4OzsjLy8vDqdhvvJJ58gKCgIL168gFAoxLp16zBjxgzs3r0bLi4uEIlEmD59eoNdMOju7g53d/cmO9UJYwxf/fMQj9Jy4D3FEZ2oCxpnb7eavRydiaUulpjkTK1m3wdjDOv8IqCroYLPh3TiOw6pp3cWDZFIhE6dOiEyMhKqqq/nhvnggw/qvKFDhw5Vu9zV1RWurq51fj5Su71XE3Dyfhq+/KgThli34TuO3KloNTuiqxFWnXyE1ScjcCw0BRtH2sJOKDvNqeTBqQdpuJP0Ct+P6iKXE2KSyt55eEpJSQlKSkooLpavr+hN+fBUYHQmfgiIxjA7Q8wbaMF3HLlWXavZ1Sep1SxXBSXl+O5MFOyE2hjnaMJ3HNIAOI1pLF68GOPGjcOVK1cQHx+PhIQEyY+scnd3h7e3N7S1tfmO0qgeZ+Zj4aEwWLVtic1jFHeKkMb0dqvZP29Rq1mudgc+RkYuNVdSJJzGNObPnw8AuHDhQqXlAoEAIhGdmigrcorK4OUTCpXmzbDP0xEaKnSVc0OqaDU7+v+nI1l85D6Ohj7Ft8NtYWEgexd38S3xRQF+u5aA0d2F6E7NlRQGp28aYrG42h8qGLJDJGZYeCgMT18V4tfJDjCm5kNSU12r2S3nYlBcRv8f3rTePxKqzZXw1VBLvqOQBkQn7SuIHwKicSX2OdZ52KJHB+obIW1vt5rdHfgYQ366gsDoTL6jyYTL0Rm4HJ2JRYM7wqCFGt9xSAPidPyib9++1R4bV1VVhVAoxKhRo+Du7t7g4erDz88Pfn5+TWIg/HhYCryvJmByz3aY6NyO7zhNytutZj/94w4+tmmL1e7WTbbVbEm5CN/6RcKstSY1V1JAnL5pDBgwAElJSejfvz8mT56M/v37Izk5GY6OjmjTpg2mT5+OH3/8UdpZ66SpDIQ/eJqNr/4Jh3OHVljjTk2x+PJmq9mg2Ex8uO0K9l1NQJlIzHe0Rrf/eiKSXhZirbsNVJrTwQxFw+mbxvnz53Hu3DlYWf03b9GkSZPg6emJ27dvY9SoUZgwYQKWLVsmtaCkqszcYnj5hqK1lip+mdSdup/x7O1WsxvPROGfe6/7djSVVrPPcoqx+/JjDLFug36dqLmSIuL0KRMdHQ0zs8otQU1NTRETEwMA6NGjBzIz6VhuYyouE2H2n3eRW/R6ihA9LVW+I5H/V9Fqdu8UB+QWlWHMnmB89fdDZBWU8h1N6jadjUK5mGEVNVdSWJyKRr9+/fDpp5/i8ePHKC4uxuPHjzFr1izJleHh4eEwNDSUalDyH8YYVp54hLAn2dg2zh7WRtR9TtZUtJq9sKQ/Zvczwz/3UjB4axCO3HkCsVgxr+24k5SFk/fTMLufGdrpUXMlRcWpaPzvf/+DWCyGtbU1NDQ0YGNjA5FIhD/++AMAoKKiUuM0IXxR5CvCzyeX4++7KVg4uCOGdqFiLcs0VZtjhasVTi/sCwsDLXz1TzjG7g1G9LNcvqM1KJGYYc3JCBhpq2HuAJqFQJFxGtNo1aoVDh8+DLFYjOfPn6N169Zo1uy/emNpKXvnYSvqhIXX4p7jcHQpXGzaYPHgjnzHIRy93Wp22M7rGNJOCU69yqGpAK1mD4U8QWR6LnZP7AZ1FcXvO9+UcR45jYqKwsaNG7F+/Xo0a9YMMTExePjwoTSzkbckvSjA/L/CYKwlwLZxXWlaBjnTrJkA4xxNcPmLARjnKERAUjk+3HYFAY/S5Xo6kuzCUmw5H4OeZq0wjL75KjxORePYsWPo168fUlNT4ePjAwDIy8vDkiVLpBqO/CevuAwzfUIhEAALu6spxF+nTZWupgo2jbLDSmc1aKsrY86f9zD9jzt48rKQ72jvZev5WOQWlVFzpSaCU9FYvXo1Lly4gD179kBJ6fVXT3t7ezx48ECq4chrYjHD50fuI/FFAX6Z2B0GGnRqrSKw0FWC/4IPKrWa3X1ZvlrNRqbl4uDtZEzpaYrObemEjKaA06dPZmYm7O3tAfzXw1sgENBfFY1k64UYXIzKxGo3a/S20Oc7DmlAb7ea3XJeflrNMsaw9lQEtNWVsWSI7I1rEungVDQcHBzg6+tbadnhw4fRo0cPqYRqCIpy9pTfgzT8HBiPCU4mmNrLlO84REqqazW7WMZbzfo9TEdIUhaWunSGtgY1V2oqOB0Y37lzJz766CPs378fBQUFcHFxQWxsLM6fPy/tfO9NEc6eepSag6V/P4CjqS6+HW5L3+yaAEmr2cDH2HMlAZdktNVsQUk5vjsdBVvjlhjvRM2VmhJORaNz586Ijo6Gv78/3NzcYGJiAjc3N2hpUQ8BaXmeVwIvn1C00lDBr5MdaA6fJkRNWQlLPrLEiG7Gklazf999PR2JrLSa/SXoMZ7lFuPnSd1kqpgR6eP0SbRw4UJoaGhg3LhxWLp0KSZMmAAtLS0sXrxY2vmapNJyMT778y6yCkvhPdURrVvQFCFN0ZutZtNzZKfVbNKLAuy7mohR3YzhYNo05tQi/+FUNCqu/H7b2+McpP4YY1hz6hFCk19h8xh72Bor9iy9pHY1tZo9eZ+/VrMbTkdCWUmA5UM787J9wq9aD08dOHAAAFBeXi75d4WEhATo69OZPA3tz1vJOBTyFHMHmMPd3ojvOERGvN1qdtHh+zhy5ynWj7CFeevGO0wcGJOJi1GZWDG0MwxaUnOlpqjWolHxTaK0tLTStwqBQIA2bdrgf//7n3TTNTHB8S+xzi8Sgzsb4MuP6BRGUlVFq9m/Qp7gx4BoDN1+DbP7m2HeQAuoKUt3+o7ScvHr5kr6mvi0TwepbovIrlqLRmBgIABg5cqV2LBhQ6MEaijy1rnvaVYh5h68C1M9Dfw0gaYIITWraDX7sU1bfHcmCrsuP8aJ+6n41sMWAzsbSG27B24kIvFFAf741IlOzGjCOL3yFQUjMzMTCQkJlX5klTx17isoKccsn1CIxAy/eTqhpRqd807eraLV7F+znKGi1Ayf/nEHc3zvIj2nqMG3lZFbjF2X4vChlQEGWEqvMBHZx6lonDt3DsbGxmjbti0sLCwkPx070iyr9SUWM3xx9AFiM/Kwe2J3dNDX5DsSkTNvt5odvLXhW81+fzYaZSKGVW7UXKmp41Q05s6di1WrVqGgoABisVjyIxLJzxw5smrn5TgERDzD165W1B6TvLeKVrMXPu+PXmZ62HgmCu67ruNucla9nzs0KQvHw1Ixq18HmOrRHzVNHaei8erVK8yePRvq6urSztOkBDxKx/aLcRjV3RgzPqCBRVJ/b7eaHf3r61azr96z1axIzLDmVATatlTDvIHUXIlwLBozZszA77//Lu0sTUr0s1wsOfoAXU108N3ILjRFCGkw1bWaHbQ1CEfvPK1zq9kjd54iIi0XXw+zgoYKTcdPOBaNW7du4bPPPkOnTp3Qr1+/Sj+k7rIKSjHzf6HQUm2OvVMcpH6qJGma3m41u+yfhxhXh1az2YWl2HwuGj06tIK7HTVXIq9x+tNh5syZmDlzprSzNAllIjHmHryLzLwSHJ3dC23oAikiZdW1mp3xQQcsGtyx1mZeP12IRU5RGda6U3Ml8h9ORcPT01PaOZqM9f6RuJWQhW3j7NHVRDYmnyOKr6LV7BCrNvjxXDS8rybA70Ea1rhbw8WmbZWiEP0sF763kjG5pymsjai5EvlPrUXj8uXL73yCQYMGNVgYRXco5Al8gpMxq28HjOou5DsOaYIqWs2OcTDBN8fDMefPexho2RrfDreFSSsNAP8//9nJiuZKnXhOTGRNrUVjxowZta4sEAhk9gI/Wbsi/E5SFlaffIR+nVpj+VArvuOQJs7BVBf+Cz7AHzeT8NOFWHy47QoWDLLArH5muPNMhNuJWdg40hY6Gip8RyUyptaikZiY2Fg5GpwsNWFKzS7CHN+7EOpqYNcE6j9AZENFq9lhdoZY7x+JLedj8W9YKl7llsLGqCUmOLXjOyKRQTSBjJQVlYrg5ROK0nIx9k11pLaYROa83Wr2VQnDOg8b+uOGVItOvJYixhiW/v0Akem5OODpBAsD6nRIZFdFq9l/z12BY3tqrkSqR980pOiXoHj4P0zHMpfOUp19lJCGoqasBCMt+lggNaN3h5RcjMzAlvMxGN7VCHP6m/EdhxBCGgQVDSmIy8jD4iP3YWukjR9G29GFUYQQhUFFo4HlFJZhlk8o1JSV4D2VpgghhCgWKhoNqFwkxvxD95CaXYQ9k7vDUJtmBSaEKBY6e6oBbTobjWtxL/DD6C509gkhRCHRN40G8vfdFOy/nohpvdtjPF0URQhRUFQ0GsC9J6/w9b/h6G2uh2+G0RQhhBDFRUWjnp7lFGO271201VbDzxO7Q1mJdikhRHEp7JhGY0xYWFwmwmzfUBSWlOPPGc7Q1aTJ3Qghik1h/yx2d3eHt7c3tLW1pfL8jDGs+DccD1Jy8NP4rrBs20Iq2yGEEFmisEVD2vZdS8DxsFQsGdIJH9m05TsOIYQ0Cioa7yEoJhPfn42Ga5e2WDDIgu84hBDSaKho1FH883wsOBQGy7YtsWWsPU0RQghpUqho1EFu8espQpSVmmHfVAdoqCjseQSEEFItKhocicQMiw6F4cnLQvw6qTuEuhp8RyKEkEZHfypztPlcDAJjnmPDCFs4m+nxHYcQQnhB3zQ4OHk/FXuuxGOScztM7mnKdxxCCOENFY13eJiSjWV/P0SPDq2wxt2G7ziEEMIrKhq1yC4Rw8vnLvS1VPHrpO5QaU67ixDStNGYRg1KykXYHVaCnCIB/vmsN/S0VPmORAghvKOiUYO1pyLwOFuMnyd2h7VRS77jEEKITBAwxhjfIaRJX18f7du3f691nz9/jtatWzdsoAZAueqGctUN5aobRc2VlJSEFy9eVFmu8EWjPhwdHREaGsp3jCooV91QrrqhXHXT1HLRyC4hhBDOqGgQQgjhTGnt2rVr+Q4hyxwcHPiOUC3KVTeUq24oV900pVw0pkEIIYQzOjxFCCGEMyoahBBCOGvyRSMrKwtDhgxBx44dMWTIELx69arax7Vv3x5dunRB165d4ejoWOf1pZHr6dOnGDhwIKysrGBjY4MdO3ZI7lu7di2MjY3RtWtXdO3aFWfOnKlXnoCAAFhaWsLCwgLff/99lfsZY1i4cCEsLCxgZ2eHe/fucV5XmrkOHjwIOzs72NnZoXfv3njw4IHkvppe08bIFRQUBG1tbcnrzu8bdQAAD6ZJREFU8+2333JeV5q5Nm/eLMlka2sLJSUlZGVlAZDe/po+fToMDAxga2tb7f18vbfelYuv99a7ckn9vcWauKVLl7JNmzYxxhjbtGkTW7ZsWbWPMzU1Zc+fP3/v9aWRKy0tjd29e5cxxlhubi7r2LEji4iIYIwxtmbNGrZ58+YGyVJeXs7MzMxYfHw8KykpYXZ2dpLtVDh9+jT7+OOPmVgsZsHBwaxHjx6c15Vmrhs3brCsrCzGGGNnzpyR5GKs5te0MXIFBgayYcOGvde60sz1plOnTrGBAwdKbktrf125coXdvXuX2djYVHs/H+8tLrn4eG9xySXt91aT/6Zx8uRJeHp6AgA8PT1x4sSJRl2/Ps9raGiI7t27AwBatGgBKysrpKamNsj23xQSEgILCwuYmZlBRUUFEyZMwMmTJ6vknTp1KgQCAXr27Ins7Gykp6dzWleauXr37g1dXV0AQM+ePZGSktIg265vLmms29DPfejQIXzyyScNsu3a9OvXD61atarxfj7eW1xy8fHe4pKrJg21v5p80cjIyIChoSGA1x/CmZmZ1T5OIBDgo48+goODA7y9veu8vrRyVUhKSkJYWBicnZ0ly3bv3g07OztMnz69XofNUlNTYWJiIrktFAqrFKeaHsNlXWnmetP+/fsxdOhQye2aXtPGyhUcHAx7e3sMHToUERERdVpXmrkAoLCwEAEBARg9erRkmbT217vw8d6qq8Z6b3ElzfdWk5iw8MMPP8SzZ8+qLN+4cSPn57hx4waMjIyQmZmJIUOGoHPnzujXrx/vuQAgPz8fo0ePxvbt29Gy5evJFT/77DOsWrUKAoEAq1atwhdffIEDBw68V05WzVnZAoGA02O4rPu+6vLcgYGB2L9/P65fvy5ZJo3XlGuu7t27Izk5GVpaWjhz5gxGjBiBuLg4mdlffn5+6NOnT6W/aKW1v96Fj/dWXTTme4sLab+3mkTRuHjxYo33tWnTBunp6TA0NER6ejoMDAyqfZyRkREAwMDAACNHjkRISAj69evHeX1p5SorK8Po0aMxadIkjBo1qtL6FWbNmgU3NzfOud4mFArx9OlTye2UlBTJ/njXY0pLS9+5rjRzAcDDhw8xc+ZMnD17Fnp6/7Xqrek1bYxcFcUdAFxdXTF37ly8ePGC8+8krVwVDh8+XOXQlLT217vw8d7iqrHfW1xI/b1V51EQBfPll19WGnBeunRplcfk5+ez3Nxcyb979erFzp49y3l9aeUSi8VsypQpbNGiRVXuS0tLk/x727ZtbPz48e+dpaysjHXo0IElJCRIBtAePXpU6TH+/v6VBiudnJw4ryvNXMnJyczc3JzduHGj0vLaXtPGyJWens7EYjFjjLHbt28zExMTJhaLed9fjDGWnZ3NdHV1WX5+vmSZNPcXY4wlJibWOLDLx3uLSy4+3ltcckn7vdXki8aLFy/YoEGDmIWFBRs0aBB7+fIlY4yx1NRUNnToUMYYY/Hx8czOzo7Z2dkxa2trtmHDhneu3xi5rl27xgCwLl26MHt7e2Zvb89Onz7NGGNs8uTJzNbWlnXp0oW5u7tXKiLv4/Tp06xjx47MzMxM8vv/+uuv7Ndff2WMvS5gc+fOZWZmZszW1pbduXOn1nUbyrtyzZgxg+no6Ej2j4ODA2Os9te0MXLt2rWLWVtbMzs7O+bs7Fzpg4fP/cUYY7///nuVPzKkub8mTJjA2rZty5o3b86MjY3Zb7/9JhPvrXfl4uu99a5c0n5v0TQihBBCOGvyZ08RQgjhjooGIYQQzqhoEEII4YyKBiGEEM6oaBBCCOGMigbhzZw5c7B+/Xq+Y3A2bdo0rFy5EgBw7do1WFpa8pyoqqCgIAiFQr5jSOzduxeLFy/m/PgePXpIpr0gsomKBpGa9u3bQ11dHVpaWtDV1cWwYcMqXZG6Z88erFq1qsG3Gxsbi7Fjx0JfXx/a2tqws7PDtm3bIBKJGmwbffv2RUxMTIM9X4XZs2dj6tSpVZY/fPgQqqqqkmnKuWrfvn2tMw9IU2lpKTZs2IClS5eiuLgYOjo6uHz5cpXHff755xgzZgwA4Msvv8Tq1asbOyqpAyoaRKr8/PyQn5+P9PR0tGnTBgsWLJDq9uLj4+Hs7AwTExOEh4cjJycHx44dQ2hoKPLy8qS67YYwbdo0/PvvvygoKKi03MfHB25ubu81uylfTp48ic6dO8PY2BhqamoYP348fHx8/q+9u41p6voDOP4dbQSs0KoQaRuoCgkqiptzUREBo2wTYRofUFBpeLGZuElIFh8xQZC9IWJMJD4sLhMRfIhsUGLwAYOaqHNGt7nEdkA2gYgT3CgWqljL+b8wXq0UR9x/4IvzSZr03t+955x7m/b0nnNyjscxbrebo0ePKjM6f/LJJ9TV1XHv3r2hKLI0ALLSkAaFn58fy5Yt4/bt28q+l5t7Ojo6SE5OJjg4mJEjR5KcnOwx1fShQ4cYP348AQEBjBs3jrKyMq/55ObmEhMTw65du5RZgiMjIykvL0en0wFgsViIiopCp9ORkJCA1WpVzrdarSQkJKDT6YiKisJisXjN59VmoLFjx7Jz506io6PRarWsWLGCx48fK/HCwkL0ej0Gg4GDBw/yzjvv0NjY2CfdWbNmYTQaqaioUPa53W7Ky8uVH9aenh6ys7MxGAwYDAays7Pp6enpk9aaNWtobm4mJSWFESNGUFhYCMDy5csJCQlBq9USFxfn0Rz0119/kZKSQmBgIB988AHbtm0jNjZWidtsNhITExk1ahSRkZGcOHHC6/0BqKmpIT4+Xtk2m81UVFTgdDqVfWfOnKG3t1eZIdbPz4/333+fs2fP9puuNLRkpSENCqfTyfHjx5k5c6bXeG9vL5mZmTQ1NdHc3Iy/vz9ffPEFAN3d3WRlZVFTU4PD4eDKlSu8++67XtOpra1Vmjq8qa+vJy0tjd27d9Pe3k5SUhIpKSk8efIEl8tFSkoKH374IW1tbezZs4dVq1YNuBnqxIkTnD59mj/++INbt25x6NAh4Nlqabt27aK2tpbGxkYuXrz42nQyMjI8/pHX1tbicrmUH9avvvqKH374gZ9//plffvmFH3/8kYKCgj7plJaWEhYWpjztbdy4EYAFCxbQ0NBAW1sb06ZNY9WqVco5n3/+ORqNhj///JOSkhJKSkqUWHd3N4mJiaSnp9PW1sbRo0dZt25dv30Qv/76q0e/T0xMDHq9nu+++86jjOnp6ajVL+ZOnThxoscqeNJb5v8wFYokeWUymYRGoxFarVaoVCqh1+vFrVu3lLjZbBY5OTlez/3pp5+ETqcTQjyb9E2r1YqTJ08Kp9P52jzVavVrJ4fLz88Xy5cvV7bdbrcwGAyirq5OXLp0SYwZM0a43W4lvnLlSpGbm9unvHV1dcJoNHpca2lpqbK9YcMGsXbtWiGEEJmZmWLz5s1KrKGhQQCioaHBaxmbmpqEWq0WLS0tQggh0tPTRVZWlhIfP368MseYEEKcPn1amEymfst17ty5fu9HR0eHAITdbhdPnz4VarVa2Gw2JZ6TkyNmz54thBDi2LFjIjY21uP8zz77TGzfvt1r2hEREX0+ix07dojExEQhhBCdnZ3C399f3Lx50+OYrVu3iszMzH7LLA0t+aQh/acqKyux2+309PRQXFxMfHy81zVEnE4na9euxWQyERgYSFxcHHa7HbfbjUaj4fjx4+zfvx+9Xs/ChQux2Wxe8xs9evRr28NbW1sxmUzKto+PD6Ghody9e5fW1lZCQ0Px8XnxtTCZTANeqCYkJER5P3z4cLq6upQ8X1785uX33oSFhREXF8eRI0fo6uqisrJSaZrydg0mk4nW1tYBldHtdrN582bCw8MJDAxk7NixADx48ID29naePn3ab1mbmpq4du0aOp1OeZWVlXn9PAFGjhzZpx8pIyODuro67t69y8mTJ4mIiOC9997zOMbhcChNidLbR1Ya0qBQqVQsWbIElUrlsVjNc0VFRfz2229cu3aNhw8fcunSJeDFAjwfffQR586d4969e0yYMIFPP/3Uaz7z58/36A94lcFgoKmpSdkWQtDS0oLRaMRgMNDS0kJvb68Sb25uxmg0vtE1P6fX6z36Z14eQdYfs9nM4cOHqaioYNy4ccqyvt6uobm5ud91EV5dZKe8vJyqqipqa2vp7Ozkzp07wLP7EBwcjFqt7resoaGhxMfHY7fblVdXVxf79u3zmnd0dDT19fUe+8LCwpgzZw5lZWWUlpZ6HSlmtVqZOnVqP3dGGmqy0pAGhRCCqqoqOjo6mDhxYp+4w+HA398fnU7H33//TV5enhK7f/8+FouF7u5ufH19GTFiBCqVyms+eXl5XLlyhQ0bNij/gBsbG1m9ejV2u53U1FROnTrF+fPncblcFBUV4evrS0xMDDNmzECj0VBYWIjL5eLChQtUV1ezcuXKf3XtqampfPvtt1itVpxOJ/n5+f94ztKlS2lpaSE3N9fjKQMgLS2NgoIC2tvbefDgAfn5+axevdprOmPGjOH3339Xth0OB76+vowePRqn08nWrVuV2POKffv27TidTmw2m0ffSnJyMvX19ZSWluJyuXC5XFy/ft1jIMHLkpKSvPbfmM1miouLuXz5skd/Cjzr5L9x4waJiYn/eI+koSErDek/9XzkTmBgIDk5OZSUlBAVFdXnuOzsbB49ekRQUBAzZ87k448/VmK9vb0UFRVhMBgYNWoUFy9eZO/evV7zCw8P5+rVq9y5c4eoqCi0Wi1Lly5l+vTpBAQEEBkZyZEjR1i/fj1BQUFUV1dTXV3NsGHDGDZsGBaLhZqaGoKCgli3bh2HDx9mwoQJ/+oeLFiwgKysLObOnUtERASzZs0CwNfXt99zNBqNUnG8+sO6bds2pk+fTnR0NFOmTGHatGnKKLRXbdmyhYKCAnQ6HTt37iQjIwOTyYTRaGTSpEl9BiYUFxfT2dlJSEgIa9asIS0tTSlnQEAAZ8+e5dixYxgMBkJCQti0aZPXkVvw7LO32Wx9ms6WLVtGR0cH8+bNU0a4PWexWEhISBj0FfikgZPraUjSILNarUyePJmenh6PUUNvo02bNikjqd7E119/ze3bt9m9e/eAjp8xYwbffPMNkydPfqP8pP+erDQkaRB8//33LFy4kO7ubsxmMz4+PlRWVg51sfqw2Ww8efKEKVOmcP36dZKSkjh48CCLFy8e6qJJbwnZPCVJg+DAgQMEBwcTHh6OSqXqt/N4qDkcDpYsWYJGoyE1NZUvv/ySRYsWDXWxpLeIfNKQJEmSBkw+aUiSJEkDJisNSZIkacBkpSFJkiQNmKw0JEmSpAGTlYYkSZI0YP8Du24k5D+gwlYAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def integrated_noise_power_fit_fmin_fmax(f_min, f_max, data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value, data_dict)\n", + " #key = find_key(data_dict, str(tgv))\n", + " print(tgv)\n", + " print(key)\n", + " sub_key = \"r0_peak0\"\n", + " fit_key = find_key(data_dict[key], sub_key + \"_SNDfit\")\n", + " #print(fit_key)\n", + " if fit_key != \"not_found\":\n", + " fit_pars = data_dict[key][fit_key][\"popt\"]\n", + "\n", + " band = np.linspace(f_min, f_max, 100000)\n", + " spec = func_power2(band, *fit_pars)\n", + "\n", + " integral = np.sum(np.diff(band) * spec[:-1])\n", + " return integral\n", + "\n", + "min_freqs = [1e-4, 2e-4, 3e-4, 4e-4, 5e-4]\n", + "for fmin in min_freqs:\n", + " f = lambda data_dict, x_value: integrated_noise_power_fit_fmin_fmax(fmin, 1e-3, data_dict, x_value)\n", + " bias_cool_plotter(ovw_data, f, sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-22T16:06:47.321583Z", + "start_time": "2022-08-22T16:06:47.297937Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'shape'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0msignal\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray_split\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracked_peaks\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"tracked_peak_positions\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msignal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mfreqs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mspectrogram\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspectrogram\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msignal\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msignal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mdiv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtracked_peaks\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"time_axis\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0mmin_freqs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfreqs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3/dist-packages/scipy/signal/spectral.py\u001b[0m in \u001b[0;36mspectrogram\u001b[0;34m(x, fs, window, nperseg, noverlap, nfft, detrend, return_onesided, scaling, axis, mode)\u001b[0m\n\u001b[1;32m 738\u001b[0m \u001b[0;31m# need to set default for nperseg before setting default for noverlap below\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 739\u001b[0m window, nperseg = _triage_segments(window, nperseg,\n\u001b[0;32m--> 740\u001b[0;31m input_length=x.shape[axis])\n\u001b[0m\u001b[1;32m 741\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 742\u001b[0m \u001b[0;31m# Less overlap than welch, so samples are more statisically independent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'shape'" + ] + } + ], + "source": [ + "import scipy.signal as ss\n", + "\n", + "dividers = range(1,3)\n", + "min_freqs = []\n", + "for div in dividers:\n", + " signal = np.array_split(tracked_peaks[\"tracked_peak_positions\"][0], 1)\n", + " print(type(signal))\n", + " freqs, times, spectrogram = ss.spectrogram(signal[:int(len(signal)/div)], tracked_peaks[\"time_axis\"][1]**-1)\n", + " min_freqs.append(freqs[1])\n", + "\n", + "print(min_freqs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Automatic parameter recording in the indiv analysis files" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T14:11:43.999461Z", + "start_time": "2022-09-15T14:11:43.979025Z" + } + }, + "outputs": [], + "source": [ + "def load_file(date_time_string, connection_type = \"sftp\"):\n", + " date = date_time_string.split(\"/\")[0]\n", + " time = date_time_string.split(\"/\")[1]\n", + " \n", + " if connection_type == \"sftp\":\n", + " filepath = (\"sftp://tp1435@os-login.lsdf.kit.edu/kit/phi/\"\n", + " \"projects/nanospin/SEMICONDUCTOR_SYSTEMS/data/\"\n", + " f\"{date}/{time}_2D_Peak_tracking/\"\n", + " f\"{time}_2D_Peak_tracking.h5\")\n", + " elif connection_type == \"smb\":\n", + " filepath = (f\"smb://nanospin@phi-ndus/o/data/{date}/{time}\"\n", + " f\"_2D_Peak_tracking/{time}_2D_Peak_tracking.h5\")\n", + " else:\n", + " raise ValueError(\"Invalid connection type. Currently supporting sftp and smb.\")\n", + " \n", + " settings = {\"file_info\" : {\n", + " \"filepath\" : filepath},\n", + " \"authentication\" : {\n", + " \"configpath\" : configpath}\n", + " }\n", + " \n", + " loader = Loaderh5()\n", + " return loader.load(settings)\n", + "\n", + "def create_saver(date_time_string):\n", + " date = date_time_string.split(\"/\")[0]\n", + " time = date_time_string.split(\"/\")[1]\n", + " \n", + " filepath = (\"sftp://tp1435@os-login.lsdf.kit.edu/kit/phi/\"\n", + " \"projects/nanospin/SEMICONDUCTOR_SYSTEMS/data/\"\n", + " f\"{date}/{time}_2D_Peak_tracking/\"\n", + " f\"{time}_2D_Peak_tracking.h5\")\n", + " savepath = os.path.join(\"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\",\n", + " str(pathlib.Path(filepath).parents[1]).split(\"/\")[-1],\n", + " str(pathlib.Path(filepath).parents[0]).split(\"/\")[-1])\n", + " saver = Saver_json(savepath)\n", + " saver.append_to_file = True\n", + " return saver\n", + "\n", + "def convert_dict_string(dict_string):\n", + " dict_string_split = dict_string.split(\"\\n\")\n", + " dict_string_split.remove(\"}\")\n", + " dict_string_split.remove(\"{\")\n", + "\n", + " static_voltages = {}\n", + " for raw_kv_pair in dict_string_split:\n", + " raw_k, raw_v = raw_kv_pair.split(\":\")\n", + " v = float(raw_v.replace(\",\", \"\"))\n", + " k = raw_k.replace(\" \", \"\").replace('\"', \"\")\n", + " static_voltages[k] = v\n", + " return static_voltages\n", + "\n", + "def get_bcv_forh5(settings_string):\n", + " try:\n", + " bcv = float(settings_string.split('\"bias_cooling_v\"')[1].split(\": \")[1].split(\",\")[0])\n", + " except IndexError:\n", + " print(\"No bcv has been found.\")\n", + " print(date_time)\n", + " bcv = float(input(\"Please input bcv manually.\"))\n", + " return round(bcv, 3)\n", + "\n", + "def get_tgv_forh5(static_voltages, side):\n", + " if side == \"l\":\n", + " key = \"gate4_out\"\n", + " elif side == \"r\":\n", + " key = \"gate14_out\"\n", + " return round(static_voltages[key], 3)\n", + " \n", + "def get_most_common_voltage_forh5(static_voltages):\n", + " voltages = list(static_voltages.values())\n", + " most_common_voltage = max(set(voltages), key = voltages.count)\n", + " return round(most_common_voltage + 0.5, 3)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T10:04:47.092481Z", + "start_time": "2022-09-15T10:04:46.845376Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "#B3\n", + "date_times = {\"20220501/140941\", \"20220502/014148\", \"20220517/104543\", \"20220517/232824\", \"20220518/120037\"}\n", + "print(len(date_times))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T10:04:50.240933Z", + "start_time": "2022-09-15T10:04:50.217360Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "16\n" + ] + } + ], + "source": [ + "#B4\n", + "date_times = {\"20220408/173804\", \"20220410/014626\", \"20220410/174848\", \"20220421/011122\",\n", + " \"20220421/084935\", \"20220423/194835\", \"20220424/095946\", \"20220424/212521\",\n", + " \"20220528/125951\", \"20220529/014453\", \"20220529/194625\", \"20220531/174026\",\n", + " \"20220601/023259\", \"20220602/211422\", \"20220603/015345\", \"20220603/015345\", \n", + " \"20220603/174843\"}\n", + "print(len(date_times))" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T14:18:47.378028Z", + "start_time": "2022-09-15T14:18:47.353426Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "46\n" + ] + } + ], + "source": [ + "#A4\n", + "date_times = {\"20220810/011635\",\n", + "\"20220810/145859\",\n", + "\"20220827/232944\",\n", + "\"20220828/163623\",\n", + "\"20220829/122037\",\n", + "\"20220830/115720\",\n", + "\"20220831/012540\",\n", + "\"20220831/132139\",\n", + "\"20220901/093721\",\n", + "\"20220902/000231\",\n", + "\"20220902/191607\",\n", + "\"20220902/201312\",\n", + "\"20220902/223428\",\n", + "\"20220903/122853\",\n", + "\"20220904/001904\",\n", + "\"20220904/142951\",\n", + "\"20220905/063708\",\n", + "\"20220905/213523\",\n", + "\"20220906/104659\",\n", + "\"20220907/000019\",\n", + "\"20220907/154621\",\n", + "\"20220907/211200\",\n", + "\"20220908/111803\",\n", + "\"20220908/222946\",\n", + "\"20220909/003317\",\n", + "\"20220909/120306\",\n", + "\"20220910/004802\",\n", + "\"20220910/115020\",\n", + "\"20220910/140100\",\n", + "\"20220911/020244\",\n", + "\"20220911/151648\",\n", + "\"20220912/000554\",\n", + "\"20220912/004156\",\n", + "\"20220912/133834\",\n", + "\"20220912/160422\",\n", + "\"20220913/014045\",\n", + "\"20220913/020214\",\n", + "\"20220913/143347\",\n", + "\"20220914/015804\",\n", + "\"20220914/163226\",\n", + "\"20220914/164732\",\n", + "\"20220914/232540\",\n", + "\"20220914/234914\",\n", + "\"20220915/000426\",\n", + "\"20220915/114047\",\n", + "\"20220915/142632\"}\n", + "print(len(date_times))" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T14:35:48.646903Z", + "start_time": "2022-09-15T14:35:45.202170Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done loading file, formatting now...\n" + ] + } + ], + "source": [ + "date_time = '20220913/143347'\n", + "numpy_dict, h5 = load_file(date_time, \"smb\")" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T14:29:18.918721Z", + "start_time": "2022-09-15T14:23:32.614767Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done loading file, formatting now...\n", + "{'bcv': 0.2, 'ltgv': 1.385, 'rtgv': 0.45, 'vref': 0.95}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.1, 'ltgv': 1.271, 'rtgv': 0.379, 'vref': 0.879}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220911/151648\n", + "{'bcv': -0.4, 'ltgv': 1.515, 'rtgv': -0.033, 'vref': 0.467}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220913/014045\n", + "{'bcv': -0.7, 'ltgv': 1.508, 'rtgv': -0.333, 'vref': 0.167}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.0, 'ltgv': 1.45, 'rtgv': 0.334, 'vref': 0.834}\n", + "Done loading file, formatting now...\n", + "No bcv has been found.\n", + "20220810/145859\n", + "Please input bcv manually.0\n", + "Couldn't find: 20220810/145859\n", + "{'bcv': 0.0, 'ltgv': 1.209, 'rtgv': 0.656, 'vref': 0.468}\n", + "Done loading file, formatting now...\n", + "No bcv has been found.\n", + "20220810/011635\n", + "Please input bcv manually.0\n", + "{'bcv': 0.0, 'ltgv': 1.209, 'rtgv': 0.656, 'vref': 0.468}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220912/160422\n", + "{'bcv': -0.6, 'ltgv': 1.703, 'rtgv': -0.237, 'vref': 0.263}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.5, 'ltgv': 1.646, 'rtgv': 0.672, 'vref': 1.172}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.5, 'ltgv': 1.776, 'rtgv': 0.666, 'vref': 1.166}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220914/234914\n", + "{'bcv': -0.9, 'ltgv': 1.377, 'rtgv': -0.518, 'vref': -0.018}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.8, 'ltgv': 1.573, 'rtgv': 0.779, 'vref': 1.279}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220910/004802\n", + "{'bcv': -0.1, 'ltgv': 1.962, 'rtgv': 0.225, 'vref': 0.725}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.9, 'ltgv': 1.88, 'rtgv': 0.799, 'vref': 1.299}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220913/143347\n", + "{'bcv': -0.8, 'ltgv': 1.366, 'rtgv': -0.428, 'vref': 0.072}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220915/142632\n", + "{'bcv': -0.8, 'ltgv': 1.169, 'rtgv': -0.431, 'vref': 0.069}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.8, 'ltgv': 2.096, 'rtgv': 0.72, 'vref': 1.22}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220914/232540\n", + "{'bcv': -0.9, 'ltgv': 1.377, 'rtgv': -0.518, 'vref': -0.018}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220912/000554\n", + "{'bcv': -0.5, 'ltgv': 1.249, 'rtgv': -0.139, 'vref': 0.361}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220914/015804\n", + "{'bcv': -0.9, 'ltgv': 1.309, 'rtgv': -0.489, 'vref': 0.011}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.3, 'ltgv': 1.91, 'rtgv': 0.532, 'vref': 1.032}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.7, 'ltgv': 1.404, 'rtgv': 0.751, 'vref': 1.251}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.7, 'ltgv': 1.919, 'rtgv': 0.742, 'vref': 1.242}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.9, 'ltgv': 1.88, 'rtgv': 0.799, 'vref': 1.299}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220915/114047\n", + "{'bcv': -0.8, 'ltgv': 1.169, 'rtgv': -0.431, 'vref': 0.069}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.4, 'ltgv': 1.765, 'rtgv': 0.62, 'vref': 1.12}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.1, 'ltgv': 1.222, 'rtgv': 1.16, 'vref': 1.192}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220912/133834\n", + "{'bcv': -0.6, 'ltgv': 1.703, 'rtgv': -0.237, 'vref': 0.263}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.3, 'ltgv': 1.965, 'rtgv': 0.562, 'vref': 1.062}\n", + "Done loading file, formatting now...\n", + "{'bcv': 1.0, 'ltgv': 2.272, 'rtgv': 0.811, 'vref': 1.311}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.6, 'ltgv': 2.328, 'rtgv': 0.661, 'vref': 1.161}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.2, 'ltgv': 1.237, 'rtgv': 0.435, 'vref': 0.935}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.4, 'ltgv': 1.764, 'rtgv': 0.565, 'vref': 1.065}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220910/115020\n", + "{'bcv': -0.2, 'ltgv': 1.252, 'rtgv': 0.161, 'vref': 0.661}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.9, 'ltgv': 1.499, 'rtgv': 0.802, 'vref': 1.302}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220911/020244\n", + "{'bcv': -0.3, 'ltgv': 1.429, 'rtgv': 0.063, 'vref': 0.563}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.3, 'ltgv': 1.91, 'rtgv': 0.532, 'vref': 1.032}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.9, 'ltgv': 1.88, 'rtgv': 0.799, 'vref': 1.299}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220915/000426\n", + "{'bcv': -0.9, 'ltgv': 1.377, 'rtgv': -0.518, 'vref': -0.018}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220914/164732\n", + "{'bcv': -1.0, 'ltgv': 1.184, 'rtgv': -0.549, 'vref': -0.049}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.6, 'ltgv': 2.188, 'rtgv': 0.712, 'vref': 1.212}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220910/140100\n", + "{'bcv': -0.2, 'ltgv': 1.252, 'rtgv': 0.161, 'vref': 0.661}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220912/004156\n", + "{'bcv': -0.5, 'ltgv': 1.421, 'rtgv': -0.139, 'vref': 0.361}\n", + "Done loading file, formatting now...\n", + "{'bcv': 0.1, 'ltgv': 1.271, 'rtgv': 0.379, 'vref': 0.879}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220913/020214\n", + "{'bcv': -0.7, 'ltgv': 1.508, 'rtgv': -0.333, 'vref': 0.167}\n", + "Done loading file, formatting now...\n", + "Couldn't find: 20220914/163226\n", + "{'bcv': -1.0, 'ltgv': 1.155, 'rtgv': -0.549, 'vref': -0.049}\n", + "Total missing: {'20220911/151648', '20220913/014045', '20220810/145859', '20220912/160422', '20220913/020214', '20220914/234914', '20220910/004802', '20220915/142632', '20220914/232540', '20220912/000554', '20220914/015804', '20220915/114047', '20220912/133834', '20220910/115020', '20220911/020244', '20220915/000426', '20220914/164732', '20220910/140100', '20220912/004156', '20220913/143347', '20220914/163226'}\n" + ] + } + ], + "source": [ + "not_found = set()\n", + "\n", + "for date_time in date_times:\n", + " try:\n", + " numpy_dict, h5 = load_file(date_time, \"smb\")\n", + " saver = create_saver(date_time)\n", + "\n", + " settings_string = h5[\"measurement\"][0]\n", + " dict_string = h5[\"static_voltages\"][0]\n", + " static_voltages = convert_dict_string(dict_string)\n", + "\n", + " bcv = get_bcv_forh5(settings_string)\n", + " ltgv = get_tgv_forh5(static_voltages, \"l\")\n", + " rtgv = get_tgv_forh5(static_voltages, \"r\")\n", + " vref = get_most_common_voltage_forh5(static_voltages)\n", + "\n", + " parameters = {\"bcv\" : bcv, \"ltgv\" : ltgv, \"rtgv\" : rtgv, \"vref\" : vref}\n", + " saver.add_info(\"bias_cooling_parameters\", parameters)\n", + " saver.save()\n", + " \n", + " except FileNotFoundError:\n", + " not_found.add(date_time)\n", + " print(\"Couldn't find: \", date_time)\n", + " \n", + " print(parameters)\n", + " \n", + "if not_found:\n", + " print(\"Total missing: \", not_found)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T14:30:14.181569Z", + "start_time": "2022-09-15T14:30:14.156323Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(len(not_found))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Choose lowest tgv for each bcv on the indiv file level" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T10:09:02.136440Z", + "start_time": "2022-09-15T10:09:02.110491Z" + } + }, + "outputs": [], + "source": [ + "def load_analyzed_file(date_time_string):\n", + " date = date_time_string.split(\"/\")[0]\n", + " time = date_time_string.split(\"/\")[1]\n", + " analyzed_path = (f\"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project\"\n", + " f\"/Analysis/{date}/{time}_2D_Peak_tracking/analyzed_data.json\")\n", + "\n", + " loader_analyzed = LoaderJSON()\n", + " return loader_analyzed.load(analyzed_path)\n", + "\n", + "def get_bcv_forjson(data_dict):\n", + " return data_dict[\"bias_cooling_parameters\"][\"bcv\"]\n", + "\n", + "def choose_lowest_tgv_for_given_bcv(wanted_bcv, side, data_dict):\n", + " sidekey = f\"{side}tgv\"\n", + " if side == \"l\":\n", + " demod_key = \"demod0&4.r0_tracked_peaks\"\n", + " else:\n", + " demod_key = \"demod0&4.r4_tracked_peaks\"\n", + " \n", + " tgvs = []\n", + " dates = []\n", + " for date, parameters in data_dict.items():\n", + " if parameters[\"bias_cooling_parameters\"][\"bcv\"] == wanted_bcv and \\\n", + " demod_key in parameters.keys(): \n", + " tgvs.append(parameters[\"bias_cooling_parameters\"][sidekey])\n", + " dates.append(date)\n", + " if tgvs:\n", + " val = min(tgvs)\n", + " idx = tgvs.index(val)\n", + " return val, dates[idx]\n", + " else:\n", + " return None, None" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:26:16.212456Z", + "start_time": "2022-09-15T12:26:15.863182Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "{'bcv': 0.0, 'ltgv': 0.703, 'rtgv': 0.887, 'vref': 0.703}\n", + "---------------\n", + "-0.5\n", + "{'bcv': -0.5, 'ltgv': 0.442, 'rtgv': 0.962, 'vref': 0.129}\n", + "---------------\n", + "0.25\n", + "{'bcv': 0.25, 'ltgv': 1.429, 'rtgv': 1.026, 'vref': 0.699}\n", + "---------------\n", + "0.75\n", + "{'bcv': 0.75, 'ltgv': 1.104, 'rtgv': 1.104, 'vref': 1.104}\n", + "---------------\n", + "-1.0\n", + "{'bcv': -1.0, 'ltgv': 0.212, 'rtgv': 1.696, 'vref': -0.209}\n", + "---------------\n" + ] + } + ], + "source": [ + "side = \"l\"\n", + "\n", + "bcvs = set()\n", + "files = {}\n", + "parameters = {}\n", + "#build the dictionary containing the dates and bias cooling params\n", + "for date_time in date_times:\n", + " file = load_analyzed_file(date_time)\n", + " bcvs.add(get_bcv_forjson(file)) \n", + " files[date_time] = file\n", + "\n", + "chosen_measurements = {}\n", + "\n", + "for bcv in bcvs:\n", + " tgv, date = choose_lowest_tgv_for_given_bcv(bcv, side, files)\n", + " if date:\n", + " chosen_measurements[bcv] = files[date]\n", + " print(bcv)\n", + " print(files[date][\"bias_cooling_parameters\"])\n", + " print(\"---------------\") " + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T11:39:15.417039Z", + "start_time": "2022-09-15T11:39:15.389998Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20220601/023259\n", + "{'bcv': 0.25, 'ltgv': 1.927, 'rtgv': 1.524, 'vref': 0.699}\n", + "---------------\n", + "20220531/174026\n", + "{'bcv': 0.25, 'ltgv': 1.429, 'rtgv': 1.026, 'vref': 0.699}\n", + "---------------\n" + ] + } + ], + "source": [ + "wanted_bcv = 0.25\n", + "found_files = {}\n", + "for date, file in files.items():\n", + " if file[\"bias_cooling_parameters\"][\"bcv\"] == wanted_bcv:\n", + " found_files[date] = file[\"bias_cooling_parameters\"]\n", + " print(date)\n", + " print(found_files[date])\n", + " print(\"---------------\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Slicing the SND" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-14T12:35:52.673023Z", + "start_time": "2022-09-14T12:35:52.357626Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['0.75tg1.602vr1.104sidel', '0tg0.703vr0.703sidel', '0tg0.887vr0.703sider', '0.75tg1.104vr1.104sidel', '0tg0.838vr0.717sidel', '0tg0.838vr0.717sidelnum2', '0.75tg2.051vr1.307sider', '0.75tg1.380vr1.307sidel', '0.75tg1.877vr1.307sidel', '0.75tg2.549vr1.307sider', '0.75tg1.877vr1.307sidelnum2', '0tg0.717vr0.717sidel', '0tg0.567vr0.717sider', '0.75tg1.341vr1.287sidel', '0.75tg1.965vr1.287sider', '1tg1.548vr1.390sidel', '1tg1.626vr1.390sider', '0.25tg1.429vr1.127sidel', '0.25tg1.026vr1.127sider', '0.25tg1.927vr1.127sidel', '0.25tg1.524vr1.127sider', '-0.5tg0.442vr0.127sidel', '-0.5tg0.739vr0.127sidel', '-0.5tg1.685vr0.127sider', '-1tg0.212vr-0.211sidel', '0tg0.957vr0.169sidel', '0tg0.958vr0.169sidel'])" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "overview_path = \"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\"\n", + "sample = \"P35B4\"#_post_analysis\"\n", + "fname = f\"{sample}.json\"\n", + "\n", + "loader = LoaderJSON()\n", + "ovw_data = loader.load(os.path.join(overview_path, fname))\n", + "ovw_data.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-14T12:37:08.177451Z", + "start_time": "2022-09-14T12:37:08.005072Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'P35B4'" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "path = os.path.join(overview_path, fname)\n", + "os.path.basename(path).split(\".\")[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-13T10:02:52.695962Z", + "start_time": "2022-09-13T10:02:50.538828Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Specify current bias cooling voltage in V: 0\n", + "Savepath: /V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/20220501/140941_2D_Peak_tracking\n" + ] + } + ], + "source": [ + "date_time_string = \"20220501/140941\"#\"20220518/211236\"\n", + "date = date_time_string.split(\"/\")[0]\n", + "time = date_time_string.split(\"/\")[1]\n", + "filepath = f\"sftp://tp1435@os-login.lsdf.kit.edu/kit/phi/projects/nanospin/SEMICONDUCTOR_SYSTEMS/data/{date}/{time}_2D_Peak_tracking/{time}_2D_Peak_tracking.h5\"\n", + "savepath = os.path.join(\"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\",\n", + " str(pathlib.Path(filepath).parents[1]).split(\"/\")[-1],\n", + " str(pathlib.Path(filepath).parents[0]).split(\"/\")[-1])\n", + "\n", + "configpath = \"/home/ws/lr1740/Dokumente/Doktorarbeit/Sonstiges/sftp_config.txt\"\n", + "overview_path = \"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\"\n", + "\n", + "saver = Saver_json(savepath)\n", + "saver.append_to_file = True\n", + "saver_overview = Saver_json(overview_path)\n", + "bcv = input(\"Specify current bias cooling voltage in V: \")\n", + "saver.add_info(\"bias_cooling_parameters\", {\"bcv\" : bcv})\n", + "\n", + "saver_overview.fname = \"P35B3_post_analysis_wjumps\"\n", + "saver_overview.append_to_file = True\n", + "\n", + "print(\"Savepath: \" + savepath)\n", + "\n", + "settings = {\"file_info\" : {\n", + " \"filepath\" : filepath,\n", + " \"savepath\" : savepath,\n", + " \"analysis\" : \"plunger_sweep_timetrace\"},\n", + " \"authentication\" : {\n", + " \"configpath\" : configpath}\n", + " }\n", + "\n", + "analyzed_path = (f\"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project\"\n", + " f\"/Analysis/{date}/{time}_2D_Peak_tracking/analyzed_data.json\")\n", + "\n", + "loader_analyzed = LoaderJSON()\n", + "data_analyzed = loader_analyzed.load(analyzed_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-13T10:03:43.568938Z", + "start_time": "2022-09-13T10:02:54.266969Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done loading file, formatting now...\n", + "dict_keys(['demod0&4.r0', 'demod0&4.r4', 'demod0&4.timestamp0', 'demod0&4.timestamp4', 'demod0&4.x0', 'demod0&4.x4', 'demod0&4.y0', 'demod0&4.y4', 'gates_6_16', 'measurement', 'number', 'settings', 'static_voltages'])\n", + "\n", + "\n", + "['{\\n \"gate10_out\": 0.16998291015625,\\n \"gate11_out\": 0.16998291015625,\\n \"gate12_out\": 0.16998291015625,\\n \"gate13_out\": 0.16998291015625,\\n \"gate14_out\": 1.10595703125,\\n \"gate15_out\": 0.255126953125,\\n \"gate16_out\": 0.21331787109375,\\n \"gate17_out\": 0.26397705078125,\\n \"gate18_out\": 0.16998291015625,\\n \"gate19_out\": 0.16998291015625,\\n \"gate20_out\": 0.16998291015625,\\n \"gate21_out\": 0.16998291015625,\\n \"gate22_out\": 0.16998291015625,\\n \"gate23_out\": 0.16998291015625,\\n \"gate4_out\": 0.95794677734375,\\n \"gate5_out\": 0.28228759765625,\\n \"gate6_out\": 0.16754150390625,\\n \"gate7_out\": 0.20721435546875,\\n \"gate9_out\": 0.16998291015625\\n}']\n", + "\n", + "\n", + "dict_keys(['0tg0.957vr0.169sidel', '0.75tg1.239vr0.604sidel', '-0.5tg0.383vr-0.445sidel', '1.5tg3.31vr0.655sidel'])\n", + "Specify reference voltage in V: 0.169\n" + ] + } + ], + "source": [ + "loader = Loaderh5()\n", + "data_raw, _ = loader.load(settings)\n", + "print(data_raw.keys())\n", + "print(\"\\n\")\n", + "print(data_raw[\"static_voltages\"])\n", + "print(\"\\n\")\n", + "print(ovw_data.keys())\n", + "vr = input(\"Specify reference voltage in V: \")\n", + "saver.add_info(\"bias_cooling_parameters\", {\"vr\" : vr})" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-13T10:04:52.160298Z", + "start_time": "2022-09-13T10:03:45.386937Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Specify side of SET (l/r): l\n", + "Specify current top gate voltage in V: 0.957\n" + ] + } + ], + "source": [ + "side = input(\"Specify side of SET (l/r): \")\n", + "while side != \"l\" and side != \"r\":\n", + " side = input(\"Specify side of SET (l/r): \")\n", + " \n", + "tgv = input(\"Specify current top gate voltage in V: \")\n", + "saver.add_info(\"bias_cooling_parameters\", {\"side\" : side})\n", + "saver.add_info(\"bias_cooling_parameters\", {\"tgv\" : tgv})\n", + "\n", + "demod_prefix = \"demod0&4\"\n", + "if side == \"l\":\n", + " demod_idx = 0\n", + "else:\n", + " demod_idx = 4\n", + " \n", + "node_timestamp = f\"{demod_prefix}.timestamp{demod_idx}\"\n", + "node_x = f\"{demod_prefix}.x{demod_idx}\"\n", + "node_y = f\"{demod_prefix}.y{demod_idx}\"\n", + "node_r = f\"{demod_prefix}.r{demod_idx}\"\n", + "\n", + "gates = \"gates_6_16\"\n", + "tracked_peaks = data_analyzed[f\"{node_r}_tracked_peaks\"]\n", + "analysis_key = f\"{bcv}tg{tgv}vr{vr}side{side}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-13T10:04:56.096768Z", + "start_time": "2022-09-13T10:04:54.954675Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax1 = plt.subplots()\n", + "ax1.set_title(\"Peak tracking\", fontsize = 14)\n", + "ax1.set_xlabel(\"Measurement Time (hrs)\", fontsize = 12)\n", + "ax1.set_ylabel(\"Plunger Gate Voltage (V)\", fontsize = 12)\n", + "ax1.set_axisbelow(True) # pushes grid to background\n", + "fig.set_facecolor(\"White\")\n", + "\n", + "len_x = len(tracked_peaks[\"time_axis\"])\n", + "data_cut = np.transpose(data_raw[node_r])[:, :len_x]\n", + "ax1.pcolor(tracked_peaks[\"time_axis\"]/3600, data_raw[gates], data_cut)\n", + "for tracked_peak in tracked_peaks[\"tracked_peak_positions\"]:\n", + " length = min([len(tracked_peaks[\"time_axis\"]), len(tracked_peak)])\n", + " ax1.plot(tracked_peaks[\"time_axis\"][:length]/3600, tracked_peak[:length], color = \"r\")\n", + "#fig.savefig(os.path.join(savepath, \"peak_tracking.png\"), dpi = 400)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-13T10:20:20.928397Z", + "start_time": "2022-09-13T10:20:14.941074Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-7.068138872492228\n", + "{'popt': array([-6.50419589e-01, 8.54793336e-08]), 'cov': array([[0.01881064, 0.0400142 ],\n", + " [0.0400142 , 0.08801355]]), 'fit_range': [0.0002773946906524992, 0.019417628345674943], 'sigma': array([1.37151904e-01, 5.83917638e-08])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-9.367184210640064\n", + "{'popt': array([-1.79788113e+00, 4.29354273e-10]), 'cov': array([[0.01723454, 0.03666148],\n", + " [0.03666148, 0.08063906]]), 'fit_range': [0.0002773946906524992, 0.019417628345674943], 'sigma': array([1.31280371e-01, 2.80739944e-10])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-8.823911129863689\n", + "{'popt': array([-1.87822209e+00, 1.49999175e-09]), 'cov': array([[0.0112758 , 0.02398601],\n", + " [0.02398601, 0.05275861]]), 'fit_range': [0.0002773946906524992, 0.019417628345674943], 'sigma': array([1.06187585e-01, 7.93325189e-10])}\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEdCAYAAADwwTuSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdd1iT5/oH8G9YArKnQBgiigwByxBQhlsRcHDECSgq1WprbU9bqa2tPQ66Tpe2FtTiRqtVC64qghNBlKFFEaqMgAMHCgLKeH5/cMhPdoCQhHB/rqvX1bx587x3wmvuPJvDGGMghBBCBCAj7gAIIYT0HJQ0CCGECIySBiGEEIFR0iCEECIwShqEEEIERkmDEEKIwChpECIGeXl54HA4qKmp6ZbyJ06ciO3bt3dL2aJWUFAAFRUV1NbWijsUAkoapB1mZmZQUlKCiooK9PX1MX/+fJSXl4s7LL5Xr17h/fffB5fLhYqKCvr3748VK1Z06zWjo6MxYsSIbr2GmZkZ9PX18eLFC/6xLVu2wNvbW6DXHz9+HCEhIUKNydvbG4qKilBVVYWamhocHR0RERGBly9fCvU6TZmYmKC8vByysrL8OLZs2dKt1ySto6RB2hUbG4vy8nJcu3YNV65cwdq1a8USR0u/yjds2IDU1FSkpKSgrKwMCQkJGDp0qBiia0wYv4pramrwww8/CCEa4dm4cSPKyspw7949fPvtt4iJiYGPjw9ojnDvQUmDCMzIyAgTJ07EjRs3AADFxcXw9/eHlpYWLCwsEBUVBQCoqqqCkpISHj16BABYu3Yt5OTk8Pz5cwDAJ598gnfffRcA8PLlS/z73/+GiYkJ9PX1sXjxYlRWVgIAEhMTweVy8eWXX6Jfv36YP39+s5iuXLmCqVOnwtDQEBwOB2ZmZggODuY/b2Zmhg0bNsDa2hqampqYP38+qqqq+M/HxcXBwcEBGhoacHd3R2ZmJv+5wsJCTJs2Dbq6utDW1sayZctw8+ZNLF68GElJSVBRUYGGhgYAYN68eViyZAl8fHzQt29fJCQk4OjRoxg6dCjU1NRgbGyMzz//vEOf9wcffIBvvvkGpaWlLT5/6dIlODs7Q11dHc7Ozrh06RL/udd/jefm5sLLywvq6urQ0dHBjBkz+OfdunULY8eOhZaWFiwtLbF//36BYuvbty+8vb3x559/IikpCUePHgUA1NXVISIiAgMGDIC2tjYCAwPx5MkTAP/fJLd9+3aYmJhAR0cH69at45eZkpICJycnqKmpQV9fH++9916j19XU1GDVqlU4f/48li1bBhUVFSxbtgxLly7F+++/3yg+Pz8/fP/99wK9F9JBjJA2mJqaslOnTjHGGCsoKGDW1tbsk08+YYwx5unpyZYsWcIqKytZWloa09HRYadPn2aMMebh4cEOHDjAGGNs7NixzNzcnB07doz/3B9//MEYY2z58uXMz8+PPX78mD1//pz5+vqylStXMsYYS0hIYLKysuzDDz9kVVVVrKKioll8//nPf5ixsTHbtGkTy8zMZHV1dc3it7GxYQUFBezx48fM3d2drVq1ijHG2NWrV5muri67fPkyq6mpYdHR0czU1JRVVVWxmpoaZmdnx959911WXl7OKisr2fnz5xljjP32229s+PDhja4TEhLC1NTU2IULF1htbS2rrKxkCQkJLDMzk9XW1rKMjAymp6fHDh06xBhj7O7duwwAq66ubvNznzp1Kj/eqKgo5uXlxRhj7PHjx0xDQ4Pt2LGDVVdXsz179jANDQ326NEjxhhjXl5eLCoqijHG2MyZM9natWv5cTW8j/Lycsblctm2bdtYdXU1u3r1KtPW1mY3btxoMabXy3ydh4cH+/DDDxljjH333Xds2LBhrLCwkFVVVbGwsDA2c+bMRu954cKFrKKigqWnpzMFBQWWlZXFGGPM1dWV7dixgzHGWFlZGUtKSmrxs2oaR3JyMjMwMGC1tbWMMcZKSkqYkpISu3//fovvg3QNJQ3SJlNTU9a3b1+mrq7OTExM2JIlS1hFRQUrKChgMjIy7Pnz5/xzV65cyUJCQhhjjH3yySfs7bffZtXV1UxfX599//337KOPPmKVlZVMUVGRlZSUsLq6OqasrMxyc3P5ZVy6dImZmZkxxuqThry8PKusrGw1vpqaGrZx40bm7u7OFBQUmIGBAYuOjm4U/y+//MJ/fPToUWZubs4YY2zx4sX8BNhg0KBBLDExkV26dInp6Oi0+KXeWtIICgpq87Ncvnw5e/fddxljgieN69evMzU1Nfbw4cNGSWPHjh3M2dm50WtcXV3Zb7/9xhhr/MUaFBTEFi1axAoLCxudHxMTw0aMGNHoWFhYGPv8889bjKm1pDFjxgy2cOFCxhhjgwcP5v9wYIyx4uJiJicnx6qrq/nv+fU4nJ2d2d69exlj9cln9erVrKSkpFH57SWNhuv+9ddfjDHGfvrpJzZx4sQW3wPpOmqeIu06fPgwSktLkZ+fj59//hlKSkooLi6GlpYWVFVV+eeZmpqiqKgIAODl5YXExERcu3YNQ4YMwdixY3H27FlcvnwZFhYW0NHRQUlJCSoqKuDo6AgNDQ1oaGhgwoQJKCkp4Zepq6sLRUXFVmOTlZXF0qVLcfHiRZSWlmLVqlUIDQ3FzZs3+ecYGxs3irG4uBgAkJ+fj2+//ZZ/bQ0NDRQWFqK4uBiFhYUwNTWFnJycwJ/T69cBgOTkZIwcORK6urpQV1fH5s2b+U12grK1tYWvry8iIiIaHS8uLoapqWmjY69//q/76quvwBiDi4sLbGxssG3bNgD17z85ObnR+9+9ezfu37/foRiLioqgpaXFL3Pq1Kn88qysrCArK4sHDx7wz+/Xrx///5WVlfkDK7Zu3Yrbt29j8ODBcHZ2RlxcnMAxhISEYNeuXQCAXbt2ISgoqEPvgQiOkgbpFENDQzx58gRlZWX8YwUFBTAyMgIAuLu7Izs7G4cOHYKXlxesra1RUFCAo0ePwsvLCwCgo6MDJSUl/P333ygtLUVpaSmePXvWaHQWh8MROCYlJSUsXboUmpqayMrK4h8vLCxsFKOhoSGA+i/5VatW8a9dWlqKiooKzJo1C8bGxigoKGix8721mJoenz17Nvz9/VFYWIhnz55h8eLFneowXrNmDaKioholBENDQ+Tn5zc67/XP/3X9+vVDVFQUiouL8euvv+Ktt95Cbm4ujI2N4eXl1ej9l5eX45dffhE4tsLCQly9ehUeHh4A6j/T48ePNyqzqqqqxbiaGjhwIPbu3YuHDx/io48+wr/+9a9Go8catPT5z507F0eOHEFGRgZu3ryJKVOmCPweSMdQ0iCdYmxsDHd3d4SHh6OqqgqZmZnYunUr5syZA6D+F6SjoyM2bdrETxLu7u749ddf+Y9lZGSwaNEirFixAg8fPgRQ/6v15MmTAsfx/fffIzExEZWVlaipqcH27dtRVlbWaATVpk2bwOPx8OTJE6xfv57fEbxo0SJs3rwZycnJYIzhxYsXOHr0KMrKyuDi4gIDAwOsXLkSL168QFVVFS5evAgA0NfXB4/Hw6tXr9qMraysDFpaWlBUVERKSgr27Nkj8Pt6nYWFBWbMmIEff/yRf8zHxwe3b9/Gnj17UFNTg3379iErKwu+vr7NXv/777+Dx+MBADQ1NcHhcCArKwtfX1/cvn0bO3fuRHV1Naqrq3HlypVGtbTWVFRU4OzZs5g8eTJcXFzg4+MDAFi8eDFWrVrFT2glJSU4cuSIQO9z165dKCkpgYyMDH+AQcMw29fp6+vjzp07jY5xuVw4OzsjKCgIAQEBUFJSEuiapOMoaZBO27t3L/Ly8mBoaIipU6dizZo1GDt2LP95Ly8vVFdXw8XFhf+4rKwMnp6e/HO+/PJLWFhYwNXVFWpqahgzZgyys7MFjkFJSQnvv/8++vXrBx0dHWzatAkHDx6Eubk5/5zZs2dj3LhxMDc3h7m5OT755BMAgJOTE6KiorBs2TJoamrCwsIC0dHRAOq/rGJjY5GbmwsTExNwuVzs27cPADBq1CjY2Njwr9man3/+GatXr4aqqiq++OILBAYGCvy+mlq9enWjX93a2tqIi4vDt99+C21tbXz11VeIi4trMZ4rV65g2LBhUFFRgb+/P3744Qf0798fqqqq+OuvvxATEwNDQ0P069cPH330UZvzLpYtWwZVVVXo6+vj3XffRUBAAE6cOAEZmfqvkuXLl8Pf3x/jxo2DqqoqXF1dkZycLNB7PHHiBGxsbKCiooLly5cjJiamxabJ5cuX48CBA9DU1MQ777zDPx4SEoLr169T01Q347DO1JcJ6SHMzMywZcsWjBkzRtyhkG527tw5zJ07F3l5efwkRoSPPllCSI9XXV2NH374AQsXLqSE0c3o0yWE9Gg3b96EhoYG7t27x580SroPNU8RQggRGNU0CCGECIySBiGEEIEJPt21h9LR0YGZmZm4wyACePHiBfr27SvuMAjh6833ZF5eXosrGEh90jAzM0Nqaqq4wyACSExMFHi/CEJEoTffk05OTi0el9qkERsbi9jYWDx79kzcoRBCiNSQ2j4NPz8/REZGQl1dXdyhEEKI1JDapEEIIUT4qHmKEEKIwKS2pkHNU4QQInxSmzQIIYQIn9QmjdjYWISFhXW6eYoxhvT09E5tmkMIIdJKapNGV5unMjIyEBAQgIyMDCFHRgghPZfUJo2usre3x8GDB2Fvby/uUAghRGJI7eipruJwOHBwcBB3GIQQIlGopkEIIURgUlvToHkahBAifFJb06B5GoQQInxSmzQIIYQIHyUNQgghAqOkQQghRGCUNAghhAiMRk8RQggRmNTWNGj0FCGECJ/UJg1CCCHCR0mDEEKIwChpEEIIERglDUIIIQKjpEEIIURglDQIIYQIrMcljcOHD2PRokWYPHky/vrrL3GHQwghvYpIk0ZoaCj09PRga2vb6PiJEydgaWkJCwsLREREtFnGlClTEBUVhejoaOzbt687wyWEENKESGeEz5s3D8uWLUNwcDD/WG1tLZYuXYpTp06By+XC2dkZ/v7+qK2tRXh4eKPXb9u2DXp6egCAtWvXYunSpaIMnxBCej2RJg1PT0/k5eU1OpaSkgILCwuYm5sDAGbOnIkjR44gPDwccXFxzcpgjGHlypWYOHEi3njjDVGETQgh5H/EvvZUUVERjI2N+Y+5XC6Sk5NbPf+nn37C6dOn8ezZM+Tm5mLx4sXNzomMjERkZCQAgMfjITExUehxE+ErLy+nvxWRKHRPNif2pMEYa3aMw+G0ev4777yDd955p80yw8LCYGBgwF+w0Nvbu6thEhFITEykvxWRKHRPNif20VNcLheFhYX8xzweD4aGhl0ulxYsJIQQ4RN70nB2dkZOTg7u3r2LV69eISYmBv7+/l0uNzY2FmFhYZ1eGv1VTV2LtSBCCOnNRJo0Zs2aBTc3N2RnZ4PL5WLr1q2Qk5PDxo0bMX78eFhZWSEwMBA2NjZdvlZXaxrfnsqG/8aL+D21EFXVtV2OhxBCpIFI+zT27t3b4nEfHx/4+PgI9Vpd3YTJUl8VCbce4oMDmVh/7CZmOJtgrqsJuJrKQo2TEEJ6ErE3T3WXrtY0pr3Bxcl3PbF3kStczbURdf4OPL9KwKIdqbiQ86jHNF0xxpCent5j4iWESDaxj56SZBwOB24DtOE2QBvFpZXYk1yAvSkFOJX1AAN0+yLYzQzT3jCCqqK8uENtVUZGBgICAnDw4EE4ODiIOxxCSA8ntTWNrnaEN2WooYR/j7fEpfBR+G+gPVQU5fHZn3/DdX08Vh+5gdyHZUK5jrDZ29vj4MGDsLe3F3cohBApILU1DT8/P/j5+cHJyUmo5faRk8W0N7iY9gYX6YWl2JGUh5iUQuxIysdwC20Eu5lh9GA9yMlKRj7mcDhUwyCECI3UJg1RcDDWgIOxA1b5WCHmSiF2X87HmzuvwkhDCXNcTTDT2QRafRXEHSYhhAiN1CaNro6e6ghtlT5YOtICb3qa4/TNh9iRlIevTmTj+9M58LMzRIi7Key4Gt0eByGEdDepTRrd1TzVFjlZGUyw7YcJtv2Q86AMO5LycfAaDwev8eBgrIEQd1P4DDFAHzlZkcVECCHCJBkN71JooL4q/jPFFpc/Ho3P/azxvLIaK/ZlwH3DGXxzMhv3nlWKO0RCCOkwqa1piLJ5qi1qivKYN7w/gt3McPGfR9h+KR+bEnPxy9l/MN5GH8FuZhjWX6vNRRoJIURSSG3SEEfzVFtkZDjwGKgLj4G6KHxSgV3J+dh3pRDHrt+Hpb4qgt1NMcXBCH37SO2fhBAiBah5SgyMtZQRPtEKl8NH46t/2UFOloNVh27AdUM8vojNwt1HL8QdIiGEtIh+1oqRorwsAp2MMd2Ri2sF9XM+dl7Ow7aLd+E1SBch7qbwGqQHWRlquiKESAZKGhKAw+HA0VQTjqaaWDXJCjEphdidnI/Q6FSYaCkjyNUU05240FCmOR+EEPGS2qQhKR3hHaWnqoh3Rg/EEu8BOPn3fey4lI91x27i21PZmOJghGA3M1gbqok7TEJILyW1SUPSOsI7Sl5WBr52hvC1M8TNe8+xIykfh9J4iLlSCGczTQS7mWGCbT/IS8hyJYSQ3kFqk4Y0sTJQw4ZpQ7BywmD8frV+nau396ZBT7UPZg8zwWwXE+ipKYo7TEJIL0BJowdRV5bHQg9zhA7vj7O3S7A9KQ/fn87BxjO5mDjEACFupnA01aQ5H4SQbkNJoweSkeFg5GA9jBysh7xHL7Dzcj72pxYiNqMY1gZqCHE3hb+9EZQUaLkSQohwUYN4D2em0xef+loj+ePRWD91COoYw0cHr8N1QzzWH7uJgscV4g6RECJFpLam0VNHT3WWsoIcZg8zwSwXY6TcfYIdSfnYeuEuos7fwShLPQS7m8HDQgcyNOeDENIFUps0evroqc7icDgYZq6NYebauPfs/7eoDdmWAnOdvghyM0WAIxdqErxFLSFEclHzlBQzUFfC++MscXHlKPww0wHqyvJYE5sF1/Xx+OTwddx+IJlb1BJCJJfU1jTI/+sjJ4vJDkaY7GCETF4pdiTlY38qD7suF8DNXBsh7qYYY6UvMVvUEkIkFyWNXsaOq4FvpmvgYx8r7LtSiF2X87F41zUYqCtirqspZjgbQ0elj7jDJIRIKPpp2Utp9VXAEu8BOPfhSEQGOWKArgq+PpkN9w1n8N6+dKQXloo7REKIBKKaRi8nK8PBOJt+GGfTD7kPy7AzKR8HrvLwR1oR7LnqCHYzwyQ7AyjK05wPQgjVNMhrLPRUsWZy/Ra1X0y2QfnLGrz/ewaGR5zB1ydvobiUtqglpLfrUTWNmzdv4ocffsCjR48wevRoLFmyRNwhSSVVRXkEu5khyNUUl/55jO2X8vBL4j/4JfEfjLPuh2B3U7iZa9NyJYT0QiKraYSGhkJPTw+2traNjp84cQKWlpawsLBAREREm2VYWVlh8+bN2L9/P1JTU7szXIL6OR/DLXQQGeyEcx+OxJteA5B89zFmRyVj3HfnsPNyPl68rBF3mIQQERJZ0pg3bx5OnDjR6FhtbS2WLl2K48ePIysrC3v37kVWVhauX78OX1/fRv89fPgQAPDnn39ixIgRGD16tKhCJwC4msr4aMJgJIWPxjfT7aEoL4tPD9+A6/p4fP7n3/inpFzcIRJCREBkzVOenp7Iy8trdCwlJQUWFhYwNzcHAMycORNHjhxBeHg44uLiWizH398f/v7+mDRpEmbPnt3dYZMmFOVl8S9HLgLeMEJaYSl2XMrD7uR8RF/Kg8dAHYS4mWHkYNqilhBpJdY+jaKiIhgbG/Mfc7lcJCcnt3p+YmIi/vjjD7x8+RI+Pj6tnhcZGYnIyEgAAI/HQ2JiotBiJo1N6QeM1FTCWV41EgoeY2HOI+gocTDKRA6eRvJQURA8eZSXl9PfikgUuiebE2vSYIw1O9ZW56q3tze8vb3bLTcsLAwGBgb8BQsFeQ3pmskAqmvrcCrrAbZfysP+7Cc48k8tJjsYItjNDLZG6u2WkZiYSH8rIlHonmxOrEmDy+WisLCQ/5jH48HQ0FAoZffWBQvFSV5WBj5DDOAzxAC37v9vi9prRdifyoOjqSaC3Uwx0dYACnI00puQnkqs/3qdnZ2Rk5ODu3fv4tWrV4iJiYG/v79Qyo6NjUVYWFivWRpd0gzup4b1U4fg8sej8amvNR6Xv8TymHS4R5zBf0/dxoPnVeIOkRDSCSJLGrNmzYKbmxuys7PB5XKxdetWyMnJYePGjRg/fjysrKwQGBgIGxsboVzPz88PkZGRUFdvv1mEdB91JXksGNEfZ973RvR8Z9hx1fHTmRwMjziDpXuuIeXukxabKQkhkklkzVN79+5t8biPj0+bndqd1ds2YZJ0MjIceFvqwdtSD/mPX2BnUv0WtUcz72FwP1WEuJtBq4aSByGSjsOk/Geek5MTTQSUUJWvanEkvQjRl/Jw634ZlOWA2a79EeRmClPtvuIOj5Be3RHe2ncn9UgSsVFSkMVMFxMcX+6B3xe7wVZHFtGX8uD9TSLm/5aChOyHqKvr+m8axhjS09OpGYwQIRC4eaq6uhrZ2dkoLS2FhoYGLC0tIS8vuVuGUvNUz8HhcOBspoW3HBQxeKgr9qQUYE9yAeb/dgWm2soIcjXFdCdjqCt17n7LyMhAQEAADh48CAcHByFHT0jv0m7z1NGjR7F582bEx8dDXl4eqqqqKCsrQ3V1NUaNGoXFixfD19dXVPF2GDVP9RyvNwW8qqnD8Rv3sDMpH6n5T6EkL4spQ40Q4m6Kwf3UOlQuYwwZGRmwt7enRRZJh1DzVPPvzjZrGsOHD4empiZmz56NX3/9tdEcinv37iExMRGbN2/Ghg0bcPHiReFHTXotBTkZ/ha1N4qeYUdSHv64xsPelAIM66+FEHczjLXWh7wAW9RyOByqYRAiJG0mjc2bN2PIkCEtPmdgYIBZs2Zh1qxZuHHjRrcE1xXUPCU9bAzVMNuCYeWEUfj9Kg87L+fjrd3X0E9NEXOGmWCmiwl0VWmLWkJEoc2faa8njIKCAtTW1jY7h8fjNVvuXBLQPA3p0dAnUZB7E296DcDZD0YiKtgJA/VV8O2p23CPiMe7MWm4VvBUaJ3d1HlOSMsEHj1lZmaGMWPG4MmTJ42OW1tbCz0oQl5nb2+PgwcPwt7eHkD9FrVjrfWxc8EwxL/vhTnDTHH65kNM+/kS/DdexO+phaiqbv4DpyMaElVGRoYw3gIhUkPgpKGsrAx3d3c4OTkhMzOTf1xSf4nRMiLSo6FPoqVO7AG6Kvjc3waXPx6N/0yxRVV1LT44kAm3DfGIOH4LvKcVnbpm00RFCKkncNKQkZHBunXrsGHDBowZMwYHDhwA0PaqtOJEzVO9i0ofOQS5muKvFZ7Ys2gYhvXXRuS5f+D5VQIW7UjFhZxHHfqB01aiIqQ36/AyIjNmzMCgQYMwbdo0ZGRkSGxNg4iPOIe4cjgcuA/QgfsAHRSVVmJPcj72phTiVNYDDNDti2A3M0x7wwiqipI7x4gQSSZwTUNWVpb//0OHDkVKSgrOnj2LiorOVf+J9JKU/gAjDSV8MH4wLq0chW+n20NFUR6f/fk3XNfHY/WRG8h9SFvUEtJRAtc0nj592uixrq4uEhISwOPxhB4U6dkkrT9AUV4WAY5cBDhykV5Yih1JeYhJKcSOpHyMsNBBsJspRlvp0xa1hAig3aRx584dUcQhdDRPQ3wkeTKdg7EGHIwd8LGPFfZdKcSuy/kI23kVRhpKmOtqihnOxtDqqyDuMAmRWO0uIyIjIwMOh8Pvu3j9/xsetzR/Q1LQMiI9hziWbKiprcPpmw+w/VI+ku48hoKcDPztDRHiZoYhXBpE0dvRMiIdXEYEAOrq6ho91tTUbNZURUhPJScrgwm2Bphga4DbD8r+t1xJEQ5c5WGoiQZC3MwwcUg/9JGTbbcsQnqDDi+NTkMQibQapK+KtVPqt6j9zM8apRXVeHdfOoZHnMG3f2Xj3rPKLpVPs8yJNKD9NAhpQk1RHvOH90f8e17YEeoCB2MNbEzIxYgvE7B09zVcvvO4U1/8kjKqjJCuENl2r4T0NDIyHHgO0oXnIF0UPqnAzsv52HelEEev34OlviqC3U0xdagRlBUE+2ckaaPKCOmMdu/2oKCgRk1SL168QHBwcKNzduzYIfzICJEgxlrK+NjHCivGDMKfGUXYfikfqw7dQMTxWwh0MkaQqynMdNreolaSR5URIqh2k4aFhUWjxx9//HG3BSNMNOSWdAclBVnMcDZBoJMxruY/xfakfGy/lIetF+7C21IXIW5m8BqkCxma80GkVLtJY/jw4fDy8pLorV1b4ufnBz8/Pzg5OYk7FCKFOBwOnMy04GSmhYeTrLAnpQC7kwswP/oKTLSUEexmiumOxlBX7ln/bghpT7sd4V9//TUMDQ0xZcoUREVFoaioSBRxEdJj6Kkp4t0xg3Dxo1H4adZQ6Kn2wdqjNzFsw2mE/5GJrOLn4g6REKFpt6Zx8uRJVFRUID4+HseOHcO6deugrq6OSZMmwcfHB+7u7pCRoUFYhCjIycDP3hB+9ob4u/gZdibl41BaEfamFMLZTBPBbmaYYNtPoC1qCZFUAt29ysrK8PPzwy+//IK8vDzs3r0bGhoaWLVqFQwMDDBz5kwkJyd3d6yE9Bg2huqICLDD5fDRWOVjhQfPX+LtvWkYHnEG35++jYdlVeIOkZBO6dSQW1tbW9ja2uLDDz/E8+fPcfLkSZSVlQk7NkJ6PA1lBSzyNEfoiP44e/shdiTl4/vTOdiUkIuJtgYIcTfFGyaaNGmW9Bjt1jSSk5PxwQcf8Fez/eabbxo9r6amhunTp2PMmDHdEyEhUkBWhoNRg/URPd8FCf/2RpCrGRKyHyLglyT4/nQB+690fYtaQkSh3aSxYsUKuLi4ICQkBDdu3MC5c+dEEVerXrx4AUdHR8TFxYk1DkI6q79OX6z2s8bl8NFYN9UWNbUMHx7MhOuGeGw4dhOFT2iPGiK52k0aXC4X06dPx++//44PP/yw06OnQkNDoaenB1tb2wqpUMMAACAASURBVEbHT5w4AUtLS1hYWCAiIqLdcr788ksEBgZ2KgZCJEnfPnKYM8wUJ971QEyYK9wHaGPLhbvw/DoBC7dfwbnbJairo3WqiGRpt0+jf//+AAAtLS1s27YN06dP79SF5s2bh2XLljWaTV5bW4ulS5fi1KlT4HK5cHZ2hr+/P2praxEeHt7o9du2bUNmZiasra1RVUWdiER6cDgcuJprw9VcG/eeVWJPcgH2phTg9M0UmOv0RZCbKQIcuVCjLWqJBGg3aXh5eaGurg4yMjLo168fzp8/36kLeXp6Ii8vr9GxlJQUWFhYwNzcHAAwc+ZMHDlyBOHh4S02PyUkJODFixfIysqCkpISfHx8aLgvkSoG6kp4f5wllo2ywPHr97E9KQ9rYrPw9clsTHvDCMFuZhikr9rsdeLcl530Lu0mjfnz50NGRgZz5sxBSEgIhgwZIrSLFxUVwdjYmP+Yy+W2OXR33bp1AIDo6Gjo6Oi0mjAiIyMRGRkJAODxeEhMTBRazKT7lJeX09/qNRoAllsDd40UEV9Qg5iUAuy6XAArLRmMNpHHUD1Z/ha1ubm5WL16Nb744otmS/+QzqN7srl2k0ZxcTGOHz+OnTt3YtiwYbC0tERISAhmz54NPT29Ll28peWlBfmVNG/evDafDwsLg4GBAX/tqd6681ZP05t3SWvQUo3BG8B8AE9evOJvUbsxvRIG6or8LWq9vLzg5ORENQ0ho3uyuXbbdmRlZeHr64t9+/bh/v37eOutt3Do0CGYmJjAz88PBw4c6PTFuVwuCgsL+Y95PB4MDQ07Xd7r/Pz8EBkZCXV12rKT9Bxt7bmh1VcBS7wH4NyHIxEZ5IgBuir4+mQ23Decwfv7MwBtM0oYpNt1aHKfmpoaFi1ahEWLFuHy5cuYNWsWZsyY0ek9wp2dnZGTk4O7d+/CyMgIMTEx2LNnT6fKaopWuSU9kSB7bsjKcDDOph/G2fRD7sMy7EzKx4GrPPyRVgR7rjqC3cwwyc4AivK0RS0Rvg71Ir98+RIxMTHw8fGBl5cX+vfvj23btgn02lmzZsHNzQ3Z2dngcrnYunUr5OTksHHjRowfPx5WVlYIDAyEjY1Np95IU1TTID1Rw54bgtYYLPRUsWayLS5/PBpfTLZB+csavP97BoZHnMHXJ2+huLRrW9QS0hSHCbBv5blz57Bjxw4cOHAA+vr6CAoKQnBwMExMTEQRY6c01DQSEhKQk5Mj7nCIAKj9uOsYY7iY+xjbk/IQf/MBAGCcdT8Eu5vCzVybmq86qDffk05OTkhNTW12XKB5Gs+ePcP06dNx7NgxuLu7d0uAwkb7aZDeiMPhYMRAHYwYqIPCJxXYlVy/Re2Jv+9joJ4Kgt3NMG2oEfr2oZ2eSee0e+ds2LABU6dORZ8+fUQRDyFESIy1lBE+sX6L2tiMYmxPysOnh2/gq+O3EODIRZCbKQboqnS4XJoT0ru12aeRkZGBmTNntpswWhrpIW6xsbEICwujjnDS6ynKy2K6kzFil43AH2+5Y7SVHnYn52P0t2cRtDUZp7MeoLYDy5W0NcKLSL82+zRGjBgBNTU1BAUFwcvLq9Fw2Hv37uHs2bPYsWMHysvLxb6QYWtaa5cjkqc3tx+LWknZy/rJgsn5ePD8JbiaSghyNUWgkzE0+yq0+dreVNPozfdkp/o0Lly4gLi4OGzevBkLFiyArKwsVFVVUVZWBsYYxowZg2XLlsHHx6fbAieECJ+uah+8PXogFnsPwKmsB4i+lIcNx2/hv6duY7KDIYLdzGBr1PLIw4YRXqR3ardPw9fXF76+vqiurkZOTg5KS0uhqamJgQMHQk5OcjvTaJ4GIa17vbbgM8QAPkMMcPPec+xIysfhtCLsT+XB0VQTIe5mmGDTDwpytMYbqSfQkNuejJqneo7e3BQgaunp6QgICMDBgweb1RqeVVTj96uF2Hk5H/mPK6Cr2gezXUwwe5gJ9NUUxRSxePTme7K17076+UCIFGOMIT09vdk6b23NPFdXlsdCD3MkvO+N3+Y7Y4iROn48k4PhEWewbM81XMl70uK6caR3kNz2pS6i5ilC/n+kU9MahSD9EjIyHIy01MNISz3kP36BXZfr53zEZd6DlYEaQtxMMdnBCEoKtFxJb0LNU0Ri9OamgO7S1ZFOTV9f+aoWh9OLsP1SHm7dL4O6kjwCnbgIcjWDibZyN7wD8erN96RQmqcqKytx7949VFbSejaEiFprTU1t6ehaVk01nZOhpCCLWS4mOL7cA/vfdMOIgTrYdjEPXt8kIDT6ChKzH0rMFrWd+bxI+wRKGgkJCXBxcYGqqiq4XC5UVVXh4uKC+Pj47o6PEPI/4phU11rfB4fDgUt/LWya/QYufDgSgdaqyOSVYt5vVzDq20RsvXAXzyqrRRZnS2gSYvdoN2mkpqbCx8cHw4YNw6lTp5CVlYW//voLLi4u8PPzw5UrV0QRJyG9niDLpgubIDWVB3nZOPD5fPwyUQc/zHSAVl8F/CcuC67r4/HxoevIvl/W6mu7szYgjs+rN2i3T2PGjBkYPHgw1qxZ0+y5NWvW4O+//8b+/fu7LcDOolVue57e3H7ckzXt92CM4Y+EK0h+0gdH0ovxsqYOruZaCHEzw1hrfcjJ/v9v1baG/kqC3nxPttan0W7SMDExweXLl1vcUa+4uBguLi7g8XjCi1TIqCO85+jN/0ClyeuJwHSgNfal1m9Ry3tav0XtnGEmmOliAh2VPhK/JElvvic73RFeWlra6hashoaGNKSVENLI681Cmn0VsNhrAM5+MBJbgp1goaeCb/66DfcNZ/BuTBrSCkuFkjCo01t0ujxPQxJ/HRBCxKelOSCyMhyMsdbHGGt9/FNSzt+i9nB6MYYYqSPYzRR+9oad3qK2tfkoRPjaTRovXrxodYc+xhgqKiqEHhQhRHqZ6/TFFJNqvD9uFA6nFWFHUj4+OJCJ9cduYoazCea6moCrqdyhpivq9BaddpPGmTNnRBEHIT2apLfNC0JU7+H1WkGQmwPmupoi6c5j7LiUj8hz/yDy3D8YbaWPEXo1WLN0Dv4QoPbQlZV3peFvJ0rtJg0vLy9RxEFIjyYNzSOieg9NawUcDgfuA3TgPkAHvKcV+D72Cs7kP8WprFfgLvgZGRXqsHhZA5X/bVEr7C95afjbiVK7HeEnTpzApUuX+I//+ecfDB8+HOrq6pgwYQLu3bvXrQF2Fu3cR0RJGppHRPUe2pr78Sj/Ng6tCcVmHx18O90eWmp98dmf9XM+PjtyA7kPy4U+aU8a/nai1O6QW2dnZ/z4449wc3MDAHh7e0NZWRlLly7Ftm3boKioiN27d4sk2M6gIbc9R28e3kjqtVSLSC8sxfZLeTiaeQ+vausw3EIbnv0YFkwc1mjOR3dcuzffk53auQ+or1k4OzsDAB4+fIgLFy4gPz8fRkZGGDZsGOzs7IQfLSGkV2qpb8LBWAMOMxywapIV9l2pn/NxMbcKO24kYq6rKWY4G0OrnS1qBUHNVILpUJpOSkpC//79YWRkBADQ1tZGeXl5twRGCCGv01Hpg6UjLXD+w5HYPPcNmGgp48sTt+C6IR7//j0D13mtN0ULMo+jvWYqmgtSr92k0dA89fz5c2zZsgUTJ07kP3fnzh3o6Oh0a4CEEPI6OVkZTLA1wN4wV5x81wOjzJRw7Po9+G28gGk/X8ThtCK8rKlt9Jqm/SAtJYD21tmiBRDrtZs0vvvuO2zatAkaGhq4ffs2Vq5cyX9u586d8PT07NYACSGkNZX37+DUhgWI8tXDZ37WeFpRjXf3pWN4RAL++1c27j+rAtC8FtGZBEAd5vUE3oTp8ePH0NbWbnSstLQUCgoKUFaW3M1XqCO85+jNnY6kc5p2XtfVMZzLKcGmk9eReq8KMhwOJtj0Q7CbKVz6a/FrEYIO2+3N92Sn156qqKjAxx9/jPnz5+Pzzz/Hy5cv+c9paGiINGEkJibCw8MDixcvRmJiosiuSwiRTE2blGRkONCoLMa1H8KweZI+Fozojwu5jzAj8jIm/nAee5ILUPGqpsubU/Vm7SaNZcuWITY2FoMHD8aBAwfw73//u1MXCg0NhZ6eHmxtbRsdP3HiBCwtLWFhYYGIiIg2y+BwOFBRUUFVVRW4XG6n4iCESLeGZqRxwx3xsY8VLoePxpcBQ8DhcPDxoesYtj4e/4nLQt6jF50qv9d3iLN29OvXjxUXFzPGGCsoKGBmZmbtvaRFZ8+eZVevXmU2Njb8YzU1Nczc3Jz9888/7OXLl8zOzo79/fffLDMzk02aNKnRfw8ePGC1tbWMMcbu37/PZs+eLdB1HR0dOxUvEb2EhARxh0CkWF1dHUu5+5gt23ONDQg/ykw/imMh25LZmZsPWG1tXYuvaemeTEtLY+bm5iwtLa1LsaSlpbG6upav29L5165dY9euXRP4NV3V2nenQAsWGhgYAACMjY07PcPa09MTeXl5jY6lpKTAwsIC5ubmAICZM2fiyJEjCA8PR1xcXKtlaWpqNmomI4RILiYhaztxOBw4m2nB2UwLDydZYU9KAfYkF2B+9BWYaisjyNUU0x2Noa4s32Y5Xe0QZ4xh//79+PjjjwWeE5KRkQE/Pz8AQFxcnFjnkbSbNGpqapCQkMCvijV9DACjRo3q1MWLiopgbGzMf8zlcpGcnNzq+X/88QdOnjyJ0tJSLFu2rNXzIiMjERkZCQDg8XjU/9FDlJeX099KCuXm5mL16tX44osvYGFhIdZYGGP4559/MGDAADjIcWDrJovUB30Qn1+FtUdv4qvjN+FmKIcxpvIwVpVp8548e/Zsp2LIzc3Fp59+ikWLFuHp06cC3fOMMXz22WcA0Ow1r78nUSTldpOGnp4eQkND+Y+1tbUbPeZwOLhz506nLs5aaBNs601PmzYN06ZNa7fcsLAwGBgYIDY2Fs+ePeu1ox96mt48UkWaeXl5wcnJSew1DaB+V8ENGzY0+oU/BsBKAH8XP8POpHwcTi/CWV4lXMy04KRegxUTPSEvxOVKBP08mtbQRo4cKfB76k7tJo2mTUrCxOVyUVhYyH/M4/Fa3SWwo/z8/ODn5wcnJyehlEcI6ZyuLFsubG01LdkYqiMiwA4rJw7G76k87Lich5/zXuLAnTMYbaqAFf4u0FNT7HIMgn4egi5rIur5I8JLn53g7OyMnJwc3L17F69evUJMTAz8/f2FUjatcksIaUqQobYaygpY5GmOxH+PxLtv9IFRX2DvjTK4R8Tjnb1puJr/RGgjpxhjSEtLQ1paWrMyBU0GHA4H9vb2yMjIEMmILpEljVmzZsHNzQ3Z2dngcrnYunUr5OTksHHjRowfPx5WVlYIDAyEjY2NUK7n5+eHyMhIqKurC6U8QkjvIivDgYOeHP5YPhqbfPQw19UMCbceIuCXJPhtvID9qYWoqq5tv6A2NHRw+/n5NZud3pG5JKJc4kTgGeE9TWxsLGJjY5GQkICcnBxxh0MEQH0aRNI0vSdfvKzBobQi7EjKw+0H5dBQlscMZ2PMHWYKY62OT3Rm/5vzAaDVBCHI6LPuGKHW2oxwqU0aDWgZkZ6DkgaRNK3dk4wx/ha1p24+QB1jGD1YDyHuZhhhoSPUDv/09HSxLNne6WVECCGkN2KMITc3t9VRnu4DdPDL3Dfwq68+3vIegPTCUgRtTcHo/57FbxfvoqyqulPXbDrbXNIWSpTapEEd4YSQrsjIyMDq1avb7CfIyMjAm0GBGKtfhYsrR+G7GfZQU5THmtgsDFsfj08OX0fOg7IOXbNp30RH18lqKfEIEzVPEYlBzVNEkjDGsHXrVixYsKDDfQmZvFJsv5SP2MxivKqpg/sAbQS7mWGMlV6bW9QKo29CWM1Znd7ulRBCeiMOhwMLC4s2v7xbm3Nhx9XAt4EaWDXJCjFXCrArKR+Ld12Foboi5riaYqazMbRV+jR6jbA6s7u7OYuapwghpJtoKsvDXaMcZz/wxq9BjjDT6YuvT2bDLeIM3tufjozCUv65who2293Lvktt0qB5GoQQcXi9T6EhEfx94zrG2/TDnkWuOLXCEzOdjXHyxn1M3nQRkzddxB/XeBhsY4uDBw/Czs6uU30S3d2X0UBqkwYhhIhawwq2DTWGlpqKBuqr4ovJtrj88Wh87meNsqpqvLc/A8MjEnD6gRLik651qsYhqgl+Utun0TC5j5qnCCGikpGRgfDwcGzYsIHfN9HQ59G0z0JVUR7zhvdHiLsZLuY+RvSlPPycmFu/hPuKSFSocFFXV4fMzEyB+jlENTRXamsa1DxFCOkuTZuCGh7b2dnhjz/+QGBgYLMv+dZqAhwOByMG6mBLiBPOfjASCz3649aTWszekgzvL09h6gff4XJqWrsxiWoLW6lNGoQQ0l2aJoCGx5mZma1+cQtSEzDWUkb4xPotar/6lx3U+iqDOQYiLK4Ea2L/xp2S8m57T4KS2uYpQgjpLk0TgCAJoSNLxCvKyyLQyRjTHbm4VlCKHUl52HU5H79dzIPnIF2EuJnC21IPsjKi35+EkgYhhHRQ0wTQUkIQxrwLDocDR1NNOJpqYtUkK+xNLsSelHws2J4KY00lBLmZItDJGBrKCl16Px0htc1TNE+DECJOwh7NpKeqiOVjBmLTBG1wLm2D3KtyrD92C8PWx+OjA5n4u1g033VSmzSoI5wQIk7dNZrJcagDIpYGoiB6Bb4brwsvU0X8mVGMST9ewL9+uYQ/M+qXLukuUps0CCHSQ1QT14Spu0YzcTgcBAYG4uDBgzDTkEd8xEJE+enhk0lWKCl/iXf2pmH4l2dwreCpUK/bgPo0CCEST9D9snuLhoTEGOPXZkZwOAgd3h9nb5cg5koBLPRUuuXalDQIIRJP0vaUkBRNO+BlZDgYOVgPIwfrdds1KWkQQiReR4arku5FfRqEEEIEJrVJg4bcEkIkRXd05ItrcIDUJg0acksIkRTdsQKtqFa1bUpqkwYhhHRGd/yC746OfHENDqCkQQghr+mOX/DdMWdDVKvaNkVJgxBCXkPDe9tGQ24JIeQ1NLy3bVTTIIQQIrAeVdOoq6vDp59+iufPn8PJyQkhISHiDokQQnoVkdU0QkNDoaenB1tb20bHT5w4AUtLS1hYWCAiIqLNMo4cOYKioiLIy8uDy+V2Z7iEENLjiGLuhsiSxrx583DixIlGx2pra7F06VIcP34cWVlZ2Lt3L7KysnD9+nX4+vo2+u/hw4fIzs6Gm5sb/vvf/+KXX34RVeiEENIjiGLuhsiapzw9PZGXl9foWEpKCiwsLGBubg4AmDlzJo4cOYLw8HDExcU1K4PL5UJBoX6HKllZ2W6PmRBCehJRjPwSa59GUVERjI2N+Y+5XC6Sk5NbPX/atGl4++23cf78eXh6erZ6XmRkJCIjIwEAPB4PiYmJQouZdJ/y8nL6WxGJ0lPvybNnz3Zb2WJNGi21u7U1UUVZWRlbt25tt9ywsDCEhYUBAJycnODt7d3pGInoJCYm0t+KSBS6J5sTa9LgcrkoLCzkP+bxeDA0NBRK2bGxsYiNjaUFCwkhRIjEmjScnZ2Rk5ODu3fvwsjICDExMdizZ0+3X7e6uho8Hg9VVVXdfi0iOHV1ddy8eVPcYYiFoqIiuFwu5OXlxR0KIW0SWdKYNWsWEhMT8ejRI3C5XKxZswYLFizAxo0bMX78eNTW1iI0NBQ2NjZCuZ6fnx/8/Pzg5OTU7DkejwdVVVWYmZmJfN0W0rqysjKoqqqKOwyRY4zh8ePH4PF46N+/v7jDIaRNIksae/fubfG4j48PfHx8RBUGAKCqqooSBpEYHA4H2traKCkpEXcohLSrR80I74j2+jQoYRBJQvcj6Smkdu0p2oSJEEKEr9fWNAghhHQc1TTERFZWFg4ODrC1tcX06dNRUVEBAFi3bh1sbGxgZ2cHBwcH/mRHb29vWFpaws7ODoMHD8ayZctQWlrKL6+yshJeXl6ora0FAEyYMAEaGhrw9fVtdF1vb2+kpqbyH+fl5TVbD+x1JSUlmDBhQoff38aNG2FhYQEOh4NHjx61+zk4ODhgxowZrZ4XHR2NvLy8Lq2pc+bMGbzxxhuwtbVFSEgIampqGj3/4sULaGtrN/uhMWXKFOzfvx+fffYZQkNDGy2UWV1dDUdHRwCAiopKs5iXLVvW6XgJkURSmzQknZKSEtLT03Hjxg0oKChg8+bNSEpKQlxcHK5du4bMzEycPn260Yz53bt3IzMzE5mZmejTpw8mT57Mf27btm2YNm0af3mVDz74ADt37uxynLq6ujAwMMDFixc79Lrhw4fj9OnTMDU1bfO8hs8hPT0d+/bta/Z8UVERFixYgIKCAly4cAGLFy/uUBwN6urqEBISgpiYGNy4cQOmpqbYvn17o3P69u2LcePG4fDhw/xjz549w4ULF+Dr64s1a9Zg48aNePjwIf/5CxcuwN3dvVMxEdITSW3SiI2NRVhYWI9onvLw8EBubi7u3bsHHR0d9OnTBwCgo6PT4mRHBQUFfPXVVygoKOAvTLZ79+5GSWT06NEdHr66cOFC/q9+XV1drFmzBkD9L+3du3d3qKyhQ4fCzMysQ69piZGREdavX49t27YhJiamxYUqS0pKEBAQAGdnZzg7O7eY4B4/fow+ffpg0KBBAICxY8fi4MGDzc6bNWsWYmJi+I8PHTqECRMmQFlZGU+fPsXbb7+Nn3/+mf/8iRMnMHHixHbfR8Pn6uDgACUlpW5d5oGQ7iS1SUPSm6ca1NTU4Pjx4xgyZAjGjRuHwsJCDBo0CG+99VabXyyysrKwt7fHrVu38OrVK9y5c0fgL+k5c+bwv8BeH+68ZcsWpKen48iRI9DW1sa8efMA1C/Fcv78+RbL6uoOZ1VVVXBycoKrq2uLi1QWFxfjk08+QWhoKGbMmIGlS5c2O2f58uVYsWIFrly5goMHD2LhwoXNztHR0UF1dTW/ae7AgQONViNoMGHCBFy9ehWPHz8GAMTExGDWrFkAgDFjxuDJkydYt24dv2krISGBv8xEZWVlo+SwevVqfrkNtan//Oc/cHJyotoJ6bGktiNc0jV8wQD1NY0FCxZAQUEBV69exfnz55GQkIAZM2YgIiKC/+XdVEP7/qNHj6ChoSHwtXfv3s2f9JiXl9eo36OqqgrTp0/Hxo0b+U1Lenp6KC4ubrGs9PR0ga/bkoKCAhgaGuLOnTsYOXIkXFxcMGDAAP7zhoaGiIqKQnR0NDw8PDB37txmZZw+fRpZWVn8x8+fP282UZDD4SAmJgYrVqzAy5cvMW7cOMjJNb/9FRQU4O/vjwMHDiAgIADp6ekYN24cAODq1auNzi0uLoaWlhaUlZUB/H9TW4Po6OhG/Uc5OTn44IMPcObMGZr5TXosShpi0vQLpoGsrCy8vb3h7e2NIUOGYPv27S0mjdraWly/fh1WVlZQUlIS2pIoixcvxrRp0zBmzBj+saqqKigpKQml/KYamt/Mzc0xYsQIpKWlNUoaDVpLnEB9f0VSUlKzGMePH48HDx7AyckJW7ZsgZubG7/G9Ndff+H27dstljdr1iysXbsWjDFMnjy51S/448ePY/z48YK8Tbx48QKBgYGIiooS2vpqhIiD1DZP9aQ+jQbZ2dnIycnhP05PT2+xI7m6uhrh4eEwNjaGnZ0dNDU1UVtb2+XEsWnTJpSVlWHlypWNjt++fbvNEVad9fTpU7x8+RJAfW3p8uXLsLa27nA548aNw8aNG/mPG5LxyZMnkZ6eji1btgAAvwP75cuX+PLLL1vtVB85ciRycnKwadMmftNUSwTtzwCA+fPnY/78+fDw8BDofEIkldQmjZ7Sp/G68vJyhISEwNraGnZ2dsjKysLnn3/Of37OnDmws7ODra0tXrx4gSNHjvCfGzduHC5cuMB/7OHhgenTpyM+Ph5cLhcnT55s9/rffPMNrl+/zm+T37x5M4D6dvtJkya1+JrW+jR+/PFHcLlc8Hg82NnZ8fsZUlNT+f9/8+ZNODk5wd7eHiNHjsR7773XqaTx448/IjU1FXZ2drC2tubH3dTXX38NKysr2NnZwc/PD6NGjWrxPBkZGQQEBODx48et7ttSW1uLnJwcDB48uN348vPzceDAAWzbto3/2b7ebEVIj8KknKOjY7NjWVlZYoike127do3NnTu3W8r28PBgT5486ZayX/f8+fNuv4awnD9/nr355ptCLVMa78ueLiEhQdwhiE1L352MMdbr+zTWxP6NrOLnQi3T2lANn/kJZ7VeQQ0dOhQjR45EbW2tULfCLSkpwXvvvQdNTU2hlSkNRowYgREjRog7DEJETmqTRm9cRiQ0NFToZerq6mLKlClCL5cQ0kOJuMYjcr2leao7rVu3rtHjiooK5unpyWpqahhjjI0fP56pq6uzSZMmNTrPy8uLXblyhf/47t27zMbGptXr3Llzh40fP77L8bYWz+vy8/OZt7c3c3BwYEOGDGFHjx5ljDF25swZZm9vz/+vT58+7NChQ4wxxk6fPs2GDh3K7O3t2fDhw1lOTk6XY30d3ZeSh5qnmpPajnAiPOvXr2/0uLuWLNHR0enUkiVNCRLP2rVrERgYiLS0NMTExOCtt94CUD9yqmEi3pkzZ6CsrMyfp7FkyRLs3r0b6enpmD17NtauXdulOAnpiShpiMmuXbvg4uICBwcHvPnmm6itrUV+fj4GDhyIR48eoa6uDh4eHvjrr7+Ql5eHwYMHIyQkBHZ2dvjXv/7FX+AwPj4eQ4cOxZAhQxAaGsofwmpmZobPPvsMb7zxBoYMGYJbt24BqJ8vEBoaCmdnZwwdOpQ/Ais6OhrTpk3DhAkTMHDgQHz44YcAgJUrV/InIs6ZMweA5C1Z0pQg8XA4HDx/Xt+X9ezZsxbnThw4cAATJ07kT94T5DWESD0R13hEThKbp7Kyspivry979eoVY4yxJUuW6EfmWwAADs9JREFUsO3btzPGGIuKimIBAQHsq6++YmFhYYyx+mYdAOzChQuMMcbmz5/Pvv76a1ZZWcm4XC7Lzs5mjDEWFBTEvvvuO8YYY6ampuzHH39kjDG2adMmtmDBAsYYY+Hh4Wznzp2MMcaePn3KBg4cyMrLy9lvv/3G+vfvz0pLS1llZSUzMTFhBQUFjDHG+vbty4/95cuXTF9fv9l7SkhIaLF5atCgQfymHisrq2bNU3l5eczS0pLl5eWx58+fMx6Px2xtbVv83Ozt7QX6fFuL53XFxcXM1taWGRkZMQ0NDZaamtrsnJEjR7LY2Fj+43PnzjEtLS1mZGTErKys2LNnzwSORxDivi9Jc9Q81RzVNMQgPj4eV69ehbOzMxwcHBAfH487d+4AqP8FXlZWhs2bN+Obb77hv8bY2BjDhw8HAMydOxcXLlxAdnY2+vfvz1+ELyQkBOfOneO/Ztq0aQAAR0dH5OXlAaifCR0REQEHBwd4e3ujqqoKBQUFAOp/oaurq0NRURHW1tbIz89vFntnlixpaO45duxYo+dEvWTJ6/bu3Yt58+aBx+Ph2LFjCAoKQl1dHf/5e/fu4fr1641mfH/33Xc4duwYeDwe5s+fj/fee09o8RDSU0jt6ClJxhhDSEgINmzY0Oy5iooK8Hg8APWT/RqaWZpuB8rhcNrdW6JhtVxZWVn+AnuMMRw8eBCWlpaNzk1OTuaf3/Q1r5O0JUuSk5Px5ptvAgC++OIL+Pv7C/S6rVu34sSJEwAANzc3VFVV4dGjR9DT0wMA7N+/H1OnTuUvIVJSUoKMjAwMGzYMADBjxoxO7TNCSE8ntTUNSV5GZPTo0Thw4AB/WYsnT57wf9V/9NFHmDNnDr744gssWrSI/5qCggIkJSUBqP+VPGLECAwePBh5eXnIzc0FAOzcuRNeXl5tXnv8+PH46aef+AknLS2t3Xjl5eVRXV0NABK3ZMmwYcP4NRlBEwYAmJiYID4+HkD9zPSqqiro6uryn9+7d2+jJUQ0NTXx7Nkz/npVp06dgpWVlcDXI0RaSG3SkORlRKytrbF27VqMGzcOdnZ2GDt2LO7du4ezZ8/iypUr/MShoKCA3377DQBgZWWF7du3w87ODk+ePMGSJUugqKiI3377DdOnT8eQIUMgIyPT7iZFn376Kaqrq/nLkXz66aftxhsWFgY7Ozt+R7ikLVnSVGvxrF69Gn/++ScA4Ntvv0VUVBTs7e0xa9YsREdH82tzeXl5KCwsbJSA5eTkEBUVhYCAANjb22Pnzp34+uuvBYqHEFFjjCE9Pb1LO122VbhUk8SO8I5qb36DqHXXkiXPnz8X2ZIlkqin3Ze9QU/tCE9LS2Pm5uYsLS2t02VQRzgRmteXLBGmR48e0ZIlhAiBvb09Dh48CHt7e6GXTR3hPYCZmRlu3Lgh7jAa6Y4lS3R0dGjJEkKEgMPhdHlXzdb02poG6462PkI6ie5H0lP0yqShqKiIx48f0z9UIhEYY3j8+DEUFRXFHQoh7epRzVPnz5/H7t27UVNTg6ysLFy6dKlT5TRsDlRSUiLkCElXVFVV9dovTkVFRXC5XHGHQUi7RJY0QkNDERcXBz09vUbt8ydOnMDy5ctRW1uLhQsXNhu3/zoPDw94eHjg8OHDcHZ27nQs8vLy6N+/f6dfT7pHYmIihg4dKu4wCCFtEFnSmDdvHpYtW4bg4GD+sdraWixduhSnTp0Cl8uFs7Mz/P39UVtbi/Dw8Eav37ZtG3+27p49e/j7PhNCCBEdkSUNT09P/vpHDVJSUmBhYQFz8/9r705DovreOIB//emLajJtsU1H5a+4UCBU0kJgBRkZpmEMjY5JaiIUJRVRVLRQIhTSRqVhKVRaQY3ZntGYEhlBaC8GyzIbM0rbNS0bz/+FdGnS9I6OXp35fuCCM/ecc597Pfh4t3P+BwBYsWIFCgsLsXXrVly9erXLdl6/fg03NzeMGjWqv0MmIqK/KHpP482bN1Cr1dJnLy8vlJeXd1snJycHq1at6rZMdnY2srOzAQB1dXUwGAx9jpX6X1NTE39XNKiwT3amaNLo6umlvwfm+9vveRe6k5KSgpSUFAAdz/5v2rSpdwH+w5cvX2w6PElf2+tNfWvqyC3bU7me1jc0NFiM/zRU2bp/KLFN9skOjtwn/74yJOn1O+a98PdwGA8ePBDh4eHS5/T0dJGenj6QIfXK6tWrB1V7valvTR25ZXsq19P6fw1bMNTYun8osU32yQ7sk50p+p5GaGgonj9/jpqaGvz8+RMFBQVWjVSqlMjIyEHVXm/qW1NHbtmeytn6uA1WSuwn+2TvyrFPWs9JiIF5w02r1cJgMKCxsRETJkzA7t27kZSUhOvXryMtLQ1msxmJiYnYtm3bQIRDg9CMGTPw+PFjpcMgkrBPdjZgSYOoJ9nZ2dK9KKLBgH2yMyYNIiKSzSHHniIiot5h0iAiItmYNIiISDYmDRoSjEYjUlNTsXz5chw/flzpcIig1+uxevVqREVF4fbt20qHM2CYNKjfJSYmYvz48Zg6darF9zdv3kRgYCD8/f2RkZHRbRvBwcE4ceIELly4wEcgqc9s0Sejo6Nx8uRJ5Obm4vz58/0Z7qDCp6eo392/fx8jR47EypUrpWHxzWYzAgICLEY4zs/P73aE4ytXriAjIwNr165FbGysErtCdsJWfRIANm7ciLi4OEybNm3A90MRNnu3nKgbthxCJiIiwubxkePpa59sb28XmzdvFnfu3OnXOAebITVzH9kPa0c4NhgMuHTpEn78+IGIiIiBCJEcjLV98siRIyguLsaXL19QXV2N1NTUgQhTcUwapAhh5QjH8+bNw7x58/oxInJ01vbJdevWYd26df0Z0qDEG+GkCC8vL5hMJulzXV0dJk+erGBE5OjYJ+Vh0iBFDNURjsl+sU/Kw6RB/U6r1WL27NmoqqqCl5cXcnJy4OLigqNHj2LRokUIDg6GRqPBlClTlA6VHAT7ZO/xkVsiIpKNZxpERCQbkwYREcnGpEFERLIxaRARkWxMGkREJBuTBhERycakQWSntFot9Hp9n9t59+4dgoOD8ePHDxtERUMdkwbZDV9fXwwfPhwjR46Ulvr6eqXDUkRlZSUqKioQFRUFAMjNzcXcuXM7lfP19UVxcXG3bU2YMAHz589HdnZ2v8RKQwuTBtmVoqIiNDU1SUtXYwf9+vVLgcgGVlZWFuLi4rodcM8acXFxyMrKsklbNLQxaZDde/XqFZycnJCTkwNvb28sWLAAAPDw4UPMmTMH7u7uCAkJgcFgkOrU1NQgLCwMrq6uWLhwIdauXQudTgegY5h2Ly8vi238+R97e3s7MjIy4Ofnh7Fjx0Kj0eDjx48WseTl5cHb2xvjxo3Dvn37pHbMZjPS09Ph5+cHV1dXTJ8+HSaTCWvWrMHGjRstthkZGYmDBw92uc83btxAWFiYVccpJCTE4izNyclJOiYzZ87Ey5cvUVtba1WbZH+YNMhhlJSUwGg04tatW3jz5g2WLFmC7du34+PHjzhw4ABiYmLQ0NAAAIiNjcX06dPR2NiIHTt2IC8vT/Z2Dh8+DL1ej5KSEtTX12P06NFYs2aNRZmysjJUVVXh7t272LNnD4xGIwAgMzMT+fn5uH79Or5+/YpTp05hxIgRSEhIQH5+Ptrb2wEAjY2NuHv3LrRabaftNzc3o6amBoGBgVYdn4qKCukMLTMzE4GBgdJsdC4uLvD390dFRYVVbZIdUnYOKCLb8fHxESqVSri5uQk3NzcRFRUlhOiYoQ2AePHihVQ2IyND6HQ6i/rh4eEiNzdX1NbWCmdnZ9HU1CSt02q1Ii4uTgghxL1794Snp2enbf+ewS0oKEgUFxdL6+rr64WLi4toa2uTYjGZTNL60NBQkZ+fL4QQIiAgQOj1+i73LygoSNy+fVsIIcSRI0fE4sWLuyxXV1cnAIiWlhbpu9OnTwtnZ2fp2PxenJycOs08V1paKjw8PERVVZXF93PmzBF5eXldbpMcB880yK7o9Xp8/vwZnz9/7vTk0J+zstXW1uLixYtwd3eXlrKyMrx9+1Y6O1CpVFJ5Hx8f2THU1tZi2bJlUrvBwcFwdnbGu3fvpDITJ06Ufh4xYgSampoAACaTCX5+fl22m5CQgDNnzgAAzpw5g/j4+C7Lubu7AwC+fftm8f2sWbOkY/N78fb2tihjMpmg0WiQl5eHgIAAi3Xfvn2T2ibHxaRBDuPPm8JqtRrx8fEWf0Cbm5uxZcsWTJo0CZ8+fUJzc7NU/vXr19LPKpUK379/lz6bzWbpstbvtm/cuGHRdmtrKzw9PXuMUa1W48WLF12u0+l0KCwsREVFBYxGI6Kjo7ssp1Kp4Ofnh2fPnvW4vT+1tLQgOjoaaWlpWLx4scW6X79+obq6GiEhIVa1SfaHSYMckk6nQ1FREW7dugWz2YzW1lYYDAbU1dXBx8cHM2bMwM6dO/Hz50+UlZWhqKhIqhsQEIDW1lZcu3YNbW1t2Lt3r8U7DKmpqdi2bZt007ihoQGFhYWy4kpOTsaOHTvw/PlzCCFQWVmJDx8+AOiYWS40NBTx8fGIiYnB8OHD/9lOREQESkpKrDomiYmJCAoKwubNmzute/ToEXx9fa064yL7xKRBDkmtVqOwsBDp6enw8PCAWq3G/v37pRvN586dQ3l5OcaMGYPdu3dj5cqVUl03NzccO3YMycnJ8PT0hEqlsniaav369Vi6dCnCw8Ph6uqKWbNmoby8XFZcGzZsgEajQXh4OEaNGoWkpCS0tLRI6xMSEvD06dN/Xpr6LSUlBWfPnu1y3ut/KSgowOXLly2eoCotLQUAnD17FqmpqbLbIvvFSZiIZNi1axeqq6ulewpKuX//PnQ6HV69eoX//uv+f77Y2FhoNJp/XsaS6/379wgLC8OTJ08wbNiwPrVFQ5+L0gEQkTxtbW04dOgQkpOTe0wYQMfZki2MHz9eeiSYiJeniIYAo9EId3d3vH37FmlpaUqHQw6Ml6eIiEg2nmkQEZFsTBpERCQbkwYREcnGpEFERLIxaRARkWxMGkREJNv/Aaoy0b7Nb3jOAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-9.905816349706912\n", + "{'popt': array([-2.01279955e+00, 1.24217748e-10]), 'cov': array([[0.0169865 , 0.03613385],\n", + " [0.03613385, 0.07947851]]), 'fit_range': [0.0002773946906524992, 0.019417628345674943], 'sigma': array([1.30332260e-01, 8.06351131e-11])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-7.875270926993996\n", + "{'popt': array([-1.02903248e+00, 1.33268980e-08]), 'cov': array([[0.0246899 , 0.05252062],\n", + " [0.05252062, 0.11552214]]), 'fit_range': [0.0002773946906524992, 0.019417628345674943], 'sigma': array([1.57130208e-01, 1.04298337e-08])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 3.6069998486601246e-07\n", + "Stddev: 2.2821294140496834e-07\n", + "Stddev/Mean: 0.6326946242865564\n" + ] + } + ], + "source": [ + "num_slices = 3\n", + "peak_no = 0\n", + "type_of_fit = \"lin\"\n", + "\n", + "dejump = 0\n", + "min_jump_height = 5e-3\n", + "\n", + "f_min = 5e-4\n", + "f_max = 1e-2\n", + "\n", + "saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"num_slices\" : num_slices}})\n", + "saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"peak_no\" : peak_no}})\n", + "saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"type_of_fit\" : type_of_fit}})\n", + "saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"dejump\" : dejump}})\n", + "saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"dejump_min_height\" : min_jump_height}})\n", + "saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"integration_limits\" : [f_min, f_max]}})\n", + "\n", + "if dejump:\n", + " used_trace = remove_jumps(tracked_peaks[\"tracked_peak_positions\"][peak_no], min_jump_height)\n", + " plt.plot(used_trace)\n", + " plt.plot(tracked_peaks[\"tracked_peak_positions\"][peak_no])\n", + "else:\n", + " used_trace = tracked_peaks[\"tracked_peak_positions\"][peak_no]\n", + " plt.plot(used_trace)\n", + "\n", + "from scipy.stats import sem\n", + "from scipy import mean\n", + "\n", + "signals = np.array_split(used_trace, num_slices)\n", + "sampling_f = tracked_peaks[\"time_axis\"][1]**-1\n", + "min_len = min([len(element) for element in signals])\n", + "\n", + "if type_of_fit == \"lin\":\n", + " fit_func = linear\n", + " guess = [-1, 1]\n", + "elif type_of_fit == \"bilin\":\n", + " fit_func = bilinear2\n", + " guess = [-2, 1, -1, -3]\n", + "\n", + "integrals = []\n", + "for i, signal in enumerate(signals):\n", + " #do the signal processing here\n", + " #also save the slices in a way that further parts can understand it.\n", + " noise_calculator = AnalyzerTimetraceSpectralNoiseDensity(signal[:min_len],\\\n", + " sampling_f, fit_func = fit_func)\n", + " noise_calculator.guess = guess\n", + " #saver.add_info(f\"{node_r}_peak{peak_no}_fit_interval\", noise_calculator.fit_interval)\n", + " spectral_result = noise_calculator.analyze()\n", + " #saver.add_info(f\"{node_r}_peak{peak_no}_spectrum\", spectral_result)\n", + " #saver_overview.add_info(f\"{node_r}_peak{peak_no}_spectrum\", spectral_result)\n", + "\n", + " fit = noise_calculator.fit()\n", + " print(fit)\n", + " #saver.add_info(f\"{node_r}_peak{peak_no}_SNDfit_parameters\", fit)\n", + " #saver_overview.add_info(f\"{node_r}_peak{peak_no}_SNDfit_parameters\", fit)\n", + "\n", + " f, s = spectral_result[\"freq\"], spectral_result[\"spectrogram\"]\n", + " saving_path = os.path.join(\"testfigures\", f\"{i}\")\n", + "\n", + " plotter_SND = PlotterTimetraceSpectralNoiseDensity(saving_path, [f,s], fit)\n", + " plotter_SND.plot()\n", + " \n", + " #integrate the total noise power\n", + "\n", + "\n", + " band = np.linspace(f_min, f_max, 100000)\n", + " spec = func_power2(band, *fit[\"popt\"])\n", + " integrals.append(np.sum(np.diff(band) * spec[:-1]))\n", + " \n", + "integral_mean = mean(integrals)\n", + "integral_sem = sem(integrals)\n", + "print(\"Mean: \", integral_mean)\n", + "print(\"Stddev: \", integral_sem)\n", + "print(\"Stddev/Mean: \", integral_sem/integral_mean)\n", + "\n", + "saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"integrals\" : integrals}})\n", + "saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"integral_mean\" : integral_mean}})\n", + "saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"integral_sem\" : integral_sem}})" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-14T15:21:14.716336Z", + "start_time": "2022-09-14T15:21:14.692839Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['demod0&4.r4_tracked_peaks', 'demod0&4.r4_peak0_welch_segment_length', 'demod0&4.r4_peak0_fit_interval', 'demod0&4.r4_peak0_spectrum', 'demod0&4.r4_peak0_SNDfit_parameters', 'demod0&4.r4_peak0_jumphist', 'demod0&4.r4_peak0_big_jumps', 'demod0&4.r4_peak0_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r0_tracked_peaks', 'demod0&4.r0_peak0_welch_segment_length', 'demod0&4.r0_peak0_fit_interval', 'demod0&4.r0_peak0_spectrum', 'demod0&4.r0_peak0_SNDfit_parameters', 'demod0&4.r0_peak0_jumphist', 'demod0&4.r0_peak0_big_jumps', 'demod0&4.r0_peak0_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r0_tracked_peaks', 'demod0&4.r0_peak0_welch_segment_length', 'demod0&4.r0_peak0_fit_interval', 'demod0&4.r0_peak0_spectrum', 'demod0&4.r0_peak0_SNDfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r4_tracked_peaks', 'demod0&4.r4_peak0_welch_segment_length', 'demod0&4.r4_peak0_fit_interval', 'demod0&4.r4_peak0_spectrum', 'demod0&4.r4_peak0_SNDfit_parameters', 'demod0&4.r4_peak0_jumphist', 'demod0&4.r4_peak0_big_jumps', 'demod0&4.r4_peak0_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r0_tracked_peaks', 'demod0&4.r0_peak0_welch_segment_length', 'demod0&4.r0_peak0_fit_interval', 'demod0&4.r0_peak0_spectrum', 'demod0&4.r0_peak0_SNDfit_parameters', 'demod0&4.r0_peak0_jumphist', 'demod0&4.r0_peak0_big_jumps', 'demod0&4.r0_peak0_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r4_tracked_peaks', 'demod0&4.r4_peak0_welch_segment_length', 'demod0&4.r4_peak0_fit_interval', 'demod0&4.r4_peak0_spectrum', 'demod0&4.r4_peak0_SNDfit_parameters', 'demod0&4.r4_peak0_jumphist', 'demod0&4.r4_peak0_big_jumps', 'demod0&4.r4_peak0_jumpfit_parameters', 'demod0&4.r4_peak1_welch_segment_length', 'demod0&4.r4_peak1_fit_interval', 'demod0&4.r4_peak1_spectrum', 'demod0&4.r4_peak1_SNDfit_parameters', 'demod0&4.r4_peak1_jumphist', 'demod0&4.r4_peak1_big_jumps', 'demod0&4.r4_peak1_jumpfit_parameters', 'demod0&4.r4_peak2_welch_segment_length', 'demod0&4.r4_peak2_fit_interval', 'demod0&4.r4_peak2_spectrum', 'demod0&4.r4_peak2_SNDfit_parameters', 'demod0&4.r4_peak2_jumphist', 'demod0&4.r4_peak2_big_jumps', 'demod0&4.r4_peak2_jumpfit_parameters', 'demod0&4.r4_peak3_welch_segment_length', 'demod0&4.r4_peak3_fit_interval', 'demod0&4.r4_peak3_spectrum', 'demod0&4.r4_peak3_SNDfit_parameters', 'demod0&4.r4_peak3_jumphist', 'demod0&4.r4_peak3_big_jumps', 'demod0&4.r4_peak3_jumpfit_parameters', 'demod0&4.r4_peak4_welch_segment_length', 'demod0&4.r4_peak4_fit_interval', 'demod0&4.r4_peak4_spectrum', 'demod0&4.r4_peak4_SNDfit_parameters', 'demod0&4.r4_peak4_jumphist', 'demod0&4.r4_peak4_big_jumps', 'demod0&4.r4_peak4_jumpfit_parameters', 'demod0&4.r4_peak5_welch_segment_length', 'demod0&4.r4_peak5_fit_interval', 'demod0&4.r4_peak5_spectrum', 'demod0&4.r4_peak5_SNDfit_parameters', 'demod0&4.r4_peak6_welch_segment_length', 'demod0&4.r4_peak6_fit_interval', 'demod0&4.r4_peak6_spectrum', 'demod0&4.r4_peak6_SNDfit_parameters', 'demod0&4.r4_peak6_jumphist', 'demod0&4.r4_peak6_big_jumps', 'demod0&4.r4_peak6_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r4_tracked_peaks', 'demod0&4.r4_peak0_welch_segment_length', 'demod0&4.r4_peak0_fit_interval', 'demod0&4.r4_peak0_spectrum', 'demod0&4.r4_peak0_SNDfit_parameters', 'demod0&4.r4_peak0_jumphist', 'demod0&4.r4_peak0_big_jumps', 'demod0&4.r4_peak0_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r4_tracked_peaks', 'demod0&4.r4_peak0_welch_segment_length', 'demod0&4.r4_peak0_fit_interval', 'demod0&4.r4_peak0_spectrum', 'demod0&4.r4_peak0_SNDfit_parameters', 'demod0&4.r4_peak0_jumphist', 'demod0&4.r4_peak0_big_jumps', 'demod0&4.r4_peak0_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r0_tracked_peaks', 'demod0&4.r0_peak0_welch_segment_length', 'demod0&4.r0_peak0_fit_interval', 'demod0&4.r0_peak0_spectrum', 'demod0&4.r0_peak0_SNDfit_parameters', 'demod0&4.r0_peak0_jumphist', 'demod0&4.r0_peak0_big_jumps', 'demod0&4.r0_peak0_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r0_tracked_peaks', 'demod0&4.r0_peak0_welch_segment_length', 'demod0&4.r0_peak0_fit_interval', 'demod0&4.r0_peak0_spectrum', 'demod0&4.r0_peak0_SNDfit_parameters', 'demod0&4.r0_peak0_jumphist', 'demod0&4.r0_peak0_big_jumps', 'demod0&4.r0_peak0_jumpfit_parameters', 'demod0&4.r0_peak1_welch_segment_length', 'demod0&4.r0_peak1_fit_interval', 'demod0&4.r0_peak1_spectrum', 'demod0&4.r0_peak1_SNDfit_parameters', 'demod0&4.r0_peak1_jumphist', 'demod0&4.r0_peak1_big_jumps', 'demod0&4.r0_peak1_jumpfit_parameters', 'demod0&4.r0_peak2_welch_segment_length', 'demod0&4.r0_peak2_fit_interval', 'demod0&4.r0_peak2_spectrum', 'demod0&4.r0_peak2_SNDfit_parameters', 'demod0&4.r4_tracked_peaks', 'demod0&4.r4_peak0_welch_segment_length', 'demod0&4.r4_peak0_fit_interval', 'demod0&4.r4_peak0_spectrum', 'demod0&4.r4_peak0_SNDfit_parameters', 'demod0&4.r4_peak0_jumphist', 'demod0&4.r4_peak0_big_jumps', 'demod0&4.r4_peak0_jumpfit_parameters', 'demod0&4.r4_peak1_welch_segment_length', 'demod0&4.r4_peak1_fit_interval', 'demod0&4.r4_peak1_spectrum', 'demod0&4.r4_peak1_SNDfit_parameters', 'demod0&4.r4_peak1_jumphist', 'demod0&4.r4_peak1_big_jumps', 'demod0&4.r4_peak1_jumpfit_parameters', 'demod0&4.r4_peak2_welch_segment_length', 'demod0&4.r4_peak2_fit_interval', 'demod0&4.r4_peak2_spectrum', 'demod0&4.r4_peak2_SNDfit_parameters', 'demod0&4.r4_peak3_welch_segment_length', 'demod0&4.r4_peak3_fit_interval', 'demod0&4.r4_peak3_spectrum', 'demod0&4.r4_peak3_SNDfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['0.75tg1.602', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r4_tracked_peaks', 'demod0&4.r4_peak0_welch_segment_length', 'demod0&4.r4_peak0_fit_interval', 'demod0&4.r4_peak0_spectrum', 'demod0&4.r4_peak0_SNDfit_parameters', 'demod0&4.r4_peak0_jumphist', 'demod0&4.r4_peak0_big_jumps', 'demod0&4.r4_peak0_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r4_tracked_peaks', 'demod0&4.r4_peak0_welch_segment_length', 'demod0&4.r4_peak0_fit_interval', 'demod0&4.r4_peak0_spectrum', 'demod0&4.r4_peak0_SNDfit_parameters', 'demod0&4.r4_peak0_jumphist', 'demod0&4.r4_peak0_big_jumps', 'demod0&4.r4_peak0_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r0_tracked_peaks', 'demod0&4.r0_peak0_welch_segment_length', 'demod0&4.r0_peak0_fit_interval', 'demod0&4.r0_peak0_spectrum', 'demod0&4.r0_peak0_SNDfit_parameters', 'demod0&4.r0_peak0_jumphist', 'demod0&4.r0_peak0_big_jumps', 'demod0&4.r0_peak0_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r4_tracked_peaks', 'demod0&4.r4_peak1_welch_segment_length', 'demod0&4.r4_peak1_fit_interval', 'demod0&4.r4_peak1_spectrum', 'demod0&4.r4_peak1_SNDfit_parameters', 'demod0&4.r4_peak1_jumphist', 'demod0&4.r4_peak1_big_jumps', 'demod0&4.r4_peak1_jumpfit_parameters', 'bias_cooling_parameters'])\n", + "dict_keys(['demod0&4.r0_tracked_peaks', 'demod0&4.r0_peak0_welch_segment_length', 'demod0&4.r0_peak0_fit_interval', 'demod0&4.r0_peak0_spectrum', 'demod0&4.r0_peak0_SNDfit_parameters', 'bias_cooling_parameters'])\n" + ] + } + ], + "source": [ + "for file in files.values():\n", + " print(file.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:28:02.555117Z", + "start_time": "2022-09-15T12:27:40.285178Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-8.40542517224761\n", + "{'popt': array([-1.35808582e+00, 3.93164980e-09]), 'cov': array([[0.00599063, 0.01461556],\n", + " [0.01461556, 0.03669356]]), 'fit_range': [4.1202825700001986e-05, 0.009723866865200468], 'sigma': array([7.73991664e-02, 1.73414515e-09])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-6.768061985116725\n", + "{'popt': array([-6.35551756e-01, 1.70583890e-07]), 'cov': array([[0.00652374, 0.0159162 ],\n", + " [0.0159162 , 0.03995892]]), 'fit_range': [4.1202825700001986e-05, 0.009723866865200468], 'sigma': array([8.07696547e-02, 7.85164360e-08])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-7.433231021111698\n", + "{'popt': array([-9.18629959e-01, 3.68781375e-08]), 'cov': array([[0.00922769, 0.02251313],\n", + " [0.02251313, 0.05652105]]), 'fit_range': [4.1202825700001986e-05, 0.009723866865200468], 'sigma': array([9.60608619e-02, 2.01878373e-08])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 7.843926372053899e-08\n", + "Stddev: 1.5940480602687182e-08\n", + "Stddev/Mean: 0.20322068115630765\n", + "-7.137466071875734\n", + "{'popt': array([-9.15026052e-01, 7.28675098e-08]), 'cov': array([[0.03246123, 0.06911687],\n", + " [0.06911687, 0.15221583]]), 'fit_range': [0.000255056662524492, 0.01938430635186139], 'sigma': array([1.80169995e-01, 6.54605308e-08])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-7.115864834482222\n", + "{'popt': array([-8.97977140e-01, 7.65834921e-08]), 'cov': array([[0.02541733, 0.05411892],\n", + " [0.05411892, 0.1191859 ]]), 'fit_range': [0.000255056662524492, 0.01938430635186139], 'sigma': array([1.59428145e-01, 6.08784082e-08])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-7.601380390637306\n", + "{'popt': array([-1.17315934e+00, 2.50391516e-08]), 'cov': array([[0.02388852, 0.05086374],\n", + " [0.05086374, 0.11201702]]), 'fit_range': [0.000255056662524492, 0.01938430635186139], 'sigma': array([1.54559099e-01, 1.92964451e-08])}\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEdCAYAAADwwTuSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdd1hTZ/sH8G8IIChTNgZERJERQAVnZdSBxlW17losVmorrd2W2qGtq+vXt62+tbi1KrVaq8hwglucLFFcICsooChTITy/PyJ5iawACRncn+vq9b45OXme+4TjufOM8xwOY4yBEEIIkYGWsgMghBCiPihpEEIIkRklDUIIITKjpEEIIURmlDQIIYTIjJIGIYQQmVHSIEQJMjMzweFwUF1drZDyx4wZg61btyqk7PaWlZUFAwMDiEQiZYdCQEmDNMPBwQH6+vowMDCAlZUV3njjDZSWlio7LIlnz57ho48+Ao/Hg4GBAXr06IEPPvhAoXVu2bIFL730kkLrcHBwgJWVFcrKyiTbNmzYAH9/f5k+HxMTg6CgILnG5O/vDz09PRgaGsLIyAj9+/fH6tWr8fTpU7nW8yJ7e3uUlpaCy+VK4tiwYYNC6ySNo6RBmhUZGYnS0lJcuXIFFy9exPLly5USR0O/yletWoVLly7hwoULKCkpQVxcHPr27auE6KTJ41dxdXU1fvnlFzlEIz9r1qxBSUkJhEIhfvrpJ0REREAgEIDuEe44KGkQmXXr1g1jxoxBamoqACAvLw8TJkxA165d4eTkhPXr1wMAKisroa+vj8LCQgDA8uXLoa2tjSdPngAAvvjiC7z//vsAgKdPn+Ljjz+Gvb09rKyssGDBAlRUVAAA4uPjwePx8N1338Ha2hpvvPFGvZguXryISZMmwdbWFhwOBw4ODnj99dcl7zs4OGDVqlVwdXWFqakp3njjDVRWVkreP3jwILy8vGBiYoIhQ4YgOTlZ8l52djYmT54MCwsLmJmZITQ0FNevX8eCBQtw7tw5GBgYwMTEBAAwd+5cvP322xAIBOjSpQvi4uIQFRWFvn37wsjICHZ2dli6dGmLvu9PPvkEP/74I4qLixt8/+zZs/Dx8YGxsTF8fHxw9uxZyXt1f43fvn0bfn5+MDY2hrm5OaZPny7Z78aNGxg5ciS6du0KZ2dn7N69W6bYunTpAn9/fxw4cADnzp1DVFQUAKCmpgarV69Gz549YWZmhmnTpuHhw4cA/tclt3XrVtjb28Pc3BwrVqyQlHnhwgV4e3vDyMgIVlZW+PDDD6U+V11djSVLluDUqVMIDQ2FgYEBQkNDsXDhQnz00UdS8Y0fPx7/+c9/ZDoW0kKMkCZ0796dHTlyhDHGWFZWFnN1dWVffPEFY4wxX19f9vbbb7OKigp29epVZm5uzo4ePcoYY2zYsGFsz549jDHGRo4cyRwdHVl0dLTkvX/++YcxxtiiRYvY+PHjWVFREXvy5AkbN24c++yzzxhjjMXFxTEul8s+/fRTVllZycrLy+vF9+233zI7Ozu2du1alpyczGpqaurF7+bmxrKyslhRUREbMmQIW7JkCWOMscuXLzMLCwt2/vx5Vl1dzbZs2cK6d+/OKisrWXV1NfPw8GDvv/8+Ky0tZRUVFezUqVOMMcY2b97Mhg4dKlVPUFAQMzIyYqdPn2YikYhVVFSwuLg4lpyczEQiEUtKSmKWlpZs3759jDHGMjIyGABWVVXV5Pc+adIkSbzr169nfn5+jDHGioqKmImJCdu2bRurqqpiO3fuZCYmJqywsJAxxpifnx9bv349Y4yxGTNmsOXLl0viqj2O0tJSxuPx2KZNm1hVVRW7fPkyMzMzY6mpqQ3GVLfMuoYNG8Y+/fRTxhhjP//8Mxs4cCDLzs5mlZWVLCQkhM2YMUPqmN98801WXl7OEhMTma6uLktLS2OMMTZo0CC2bds2xhhjJSUl7Ny5cw1+Vy/GkZCQwGxsbJhIJGKMMVZQUMD09fVZfn5+g8dB2oaSBmlS9+7dWZcuXZixsTGzt7dnb7/9NisvL2dZWVlMS0uLPXnyRLLvZ599xoKCghhjjH3xxRfs3XffZVVVVczKyor95z//YYsXL2YVFRVMT0+PFRQUsJqaGta5c2d2+/ZtSRlnz55lDg4OjDFx0tDR0WEVFRWNxlddXc3WrFnDhgwZwnR1dZmNjQ3bsmWLVPy///675HVUVBRzdHRkjDG2YMECSQKs1bt3bxYfH8/Onj3LzM3NG7yoN5Y05syZ0+R3uWjRIvb+++8zxmRPGikpKczIyIg9ePBAKmls27aN+fj4SH1m0KBBbPPmzYwx6QvrnDlz2Pz581l2drbU/hEREeyll16S2hYSEsKWLl3aYEyNJY3p06ezN998kzHGWJ8+fSQ/HBhjLC8vj2lra7OqqirJMdeNw8fHh+3atYsxJk4+X331FSsoKJAqv7mkUVvv4cOHGWOM/fbbb2zMmDENHgNpO+qeIs36999/UVxcjHv37uG///0v9PX1kZeXh65du8LQ0FCyX/fu3ZGbmwsA8PPzQ3x8PK5cuQI+n4+RI0fixIkTOH/+PJycnGBubo6CggKUl5ejf//+MDExgYmJCUaPHo2CggJJmRYWFtDT02s0Ni6Xi4ULF+LMmTMoLi7GkiVLEBwcjOvXr0v2sbOzk4oxLy8PAHDv3j389NNPkrpNTEyQnZ2NvLw8ZGdno3v37tDW1pb5e6pbDwAkJCQgICAAFhYWMDY2xrp16yRddrJyd3fHuHHjsHr1aqnteXl56N69u9S2ut9/Xd9//z0YYxgwYADc3NywadMmAOLjT0hIkDr+HTt2ID8/v0Ux5ubmomvXrpIyJ02aJCnPxcUFXC4X9+/fl+xvbW0t+f+dO3eWTKzYuHEjbt68iT59+sDHxwcHDx6UOYagoCD8+eefAIA///wTc+bMadExENlR0iCtYmtri4cPH6KkpESyLSsrC926dQMADBkyBOnp6di3bx/8/Pzg6uqKrKwsREVFwc/PDwBgbm4OfX19XLt2DcXFxSguLsbjx4+lZmdxOByZY9LX18fChQthamqKtLQ0yfbs7GypGG1tbQGIL/JLliyR1F1cXIzy8nLMnDkTdnZ2yMrKanDwvbGYXtw+a9YsTJgwAdnZ2Xj8+DEWLFjQqgHjZcuWYf369VIJwdbWFvfu3ZPar+73X5e1tTXWr1+PvLw8/PHHH3jnnXdw+/Zt2NnZwc/PT+r4S0tL8fvvv8scW3Z2Ni5fvoxhw4YBEH+nMTExUmVWVlY2GNeLevXqhV27duHBgwdYvHgxXn31VanZY7Ua+v5fe+017N+/H0lJSbh+/TpeeeUVmY+BtAwlDdIqdnZ2GDJkCMLCwlBZWYnk5GRs3LgRs2fPBiD+Bdm/f3+sXbtWkiSGDBmCP/74Q/JaS0sL8+fPxwcffIAHDx4AEP9qPXTokMxx/Oc//0F8fDwqKipQXV2NrVu3oqSkRGoG1dq1a5GTk4OHDx9i5cqVkoHg+fPnY926dUhISABjDGVlZYiKikJJSQkGDBgAGxsbfPbZZygrK0NlZSXOnDkDALCyskJOTg6ePXvWZGwlJSXo2rUr9PT0cOHCBezcuVPm46rLyckJ06dPx6+//irZJhAIcPPmTezcuRPV1dX466+/kJaWhnHjxtX7/N9//42cnBwAgKmpKTgcDrhcLsaNG4ebN29i+/btqKqqQlVVFS5evCjVSmtMeXk5Tpw4gYkTJ2LAgAEQCAQAgAULFmDJkiWShFZQUID9+/fLdJx//vknCgoKoKWlJZlgUDvNti4rKyvcvXtXahuPx4OPjw/mzJmDKVOmQF9fX6Y6SctR0iCttmvXLmRmZsLW1haTJk3CsmXLMHLkSMn7fn5+qKqqwoABAySvS0pK4OvrK9nnu+++g5OTEwYNGgQjIyOMGDEC6enpMsegr6+Pjz76CNbW1jA3N8fatWuxd+9eODo6SvaZNWsWRo0aBUdHRzg6OuKLL74AAHh7e2P9+vUIDQ2FqakpnJycsGXLFgDii1VkZCRu374Ne3t78Hg8/PXXXwCAl19+GW5ubpI6G/Pf//4XX331FQwNDfHNN99g2rRpMh/Xi7766iupX91mZmY4ePAgfvrpJ5iZmeH777/HwYMHG4zn4sWLGDhwIAwMDDBhwgT88ssv6NGjBwwNDXH48GFERETA1tYW1tbWWLx4cZP3XYSGhsLQ0BBWVlZ4//33MWXKFMTGxkJLS3wpWbRoESZMmIBRo0bB0NAQgwYNQkJCgkzHGBsbCzc3NxgYGGDRokWIiIhosGty0aJF2LNnD0xNTfHee+9JtgcFBSElJYW6phSMw1rTXiZETTg4OGDDhg0YMWKEskMhCnby5Em89tpryMzMlCQxIn/0zRJC1F5VVRV++eUXvPnmm5QwFIy+XUKIWrt+/TpMTEwgFAolN40SxVGr7qnr16/jl19+QWFhIYYPH463335b2SERQkiH0m4tjeDgYFhaWsLd3V1qe2xsLJydneHk5FRvLvqLXFxcsG7dOuzevRuXLl1SZLiEEEIa0G5JY+7cuYiNjZXaJhKJsHDhQsTExCAtLQ27du1CWloaUlJSMG7cOKn/aqdkHjhwAC+99BKGDx/eXqETQgh5rl27pzIzMzFu3DjJgnfnzp3D0qVLJfPyV61aBQAICwtrtqyxY8dKFkl7UXh4OMLDwwEAaWlp9e7UJeqhpqaGBjWJ0nXU87CoqKjBFQxkXyNBAXJzc6Uu6Dwer8k53fHx8fjnn3/w9OlTyc1EDQkJCUFISAgA8Vx86spST/Hx8TI/P4IQRemo56G3t3eD25WaNBpq5DS1bIS/v7/Mf7zIyEhERkbi8ePHrQ2PEELIC5Ta5uLxeFLrAuXk5EjWBWqr8ePHIzw8HMbGxnIpjxBCiJKTho+PD27duoWMjAw8e/YMERERmDBhgjJDIoQQ0oR2SxozZ87E4MGDkZ6eDh6Ph40bN0JbWxtr1qxBYGAgXFxcMG3aNLi5ucmlvsjISISEhFD3FCGEyFG7jWns2rWrwe0CgaDJQe3WGj9+PMaPH9/oYA4hhJCWU+pAuCLRQDghhMifxk4+butAOGMMiYmJrXpoDiGEaCqNTRptlZSUhClTpiApKUnZoRBCiMqg7qlGeHp6Yu/evfD09JRzZIQQor40tqXR1u4pDocDLy+vFj2jmhBCNJ3GJg1CCCHyR0mDEEKIzGhMgxBCiMw0tqVBa08RmjZNiPxpbNJoq8oqEV1s1BxNmyZE/jS2e6qtVsfcwPEbDzCGb42xfBvwuxnTTCo1Q9OmCZE/jU0abR3T8HHoiruFZdh4KgN/nLgLu676ELjbQMC3gQePEog6qJ02TQiRH41NGm1dsHCshw3GetjgUdkzHEm7j6gUITaezsAfJ++im4k+BHxrCPg28LIzoQRCCOkwNDZpyItpF11M87HDNB87FJeLE0h0ihBbzmZi/akMdDPRxxh3awg8bNCXEgghRMNR0mgBk866mOpth6nednhcXoUj18UJZOu5TGw4nQFbYz2MdrfBWA9r9LUzhZYWJRBCiGahpNFKxp118Gp/Hl7tz8Pjiiocfd4C+fP8PWw6kwEbYz2MdhcPovezpwRCCNEMlDTkwFhfB1P68zClPw9PKqtw7Pp9RCXnY8f5LGw+kwlro+cJxMMG/SmBEELUmMYmDWXdEW6kp4NJfXmY1JeHksoqHLv+AFEpQuy8kIUtZzNhadhJPAbCt4G3Q1dwKYEQQtSIxiYNVXjcq6GeDl7p2w2v9O2GksoqHL/xANEpQkRczMbWc/dgUSeB+FACIYSoAY1NGqrGUE8HE726YaJXN5Q+rRYnkGQh/rqYjW3PE8hoN3ECGdCDEgghRDVR0lACg07amOBpiwmetiirTSApQvx9ORvbz9+DuYEuAt3Eg+gDenSFNpdWeyGEqAZKGkrWpZM2xnvaYrynLcqfiRNITEo+/rmSix0JWTDroovA57OwBlICIYQoGSUNFdJZVxvjPGwxzkOcQOLTCxCVIsS+K7nYmZCFrl3ELRAB3xqDHc0ogRBC2h0lDRXVWVcbAr54rauKZyLEp4tnYe1PzMWuC1kw7azzPIHYYHBPM+hQAiGEtANKGmpAX5eLMXwbjOHboLJKnECiU/IRmZSHiIvZMOmsg0BX8VImQyiBEEIUSGOThqY+uU9Ph4vR7jYY7S5OICduFiA6RYioFCH+uiROIKNcrTCGb4OhPc2hq00JhBAiPxqbNFThPg1F09PhItDNGoFu1qisEuHkzQLEpOYjJiUfuy/lwFhfByNdrTCWb4OhTpRACCFtp7FJo6PR0+FilJs1RrlZ42m1CKduFiI6RYhDqfnYczkHRnraGOkqHkR/qZc5OmlzlR0yIUQNUdLQQJ20uRjhaoURrlZ4Wi3C6VuFiEoR4nBaPvZeyYGhnjZGulhBwLfBsN6UQAghsqOkoeE6aXMx3MUKw13ECeTs7SJxArmWj3+u5sKwkzZGuD5PIL3MoadDCYQQ0jhKGh1IJ20uAvpYIqCPJZ5N4uPMnUJEJwtxOO0+9l3NhUEnbYxwscQYvg38eltQAiGE1ENJo4PS1dZCgLMlApwtsVJUgzO3CxGTko9Dafn4NzEPXXTFLRQB3wb+zpRACCFilDQ0GGMMSUlJ8PT0bPIxtDpcLfg7W8Lf2RLLRe44d6dIPIh+LR8HksQJ5GUXK4zlW8Pf2ZISSAvI+jcgRF1Q0tBgSUlJmDJlCvbu3QsvLy+ZPqPD1YJvbwv49rbAt6+44/zdIkSn5OPQNfHNhJ11uXi5jyUEfBsEOFtCX5cSSFNa8zcgRJVR0tBgnp6e2Lt3Lzw9PVv1eR2uFob1ssCwXhb4dqIbEjIeIur5NN6DyULo69RJIH0s0FmXTqcXtfVvQIiqUbt/5WVlZfD19cWyZcswbtw4ZYej0jgcjtx+3WpztTDUyRxDnczxzQQ3XKhNINfyEZUiTiABfSwg4Nvg5T6WlECek+ffgBBV0G63CAcHB8PS0hLu7u5S22NjY+Hs7AwnJyesXr262XK+++47TJs2TVFhEhloc7UwxMkcKybxkfD5COyaPwiv9ufhQsYjhO68in7fHsHbf15GZFIeyp5WKztcQogctdvPwblz5yI0NBSvv/66ZJtIJMLChQtx5MgR8Hg8+Pj4YMKECRCJRAgLC5P6/KZNm5CcnAxXV1dUVla2V9ikGVwtDgb3NMPgnmZYOsENFzMfIjpFKF7OJDUfnbS14O8sboEMd7GCQaeWnXI0kEyIamm3pOHr64vMzEypbRcuXICTkxMcHR0BADNmzMD+/fsRFhaGgwcP1isjLi4OZWVlSEtLg76+PgQCAbS0aD0lVcHV4mCQoxkGOZrh6/FuuFQngRy6dh+dtLXg19sCYz1kTyA0kEyIalFqx3Nubi7s7Owkr3k8HhISEhrdf8WKFQCALVu2wNzcvNGEER4ejvDwcABATk4O4uPj5Rc0aZEAY8BvCBe3i/VwMb8aF+48wOG0+9DWAvjmXPhYa6OvJRf62vVbEaWlpWCMISwsDI8ePaK/I1GK0tJSOvfqUGrSYIzV2yZLF8TcuXObfD8kJAQhISEAAG9vb/j7+7cmPCJHLwMIAVBTw3Al6xGiUoSISclHeHIldLla8O1tDgHfBiNcrWCkpwMAiI+Ph7+/PwICApQaO+nYas9DIqbUpMHj8ZCdnS15nZOTA1tbW7mUranP01B3WloceDt0hbdDV3w51hVXs4vFXVgpQhy9/gC6XC0M6yVOIHpV9X9UEEKUS6lJw8fHB7du3UJGRga6deuGiIgI7Ny5Uy5ld4Tnaag7LS0O+nc3Rf/uplgicEFiTjGik8VjIMduPACXA+zJuQAB3wajXK1h3FlH2SET0uG1W9KYOXMm4uPjUVhYCB6Ph2XLlmHevHlYs2YNAgMDIRKJEBwcDDc3N7nURy0N9aKlxUE/e1P0szfFkrEuSMwuxh/RF5FyvxRx6cn4nJuCoU7mzxOIFUw66yo7ZEI6JA5raGBBg3h7e+PSpUvKDqNDkPf02Pj4ePj5+SE557HkkbY5jyqgrcV5nkCsMcrVGqZdKIEQxemoYxqNXTtpviqRm9rpsUlJSXIrk8PhwNPOBGECF5z6NAAHQodi3rAeuFtYisV7U+Cz4ijmbExAxIUsPCx7Jrd6yf8wxpCYmNjgxBXS8WjsWg/UPdX+FL3OEofDgQfPBB48E3w2ug+u5T1BVIoQ0SlCfPZPCpb8m4ohPc0kXVhmBp0UEkdHQ/fKkLqoe4qoLFm7BRhjuJb3BNHPE0hmUfnzGw27QsC3wWg3a0ogbdDR78qn7ilpGtvSIB0Hh8OBezdjuHczxieBzkgT1iaQfCzZl4ov/03FIEdxC2S0uzXMKYG0CC26SOrS2KRB3VMdE4fDgZutMdxsjfHxKGfcyC+RDKJ/8W8qvtqfigE9umIs3waB7tawNNRTdsiEqBXqniIqS57dAowxpN8vQXSyOIHcKSgDhwMMcOiKsR7iLixLI0ogpD7qnpKmsS0NQuricDjoY22EPtZG+GBkb9y8XyoZRP9q/zV8feAafLp3hYBvjTF8G1ipSAJpajyho481EOWgKbekw+FwOHC2NsSHI3vj6Id+OPKBLxYN74XiimdYGpmGQauOYeq6s9h8JgP5j5W7DH9T05gVMcWZkOZobEuDxjSIrHpZGeJ9K0O8P6I3bt0vQXRKPqJThFgWmYZlkWnw7m4KAd8GY/jWsDHWb9fYmprGTI+SJcpAYxpEZSm7L/n2g1LEPB9Ev5FfAgDoZ28CAd8GAr4NbE3kk0Com0m1tdd5qGrnAd0RTkgLOVka4N3hvRD7vi+Of+SHj0f1RkVVDZZHXceQ1ccx6b9nsOHUXeQWV7SpHupmIoD6nAca2z1FiDw5Whgg9OVeCH25FzIKyyQ3Ei6Puo7lUdfhZWeCsc/vA7Hr2rlFZVM3EwHU5zzQ2KRBYxpEUXqYd8HCACcsDHBCZmEZolPFCWRF9HWsiL4OT56xpAtLlgRCN88RQH3OAxrTICpL2WMaLXWvqEwyiJ6SK/6x4sEzxhh3G4zl28DerGUtEGVQtX51VaBu56G80H0ahChYd7MueNu/J97274msonJJC+S72Bv4LvYG3LsZQcAXJ5DuZl2UHW6DaHFC0hxKGoQogL1ZZyzw64kFfj2R/bAcMalCRKXk4/vYdHwfmw432/8lEAdz1Ukg6tKvTpSHkgYhCmbXtTNCfHsixLcnch6VIyYlH1EpQvxwKB0/HEqHq40RxnqIx0B6KDmBqEu/OlEeShqEtFJr+v95pp0x39cR830dkVtcgZjns7BqE0gfa0OM5dtA4GGDnhYGCj4CQlpOY5MGzZ4iitbW/v9uJvp4c5gj3hzmiLziCsSkigfRfzpyEz8duYk+1oaSWVhOlpRANJE6Tjyg2VNEZan6rBVF/YMXPq5AzPNZWJfuPQIA9LYykIyB9LIylFtdpHmKPA8TExNVduIBzZ4iRM4U1f9vY6yP4Jd6IPilHsh/XInYVPEDpX45dgv/OXoLvSyfJxAPG/SmBKLW1HHiASUNQlSYtbEe5g7tgblDe+D+k0rEPu/C+vX4Lfxy7BacLP/XAultZaA2XRxETB0nHlDSIERNWBnpIWiIA4KGOOBBSSUOpYpnYa05fgu/HruFnhZdMJZvgzF8G/SxNmy3BKLMfnl1HBNQd7RgISFqyNJQD3MGOyAiZDASPh+Bb19xh6WhHtbE3caYX05h+E8n8OOhdKTlPYGihy2bW2iPMYbExESFxKEui/xpEplbGlVVVUhPT0dxcTFMTEzg7OwMHR0dRcZGCJGBhWEnzBnUHXMGdUdh6VMcuibuwvpv/G2sibuNHuZdxE8kdLeBm62R3H+RN9cvr8i7zNVxTEDdNZs0oqKisG7dOhw7dgw6OjowNDRESUkJqqqq8PLLL2PBggUYN25ce8RKCGmGuUEnzB7YHbMHihPI4Wv3EZ0ixLoTd7E27g4czDpjzPMxEHklkOb65RV5YVfHMQF112TSGDp0KExNTTFr1iz88ccfsLW1lbwnFAoRHx+PdevWYdWqVThz5ozCg20Juk+DdHTmBp0wa6A9Zg20R1HpUxxOEyeQ8JN38Xv8Hdh37SwZRHfvJv8WSC26sGuWJu/TSElJAZ/Pb7aQ1NRUuLu7yzUweaH7NNSXqt+noa4elT3D4bR8RKXk4+ztQlTXMNh37YwxfGuM5duA382YBpXr6KjnYaue3Fc3YWRlZUEkEtXbJycnR2UTBiGkPtMuupjuY49twQOweaI1OBd3wryTCBtPZWDCmjMY9n0cVkZfR2J2scIH0UnDFDl5oK1knj3l4OCAESNG4OHDh1LbXV1d5R4UIcqiyv9YFeGlAX2x76dPsPe94bj8xUj88KoHelkaYPOZDLyy9gxe+i4OK6LScDXrUYf5TlSBKs8KkzlpdO7cGUOGDIG3tzeSk5Ml2+lEIppElf+xKkLteAOHw4FxZx1M9bbD5jcG4NKSkfhxqiecrQ2x5WwmJv33LIauPo5vD6bh8r1HqKlR3L/7jpC4mztGVZ4VJnPS0NLSwooVK7Bq1SqMGDECe/bsAQDq+yQaRZX/sbYn4846eLU/D5vm+uDSFyPx01RPuNgYYfu5e5jy+1kM/e44lkVew6XMh61OII1dOGVJ3MpMLPKou7ljrJvMVQ6TkaGhoeT/X7lyhTk4OLAvvviCGRgYyFqEUvTv31/ZIZBWiouLU3YI5AWPK56xvZez2bwtF1ivz6NZ98UH2cAVR9nX+1PZhYwiJhLVsJqaGnb16lVWU1PTZFlXr15ljo6O7OrVq1LbZfl8Y5+Vt5qaGrZ+/XqpWORRt6zfkTI1du2UeZVbU1NTPHr0SPK6oKAAU6ZMwZkzZxocIFcVNHtKfXXUWSuKwBSw3EZJZRWOXX+AqBQhTtwswLPqGlgZdYK3lTZiwldgz7rv0a9vX4XEpIjjaUhiYiIEAgGio6Ml04bbq25la+za2aal0UUiEXJyctC9e/c2BadIlDTUFyUN+VH0EtwllVU4fuMBolOEiE8vwNPqGlgadsIYd2sI+DbwdugKrpb6XWAZY9i4cSPmzZun0TADiFAAACAASURBVAmiIa1eGv3u3bsKCYgQ0n4UPVZjqKeDiV7dMNGrG0qfVosTSLIQERezsfXcPVjUSSA+apRAOBwOnJycOlzCaEqzSaP2C6ttkNT9/7Wv26t7Kj4+Hl9++SXc3NwwY8YM+hVKiIza865sg07amOBpiwmetih7nkBiUoXYfSkb287dg7lBJ4x2t4KAb4OBPczknkDk3X3Eng98a3p3lKyanT1VU1MDkUiEmpoa1NTUwMjISPL/a9+TRXBwMCwtLevdCBgbGwtnZ2c4OTlh9erVTZbB4XBgYGCAyspK8Hg8meolhChPl07aGO9pi//O7o8rX47E2ln9MLBHV+y9nItZ6xMwcOVRfL4vBWduF6JaVCOXOuU9bfrOnTsdahp2c1o8ptG1a9d6N/jJ4uTJkzAwMMDrr7+O1NRUAOIxkd69e+PIkSPg8Xjw8fHBrl27IBKJEBYWJvX5TZs2wdzcHFpaWrh//z4+/PBD7Nixo9l6aUxDfdGYhuYqf1aN+PQCRKUIcfz6A1RUiWDWRRej3MRLmQxy7Aptbuue3CDvlkZcXBxMTU2bLE8TB8eV/rhXX19fZGZmSm27cOECnJyc4OjoCACYMWMG9u/fj7CwMBw8eLDRskxNTfH06VNFhksIUaDOutoQ8G0g4Nug4pkI8eniWVj7E3Ox60IWunbRRaCbFca422BwTzPotCCByLsrTpbyFLn8u6pR6pP7cnNzYWdnJ3nN4/GQkJDQ6P7//PMPDh06hOLiYoSGhja6X3h4OMLDwwGI18aKj4+XW8yk/ZSWltLfroPQB/CqLTDBqhNSCkW4mF+NfZezsetCNgx0gH5W2vCx4sLFjAvtdh5El+U8ZIwhLCwMjx49ktqXMYY7d+6gZ8+eGtMCaTZpzJkzR+pgy8rK8Prrr0vts23btlZV3lDPWFNf7OTJkzF58uRmyw0JCUFISAgAcROLujjUE3VPdUyjnv9vZZUIJ24WIDpFiGPXH+BkzlOYdNbBKFfxIPpQJ/MWtUBaS9bzMCAgoN62xMRErFq1SqNaIDLNnqrr888/l1vlPB4P2dnZktc5OTlSz+xoC3qeBiHqTU+Hi0A3awS6WaOySoSTNwsQk5qPmJR87L6UA2N9HYx0tcLY5wlEV7vxBKKsMQdFT3VWxnE1mzSGDh0KPz8/hTza1cfHB7du3UJGRga6deuGiIgI7Ny5Uy5ljx8/HuPHj4e3t7dcyiOEKI+eDhej3Kwxys0aT6tFOHWzENEpQhxKzceeyzkw0tPGSFdrjPWwxktOFvUSSHNjDoqYpltbniJbGEoZS2lu/ZFRo0Yxc3NzNnHiRBYeHs5ycnJatY7JjBkzmLW1NdPW1mbdunVjGzZsYIwxFhUVxXr16sUcHR3Z8uXLW1V2Qw4cOMDmz5/PnJyc5FYmaV+09lTrqMO6RvJSWVXNjl3PZx/+lcjcv45l3RcfZO5fx7IP/rrKjqbls8qqasZY899JU+tJteY8lPfaWI3Fr8i/dZvWniovL8exY8cQHR2NmJgYGBsbY+zYsRAIBBgyZAi0tBTfr9haNOVWfdGYRusoesmQ9sRa0AJ4Vl2DM7cLEZUixOFr+XhSWQ1DPW2MdLHCGL4NhvUyh54Ot8X1tOY8bEncspS1e/dufP755zL/TeVRf6PXztZkoJSUFPbdd98xX19fZmlpyaZPn87Onz/funSmYLTKrfqilkbrKLql0Z4tmdb+Yn9aJWLHb9xnH+9OZB5LD7Huiw8yt69i2aJdV9ihVCGreCZbC4Qx5Z+HV69eZT169GARERFMJBK1aQXhlmjzKreNefLkCQ4dOgRTU1OMGDGiLUXJVe1AeFxcHG7duqXscEgrUEtDNbVnS4bJ4RdzlUjcAolOEeJw2n0Ul1ehiy4X/ax1McRODz98GIx//o5o9FgUfR6y58uUAGjwGRp1vwNZxzDk8b21epXbhIQE7NmzB4sWLQKPx8OPP/6Ijz/+uFVBKAN1T6kvShqqSR4XJGWpEtXg7J0i/BmfiiPXHwCdDKCnzXk+iG4Df2fLel1Yij4PExMTMW7cOADAwYMHFZ4MZNXYtbPZwYgPPvgAAwYMQFBQEFJTU3Hy5EmFBEgIUQ8q/VS5ZuhwteDX2wLh8/2xZ05vbAv2waR+djhzpwgL/ryCft8eQejOK4hOEaLimfS6erUtgsZ+Zzf3fmM8PT0lPSPNTc1Vhe++2Sm3PB4PU6dOxfDhw/Haa6/h/v377RFXm9F9GoSQxnA4HHj3Ez8gyre3Jb6d6IaEjIc4mCzEoWv5OJgshL4OFy/3sUR3bjUGPKvGzbTUJruGWjv9lcPhoG8TD6uSVXPdXPLSbPfU4sWL8d133wEA8vPzMXXqVJw6dUohwSgCdU+pL+qe0jzq0LVVLapBQsZDRKcIEZuaj6KyZ9DX4cLf2QJuRk/xRqAPOutq1zsOZR9bS7q5ZNHqMY3o6GiMHj1apafVNoWShvqipKF51G06sKiGIXzfceRyLRGbeh+FpU+hp6OFvla6OL9nHXb+EIbBPv2UHSYA+bc0Wp00rKysoKWlhdmzZyMoKAh8Pr9NgbQXmj2l/ihpaB5l/xpvjdrzUFTDcDHzIaKShYhJFaKw9Bk6aWshwNkSY/jWGO5iBYNOSl0DVq5avTR6Xl4eYmJisH37dgwcOBDOzs4ICgrCrFmzYGlpqZBg5YGWESFE9bTnEwTljavFwSBHMwxyNMPSCW64lCnuwopJzUfstXx00hYPsgv4NhjuYglDPfkvvSQLRSfmZvucuFwuxo0bh7/++gv5+fl45513sG/fPtjb22P8+PHYs2eP3IMihBBVxtXiYKCjGZZNdMf5sOH4e8FgzBxgj6ScYrz/VyL6Lz+K+dsuYd/VHDyprGrX2OT95MIXtfrmvvPnz2PmzJnIyspqt2eEtwaNaagv6p4iqqAl52FNDcOVrEeIShEiJiUf+U8qocvVgm9vcwj4NhjhagUjBbdA5NXSkMuT+54+fYp9+/Zh27ZtOHbsGIYOHYqlS5e2OihCCNEkWloceDt0hbdDV3w51hVXsx8hKjkfMalCHL3+ALpcLQzrZY4xfBuMdLWCsX79BFJ70ffw8EBycnKLL/6K7gKUKWmcPHkS27Ztw549e2BlZYU5c+Zg3bp1sLe3V1hgbUX3aRBClElLi4P+3buif/eu+GKsC65mFyMmRSh+qNSNB9DhcvCSk7gFMsrVGsadxQmktntp5cqVLVqksL00mzR69OiBx48fY+rUqYiOjsaQIUPaI642o4FwQoiqECcQU/TvboolY12QmF2M6BQholPyEZeejM+5KRj6PIGMdHHB3r174eHhAWdnZ4U9wKm1mk0aq1atwqRJk9CpU6f2iIcQQjQah8NBX3tT9LU3xecCFyTlPH6eQIT4dE8ytLU4GOpkjrFVuRjp6qpyU5ObTBpJSUmYMWNGs4XUDroQQgiRHYfDgZedCbzsTBA2pg9Sch8jqjaB7E2G9j4OBvc0w1i+DQLdrGHaRVfZITedNBYuXAgjIyPMmTMHfn5+Us/vFgqFOHHiBLZt24bS0lJayJAQovaUefMhh8OBB88EHjwTfDa6D1JznyAqJQ/7Lt3DqVuFWPJvKob0NIPgeQLpqqQE0uR9GqdPn8Y777yDHTt2wMnJCYaGhrC1tYWhoSF69eqFiIgIhIaGUsIghGgERd/jICsOhwM+zxijbZ6iYMtC/F+gBd7ydUT2w3KE/ZMCnxVHMXvDeexIuIfC0qftG5us92lUVVXh1q1bKC4uhqmpKXr16gVtbdW9ZZ6WEVF/dJ8GaQl5tBIaKkOZ5+GL8TDGcC3vCWJShYhKFiKzqBxaHGCQ4/9aIBaG8hl/bvXaU+qObu5TX5Q0SEsoajFEeZyHiuj2YozhurAE0SlCRKUIkVFYBi0OMLCHGQR8awj4NjAzaH0CafVDmAghRB14enpi7969KjkpRxHdXhwOB662Rvg40Bn/N9wYWodWYYqLIR6UVOLL/ddwMfOR3OqqS3X7lwghpAVUeTFERSc0Ly8v/LN5jaT8Ww9KYd+1s0LqoqRBCCEKpuiE9mL5va0MFVZXi7qnKioqIBQKUVFRoah4CCGEqDCZkkZcXBwGDBgAQ0ND8Hg8GBoaYsCAATh27Jii4yOEEKJCmk0aly5dgkAgwMCBA3HkyBGkpaXh8OHDGDBgAMaPH4+LFy+2R5yEENJmtY9E1YRJo8o6lmaTxg8//IBPP/0Uv/32GwICAuDs7IyXX34Za9asweLFi/HDDz+0R5wtFhkZiZCQEFrllhA10F4XQFW5eU8elHUszSaNc+fO4a233mrwvfnz5+Ps2bNyD0oexo8fj/DwcBgbGys7FEJIM9rrAqjsabnyTI7KOpZmk0ZxcbHUmlN12dra0i95QkibtdcFsHaWUXuuK1U3USQlJWHy5MnYvXt3mxOHMo4FkMPNfaq2bC8hRP0o6wLYHuq2ojw9PbFq1Sp8/vnnCm1VKbK7r9n7NMrKyhp9Qh9jDOXl5XIPihBCNEXdVhSHw8G0adMU/nCl2kSliKf+NZs0jh8/LtcKCSGkI3nxxrv2uHNdkd19zSYNPz8/uVdKCCGk9ZpbAFGRianZMY3Y2FipGVJ37tzB0KFDYWxsjNGjR0MoFCokMEIIIQ1T5tThZpPGl19+KZXJ5s2bB2NjY+zcuRNdunTBxx9/rNAACSGESFPm1OFmu6fu3LkDHx8fAMCDBw9w+vRp3Lt3D926dcPAgQPh4eGh8CAJIYT8jzJX9G3RlNtz586hR48e6NatGwDAzMwMpaWlCgmsITU1NViyZAneffddbN26td3qJYSQhmjSsiSyajZp+Pj44Ndff8WTJ0+wYcMGjBkzRvLe3bt3YW5uLlNFwcHBsLS0hLu7u9T22NhYODs7w8nJCatXr26yjP379yM3Nxc6Ojrg8Xgy1UsIIYqiScuSyKrZpPHzzz9j7dq1MDExwc2bN/HZZ59J3tu+fTt8fX1lqmju3LmIjY2V2iYSibBw4ULExMQgLS0Nu3btQlpaGlJSUjBu3Dip/x48eID09HQMHjwY//d//4fff/+9hYdKCCHypexlSZSh2TENV1dX3LlzB0VFRTAzM5N67/3334eurq5MFfn6+iIzM1Nq24ULF+Dk5ARHR0cAwIwZM7B//36EhYXh4MGD9crg8XiS+rhcbqN1hYeHIzw8HACQk5OD+Ph4mWIkqqW0tJT+dkTpZDkPT5w40T7BqIBmk0Z5eTmWL1+O1NRU9OvXD2FhYejUSfywchMTkzZVnpubCzs7O8lrHo+HhISERvefPHky3n33XZw6darJFk5ISAhCQkIAiB+O3taHwhPliI+Pp78dUTo6D6U1mzRCQ0Nx8eJFjBkzBnv27EFRURF+++03uVTe0OBRU2vPdO7cGRs3bpSp7MjISERGRtKCioQQIkfNjmnExMTg8OHD+P777xETE9Ngt1Fr8Xg8ZGdnS17n5OQ0uqJuS9HS6IQQIn/NJo2ysjLY2NgAAOzs7OT6y93Hxwe3bt1CRkYGnj17hoiICEyYMEFu5RNCCJGvZrunqqurERcXJ+lKevE1ALz88svNVjRz5kzEx8ejsLAQPB4Py5Ytw7x587BmzRoEBgZCJBIhODgYbm5ubTic/6HuKUI0S3PrLZH2wWHN3JXi4ODQ5B+Iw+Hg7t27cg9MXry9vXHp0iVlh0FagQYgSV2JiYkKW+67Kap+HioqmTZ27Wy2pfHiNFl1QS0NQjRLR7wnQhaKfHZGQ9r85D5VRQPhhGgWTX66X1u0dzJttqVBCCFEdbX34oUa29IghBAifxqbNCIjIxESEkJjGoSQFmvL6rWavvKtxiYNGtMghLRWW1av1fSVbzU2aRBCSGu1ZXBZ02d5aexAOE25JYS0VlsGl5X5VL32oLEtDeqeIoQQ+dPYpEEIIUT+KGkQQgiRGSUNQgghMqOBcEIIITLT2JYGDYQTQoj8aWzSIIQQIn+UNAghhMiMkgYhhBCZ0UA4IYQQmWlsS4MGwgkhRP40NmkQQgiRP0oahBBCZEZJgxBCiMwoaRBCCJEZJQ1CCCEyo6RBCCFEZnSfBiGEEJlpbEuD7tMghBD509ikQQghRP4oaRBCCJEZJQ1CCCEyo6RBCCFEZpQ0CCFEjTDGkJiYCMaYUuqnpEEIIWokKSkJU6ZMQVJSklLqp6RBCCFqxNPTE3v37oWnp6dS6tfYm/sIIUQTcTgceHl5Ka1+amkQQgiRmVq1NE6dOoUdO3aguroaaWlpOHv2rLJDIoSQDqXdWhrBwcGwtLSEu7u71PbY2Fg4OzvDyckJq1evbrKMYcOGYd26dRg3bhyCgoIUGS4hhJAGtFtLY+7cuQgNDcXrr78u2SYSibBw4UIcOXIEPB4PPj4+mDBhAkQiEcLCwqQ+v2nTJlhaWgIAdu7ciQ0bNrQ6lqqqKuTk5KCysrLVZRDFMzY2xvXr15UdhlLp6emBx+NBR0dH2aEQAqAdk4avry8yMzOltl24cAFOTk5wdHQEAMyYMQP79+9HWFgYDh482GA5WVlZMDY2hpGRUaN1hYeHIzw8HACQk5OD+Ph4qfcNDAxgZWWFbt26gcPhtP6giEKJRCJwuVxlh6E0jDE8fvwYSUlJKC0tVXY4HVZpaWm9a0hHptQxjdzcXNjZ2Ule83g8JCQkNPmZjRs34o033mhyn5CQEISEhAAAvL294e/vL/X+9evXwePxKGGouJKSEhgaGio7DKUyNDREaWkpvL29lR1KhxUfH1/vGtKRKTVpNHRHY3MX8mXLlslUdnPP06CEQdQBnadE1Sh1yi2Px0N2drbkdU5ODmxtbeVSNj1PgxBC5E+pScPHxwe3bt1CRkYGnj17hoiICEyYMEGZIRFCCGlCuyWNmTNnYvDgwUhPTwePx8PGjRuhra2NNWvWIDAwEC4uLpg2bRrc3NzkUl9kZCRCQkJU9nGvXC4XXl5ecHd3x9SpU1FeXg4AWLFiBdzc3ODh4QEvLy/JGI+/vz+cnZ3h4eGBPn36IDQ0FMXFxZLyKioq4OfnB5FIBAAYPXo0TExMMG7cOKl6/f39cenSJcnrzMzMetOg6yooKMDo0aNbfHyzZ8+Gs7Mz3N3dERwcjKqqKgDi/mFjY2N4eXnBy8sL33zzTYOfz8jIQEBAAHr16oXp06fj2bNn9fap7d5cunSp1OuWevToESZNmgQPDw8MGDAAqamp9faZO3cu/vjjD6lt//77LwQCAaKjoxEaGorhw4fj9u3bkvffeustnDlzBnPnzsWePXukPmtgYNCqWAlRtnZLGrt27YJQKJRMd503bx4AQCAQ4ObNm7hz5w6WLFkit/pUvXtKX18fiYmJSE1Nha6uLtatW4dz587h4MGDuHLlCpKTk3H06FGpiQI7duxAcnIykpOT0alTJ0ycOFHy3qZNmzB58mTJbKNPPvkE27dvb3OcFhYWsLGxwZkzZ1r0udmzZ+PGjRtISUlBRUWF1BTpYcOGITExEYmJifjqq68a/PzixYuxcOFC3Lp1C6ampti4cWO9fZYsWYL9+/ejqKgI7733XqsXcFu5ciW8vLyQnJyMbdu2YdGiRfX2mTlzJiIiIqS2RUREYObMmRAIBFizZg369u2LR48eSd5PSEjAoEGDWhUTIapKY5cRUfWWRl3Dhg3D7du3IRQKYW5ujk6dOgEAzM3NGxzj0dXVxffff4+srCzJhXLHjh1SSWT48OEtnnn05ptvSloAFhYWkkkHr7zyCnbs2NGisgQCATgcDjgcDgYMGICcnByZP8sYw/Hjx/HKK68AAIKCgvDvv//W22/lypWIjY3Fn3/+iYULFza4Hs8PP/wAHx8feHh44Ouvv26wvrS0NAwfPhwA0KdPH2RmZuL+/ftS+4wYMQI3btyAUCgEAJSXl+Po0aOSGH/55Re4u7vDx8cHgHiGXu/evZudMvzVV19JvvNu3bo1OzOQEGXT2KSh6i2NWtXV1YiJiQGfz8eoUaOQnZ2N3r1745133sGJEyca/RyXy4Wnpydu3LiBZ8+e4e7du3BwcJCpztmzZ0suVAKBQLJ9w4YNSExMxP79+2FmZoa5c+cCEE9bPnXqVINlNbdwWlVVFbZv3y7VxXXu3Dl4enpizJgxuHbtWr3PFBUVwcTEBNra4sl9PB4Pubm59fb74osvEBgYiNdeew1r166t19I4fPgwbt26hQsXLiAxMRGXL1/GyZMn65Xj6emJf/75B4D43qF79+7VS3JcLheTJ0/G7t27AQAHDhxAQEAADA0N8dtvv2H9+vU4ffq05G8WExMjdcyffPKJ5Duv+5198803SExMxIkTJ2BmZobQ0NAmv09ClE1jk4aqq6iogJeXF7y9vWFvb4958+bBwMAAly9fRnh4OCwsLDB9+nRs2bKl0TJq+/ALCwthYmIic907duyQdA9FR0dLvVdZWYmpU6dizZo16N69OwDA0tISeXl5DZaVmJjYZF3vvPMOfH19MWzYMABAv379cO/ePSQlJeHdd9+V/FJv6Ljqamjq6bfffotXXnkFZmZm+PXXX+Hh4SH1/uHDh3H48GH07dsX/fr1w40bN3Dr1q165Xz22Wd49OgRvLy88Ntvv6Fv376ShFVX3S6q2q4pAHj33XeRmpqKDRs2wM/PDwBw6NAhqaTxww8/SL7zF78zxhhmz56NDz74AP37969XLyGqRK0WLGyJ5u7TULbaMY0Xcblc+Pv7w9/fH3w+H1u3bpX84q9LJBIhJSUFLi4u0NfXl9uSKAsWLMDkyZMxYsQIybbKykro6+u3uKxly5ahoKBAagC57p38AoEA77zzDgoLC2Fubi7Zbm5ujuLiYlRXVwNofCp2bSKpHQh/MbEwxhAWFoa33npLavvatWuxfv16AEB0dDRsbW2xefNmyWd69OiBHj161Ktv6NChEAqFSEpKwtmzZ+uNcdQqLy9HcXGxzNPHly5dCh6PR11TRC1obEtDXbqn6kpPT5f6JZyYmCj5tV9XVVUVwsLCYGdnBw8PD5iamkIkErU5caxduxYlJSX47LPPpLbfvHmzyRlWDdmwYQMOHTqEXbt2QUvrf6dZfn6+pCVx4cIF1NTUwMzMTOqzHA4HAQEBknGMrVu3So3XyCowMBCbNm2SLMGRm5uLBw8eYOHChZJf/La2tiguLpbMztqwYQN8fX0bXKaGw+Fg2rRpCAoKgkAggJ6eXoP1xsXFISAgQKYYDx48iCNHjuDXX39t8fERogwamzTUUWlpKYKCguDq6goPDw+kpaVJfkUD4rEIDw8PuLu7o6ysDPv375e8N2rUKJw+fVryetiwYZg6dSqOHTsGHo+HQ4cONVv/jz/+iJSUFEm/+7p16wCIL4Jjx45t8DONjWksWLAA9+/fx+DBg6Wm1u7Zswfu7u7w9PTEe++9h4iICEkLQSAQSLrBvvvuO6xZswZOTk4oKiqSzLZriVGjRmHWrFkYPHgw+Hw+Xn31VZSUlNTb7/r163Bzc0OfPn0QExODX375pdEyZ86ciaSkJMyYMaPRfV4cz2jKTz/9hLy8PAwYMABeXl6NziYjRFVwmLKeTt5OvL29pe5LAMQXCRcXFyVFpBhXr17F//3f/8llmu2LfH19sX//fpiamsq97Kao69pT/fr1Q0JCgtxWptXE81WddNS1pxq6dgI0poFlkdeQlvdErnW72hrh6/HyuUlRVn379kVAQIDcV4YtKCjAhx9+2O4JQ51duXJF2SEQojAa2z2ljmMabRUcHCz3pcQtLCwanOFECOmgmIbr379/vW1paWlKiER9rVixQup1eXk58/X1ZdXV1YwxxgIDA5mxsTEbO3as1H5+fn7s4sWLktcZGRnMzc2t0XoePHjAAgMDJa+fPHnSqngbi6euEydOsL59+zIul8v+/vtvyfbjx48zT09PyX+dOnVi+/btY4wxFhwczDw8PBifz2dTpkxhJSUlrYqvpeh8Va64uDhlh6AUDV07GWNMY1saRH5Wrlwp9VrVlix5kSzx2NvbY8uWLZg1a5bU9oCAAMnMquPHj6Nz584YNWoUAODnn39GUlISkpOTYW9vjzVr1rQpTkLUkcYmDVVfRuTPP/+UzJh56623IBKJcO/ePfTq1QuFhYWoqanBsGHDcPjwYWRmZqJPnz4ICgqCh4cHXn31VckCh8eOHUPfvn3B5/MRHByMp0+fAgAcHBzw9ddfo1+/fuDz+bhx4wYAoKysDMHBwfDx8UHfvn0lM7C2bNmCyZMnY/To0ejVqxc+/fRTAOIb32pvRJw9ezYA1Vuy5EWyxOPg4AAPDw+p6cAv2rNnD8aMGYPOnTsD+N89JowxVFRU0LMuSMfUvg2e9qeK3VNpaWls3Lhx7NmzZ4wxxt5++222detWxhhj69evZ1OmTGHff/89CwkJYYyJu3UAsNOnTzPGGHvjjTfYDz/8wCoqKhiPx2Pp6emMMcbmzJnDfv75Z8YYY927d2e//vorY4yxtWvXsnnz5jHGGAsLC2Pbt29njDH26NEj1qtXL1ZaWso2b97MevTowYqLi1lFRQWzt7dnWVlZjDHGunTpIon96dOnzMrKqt4xxcXFNdg91bt3b0lXj4uLS73uqczMTObs7MwyMzMZY4zl5OQwd3d3xlj97ilPT08Zv+GG42lIUFCQVPdUXQEBASwyMlJq29y5c5mlpSXz9/dnZWVlMsfTFso+Xzs66p6SprEtDVV27NgxXL58GT4+PvDy8sKxY8dw9+5dAOJf4CUlJVi3bh1+/PFHyWfs7OwwdOhQAMBrr72G06dPIz09HT169EDv3r0BiBf2q7u20uTJkwEA/fv3lzyf/fDhw1i9ejW8vLzg7++PyspKZGVlARD/Qjc2Noaenh5cXV1x7969erGr8pIl8iQUCpGSkoLAwECp7Zs3b0ZeXh5cXFzw119/tVs8hKgKShpKwBhDUFCQ5GKabgLQ3AAAC79JREFUnp4uuYmvvLxcslhe7Z3MQP0lMjgcTrPPj6hdLZfL5UqW5GCMYe/evZK6s7KyJPcA1O7/4mfqUrUlSxISEiTdXAcOHJBLXACwe/duTJo0qcF7LbhcLqZPn469e/fKrT5C1AUlDSUYPnw49uzZgwcPHgAAHj58KPlVv3jxYsyePRvffPMN5s+fL/lMVlYWzp07B0D8bJKXXnpJsox37YN/tm/fLlkwrzGBgYH47bffJAnn6tWrzcaro6MjeYiSqi1ZMnDgQEkClOdTH3ft2iVZkBAQJ9va75kxhsjISPTp00du9RGiLihpKIGrqyuWL1+OUaNGwcPDAyNHjoRQKMSJEydw8eJFSeLQ1dWVLKTn4uKCrVu3wsPDAw8fPsTbb78NPT09bN68GVOnTgWfz4eWlhYWLFjQZN1ffvklqqqqJMuRfPnll83GGxISAg8PD8lAuKotWfKixuL56quvJK2Rixcvgsfj4e+//8Zbb70l9cTIzMxMZGdnSyXg2tYhn88Hn8+HUCikJT9UHGMMiYmJrX6iI2lE+wyptL8DBw6w+fPnMycnp3rvqdvAYnP3N7S3K1eusNdee00hZQ8bNow9fPiQMdb6+zQ0jbqdr6ri6tWrzNHRkV29erVN5dBAuDSNbWl0xDvC20vdJUvkiZYsIfLk6emJvXv3wtPTU9mhaBSNXXtKkzg4OCA1NVXZYUgJDg6We5m0ZAmRJw6HI3OXJpGdxrY0msOon5OoATpPiarpkElDT08PRUVF9A+SqDTGGIqKihp92BMhytAhu6d4PB5ycnJQUFCg7FBIEyorKzv8BVNPTw88Hk/ZYRAi0SGTho6OToPPgCaqJT4+Hn379lV2GISQOjpk9xQhhJDW0diWhqxP7iOEECI7jW1p0H0ahBAifxym4VOIzM3N4eDg0C51PX78WK5Jqi3lteazLfmMLPu2dZ+CggJYWFjIFI+qkvc5oYz66DzsmOdhZmYmCgsL67/RbvekdwDz589XmfJa89mWfEaWfdu6T2PLGKgTeZ8TyqiPzkM6D+viLq1dk5vIhbOzs8qU15rPtuQzsuzbln3Cw8MREhIiczyqSt7nhDLqo/OQzsNaGt89RdSXt7c3Ll26pOwwSAdH56E0jR0IJ+pPE37dEfVH56E0amkQQgiRGbU0CCGEyIySBiGEEJlR0iCEECIzShpELV2/fh0LFizAq6++it9//13Z4ZAO6t9//8X8+fMxceJEHD58WNnhtAtKGqTdBQcHw9LSEu7u7lLbY2Nj4ezsDCcnJ6xevbrJMlxcXLBu3Trs3r2bpkOSVpHHefjKK69g/fr12LJlC/766y9FhqsyaPYUaXcnT56EgYEBXn/9dcljbEUiEXr37o0jR46Ax+PBx8cHu3btgkgkQlhYmNTnN23aBEtLSxw4cACrV69GaGgoZs2apYxDIWpMXuchAHz00UeYPXs2+vXr1+7H0e7kdm85IS2QkZHB3NzcJK/Pnj3LRo0aJXm9cuVKtnLlSpnKEggEco+PdAxtPQ9ramrYp59+yo4cOaLQOFWJxi6NTtRLbm4u7OzsJK95PB4SEhIa3T8+Ph7//PMPnj59CoFA0B4hkg6gpefhb7/9hqNHj+Lx48e4ffs2FixY0B5hKhUlDaISWAO9pBwOp9H9/f394e/vr8CISEfU0vPwvffew3vvvafIkFQODYQTlcDj8ZCdnS15nZOTA1tbWyVGRDoiOg+bR0mDqAQfHx/cunULGRkZePbsGSIiIjBhwgRlh0U6GDoPm0dJg7S7mTNnYvDgwUhPTwePx8PGjRuhra2NNWvWIDAwEC4uLpg2bRrc3NyUHSrRYHQetg5NuSWEECIzamkQQgiRGSUNQgghMqOkQQghRGaUNAghhMiMkgYhhBCZUdIghBAiM0oahGiomTNn4t9//21zOffv34eLiwuePn0qh6iIuqOkQTSGg4MD9PX1YWBgIPkvLy9P2WEpRXJyMpKSkjBx4kQAwJYtW/DSSy/V28/BwQFHjx5tsiwrKysEBAQgPDxcIbES9UJJg2iUyMhIlJaWSv5raN2g6upqJUTWvv744w/Mnj27ycX2WmL27Nn4448/5FIWUW+UNIjGy8zMBIfDwcaNG2Fvb4+XX34ZAHD+/HkMGTIEJiYm8PT0RHx8vOQzGRkZ8PPzg6GhIUaOHInQ0FC89tprAMTLsvN4PKk66v5ir6mpwerVq9GzZ0+YmZlh2rRpePjwoVQsW7duhb29PczNzbFixQpJOSKRCCtXrkTPnj1haGiI/v37Izs7GwsXLsRHH30kVef4/2/vbkLaaMI4gP9tclCXNqlgaQlpBCXGkwcrlV68BVTqB0JATQzUUAQPigcpqFhFSqFFWgserQE1gocmiIqiaDQXvUjqIVg/aowfWLWKGhNM7fRQHLoYXze8Bal5frCQ7Mw+M5lDnszshnn6FO/evQv7mYeHh5GdnR3ROKWnp4tmaTExMXxMHj9+jJWVFXi93ohikpuHkgaJGk6nEx6PByMjI9jY2EBeXh4aGhrw/ft3vH37FsXFxdjZ2QEAlJaWIiMjA7u7u2hsbITVapXcTnt7O+x2O5xOJzY3N3H37l1UVVWJ6rhcLiwsLGB8fBwtLS3weDwAgLa2NthsNgwNDeHw8BCdnZ2Ij4+H2WyGzWbDz58/AQC7u7sYHx9HSUnJhfb9fj++fv2K1NTUiMbH7XbzGVpbWxtSU1P5TnRyuRwpKSlwu90RxSQ30PXuAUXI36PRaJggCEyhUDCFQsEKCgoYY793ZwPAlpeXed3Xr18zo9Eoul6v17Ouri7m9XqZTCZjx8fHvKykpISVlZUxxhibmJhgKpXqQtvnu7fpdDo2NjbGyzY3N5lcLmehUIj3xefz8fLMzExms9kYY4xptVpmt9vDfj6dTsdGR0cZY4x9+PCB5eTkhK23vr7OALBAIMDPffz4kclkMj4250dMTMyFXeemp6dZYmIiW1hYEJ1/8uQJs1qtYdsk0YNmGuRGsdvtODg4wMHBwYUnh/7ckc3r9aK/vx9KpZIfLpcLW1tbfHYgCAKvr9FoJPfB6/WiqKiIx01LS4NMJsP29javc//+ff46Pj4ex8fHAACfz4fk5OSwcc1mM7q7uwEA3d3dMJlMYesplUoAwNHRkeh8VlYWH5vz4+HDh6I6Pp8PBoMBVqsVWq1WVHZ0dMRjk+hFSYNEjT9vCqvVaphMJtEXqN/vx4sXL/DgwQPs7+/D7/fz+mtra/y1IAg4OTnh78/Ozviy1nns4eFhUexgMAiVSnVlH9VqNZaXl8OWGY1GOBwOuN1ueDweFBYWhq0nCAKSk5Px5cuXK9v7UyAQQGFhIWpqapCTkyMq+/HjB5aWlpCenh5RTHLzUNIgUcloNGJgYAAjIyM4OztDMBjE5OQk1tfXodFo8OjRIzQ1NeH09BQulwsDAwP8Wq1Wi2AwiMHBQYRCIbS2tor+w1BZWYn6+np+03hnZwcOh0NSvywWCxobG7G4uAjGGD5//oy9vT0Av3eVy8zMhMlkQnFxMeLi4i6Nk5ubC6fTGdGYPHv2DDqdDnV1dRfKZmdnkZSUFNGMi9xMlDRIVFKr1XA4HHj16hUSExOhVqvx5s0bfqO5t7cXMzMzSEhIQHNzM8rLy/m1CoUCHR0dsFgsUKlUEARB9DRVdXU18vPzodfrcfv2bWRlZWFmZkZSv2pra2EwGKDX63Hnzh1UVFQgEAjwcrPZjPn5+UuXps49f/4cPT09Yfe8vkxfXx8+ffokeoJqenoaANDT04PKykrJscjNRZswESLBy5cvsbS0xO8pXJepqSkYjUasrq7i1q3//s1XWloKg8Fw6TKWVN++fUN2djbm5uYQGxv7v2KRf5/8ujtACJEmFArh/fv3sFgsVyYM4Pds6W+4d+8efySYEFqeIuQf4PF4oFQqsbW1hZqamuvuDolitDxFCCFEMpppEEIIkYySBiGEEMkoaRBCCJGMkgYhhBDJKGkQQgiRjJIGIYQQyX4B382U930eRtUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 1.5738048009669492e-07\n", + "Stddev: 3.049827302681431e-08\n", + "Stddev/Mean: 0.19378688518471987\n", + "-8.119322830970063\n", + "{'popt': array([-1.84486584e+00, 7.59761302e-09]), 'cov': array([[0.00130778, 0.00279381],\n", + " [0.00279381, 0.006182 ]]), 'fit_range': [0.0001664198302471788, 0.01930470030867274], 'sigma': array([3.61633060e-02, 1.37548934e-09])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-8.140947668017432\n", + "{'popt': array([-1.86155444e+00, 7.22856902e-09]), 'cov': array([[0.00144123, 0.00307889],\n", + " [0.00307889, 0.00681282]]), 'fit_range': [0.0001664198302471788, 0.01930470030867274], 'sigma': array([3.79635715e-02, 1.37382473e-09])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-7.662174515591115\n", + "{'popt': array([-1.88393528e+00, 2.17683486e-08]), 'cov': array([[0.00935073, 0.01997587],\n", + " [0.01997587, 0.04420161]]), 'fit_range': [0.0001664198302471788, 0.01930470030867274], 'sigma': array([9.66991758e-02, 1.05380486e-08])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 9.816732413453718e-06\n", + "Stddev: 4.564222966161531e-06\n", + "Stddev/Mean: 0.46494319840136583\n", + "-7.101694775267475\n", + "{'popt': array([-7.47564116e-01, 7.91234517e-08]), 'cov': array([[0.03744183, 0.09076646],\n", + " [0.09076646, 0.22564157]]), 'fit_range': [0.00016771562142346813, 0.009727506042561151], 'sigma': array([1.93498917e-01, 8.65427058e-08])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-6.174695193764138\n", + "{'popt': array([-3.44513059e-01, 6.68813154e-07]), 'cov': array([[0.03309846, 0.08023726],\n", + " [0.08023726, 0.19946641]]), 'fit_range': [0.00016771562142346813, 0.009727506042561151], 'sigma': array([1.81929811e-01, 6.87789245e-07])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-6.427588895407435\n", + "{'popt': array([-4.31750894e-01, 3.73603645e-07]), 'cov': array([[0.05032292, 0.12199279],\n", + " [0.12199279, 0.30326889]]), 'fit_range': [0.00016771562142346813, 0.009727506042561151], 'sigma': array([2.24327705e-01, 4.73740728e-07])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 4.471046976622739e-08\n", + "Stddev: 3.791649910217819e-09\n", + "Stddev/Mean: 0.0848045196134774\n", + "-6.353011604314411\n", + "{'popt': array([-5.78345525e-01, 4.43596791e-07]), 'cov': array([[0.03671072, 0.07791669],\n", + " [0.07791669, 0.17087042]]), 'fit_range': [0.0003359868861199787, 0.019487239394958764], 'sigma': array([1.91600414e-01, 4.22218761e-07])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-7.508121394968624\n", + "{'popt': array([-1.04070619e+00, 3.10369192e-08]), 'cov': array([[0.02948051, 0.06257092],\n", + " [0.06257092, 0.13721733]]), 'fit_range': [0.0003359868861199787, 0.019487239394958764], 'sigma': array([1.71698888e-01, 2.64727329e-08])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-7.089319616002394\n", + "{'popt': array([-8.60291687e-01, 8.14104929e-08]), 'cov': array([[0.03477769, 0.07381394],\n", + " [0.07381394, 0.16187314]]), 'fit_range': [0.0003359868861199787, 0.019487239394958764], 'sigma': array([1.86487785e-01, 7.54194685e-08])}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 1.1074864086875394e-07\n", + "Stddev: 4.3832369925899834e-09\n", + "Stddev/Mean: 0.03957824636226888\n" + ] + } + ], + "source": [ + "num_slices = 3\n", + "peak_no = 0\n", + "type_of_fit = \"lin\"\n", + "\n", + "dejump = 0\n", + "min_jump_height = 5e-3\n", + "\n", + "f_min = 5e-4\n", + "f_max = 1e-2\n", + "\n", + "overview_path = \"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\"\n", + "saver_overview = Saver_json(overview_path)\n", + "saver_overview.fname = \"P35B4_post_analysis_wjumps2\"\n", + "saver_overview.append_to_file = True\n", + "\n", + "for file in chosen_measurements.values():\n", + " bcv = file[\"bias_cooling_parameters\"][\"bcv\"]\n", + " tgv = file[\"bias_cooling_parameters\"][f\"{side}tgv\"]\n", + " vr = file[\"bias_cooling_parameters\"][\"vref\"]\n", + " analysis_key = f\"{bcv}tg{tgv}vr{vr}side{side}\"\n", + " \n", + " demod_prefix = \"demod0&4\"\n", + " if side == \"l\":\n", + " demod_idx = 0\n", + " else:\n", + " demod_idx = 4\n", + "\n", + " node_timestamp = f\"{demod_prefix}.timestamp{demod_idx}\"\n", + " node_x = f\"{demod_prefix}.x{demod_idx}\"\n", + " node_y = f\"{demod_prefix}.y{demod_idx}\"\n", + " node_r = f\"{demod_prefix}.r{demod_idx}\"\n", + "\n", + " gates = \"gates_6_16\"\n", + " tracked_peaks = file[f\"{node_r}_tracked_peaks\"]\n", + " \n", + " saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"num_slices\" : num_slices}})\n", + " saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"peak_no\" : peak_no}})\n", + " saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"type_of_fit\" : type_of_fit}})\n", + " saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"dejump\" : dejump}})\n", + " saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"dejump_min_height\" : min_jump_height}})\n", + " saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"integration_limits\" : [f_min, f_max]}})\n", + "\n", + " if dejump:\n", + " used_trace = remove_jumps(tracked_peaks[\"tracked_peak_positions\"][peak_no], min_jump_height)\n", + " plt.plot(used_trace)\n", + " plt.plot(tracked_peaks[\"tracked_peak_positions\"][peak_no])\n", + " else:\n", + " used_trace = tracked_peaks[\"tracked_peak_positions\"][peak_no]\n", + " plt.plot(used_trace)\n", + "\n", + "\n", + " signals = np.array_split(used_trace, num_slices)\n", + " sampling_f = tracked_peaks[\"time_axis\"][1]**-1\n", + " min_len = min([len(element) for element in signals])\n", + "\n", + " if type_of_fit == \"lin\":\n", + " fit_func = linear\n", + " guess = [-1, 1]\n", + " elif type_of_fit == \"bilin\":\n", + " fit_func = bilinear2\n", + " guess = [-2, 1, -1, -3]\n", + "\n", + " integrals = []\n", + " for i, signal in enumerate(signals):\n", + " #do the signal processing here\n", + " #also save the slices in a way that further parts can understand it.\n", + " noise_calculator = AnalyzerTimetraceSpectralNoiseDensity(signal[:min_len],\\\n", + " sampling_f, fit_func = fit_func)\n", + " noise_calculator.guess = guess\n", + " #saver.add_info(f\"{node_r}_peak{peak_no}_fit_interval\", noise_calculator.fit_interval)\n", + " spectral_result = noise_calculator.analyze()\n", + " #saver.add_info(f\"{node_r}_peak{peak_no}_spectrum\", spectral_result)\n", + " #saver_overview.add_info(f\"{node_r}_peak{peak_no}_spectrum\", spectral_result)\n", + "\n", + " fit = noise_calculator.fit()\n", + " print(fit)\n", + " #saver.add_info(f\"{node_r}_peak{peak_no}_SNDfit_parameters\", fit)\n", + " #saver_overview.add_info(f\"{node_r}_peak{peak_no}_SNDfit_parameters\", fit)\n", + "\n", + " f, s = spectral_result[\"freq\"], spectral_result[\"spectrogram\"]\n", + " saving_path = os.path.join(\"testfigures\", f\"{i}\")\n", + "\n", + " plotter_SND = PlotterTimetraceSpectralNoiseDensity(saving_path, [f,s], fit)\n", + " plotter_SND.plot()\n", + "\n", + " #integrate the total noise power\n", + "\n", + "\n", + " band = np.linspace(f_min, f_max, 100000)\n", + " spec = func_power2(band, *fit[\"popt\"])\n", + " integrals.append(np.sum(np.diff(band) * spec[:-1]))\n", + "\n", + " integral_mean = mean(integrals)\n", + " integral_sem = sem(integrals)\n", + " print(\"Mean: \", integral_mean)\n", + " print(\"Stddev: \", integral_sem)\n", + " print(\"Stddev/Mean: \", integral_sem/integral_mean)\n", + "\n", + " saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"integrals\" : integrals}})\n", + " saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"integral_mean\" : integral_mean}})\n", + " saver_overview.add_info(analysis_key, {\"sliced_SND\" : {\"integral_sem\" : integral_sem}})" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:28:27.452120Z", + "start_time": "2022-09-15T12:28:27.429643Z" + } + }, + "outputs": [], + "source": [ + "saver_overview.save()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Remove large jumps" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T10:04:06.736501Z", + "start_time": "2022-09-15T10:04:06.708646Z" + }, + "init_cell": true + }, + "outputs": [], + "source": [ + "def remove_jumps(peak_track, jump_min_height):\n", + " difference = np.diff(peak_track)\n", + " jumps_height = difference[abs(difference) >= jump_min_height]\n", + " jumps_idx = np.flatnonzero(abs(difference) >= jump_min_height) + 1\n", + " \n", + " prev_idx = 0\n", + " jumped = 0\n", + " baseline = np.array([])\n", + " \n", + " for idx, height in zip(jumps_idx, jumps_height):\n", + " len_x = idx - prev_idx\n", + " prev_idx = idx \n", + " baseline = np.concatenate((baseline, np.full(len_x, jumped)))\n", + " jumped += height\n", + "\n", + " baseline = np.concatenate((baseline, np.full(len(peak_track) - len(baseline), jumped)))\n", + " return peak_track - baseline\n", + "\n", + "def linear(x, a, b):\n", + " return a * x + b\n", + "\n", + "def bilinear2(x, a, b, c, switch_point):\n", + " x = np.array(x)\n", + " part1 = a * x[x <= switch_point] + b\n", + " part2 = c * x[x > switch_point] + (a - c) * switch_point + b\n", + " return np.concatenate((part1, part2))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-12T11:58:32.331954Z", + "start_time": "2022-09-12T11:58:21.475139Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Specify current bias cooling voltage in V: 0.75\n", + "Savepath: /V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/20220502/014148_2D_Peak_tracking\n" + ] + } + ], + "source": [ + "date_time_string = \"20220502/014148\"#\"20220518/211236\"\n", + "date = date_time_string.split(\"/\")[0]\n", + "time = date_time_string.split(\"/\")[1]\n", + "filepath = f\"sftp://tp1435@os-login.lsdf.kit.edu/kit/phi/projects/nanospin/SEMICONDUCTOR_SYSTEMS/data/{date}/{time}_2D_Peak_tracking/{time}_2D_Peak_tracking.h5\"\n", + "savepath = os.path.join(\"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\",\n", + " str(pathlib.Path(filepath).parents[1]).split(\"/\")[-1],\n", + " str(pathlib.Path(filepath).parents[0]).split(\"/\")[-1])\n", + "\n", + "configpath = \"/home/ws/lr1740/Dokumente/Doktorarbeit/Sonstiges/sftp_config.txt\"\n", + "overview_path = \"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\"\n", + "\n", + "saver = Saver_json(savepath)\n", + "saver.append_to_file = True\n", + "saver_overview = Saver_json(overview_path)\n", + "bcv = input(\"Specify current bias cooling voltage in V: \")\n", + "\n", + "saver_overview.fname = \"P35B3_post_analysis\"\n", + "saver_overview.append_to_file = True\n", + "\n", + "print(\"Savepath: \" + savepath)\n", + "\n", + "settings = {\"file_info\" : {\n", + " \"filepath\" : filepath,\n", + " \"savepath\" : savepath,\n", + " \"analysis\" : \"plunger_sweep_timetrace\"},\n", + " \"authentication\" : {\n", + " \"configpath\" : configpath}\n", + " }\n", + "\n", + "analyzed_path = (f\"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project\"\n", + " f\"/Analysis/{date}/{time}_2D_Peak_tracking/analyzed_data.json\")\n", + "\n", + "loader_analyzed = LoaderJSON()\n", + "data_analyzed = loader_analyzed.load(analyzed_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-12T12:02:33.060164Z", + "start_time": "2022-09-12T12:01:33.194668Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done loading file, formatting now...\n", + "dict_keys(['demod0&4.r0', 'demod0&4.r4', 'demod0&4.timestamp0', 'demod0&4.timestamp4', 'demod0&4.x0', 'demod0&4.x4', 'demod0&4.y0', 'demod0&4.y4', 'gates_6_16', 'measurement', 'number', 'settings', 'static_voltages'])\n", + "\n", + "\n", + "['{\\n \"gate10_out\": 0.604248046875,\\n \"gate11_out\": 0.604248046875,\\n \"gate12_out\": 0.604248046875,\\n \"gate13_out\": 0.604248046875,\\n \"gate14_out\": 1.41387939453125,\\n \"gate15_out\": 0.75958251953125,\\n \"gate16_out\": 0.64422607421875,\\n \"gate17_out\": 0.6915283203125,\\n \"gate18_out\": 0.604248046875,\\n \"gate19_out\": 0.604248046875,\\n \"gate20_out\": 0.604248046875,\\n \"gate21_out\": 0.604248046875,\\n \"gate22_out\": 0.604248046875,\\n \"gate23_out\": 0.604248046875,\\n \"gate4_out\": 1.239013671875,\\n \"gate5_out\": 0.62652587890625,\\n \"gate6_out\": 0.604248046875,\\n \"gate7_out\": 0.57830810546875,\\n \"gate9_out\": 0.604248046875\\n}']\n", + "Specify reference votlage in V: 0.604\n" + ] + } + ], + "source": [ + "loader = Loaderh5()\n", + "data_raw, _ = loader.load(settings)\n", + "print(data_raw.keys())\n", + "print(\"\\n\")\n", + "print(data_raw[\"static_voltages\"])\n", + "vr = input(\"Specify reference votlage in V: \")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-12T14:34:33.460111Z", + "start_time": "2022-09-12T12:02:35.746510Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Specify side of SET (l/r): l\n", + "Specify current top gate voltage in V: 1.239\n" + ] + } + ], + "source": [ + "side = input(\"Specify side of SET (l/r): \")\n", + "tgv = input(\"Specify current top gate voltage in V: \")\n", + "while side != \"l\" and side != \"r\":\n", + " side = input(\"Specify side of SET (l/r): \")\n", + "\n", + "demod_prefix = \"demod0&4\"\n", + "if side == \"l\":\n", + " demod_idx = 0\n", + "else:\n", + " demod_idx = 4\n", + " \n", + "node_timestamp = f\"{demod_prefix}.timestamp{demod_idx}\"\n", + "node_x = f\"{demod_prefix}.x{demod_idx}\"\n", + "node_y = f\"{demod_prefix}.y{demod_idx}\"\n", + "node_r = f\"{demod_prefix}.r{demod_idx}\"\n", + "\n", + "gates = \"gates_6_16\"\n", + "tracked_peaks = data_analyzed[f\"{node_r}_tracked_peaks\"]\n", + "analysis_key = f\"{bcv}tg{tgv}vr{vr}side{side}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-12T14:34:39.209169Z", + "start_time": "2022-09-12T14:34:36.130207Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEaCAYAAADg2nttAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOy9fbAlRXk//unumTnn3ruvsHvdXXYBec0CIi/yIvELhIgQwMVAoRgUEBFRKwUakrIEDJXSJBpfQK2A+IsQQUWwEjRiNqCAgC/Lu6WAAQFZFpZdlt37cu4958xMd//+eLp7eubMnHMWAbPrfKpu3TMzPd1P9/TMPJ/npYdprTVq1KhRo0aNPuB/aAFq1KhRo8b/fdQvixo1atSoMRD1y6JGjRo1agxE/bKoUaNGjRoDUb8satSoUaPGQNQvixo1atSoMRD1y6JGjT5gjOG73/3uH1qMSuy666743Oc+V3n87LPPxkknnfQaSlRje0X9sqixTeLss88GYwyMMYRhiN122w0XXXQRZmZm/qByXXvttZgzZ84fVAYfV1xxBa6//vo/tBg1tgMEf2gBatR4uXjrW9+K6667DkmS4O6778a5556LmZkZXHnllX9o0QYijmNEUfSqtzN//vxXvY0afxyomUWNbRaNRgNLlizBihUr8Fd/9Vc444wzcPPNN7vjjz76KE488UTMnTsX4+PjePe7340XXnjBHb/vvvvwtre9DYsWLcK8efPwlre8BT//+c/7tvmZz3wGixYtwpo1a3qO3XnnnXjf+96HmZkZx3ouu+wyAGQuuuyyy3DOOedgwYIFOOOMMwAAH//4x7H33ntjZGQEu+66K/7u7/4OnU4nV+8tt9yCww47DCMjI9hxxx3x9re/vaeMxfXXX4958+bh+9//PoBeM9TRRx+ND3/4w/jEJz6BRYsWYXx8HBdddBGUUq7Mhg0bsGrVKoyMjGCXXXbBNddcg/3228/1pcYfJ+qXRY3tBiMjI0iSBACwfv16HHnkkdhvv/1w77334kc/+hFarRZWrVrlHozT09N473vfi7vvvhv33nsvDjjgAJxwwgnYtGlTT91aa1x00UX48pe/jJ/85Cc47LDDesocccQRuPzyyzE6Oor169dj/fr1uOiii9zxL3zhC/iTP/kT3H///fjHf/xHAMDY2Bi+/vWv47HHHsO//uu/4oYbbsCnP/1pd87q1atx8skn49hjj8UDDzyAO+64A0cddVTu4W7xpS99CX/913+NH/zgB1i1alXlOH3zm99EEAT42c9+hq985Su4/PLL8Z3vfMcdP+uss/DMM8/g9ttvx/e+9z1cf/31eOaZZwYNf43tHbpGjW0QZ511lj7xxBPd9po1a/SOO+6o3/nOd2qttb700kv1Mccckztn8+bNGoBes2ZNaZ1KKb1kyRJ93XXXuX0A9A033KDPPvtsveeee+qnn366r1zXXHONHhsb69m/yy676JNOOmlgv6688kq9++67u+0jjjhCv+td76osv8suu+h/+Zd/0ZdeeqkeHx/XDz74YO54cZyOOuooffjhh+fKvPWtb9Xvf//7tdZa/+Y3v9EA9M9//nN3fO3atZpzrv/+7/9+oPw1tl/UPosa2yxWr16NOXPmIE1TJEmCk08+GV/+8pcBAA888ADuuuuuUmfzk08+iUMPPRQbN27EpZdeijvuuAMbNmyAlBLtdhtr167Nlb/ooosQBAHWrFmD8fHxly3vm970pp593/3ud3H55Zfjt7/9LVqtFqSUkFK64w899BDOPvvsvvVeccUVmJ6exn333Yc999xzoBz7779/bnvZsmXYuHEjAOA3v/kNOOc5WVesWIFly5YNrLfG9o3aDFVjm8WRRx6Jhx9+GP/7v/+LTqeD//iP/3APc6UUTjzxRDz88MO5vyeeeMLZ8M866yzcd999+OIXv4if/exnePjhh7F8+XLEcZxr59hjj8ULL7yAH/7wh7+XvGNjY7ntX/ziFzj99NNx3HHH4b/+67/w0EMP4VOf+pQzpQ2Lt7zlLWCM4dvf/vZQ5cMwzG0zxpxZS9eLUNeoQM0samyzGB0dxR577FF67KCDDsKNN96IXXbZpefhaHHPPffgS1/6Ek488UQA5Nhdv359T7kTTjgBp5xyCk477TQwxnDWWWdVyhRFUY4Z9MNPf/pT7LTTTrj00kvdvqJv4MADD8SPf/xjfOADH6is5+CDD8bHPvYxHHvssWCM5erbWqxcuRJKKTzwwAPOL7Nu3To8//zzL7vOGtsHamZRY7vERz7yEUxOTuJd73oX1qxZg6eeego/+tGPcN5552F6ehoAsNdee+H666/Ho48+ivvuuw+nn356ZTjrSSedhJtuugnnn38+vvGNb1S2u+uuu6LT6eC2227Dpk2bMDs7W1l2r732wnPPPYdvfvObeOqpp3DllVf2sIOLL74YN910Ey655BI8+uijeOSRR/DFL36xp95DDjkEt956Kz7/+c/jU5/61LDD1IO9994bxx13HM4//3z84he/wMMPP4z3ve99GB0dBWPsZddbY9tH/bKosV1i2bJl+OlPfwrOOY4//njsu++++MhHPoJGo4FGowEA+PrXv45Wq4WDDz4Yp59+Os455xzsuuuulXWedNJJuPHGG/HBD36w8oVxxBFH4Pzzz8e73/1uLF68GJ/97Gcr63v729+Ov/3bv8WFF16I/fffH7fddhv+4R/+IVfmhBNOwH/+53/iv//7v3HggQfiqKOOwh133AHOe2/dQw89FLfeeis+97nP/V4vjGuvvRbLly/H0UcfjVWrVuGMM87A+Pg4ms3my66zxrYPpmsjZY0aNfpg06ZNWLZsGb797W/j1FNP/UOLU+MPhPplUaNGjRxuv/12TE9P4w1veAM2btyIiy++GI899hieeOKJHid9jT8e1A7uGjVq5JAkCS655BI89dRTGB0dxWGHHYa77rqrflH8kaNmFjVq1KhRYyBqB3eNGjVq1BiI7dYMtWAHgdctp/h6BmBGNaABdGSIpeEkOGNgADqag0FjjDFIKKRaQ4GONRiDhIYGkGogBYfUHF0doMkSJFpAMI2WbGCO6GJaNiE1R6I4xoIYqRbQGmAMSBWH0gzzwjam0ybmB21s7MwFYxpaM3CmITUHNKAlAxMaWjEwrqFTDnANMGA0itFJA2jNwJiGUgysy6EDgElAM2QqgDKd1+a/0IBk9JtrgGlAMTrJlGGBgpYsKwcqy2IGcNMGpz+m6M9CC4Clpn1ltrWRw1dLNDXJNP0WibdtxbW/efY7B53JYOXU8LZtv80E0CAZcvKybFtzKs+8ul0Ze9xvS2RjAZjfganDO5+ZcYAZK9n09gcaLGVUVwLoUINJ5vrlZJLZWGpu+6fpeioGljDowAwq10DKAKFpDmkgDCQABqkYBNdIJEcoFKRimBt1MZuGSJIAIlAIhUTEUwAMSjN0UnpESM0RcBqsVHKMhgkUgE4aIhQSgilIzaE1Q0OkUJpBgSFkEjNJhJEwQao4AqYhuEIrjtAIUjAAXUlthEIiZBLT3QY41wiEQhwH4EJBawbBFVIpchMkCiXiOEAQSkjJoWNzr2gGBBqsy+i6ME37wRAEVDYwY6AUAyQHhEYYpEiVgE44WOjdC0JDBAoy4Qgjae5rjSQVgGYQgcSCqIPJuAkNhoBLdJMQnCvMibqIVQCpGBpCIlb0XAi4gtIM3SQAs/MtZeCBgko5RCihNIdOmZvHQSihFINKzISwc0Fl92sYSiSxoP5KOxG1uQnoRrPPF8js3gcD5s60S9dGA7bjl8Wy5QJXfn9nSDCEkFjT3h1Kczw2swSXLl2NJmMIGcNv4hE0eYqDowhTqo3NKsW0CtBkErsGTbR0jEQrbJACE2oEL8kxPBMvxt7N5/FCsgBjvIufTe+BI+b+FvdM7YXNySg2tufg4B2exaZ4DhIl0OApXorH0EoiHD/+KG7ftDf+YvzX+PKjR2OkkSBJBaIwRavdgEw5kukI0bwYSSdANJog3jQCjEgwoXDQ65/FYxvHEccBwlCi2w4RPjmC7iKJYEpAhxpyjG5q3ubQQoPHdMOohTH4lgiqqYARCRFJyOkQSBk9tCKNYGEHSStCMBFAhZoeTpFCc10AOQKEU4AcAZK5GkGLIejQwwwAuguBxkuAagC8C6RzAB4DwSyQjmbXhqf00OQJINrAnPUKMmLgKR3XDOCpBlNAMsYgYgDGWkoPTAYmNWTEEHQ0PYwBKMEQziqogGUvLgAqYtAMkA0gaGv38pEhg4ipnbTJ6OWnASY10ibdfDJk4FIjGWUQXfPgZ0A8FwhbQDpC54QtoLMD9U3EQGJWGQmngXgejYHoAlN7UuOizZDsmCLYHCCdL9HcINBZmiLcHCAdUxAdBhUBUEA0wZDMoxeJamiohoKOFIKxBLIbIFgfIR1PgJgDIynEixHkDinCOTFkwrF08SSUZphqNzFvpIONW+ZifOE0Wp0Gjl7+Wzy0eSese25HzN+xheXzJrFibAtSLdCWIX6zmTLiZ9oNLBhrAwA2TY7hwOXPoSMDPPHiYozPn8bCRhtbuiNIpMBu819CR4bopAHGR6ax5rld8MYlz2NTZwwLog4WRrO4+9ndsMeiTQi4wpObdwQArJg/gUXNGdz95O5ojsRYNHcGa5/bEaPzOkilwNzRDjZvngOdcIgmTbqdFm/B2ud2xPj4FDZPjUI9Nwo1JsFiDiyMEf6uiXhHCR0qiJEUWjMs3nEam6dGsXhBC61OA7OzDcjJCGwswU5LtuDFqTnovjiKxuJZdFsR2FQIPSfFvB1nMLlhLpau2EwP/jDF8xsXQKUCOyyaxokrHsEP1+0DqTh2HJ3BU88vxuicLv7f8ifx7MxCTMZNvH7uZqybmY9YBlg0MoPZNMST6xcjbNBk7WxpYt7iGUxtnIMdl01ithOhM9kkBTJSGB+fxHS7gfb6MSDUQFPSy6UVAqEChMbS103g+XU7QDRTqIkIEIAOFVjKgJRBNxQaC7qIZyLwiQAsYVCRhg41Fv1/N1Q+U2szVI0aNWrUGIjt1sH9un12wKnXn4AGT9HgKR6bWoIt3REozXDqTg9jvphFogVmVQOjvIv/N/pb3D27ByQ4fj2zE/Yc2Yjj5jyCh7vLsaOYxh3T+6AtQ6yd3QGzaYg3LFiPJ1uLsLjRwq82L8WBi9bhjmf2hFQc8UyInZZugdIMmybnkCnJ0N0F82YxPdvE/NE2XnxmBxKWARhNgekAPOEIpxhkBGihoRoaQYuTlh8AamECNh2QuUlo8A7H2DqGeD5p6VqQFi+6ZLIQHdqnBRDP14imGFQIpCMa4EC0hbRwzQHZ0FBNjXCCQ3SzsZQjQGOTsV4loPObpEWzFAi6xAaSOaRhW9OLCqnecIa0emg638rDJMnZ3KKgQjoG0Dk80dCCZaYYpaE5afna0G1lmAE0oAUDtM6ZpawZSgXEErSgNpgkxqQilmvTgkkN2bDUn+q1zMeOVdpkCNoaKmSQDSBsaaSjVB9PNZIxYio8hjMRBh2N1jJm+kPjoxpUJpoEujsAQYvEV0HWh6BNY8tjIDGMRo7QPs2AseeB7gLqtx3T9jgxLqYAOabA58dgzzchx2NEzzaQjmmoQGPBrhOY2DyG8LkG5IiGWhhjfHwK7ThEFKZ46akdyJzBQVrpiESwJYDYZQZJJwAmIuhAY4edJzDxvztALUwwd4dZhIHE5NQogihF8uwcBMtnAA0k3QCNkQTxM3NoLgcK2BJBjSiwUGH+ji20frMQOgTUiES4OUA8niB8MYQcVQhmOJgEuq9LEUwKyMUJGr+L0N1RQbQZmpsYknnmXuBA8yVisd0FdB3SMQUdagSTAul4Aj4twGKGsMWQjgB89xbS50chZjiShRKNFwWiCSAdA9rLJBobBbqLJDAnhY4FGhuNmS7SmL/PZmx+eiG4BNSCBNFaGtPw9S0kiYCMBRjT4KFCOh2BRRJMaIh1TaQLUwQTAaIJoDOuMfYsw9TKFI0XAporEV1rFWnwhEF0iK3KETPHrZmSAfEOEiMvCCRzNRqbmZvfTMGZQzvjGqJN8zWaJIYMACM//ibuv//+0mdqzSxq1KhRo8ZAbLc+i5m0gUe3LIECw8TsCOIkQKfVACTDt9M34bDxZ/BCZx6en5mHJWPTaPIEd03shRdm50Iqjpm0gUk5goXBDO6a3AuPTizBxOwIukkArRgmOyPY3BpFM0ow9dIYtrRG0d48At7h4ApYH8yH6gbArCBnY8LAFMNL7QCYCfDiWITGiwJMktYgWxyiyyDaxAYCAUAzyBHSioNZ0lQ7CCE6RoM1i6PyGIgmjNZstNmgCyhO2n+2ED1DOE1aK++aemcyjQSMIZnLEE1mDIBJIE2AaNrUoDVUSu2LLpxzjKcaXDLwWDsNV0bURjijc0zFOpB5CohEA1q7vgC0n7zK2vlDrC+BHMMMPCXvOFPGCS09n4b9X2QlCf0GA7gEYLa1kdeyCCDrv3VwCFtWE9sJ2hpcAlxqGosEYDNGXgZE09r1RYZA0NVgKRBNEZPjsWFbM3TNwlmSMWjTGAOAZoa1zNDYMknXQQtiF2GL+h626CL4YyWepXPTESCaEJCbRxBOAx1EiCaAYIZBC4aJsTkI10cY2QjIBkNHRtiQLgBLKXCi+RKHisgHxSWgBAcYkKwdA1dAOEOa60R7BzRfZIiTCFOSQbQCsAToLEzRnGKInx8FkwwiATqjERotBj0TQUXk11EhRzqmMdlagNHNDKoByNkAzReBsBWCpYCe4hAd4yOaCsBToBNHaL4EMM0RThEL46kZ94jGjmnmgizUBEc6Stp0GyGiabrfeEr/49/OwcikuaemBHhCzJhLACCWoYUAJgRYCoy8SNdXjjBMPLEDmptpzqedBqIpQE8ztMMxsJShOc2QNimwYWSKIZkrEMwyBLNAc1MAHcDcewzNLRrqyQChud7CzJe0SfM4bJn+zGRzTCQ032cTgbHnNNqLyc9GfxoiAfneYo2gTfO4OWHo9xaqux9qZlGjRo0aNQZiu2UWSSzw/Jb5iGciCj1jgJgKwBPgpdEx3N7dE40wxcTEKDZsmYsX22PYND0GrRniboiXZsawds4CxDJAnAq8+CJ9+F4npDW9sDAEFEPcGQFvc3S6AtFmQZp9CnR5A1wyBC3S+EhDBLo6RDTBkLYihFNGa+iS78Bq+IH9vLImjcKFezKy0/M40540SCsFSBPVnLRPpoBAkTZso4OiKdKeAEB1yc4ZtL0wTYNgluzrMjR29wTkGzDhqExRZA5PdC4UVXQ1RJc0ZKa0Ywg8pfhhnnr+BsMOWErRTWA2FJfOh87q0ZwBSmcMSGf1aBsma8bLsgnN88dcKK5hUIB2ZS0oTJa5MF7NyCejQsNcHINhFHmsDOtQFJ3FYfwmmiKzmAZER4EnNI7QmhiH6asy/iQbPhy1tIv8ovFR4ClpgtywBp5qKMHMbxrHqEX+HRp7U3cA8JRYohwB9AyxSM0ZsURNc1KuixBN2mtOgyAnQ8D4u6IpKmejKwHrWyK7uWWxTFJkXPg80J0NnT8rnQ0xshGA5ghm6PwwYoimaP6piNrWARBOM8QLSD494/m7EiCY1UjmEvMmVkl+KqazSDMwoDGpkHRJ0kgTs9CcjquQGAZPgMYksTWAxoVLihq0Pp+gQ8xExIb1zQI8NtF3gYmcS+E0d5nQvIomzfPH+BSYArCeQwU0lg0GKDPfgzaxCi5BcqUaQUcjnGUIZjUaEV17EcNF/4lR8pWJmO4BLZi7j0VXm2vPEU2TP625WZkQdbtNYxd0DBNPqe/QgOgy5L/kkkfNLGrUqFGjxkBst8wCkiF+aQSQQNgSFFU0Q1p5uxVipiswIzlYSyBtKMTzA8xONYGOgBYa0x0BzhVarRHIWEBsDKEaGqMbOGQDSFQEpoBokrR52RWIJkkLDdoANHcRC+BAMkaamgoZwinSOKIWRRUBRltz0SxG3WWAVJktmrQvE4UkSSPRLIsigskqs5E0WdKcBlKyhTrbvmIQRnO2dnyrdYou2d4DpV2SGZdZRIUCIIz/gFmfAINJ5GNO82OGHQBwLMJ+EoGnOq+uwmj9nHnaP9z5YAyKe/4VZGMEGE1ekYZttXjLTGAYV9aIaUfQOLhIEXuYkdYLwOVwOBldsp1tP0uYsmNLPpHseI59xV7mYQgwc+0oJ4SuD5OWvdEY0vW1102DieyaKEHthjPK87MY5imNPTvOGKyaYhAdc+0kafjRNBC2NZQAIsaQyswfFs5oMJVFcNF80Gi+ZPJiFPWpwZjTgJXRvDUnG7yIgeZmZImJCd0LLCRWIjpZ5JvoUpt2rEVM2jNPgcYWbZi7acNEv9moNBttFzDt2udSI2qZKMGGZZjEglRAc52be4Ai2aieoKsN07KReTRONv9H2Qi3buYP04wZ/xHVI7rEAkUHCBPbF0CAzrXtiyS755kkeYKuQtQiHyDTpl1J/0VsGSY9b0QXJl+IrAFjGxR4qtHcohB0lbuPiEGY+yHN7l2afxpM9+cONbOoUaNGjRoDsd0yC54Co89SxAI0AG7slSnAnglJM9DGrjrGsWnLOJodivpQEWkAsy/sgCCmRElr7+UJ/Q6nmFvKQpjcA2GzmRmxCyUyn4ONHBIxaW2hsZOGkrRf0lay31Z7CTo6s8WnAHSWdVzUzO3yGTYqyi4NQRoqoFnmY2DG7u8Yg6TjShs/hbeUBU+srwC5ZTqc1u4xActSnEwqs6MTezH7LVvy1RUGwC5t4TEZ638g/4axxycmd0L79WYx5cQqkOVqOHlMuwxe2YIsflCILSdYT399Pwjzcj1sVJXTQFVWmWU9YFl0ls1Kt1qki7picFnoVpNkCmDMaJuJ8RuZeQUALNHuWvDEaLlxxsjCFs0pp6FHHFFLg0mKWBOJF1FkbNm2rGNqGrnoNm60YS3M/bU5m7OW4djy5M8hjVwJ5s6BJtu69WXZMWWS+mHZltWQbb+ZpDG1jI0nFB7n++F4oqElECWWrWjwWCMION1LkjR6kkWbPJ9MXpqvGrphzk0z35i9r3hMY8cT6rv1CQAaQYfu2aLiTuxOu988NQzLaPvRtMwvi6O1u840JzJ/oPWpiURDsyyiz44Dk9qbr5qurWXxQHY/90HNLGrUqFGjxkBst8wCmliCe5sabdnmIbA0YwGNzZTlyVLzNjaMQQemnM4ij2wdboE8wEVGMA3Yxfag6U1s7c4U4ZNpeZZBwEugt/ZQp1U5FgBnog/aumefhc3i9BfC8xfH4/7idIr2W8bATBy69SUUz3fRQdZnYLTr3AKAxudAY5L5K8h/gJzGrr2Zx5PMBgzk/9ssZNqRjbe1zVvN2zIXZ8+WFefojLnYa0ZaZeZb8K+BXZtPRkbLlhqMZT4SG/Vk+0l5Hka7Z5ntPes4KOLKMhrGoHXWT2NSN5EulvGZLHSdaaeZRkjjbLVH3z9DmerMRcOAsRyr0JwhmtJOK7X9CyxrNWPBEzpu/SjQAGfePHHaN0wUHHOs1R6zGnDGZokhKG9SMAlw65sxrN9Gjtl9lt3aMbD+BrdPZD4kMGauBTJGaOcXo4gjNyecb42sBLmFKA1EbOaFGQcVeGPt3cvOz2XqsKwn0/LhrklukUwvcs/KY1cbyN1Xlsnb54onK9NZXy2Ls3Vrv25rKRB5Nt4PNbOoUaNGjRoDsd0yC5vvYDUU/79vp3aaT9dqKcRCAABGM7I+BKvt+1q93cdzTMNoqjbSCJm2nGmApg6Wr88um+2Wz/Zsilnn8tu+38G14WmHTlO12qOnnbn+mDacbqGztklL0eCK2lAhc/kO3LAzDU0Lu/tLjdmVYq2/osS/whQQzErIBnfjZmW0OSI2t8D5DYxGRP3MNFHNgGBWQTYYVEB2YiurH82ljY3a2Yw5o0gZc/1EYtrtKoqplxqAcHZfzQA0QT4GDrPmVCY7BKC5vaBen+04IM82LEvKfDUsG3ujGbp8FO/aOWro/C/Gj+PqNmOUeuVNndrmbdiseJG15ViVtwy99b3k5LbLx3sszM0x/zrb6wOTgxLSmPrsyNVp/UFKZ+zRzWtWmgtj8x7c+fDHiLltN5bKW3vLjrvKjru+yfxvK5tGFu3m5pQ9JrSb11b+nmXr/XtZZ75KrZnzS1lGpTly90TGaAGmvXHgWT/dvevtd/XZa2SsAJk1IptHVaiZRY0aNWrUGIjtmlkEHdKqhImmsNEdMuLOZs6MDyIdMZFKSaZFSRuXreG+teA0ds9WySQAL+rF2l5tpi35N4xWBea0DhvtASDPFIx9F0AWCQRPs7NauTlHdBRUREzGrorq6jKx93blVdE1Mel2nGSWccxV5vewkRk2qifoaPedCWjuPvQTdCiz1Eibi76w7YjYrNpqI6yY1aBJIw9btICVSBTSEdLgKdpFQ4YcQVsiHRFO82FSQ4fcsQ6orN1gNgWTglak7SioiEOFDMGMhBwVEB1JfZUaPFaZjVsJF4XDEw3B4Y4zSVm7omNi1hnAtIDoEPOQpi05wsENK1GBsYEbv4G1ddsxcdo8R06rzX34yLvmOSbsMYQeNolsfC1ozuTVxiJ7cZFOyNhy5lcBrA/G+pEse/A/IGXr9X0Ltt/5iDn67fxd1v7ua/aeouv6blisKnx4yt0TrOS/D1+r1tm2X8xF0hn2n/OF2HM4yPrgX4cUWZa/H8HnWQz8a2Qz7LX5qJnmDG4BcGZZpHYRSwzI8oycn4H+K5NP4vsyaHxtfbYuXxaPjfkrJfRBzSxq1KhRo8ZAbLfMgqca0ZSCiAERK7BEmyxIDRVGSBvMy44FAMq+DDrZtwxilmX32oxWpm0UiNWSKO5agiHwsjBlxCBs9AiMYiYBaMrYlICL8fbj+y3TUQGtsySbzEWg2LWh/ExhAAhbErLJXUYvZbfSOSKhaAoZccou7yhIRWvVgJHd3UYQcQmkI3Z9HAUVcqdZhS3ptG42ltmrRZvUKJ6Q1uyYhefn4bGvKsOxKC1IIxdTFITP2ylYGoLHkrRcqcHGQoiZBLwroUNu8hEkyRZy0v5ZxoSCyQ54M4BsBhCzKTGQhoBoJeCJAI+lu0YsTqGjgLRa1kQwm5CWlVVtYs8AACAASURBVCiKDJuNoRshkCqEgkG0EuiAg2mNNAkhOinVzRh4IsFUQJFDHMSQDKP049l97c1de+NPy0W1eNFcvv+pJyekBJZhWhTZimZG2fT8A8UYe/dJXMvmjK/I5if5uTOuDWvHt1q4lce3nWuiHMyMS1aI0Vj5TMQdQ06rt/tcVJvKftsyZewsx4Y8X4qT1f3P/BFOBK9uOuYJqJH5J+x5LBsfP6IvJ5PHtvw6nV/B9TWbP0ogN7a2HRuV5/t0/LrdPpsHBEDzLFrOtdkHNbOoUaNGjRoDsd0yC5ZqNDdL8FiBJxI8UWCpAlKF5qhA2uRmHRZ6TXMp0JiUYImCDq36IMjeL2wWqjY2U6PqGE3bRlGFs5mWCybgvtwGgLK6NZIxjqCtoBlHMKuyL8KJjDGIrkI6QseZFs4uD86QNjmE0aZJRIZwKgFPAvBEQoUiZxcXXQkVcLCGhmpwRBMJkjkBlWEMoi2JFUSkpTMTmB3MSqhAu2iMcLILzTl4nILJCFpQ9JJoJ2AyApPK2UZVJJydn3JLJHhK9fpRWLLJEU3G4DO0FC7vJmCJBJOSxk5qam+2C90MAc6hQwHWTcCjgH7H5ExiiaTtqVmIOAJLI/CZLnTAwRsh+EwXLImy8koBSQrWpmsdMgbWiUnTTuxHxROwbgpIiUAwsHZiMt8ZAq3BZ7rgzQiaMZJdNcl/kiqwNMzswFZjUxoqiBwrY8p84zuljFrlxbzTnDQs0cTaOw1d03pNbpkrzy8CmFwTRwkK2qzLmLYMFpnvjGVacQ6FiC4mYRY4yiIIwbRjR8pqsLDMUuf8fwBlULsvJprzLBuyfkMAPbk2vn/E5nlYFmu1bJ/duohD6fWL99Zj28r8YrbDGQso+oVsOcu0aGWBbBx5ip4orJwvxWOSgKfZ+/s9VlG8Fn4Oin9+kSHkcqR4noHY8qznoveiZhY1atSoUWMgtl9moRSilzrgcQoowyqkAqRE9FIIMUKaOEu10foD8FhBzCZQoSDfhGrQevEmDprHRgOMuIua4F0FkSgEIc9YSqqMDMje/kojaJNdO5il8KloKgXvSKiI3tn2zS86KXgSQLRIa+eJ5/iQAYLZ1Gn2ssEhJtvgRmvWoYCKAmo3UWBKQQAQzRCyIRBMtMFkE7IhTJ+ITUEw0oh1RL6OGbLPWz+BmOoQ++mmCBMJHQXEAuIUvJNCM2ay1zV0KACloBohrQzaSaGbgcsTsNo5jznEdAeYmQXXGujG4EkEpCldK6XAmg2gG4MlCRAEYJwDcQwmBBCFQJICnANSgjEGtNtAmoKnEmh3wAIB1kmATpf2JcZJZep36ygxBnS7tJ2a8U5ToMuz40lCzIEzCK2B2TbVbWQSShE71NqxEyYlVDMiJgMgHQsAzpyvhUlu2KmCCjIfEQSVkQ1ifHJEgHcVZJMbP5R2US2iQ9dPCZojwaxEOiqcJmyzv5kGtLJ5K96KBsaXB5isZBvXr7L1oLLMfWI6CszlGlCEHEPQVobV8iwnhTMEswpaCNgsZ1rLSkOGAEwUEdNA2uDgStO6UUGWlW79afR9lSzrORdtaGzxlF1t2HpB87blXISb6aeNJGIKbvVaf7Vil+ejvXE0/gURUwMy4sTkYwXNbZ6PueYN7/62RgmNHBN0eRrmuItu8rO8WRZVl3XKiypzUVB5NuH6Xvbfi4Kq14aqUaNGjRq/N7ZbZgGpIKbbpCUajRCcAUmKYCIE74bENpSi1Wi7IVg3AYsluKB3aMQZdMAze36iSCsWHMr4NXhXgscpRDME76aZ70EX3tqSWAs0INoJoIBgqguWSIhZRpq5zWvopGAJ2dmpDReyBSab4G2yrYMxiA4Hm5kFSyXZ4MMALBCk5Vs2ZezwLA7BZjoQWoM1I6P1x2CpguYU5SMYA5MSvJ2QTAGHDjhp0YzGjykF1iH2gCQBiwM6BlBbggOpBItSYmiphI6DTDVRoGijIABrdaC7XbKYpmmm+SsbPqKBOAEEB4LAaP4pIATtl5I0e7NPd2Pjj0iMfIzOs9vGHwKlobUCY9zJjSRxfhdoDZ2k2Zo8tl0f7U7GbNKU/Dbmq35cKtcP0U1dX6JmCBVyszqqhmwGZm6kUE3j1xEc0ORP412WrRIQEyMNOhKaMeiAtMigTX4pbnxEwSwtZKYanOa9WYXV5r4EbWIsVvukr/kZf1zESeOHZRzUJ5Zm/ithGA5zK79qMMURzFB0WPadFfJbha2E8oCM/4LyYSQwKrIsek/jDlop5ccIYkGyyckCAJ5l1Wtan8pl9dPIkUx2JQAb2VbQyDVnEIlhciZT30ZhSS3o2w4qW3OLJxqswaHtfW2iwqA1+fYsi5GGXQkGbnJvbOSkCmjcspUHLFMz42RXAjCMx48utCsZQOnM3eHYnrc2mKIIJ27YogyZ+8JiLr8Enl8s1XmfSh/UzKJGjRo1agzE9ssslAZas6QNWi2VMeg0BWsJ8DjMtEwArBtQ2dRoqlojAKBDQVp3TBq15hzggOCctOg4BZIUfDbIbN1aI7RswNQFAGy2izBVVFeqwKfaQBwDXJA2bjM40xQsDoFOFwIg7VVKgHGyi3cSKmtkQLtDDCJNgViQXZ8b27spx5IUoh0DM7NgUkIkksaoS+yFAcTGzH+0OySTEHSs3TE+E6OdC6OOdGMgECSLBefkb7AySQkWBs4/4MYjisjHkKS0hr/WxCDsb4Dakia8JU3BGIdOU0BwsCCg68k4sYRUAlJSJqzgdJ7gmQ/E1sWYu/ba9qOtqF1PPhpzYhrazikX5aOhDbNhQkAnhkXZ8bPn2rEy9YhWA9z4hyjiKwJLiMnxDl1PHQVAqojhCUFMbk4DfJbmVNCKoblhfAwQMzH5qQQxVNHqAKoJFdM10aHxIRh/W9BKwEcC6o8MELYS8MTY2kMONkK5J6Jj/C6aWKoKObTgCGZi8CQEj5XRmCVkLBBMd6FnBeRo4HwHYAxiuuP8gNanI2Ziugc1+RfBGNhoCJ5IiJkYOgqIYSkNHhMLkqmA6KSOeYEzYlSpIqYlKAeHfDwBeKqyVVthIqWkIn9fLKEj8uvw2F4rDZYEFDmpyK+mQw6WKKhUQDPm8qxkg4NLjWAyhg44RCygQo5wKobmDOmcEOEWisbTHOCcmdylzCdkaYJbCaDJIdoKqsEhOhLSqPzke+SAlyHuMsy5yQI3LEqHZswSCtGyrIXuS+aejZbh8FhTZJvK/FZVeM2YxerVq7H33ntjjz32wD//8z+XlrnzzjtxwAEHYN9998VRRx2VOyalxIEHHoiTTjrptRC3Ro0aNWp4eE2YhZQSH/nIR3Dbbbdh+fLlOOSQQ7Bq1Srss88+rszExAQ+/OEPY/Xq1dh5552xcePGXB1XXHEFVq5ciampqeEa1RrodKG1pzGSMKRNS9JCXdkgyDRPq7lMAywMyQeQJGSHF0abD0j7giRfAbrc2bpJYzRsxnubo9slzaQbgycpaevW/u5lWzqG041Jlm72eSwGZFE7AGmiSUqakNWuA5HZ3aUku3yaAkEAnSTEPCRpto55WdZg/A3Ofh/QFNFJmo2fFKRN6yzCzM/GdZq+6YuWEixNM5blGJSE7sZ0HKD/MtNftDJ5H3acGSNmJyWgFLSJaNKGyWhbh9bUJ/88KbO6TN2w5QCXXwJTRxEsSWk8LUtVytVpx0bby6Q1YPwhWlNEGhSxHdZqUySXaUOkisa70wVrRKYtSfuUorJaU1pDO0YAgHeIWdBH1BlYO4boJhSFBoC1jF9qrEGMIAqInaQKPBbgUx1ANsAkZcqLmRisk1IEVigcK+DG16I5B293KbdFCIjptsuAF2YsWBqBT3eAQIBJ8gfqUFCE3UwHwUiYRYqlCqwdO5+hjUwKbF5NO4YOUiCkceJNYl9sNAJvJ9RvK1dAuT86FMQMpKSyaeT6DIAy7xMJpAoIOJAq6IT8aCyxfixiOW6bMZfLw7vCRPnZa0wrBIiWiRJUDcrkn+lm/kRzTJuVEEQnhYoEVCgo/8n4PUU7odykVLhISjFDEYY8Jb+HBOVf2fnFY8MitCaGaaOhjE9HzKYAQucbsyyMIs80+Ws4iD3ab3nE/Z0WrwmzuPfee7HHHntgt912QxRFOP300/G9730vV+Zb3/oWTjnlFOy8884AgPHxcXds3bp1uOWWW3Duuee+FuLWqFGjRo0CXhNm8dxzz2HFihVue/ny5VizZk2uzOOPP44kSXD00UdjenoaF1xwAc4880wAwIUXXojPfvazmJ6e7tvO1Vdfjauvvpo2tCbbttUggUwrNBqV9nwWpK0arVeSrdlF6AhB/92qkCxvfzcaubWfO1i7tdV8k4TqjE1kTpyQdipULjJHS+ns7KzdoW0TzUUyeZovZ5md3mrZvmasNbSiVV1txJQGSGOFYQx2vRitwTrdLBLI9N8xE4s0de25c/0mAcq2bnfcOGgbjVZkeaaf2smaXS83Fj68bcdGfI3fym7Zob1OXhsAMjm4+c15vi1fTs7yc8XKZZibbdfKwTymQ34RI1tqxl2IbOyUJr+VjdYCXG6Hi/RijNhJNybtrtMF4wzggsbUMFDWtX6kLphW9KXGWII1AhcZpxsB2Mws5YmYecSnO4ZJcoqmk3RtXSY7QNnssYQOBOWsmMg4ABQRlypgtg0wBi5H6P6xTLIbg08bVm3b7XQpU99m63MBEZsxbnfAwhDomvvQsC8hJfnrwoD6YqP+rFwclHGfSmJsXi4Ns9feu59ZHHpRcJzYoLlH3BwLA4oADAR0IyD2oTWxp05qfHsku26GYK0OwBkxrnYHDICIAsMAE7AoIPYmJVhM14u3u+AdATUSmux/E8kJmNwnDSYD8I70ohw1YL+Dbp5HNtdJCw7RMr5Ik2ulQwFufC5acFprTTCI6Ri6YRhpV5L/ogKvyctCezeZBfPNLgDSNMUDDzyAH//4x2i323jzm9+Mww8/HI8//jjGx8dx8MEH48477+zbznnnnYfzzjsPADBfLHrF5K9Ro0aNP3a8Ji+L5cuX49lnn3Xb69atw7Jly3rKLFq0CGNjYxgbG8ORRx6JX/7yl3jwwQfx/e9/Hz/84Q/R6XQwNTWF97znPbj++usHtKqhbcy+/7JSFLevC5E5AIwGTJqhNpo/gHyEjj3PX3VSKiBFzn4O31diNerUi/rxtCqdppk93rEfGC2ZZdq0NFq71XysButp1y4ix0bxWE3XMArnH/DlsCNmfRf+fiNXxspsLoGXB2Hb82E1S1Mv88fOO4c0dBN0rrSXi5HFzkMro43rfESHy5fQ2TETNea0dt/Qav1IWYfNNxJ4xt6K0Io+GFD8IDNH1paTVGbj6PfX+kU4NzkjMmOhirRmnaZZvoCJ5NJagfm+sTTT5N2Yc4/1Wf9St0u2d8N6mcyy4lksMh+Y0jQ8s+2MxSQJsRirhdsxs5F2hlk4n5c/VxKTzT4zmx/Cjoms8yPRjN/JjY9pGwAxLevjMuNDvo405x9kgaDxT1NiWjb7XmtAyYxZ2Eg9Ky9LTU5Pmh8/wPmKcjIpBcQMLAnc3HWrAdgowUZEfq04zqwShlnzactgUrCUWBBLJVkjQgE20wUEB5cSrJuCjUTkh7JsP1WAMv4aiyTN5lcgXP9stCbrpuS3MuxQc06+GjvmnJPPZ7YLbRgOSyUwF5V4TXwWhxxyCJ544gk8/fTTiOMYN9xwA1atWpUrc/LJJ+Puu+9GmqaYnZ3FmjVrsHLlSvzTP/0T1q1bh9/97ne44YYbcMwxxwzxoqhRo0aNGq8kXhNmEQQBvvKVr+C4446DlBLnnHMO9t13X1x11VUAgPPPPx8rV67E8ccfj/333x+cc5x77rnYb7/9Xn6jNjrAxc4rZ5fURa0YyNmQrdnMRQ4V/B7M5jeYOnJsxNpgYbR4W9aWk9L4KURmB7dfEPNt9larMPX0lAE8xmEig6xtHcjL553vIqSKUUGWUaRp3m/gNEE7ZkbTtrb+3IAjx7h8H0BOrgLT00qDWaeH4rlr5SC9474chf9aaTCuMh+KdSmYNZ3sbwBu2zEM2un2ZeVU7vweOYr7YFiOP//stUlT5xPTACBFxjCtNiuzMdIq8ZgoRZhZfxJFpCWkZVrbuhCZX8pq0kpl2nOc+XncMRuRJkTGGl00WdY/nSQU4WXZqZ/jok3eiTDsJOe7U07LtuOh4xgIA1cfOHN1WR+gX7fLI/KjFRPvevgsTmkg5dlc99mfjVKTEuCZ/FY2Zvw4dp+9TxnjWV6WZTBSQscJ+TU62bpiWiuwmVmyGEgFNtv2WEoE1kXWRy4outGsoIBuTDJ0u+YbIsSsuM21snPKWgEKlg5n3pcmCs8+j2xkoxelaf2nzv+VJH2ZBdNlDoXtAPP5jjh85MTSl4Wl67mHFvNubveRc5Z72FM1A14WZh8LgvKXhZ18ZS8LW4f/srDlimV8FMN0bX/8Pvrbtl/ofVkwIXpfFn4bdhyLzmqLAZ9mLH1ZSJk9iFnFy8Kd7z2ki2Xtg6xEhr4vi4r6/XI9L4sy+fwHpB8y7W2zKMpewACZ1/x5UJhv7rcx47AoLLwsVPayUOb62QexNWEFQc7UoqXMjoVh78siCMpfFt6DlkVh/mURBNA21BvIP6DTFCwKc+OxVS8L+5DzEy19M58dJyB7WYhhXhZem0Y2F/hR9rKwIemMueumu3GWcOq/LMKQzOBSgY2NZi8LEx7t+uG9LNCIyEQYhrSv0XAvCzSioV4Wufs1CvNzq/CyAEBmUe9l8eLrfor7778fZejLLNI0xfe//33ccsst+OUvf4mJiQksWLAAb3zjG/EXf/EXeMc73oEgeE3IycuDfTNbmAeAW8PHtzlzr7zK9pXF3Bc1dbfPi/ix55VG91ht392Ipg4/UsfYxLW/DU8e/6VmH5j+w1vL/MPUaruSMopz9Xj916qw/pE/Lj6kzD8w7W/lPTBd2xXbnOXqdazAlLUP6NzDvXA9S/979RXh7/N/+yyjuN9uu/1awS7bmXuRlLGM4rXx8z48e7mdU75vx5WxkJJyObw6bBQXA+h37OWtAEbD9KK2zPpobkxVFjWorSJRLG/9W4pWj4WU0Kmpx/rNlGU/EjAvklymfFJQErTOnQ8J+m3HyM+fse1r87KQ3kvCyue/nG1Ze90sbbT3pI0YZMz1x/n/3D2ozNiqTJbCS0Wb/rpxC4NsLM3YUx6W8eWkEtDdrP+cZ2ucWSaaZJGSOf+h/9+eb59BQgA2n8KuSGB9QlZJYAwI8hF9OT+Rl/tThUqfxVe/+lXstttu+OpXv4rdd98dF198Ma666ipcfPHF2H333fG1r30Nu+22mzMl1ahRo0aN7ReVtODxxx/HvffeiyVLlvQc+8u//Et84hOfwPr16/H5z3/+VRXw5UKjnBXQQc9GbbUFmT9OdnTRqw37LVhNHchr1rb+oqkmF9XjtW1RtMcDvWwnV75Qd1k//f9+ncUyJTZ7gujV2E2frS3f/rbHiiYlp3n3+CF65dUFjbyKCfRDj8mo3/lGHl02vrAaPycGYdmUb9YosI6MiUiPdaisjI3a8X1JXuRWj3+pmGkOj61aJmLkZL7WqbWL5sv56KxZxdYPeL4va6/P2svuk4wZ5TLurXnVa4dZrdi2IelbI75Z1pX1xsHJVPDJMV8b9sfMz++RyGvHRV+cu16qp82yaMJcZKFt1zP/2nGz7IKFIXSn23MtnB9Tyiz6yjctGlOVZXQAKFozTUk2aw6T2f3lrodlM+1OZua05XTWz56VBAA3D11UXtqfVQB9Xhaf//znoYq28QKWLl2Kz33ucwMbqVGjRo0a2zb6Ohx22mknvPe978V73/tevOENb3itZHr14GmRPbZwlGieFbZwc1Kpg9dp1j578VHCFIo2b18zdfsqHLf++WWO27I+lkX3FBmCg/O9DG//r6qrrA/ajEePZp/zt/Q03KvtF8rqInsqc4wPgH8tteK9dZSdM2CcHKssZpCjYh/y+zSQs1uXRpzZ32VBEUbjduzQrN3lnMKA+2aCLmrxvp3csBfSnL3seBtNWNTo7Tzy64TRvJUGoLNMlmIAhKu74pqZwAw/ks8FapSU9bXzYia+72MsPd+gJ3LRH1fl9UWaAAS/nPXTKGtpMP4Ru+KE9Z9Yv4/W0Cy75o41CUERaACgQEzH+n08P5J2wSw+U4KxjCiqe4g4p755FldddRWefvppHHrooTjooINwxRVX4MUXXxxYaY0aNWrU2L4wVOjsxMQEvvOd7+C6667D/fffj7e97W0466yzsGrVKoRh+FrIudWYx3bA4eHxtNEvxLGIgtboR7v009zLkNfmB5/vl6naN7QtfgDK2uqLokZepfn30borZRik7Rf9KCUhs7njVecWI7OKZQooDemFxwSLsuROLh8HWkW2ZD5WjW8f+UrHwEdxrnjRerlQy2Jmu3/MrqXk1+G3Z8NZrTxAefnCPheq69flIq9K9vltVfXL70sxdNkfr7IIqqJ/sSw0vBiaXhJqb9tnYZCFOIdB5qPhvdep51gZi7P+mOLKDEV5CiHypekB9rct52HTXr+qDJ0d6q5esGABPvjBD+Kee+7BY489hje96U346Ec/iqVLlw5zeo0aNWrU2MaxVUkS3W4X9913H9asWYMNGzbgiCOOeLXkemWgSzJvzf4eTdbf9jQbaxP3NeBKezj86vKae2VUTz9NvMSWXxnRU6Z990ElqxjEDMq0+KpxLJPDk8+NKfr7ZIbxL1SWqZLTk7Vv2965pcl8VayoKrlQ51ll5hMpj6Dq20axn8UyVRF0OZ+Z7p0zLp/E+IP8iD+/ST8qKgy8yCTPWWejxwqMwWdmbvwleueXv89917zEt2hXFfD7WcxDsr+lGXs/0s/3L/ryFvdljWZ5Qoo7+797RiSpx0S9KKpihKbHioo+Et/XlIuCK9ZlkmxdhJc5rzSBt1h/Sc5YFYZiFvfccw/OO+88vO51r8Mll1ziVoO94447hjm9Ro0aNWps4+jLLC677DJcd9112Lx5M0477TTccsst+NM//dPXSrbfG1Xx9ubgoJP7H6tgInZb+2sc+fX1Wc6iKrKnkgn59W7NOVX9tFpgFTup0p6L8pT5Esw+ilLRPfLmbPn9WF9x3EvkKvUpFOQmbdbaiktyQErq26q5VByHMn8Hehle2XYxOzy3dImnqfr5HLl1rwp9z+0v8+OUjTGrWErFaeYFNuGdT8uLhPlxQcYmmRDQaUJlqsayWG9Zf4q5Qr5MhfOK0Yc9bLFMhpI8Ia00mAB9rdIuFWKYlk4MEy0ulQP0+kT8ZUxsk251aW/NtzL/ivBYiR/Z5a8qAfT4MPxItIHL9GDAy+IXv/gFPv3pT+Md73gHms3mwMpq1KhRo8b2ib4vi9WrV79Wcryq8KORihFKRS2zogL6X8YmKrTboff72mc/JlAsX+JbcJqfX6Z4TrEfZW2VtNljr++xxZf8Lmmvx18Dey36+BZ+H1RoiZUastvM5krPnOmHQcxH92apZ6eWrEPltVu2r7dr+fHtXUAxbzMvspFixnmRwWT1l+ff+G248fMiofz6/Wz3InMpjQosHO9Zjwu9c2nQOFXlJJUxwNLVhwHoNMnYkpW73+oRQLbSg/0NwEVX9ZT3vuXirT3n2HiqspUhtPfbojR/BwBKyvRBpc/ikEMOwU033YQ4jkuPx3GMG2+8EYcddtjARmrUqFGjxraNSmbx7//+7/jkJz+JD33oQzjooIOw9957Y+7cuZiensbjjz+OBx98EMcccwyuvfba11DcrUePhmDeyL4WVZZVXLosdT/NvAoDbeEDtPPekyrrrbRTD9ru1545VtR6+zKxfnX30eArNXffXj9E5NJA7b+k7bI6itpn1Tzxf1dlqfesTmuZZKGc+VF5rIp9FLed5lnYX5ZfU6yv7zUp+KKKbZQxeILsOT4op6goo39u6UoAyBiIlXFQPlHVWJbtK5btZdmitM1SRmTPo53VUWd2fyGirGfe+n7AEvae218yv4ZB5ctin332wXe/+1288MILuO222/CrX/0KmzZtwsKFC3HmmWfiuuuuw/j4+FY3WKNGjRo1tj1stx8/msd2wOHB20o1hjK76FbZpStQGodfON6v7t+n7WHaf7lt9Dtn0LGcPCU+mWwF2xIm55WrZCQVzK3Y9itxXTNx8vNnq+rtF2E2rLb3MjXDYVGWA+HnxFjN1tfgnVy2Dhv11g/FCC/r2yiLqKuQ8WWtQlCyvdUrGpTUW2Sjdsx8n81QqBjTbFcfH+zWtlGwVLy03//+fhncNWrUqFHjjxvb9ctiGFslUG6f9sv1s6P6ZYrajt3fTwMtYzdDtV+RNd6v/q3RPsrGp1iXf2ygvEBv9mohKull5cSUMI5ifcVrU3V9yqvPbOT2bxj7duXxqig5P2KtKpqqLDfC7u93Xll7VfvgjUua9B70st7LtHQmRMYYi3KhcI09v02OVfjHK/qRu25b4z8s6Yutr6ot97uqHS9vJCuue8qXzbfS+8qOr4lmq/JF+fflIHbfs99+i6NC1jJs1y+LGjVq1KjxyuCP4mVRFi9f3Pbf0lWMoExLL9tXjNooxpkXo076RbUUIz8GaVP9bLlVESSVWnEfu3i/KKKijbYfa+tXVz/Z+rVfPF5kjn6ZssiaYdouY1b9mEpPBExVlnvxWBUjKOb7lERX9dRd1JT75cr4chS3/bYKsqgkzc/p4soGlnEU2yvT3ItMqiKXJzffijk0W8sUhvEpldVTIrtWOmMdhSiuQUzd/bd9M7lO9tvfOUZhrknZ/Kt6HvSLKKvCUC8LrTW+9rWv4ZhjjsH+++8PALjrrrtw4403DnN6jRo1atTYxjHUy+KTn/wk/u3f/g3nnXce1q5dCwBYvnw5PvOZz7yqwr0i0NlqoVV+Cr+MPZavolxT7Ge7LtNuisfKYs4HsY2iZjKoXL++lDGWXH0lrK6YywAAIABJREFUeRxlGlFxvx/h1E9zH8Z/UjrOrLDyb3G7gCqb7iBNymeJg1hDWV+LLNI7UK1dDxPlNGjNLr+NKs24jNkUznNzzX1ZzrtP+ti43XhXsKgc6yhEROXkL2M2JeNT9IX19Q8N4/fxx63Yh+I5QE77t/t9rb+MQfR2IvNP5CKdCkyp9P4tyFY1Z4eZx/0w1Mvi2muvxQ9+8AOcfvrpYGY529e//vV46qmnhjm9Ro0aNWps4xjqZSGlxJw5cwDAvSxarZbbt02gKmqmJA46p5kUWEGRAfjoF81U5f8oag1VjKCIMg22jGWU2SpzfayQvajRF/0wg/ZXRmFU2Gp9Ta9SNm/9rCJz6zdeg5hNP99Nv+tU1OD8esvGxMo6EGX+iJfjb/B/V0VMVcjUM3esFm213cI940folLbhyevWNCrY2nNspDgOZeNSNj79Vlfwyw7DNsr6UFLORobl7gubZ2Lnq7/aclkbhToZZznfRJm8uXHzzxvi3i6eX8U2fAz1sjjhhBPwsY99DN1ulxrRGpdeeine/va3D3N6jRo1atTYxjHUy+ILX/gCnn/+ecyfPx+Tk5OYM2cOnnnmmW3DZ1G0ORa1lH727hIbaZl/oeq43fZRxQD6RTFV+THKbOWD2M4gW+XWRgaVYRg/RY/G7ttcTax+iRC9Mg2y8Vdog/522dj58hXHx9fEqvo6kHVWyVXUMqu04KrIpTIbfz/NuUKmnu+LFMr4cfoweRVFhuZ/3yHXL//es+smWW25mItTxpCK/S8wLaeJF6O2/LJbgxJ/TnFs7Hj4q8HmIpUqvjYIoDTDuzi3Ky0hBZ9Irt4+jKIYmTWM/3Coz6rOmzcPN998MzZs2IC1a9dixYoVWLJkyTCn1qhRo0aN7QBDvSyU+QrT4sWLsXjxYreP820kTaOPhrS1mkZV9JG/XfXGLovP76fVFzWAflp/mYZrY7KL5/ZEXFRgGNn8Y8NqKMOUqTgxz0B8+3i/nAT7349WKX77o0zGsvZKUBUdVtnPKg3ZHvP/F8v0i2Iqy33IC1rdfj+ZKmXLoqRod5YbQHZ8+u4CDwNiYiXfW/H9UaVj1s//UZEH0sNWy/IjACdr3zaKclSwvlJ/HfO+lcMK62l512vQMyUTiUGrvCXE+kJsvWX+wDJLyLBt+hjqKRkEAcIw7PlrNBp4/etfj7/5m79Bq9UapqoaNWrUqLENYqiXxZe//GUcc8wxuPXWW/HYY4/hf/7nf/Dnf/7n+OxnP4srr7wSP/vZz3DhhRe+2rK+fFRFQdhjFn0iVars0mUaRVl8/SBtsywipypap0yTLa3PaFllDKF4XmmEUkmdZdFBVaiMsCjzH/TzLXiaofNn+OWLdvnin91foQlWyjBgPpSN61DRbAV7es8YFW3kZcd6BSq1pZeWq5KpT9mcHR7IrVHkyhb9QKa8s+WX+N3sOW48h5W7xNfjtPY+192fKzlm2q+NfnV5ZXNMxYuCykTMoqMqn0d9tgdFUA5CWdTTMP5Ki6HMUF/4whfw4IMPYv78+QCAvfbaC29605tw8MEH48knn8Qb3vAGHHzwwUMJXKNGjRo1tj0MxSympqYwOzub2zc7O4vJyUkAwJIlS9But1956V5pFLVQH2W+i5K3OlVTvr5L8Xi1GOVRN70iDc74HjbqyK+z1L9htLp+mkq/KKeqyLCctjiExl6Up8gYctEyxg7s273dufnKSplHLvPWanllDGeAT2tgxFkZE6KCtKsoh3es55yskfK6h5A3x2zK+mnmgW9fL8b892jlpt7Kue/3tXiv2etWFoFV9C1WaOT265eV41dE2b4y/02Vf6QwX9w8LEZ1Fc8tzrGSY64ev/7CSrP+Kr1+5NSwkXkvx284FLM488wzceyxx+KCCy7AihUrsG7dOlxxxRU466yzAAC33nor9t57761uvEaNGjVqbBsY6kt5SilcffXVuOmmm/D8889j6dKleOc734kPfOADEEKg0+lAa42RkZHKOlavXo0LLrgAUkqce+65+PjHP95T5s4778SFF16IJEmwaNEi/OQnP8Gzzz6LM888Ey+88AI45zjvvPNwwQUXDOzYPLYDDuPH9i9U1HCq2AXLfwWriKI/oiwfosgEho1IKhf79/hC1muNMjZR0NaKX1UrG6PyqsvZWBkD8woM9xW3fqhgRgOvRdlcK0YxFfeVtV0sP6hO23a/yLHiPhvJIwSNl/22hXcv+DkF/cYjpwl7MvnRen37URbVVLYfKL3mLgqprJ2q/hfLlp1TVmbQ2Jec1/N8sGzO84EMevb421UofQYVrl+/L+W9Jp9VlVJir732wm233Ybly5fjkEMOwbe//W3ss88+rszExASOOOIIrF69GjvvvDM2btyI8fFxrF+/HuvXr8dBBx2E6elpHHzwwbj55ptz55ahfln8H0H9svAFztdRvyzql0VB5v/LL4uhzFAAsGHDBtx7773YtGkT/PfLOeecM/Dce++9F3vssQd22203AMDpp5+O733ve7kH/re+9S2ccsop2HnnnQEA4+PjAIClS5di6dKlAIC5c+di5cqVeO655wa+LByqbq5+N6QPU6bKN/Fy4pWLddjzBj5ovCiOKt/DwIdCf2FghOnbft/9xTr63ZBDylb1si3bVzyn5xp5tt1BL6M+ApXe/IxX9Kffw6Jgu7ex9H3bLv6usvMPOnfA+Ltx9V4UQGaPL/W1lMjEuMof9x6GfR+2ZX0t6ae7hlqVjl0uCimn/A3pyyjKVjKHc/dv2UvMZrPbueb1s2ce+ve5/41683K2fS3KOkj57HmxFKPZBsyHoV4WN998M97znvdgzz33xCOPPIJ9990Xv/71r/GWt7xlqJfFc889hxUrVrjt5cuXY82aNbkyjz/+OJIkwdFHH43p6WlccMEFOPPMM3Nlfve73+Ghhx7CYYcdNozYNWrUqFHjFcJQL4tLLrkE11xzDU477TQsXLgQDz30EK655ho88sgjQzVSZumyq9dapGmKBx54AD/+8Y/Rbrfx5je/GYcffjj22msvALTK7amnnorLL78c8+bNK23n6quvxtVXX11oqEI7yQnoRVpUoIpFlMU894uQyp1TYAt9NbSChl6pxfr1VtH5KhS1ukFMYhjTRtn5JcfKGFKxj6Ux4d44FcfVRZBYBaqi/z7VH2RS7OlLYWx7NL8SLdOh5Fjp3OljiijVkIumtn7a8kBWwKBloV9OTi8ju6QdF9VTZlorMSlRGxVMNdffwn1oNW6ZnyM913HAOOfkKWuzeG94zAasYs6YckUzWJblXm25sPeAY9Amx4jui4yp+M+OsmdLsS89fRhk+jQYwg4DrF27Fqeddlpu31lnnYVvfOMbw5yO5cuX49lnn3Xb69atw7Jly3rKHH/88RgbG8OiRYtw5JFH4pe//CUAIEkSnHrqqTjjjDNwyimnVLZz3nnn4f7776+0udWoUaNGjZeHoV4W4+Pj2LBhAwBg1113xc9//nM8+eSTkMUVIitwyCGH4IknnsDTTz+NOI5xww03YNWqVbkyJ598Mu6++26kaYrZ2VmsWbMGK1euhNYa73//+7Fy5Up87GMf28ruoVqbHoJxDMphKNN0q3Ij7LHcfn/VzhK7eqWmXra/2IdBZf1zBtm6+6GsHhTsoQU5esatWAfjQDF3wl+J1pffv0bFa1p2/bxzc1qxJ1fZ/krfUKHvPdo84yibL349ZXHwufIe+/SPlflyirJXMpoy30CRjXoMw8+7YEKAh4Gn6eZZsV+uEiUy5MauMKdLWaXdNqynxy9QQOn4F1kMK+TuYAh/oqnHX4m3yHxZEOacyUX/mssTsce8+dXDWPw5bO+LonWk6CMq9LEH/a6VwVBPhw984AO45557AAAf/ehH8Wd/9md44xvfiA996EPDnI4gCPCVr3wFxx13HFauXIl3vvOd2HfffXHVVVfhqquuAgCsXLkSxx9/PPbff38ceuihOPfcc7Hffvvhpz/9Ka677jrcfvvtOOCAA3DAAQfghz/84VDt1qhRo0aNVwYvK3R27dq1mJmZwcqVK18NmV4RlIbOWruoZysciAFRB1UROANR1EyHDaEs8RH0hIJWhVS+wqiKQsqaLQ/xLWrDPbLZ/UrT76Km6O/zx9qWt78FB7TuradYJ2dAyWqgRtge+2+/0OjidlUY8DBRcD3jRBt0zFtraWvDJYeC5/Px6yi7pmXhyb6sfn1bG1ZeLFfs61Ah6J7PoEfeinujrK6h/Bx97rWBshf9R/3mbFU48SCUzX2vjZdWPlppxh/qCXLyySfntnfeeWesXLmyr/+gRo0aNWpsPxjqZXHHHXeU7r/zzjtfSVleVdg398uKqUdmIx7kryjLAyhFMcqpTEMo0xQGaA89NmtzzjBsp59d2O4bijUV2s7Ztf16rJyc5f8s7G/B88dZ4beNrHNMheV/+7CalF8n82QRIjvXyujL6tm0y3wIxW3/HHduP/twwadSxips/f7/Utt0UY6qcyv2+xp/kTFWne/q8Pro33tV2nVx3vprgFX6Y+AxDv+b117/i+PQ06fC9SzrV9m45w57voieNaoK41L2XOjpl52DlhFb5uvfH/719uepj+I95ddpt+1/MfhV0Dd09pOf/CQAII5j99viqaeewi677DKwgRo1atSose2j78vChrsqpXKhr4wxrFixApdddtmrKtwrhR4fwwA7n4tUYvllPsryKornud/+UgblQmW/c76HLPqnqF2VZm46LbQ82mhr7L6l49BHi7Q21iq20bOfM0B5Y68VaVG+9q/9qBYbBWRszn45lmmw/jHGuTvX/c4qBxgDC0vq9113jAGCkb/DMRmQ7LYPVbkrRbuzv9/vv9N4+/incueV+G/88vZYsf2CfJk2XYjf97OGlQYLwl5bPLJr2uOnEgI6SXPM6f9n783DLKvKs+/fWmvPZ6q5q7uqmm6aeRKCCIqiohGC4BSRxCjGAcXhi2CM0byaQc2bvBl8Mxhj1DhEo+JnjPopijNKAoqKgojM0E1Xd1dX13DGPa/vj3X2OaeGbkoTEzV1X1dddc4e1l577bXOfu7nuZ+1euOIvtJndV8tLO3+sfTrtF5brNPuhSW/JgY2aHnn6/fVw34/QhxjvXHRW7Eu1wjbQrBqXBVjZb3pUQbvdd2sctEfJ1qvZRC9dTzE+r6iwe1FHK/4PzBujvh7xcO8LN73vvcB8JjHPIYrrrjiiAVtYhOb2MQmfnFx2JfFfffd1/v8pCc9acX3QRTzPf2sYjUzWLVz5fcj6eY5ghUyWN5ALOKwVsoqq2gwA/dI1vyasgpf+HrqqZ5Ge0ArX6yBvKbIlbEKvcpCXaHUWGUZHrENYUCdJNf/TpcNdC2cFSxBqZ71s3Iem66FVXztze3ftZSkREDfYuuyDF1ca00DiK5luJolDFxntdW2Tnygd3+r7xXWV2+BWcZaCoqM3JXHqfXPW71v8LyiPhtgGr3nvh77GNw2kBuwwpIenEjwMH1rdf8YXId7RX8UEqE4bB9dwxZWf17NugbZ2CAzXI2NKAcH2WRR18ExUDApVlrmK9ponbr3WGVvW7eeRb9Tq/YV/Xs1C7asbpGr13tZy8R79cpz0++l7DPsh8m1OOzL4phjjkEIse5UHf3riw0n5m1iE5vYxCZ+fnHYl0W+2sr6OcZ6ftZ1j+taAjpfaZ1v4AL0ZtbcSH7DgEJj8P961ta6luBhyjus1bU6tnAEptO7l671KkQ3TlJYV0eynAePKbYVKCy8nvXfvZxSxjLqGiVCa2OprWek5DkULKQwUgZZBbBCCaUk5Bph22ZXb780bKM4V6muZSzXWHA6z1dYiDrP+/EMWHm/vfLXVn3dbPJue685btB6PNL3wXYufNDF9541rQ/fh1fHAAb/S2FiEPbA82ZlflKPgVgWOk7WzLHVO6bbvghpysuyFf57c7yJXwndPX69sbqiv8m1bKKwxLN8ZVtB9/96+TqDcY1V/bVoy8H2Wt1+vfrofr1FodCiz7zWu6fBtlxl7SO6s8xKuaLvFUxgxf/Bvrk6lscAQz8MVvT7I2DDU5SDScbbu3cv09PTK2aR3cQmNrGJTfxiYwNmM+zbt4/HP/7xHHPMMTzrWc9i165dnHfeeczOzv606/cfwnpKpsNq4bvHGN+pUW/0/q8XmxjEf2KG9BrN9YDu/rCWzaCWem2Ba8tZ736E7Fvpq33BPaWFYIXlvjrHQQhj3RUxhmLboFJJrD1XdJUewrH7GnMle2X1PttW33pUysQmbAukQFiWKcO2ELaNsMzcRaZMafYrZcoQolvWYBnd+y+YTm/G2uIYu/99kMWowbW818ZWisWDEP06rvgr1EPd76bPrWwnIeXKY4r9xTFFmww8i15sZnWso3j+vecj1+SR9KpvWyusYTHYzwb7fJquzKso5isq9q+OraynsFqv7w1ivT5XbC/6yWr2VbSdXDVOBu9j9efB8THY59WqMsQ67ZtlPYYnBvtqcezg98HyVucCwQpVYK//DPYL6LOLou93+1pxv717H4zTDbZL0d8Ltr1ePQYfwRH3dvHyl7+cRzziESwuLrJv3z4WFxc544wzuPLKKzdy+iY2sYlNbOLnHBtyQ91www3s27cPu2tdlUol/uzP/oypqamfauX+o3i4VaNWf+4dv95MtetY9YPMZfCYNfkcg9fr+oVXzywJrPT5r6d+WO1/7s00OeDDPpJ1kOV9S2jQxw39MgrLaFAdpPqqiZ56QvaZQn/enf4xPSu7qM9qVVNxbaXAcxFJYiz6LEN4Xj8mUcQw8tz8FeqPpLt6m+Mg0tRY/5k0+wprqnue0LqvkHJs6B5v2jQH20asozrSq/3YXb27GKx/d/say3oQxTlKmbr0Ht+Aj7lo1yJ+ohQ6Tddeo2jH9VRd65S7ImdkUG1T9IWe5TzwnGCtCivX/djSin7a/Qkp4gRFfGLQRz+o3uq1b5+N9c4dvJ6S/TquYDfmvld719f15Q+2Q9GGgzk7gwyxuPfVY2ig3fVAXkLPzF4RP+o/H7JubKu4j8G27TK/Ffcw+EwH4mr963W/w/p9bbBug+evLrOob9HXBnGEPjV4y0fE8PAwP/zhD1dsu/POOxkaGtrI6ZvYxCY2sYmfc2yIWbzuda/jyU9+Mi9+8Ys56qijePDBB3nf+97HW97ylp92/f5DWDdrdL2s29XHb6DMwTle1jAT+uxiXWWT6qqMVuvrB1VCA/pns0H01S1FmV2N/mq1w2D28iCKIwatrtU66541NmAt6zRdaR13r9Hz6w9YaIWP39xTvtJaGVSrDMYrAh/agOuYa5QCSFLIM3Ospcz3wucvBywn34PUqGvQFriuuUYc9/d1irhHZmIVsuszlspcw7b71nCXhQCGsRTMJk56fn4Na1nZoDprUE4uTbxkUFW1gmUNMKceE+ta8CvUWkVbZtnKNh3cXlSniLMMWI69vlQ880FLdD2smStIr7Re1cq+g5KGsaF6un/Tl5W5/zRdyWZXxR16fW+QTff8+qv6Jqzs3wNsbDDHRoh+bEZIie6y0cEYk16lgluRczDY3oNKpYH27LGOoh0KRqFzQK5gEOazYTWDY3vNmCnqtzqOUPTbXPf7a/HcHbt//TxfGcfpxfkkQki0znvjSIhu/pFSZvsRsKGXxRVXXMGuXbv48Ic/zK233sq2bdv4yEc+wvnnn7+R0zexiU1sYhM/5zjiy+Laa6/lwgsvRErJ+eef//P1chADioXetiLO0I8VrJ6TZl3mUWRKDx7D2nyI1XkMvQzNwg/ay9ZdVU8wllqh5+/623sW0ICPVYuBOY8KK8txjFXQtdhFlwmsvsbg9t4a6FKaz4U1PbjdstA6RwDCsdGJUSzpNEUKaayZPEdHce++VvjrV68p0VOD5P028T3SsTJqSZFXXNSCJJmsotqJsa7T3NynJRHtGGwFSYb2LGQnIav5yHaMtiQiyUiHfFP9MCMr26hOiog9RKYhyUAJtFLmv62QzZCs6mMBOnARYQJZRl4JkFECaYZ2LcRyq3+PMl7LmsCwGNeBJDHP0RpQXKluDKV4ToWFWFh+Ym376eLZdRU/Qkh0l5Fonfe1/av97Fqb5xRj6lmwlMK6HmAyKzKMu+f2+syglV/EAlax2BUWvuOsn0E8qOZazcgGsDqTf4U/foAprJg3rRgbRRazUv02KspQEk2KyFXfGi/ianogFjM4dnrj0jAjwLDV7v33xkyXVfZYOBjl3ECsYPC+xMC1+vVTK2I1hbpJJ8n64ynLDUPu1q8HS4HKTX6MUobFIFaqnpRCFAwOwLJ68ULxMAnWR4xZvPCFL2RqaorXvva13HbbbUcsaBOb2MQmNvGLiyMyi9nZWT73uc/xwQ9+kLPPPpvjjz+eF7zgBTz3uc9lYmLiv6qOPzFWzLOkuvPdKwVZ3GMDOh/Qg/dPXK+w/mcpEAy80ZVcnzUMKJvWqB8kfYulsOoty/h9V6lr9ICfsmAdPStICKMmyvOeykcXeQer/NLG6ulaLV2ljVijWhmw6qz+7JkEPiKMzLbCh+66YFuIVttc27LAcbr1ECbO4LomLlColMJohY5dV0s0dgaU90gyT6EtRTjmIBMbGedoKcgdgdXOsVyLtGQhco0WAquZ0DzKx257iBzcgx3aWz3QYEU5UU2hIgf/QETmWziLIblrkbkKBGSuxPYt4pqNV7RTqduWQpBUHGScEQ97eAA5htHUO/37LVhCkoCVg+eaZwPG0rMstGcjlpqmDfMcVJe5upaJhbgORLE5fsB/3ntyVteaL6xAKU3/G4gv9T4X9SliS1m2NkakJAK7X89e7ESaZzbQJwfVPL3+up6KrrCwXbebob0qs3ow+z5Nu6x0nYzhri9+RU7BAPsSXd98zyMgLUQ3b6GIi4huTEuAuY6UCK37vvmiHQbHRK4NWyuYRJcF6zgx7Q+QDbAa2a+PjvptV7RvL6YwiOJ+MhM76+VDKNV/xlneH9/FcyjiG5JuDlDeb/fBOE/BrsAo/LrqQjzX9C+lVrAhLKvf54p+cAQckVkopbj44ou55ppr2L9/P694xSv413/9V7Zv384ll1zCxz/+8SMWvolNbGITm/jFwIan+6hWq1xxxRVcccUV3HTTTfz6r/86l1122c/sRIKFVbZi3YWBjMhetvaAkomBc9bkaAzmZfT8gcXxKxUPBTTZCvYgYIWlL7o+3h6LcGzEgBWJNBarKPTbujsHj+uY+EW3LrjOgKWh+5nCShqlTxiZ6xVlFp97FS0sk277JF3LLzOWssgydNlHWBZ52Uc22oYVBC5Z2cWSAlodUw8pwXOM3zhJyUtejwFp1+5mtvat4XTIp7VFoCKXzqgkOKhoblPIBKyORuSQ+gJ3KScctbBCTTgkQYDIbMIRgRVKRApxuURzSqIFBAcFrS0CmQm0cokqkpIrSANJ6oleuU5dEg1JcuWiYo2WhnGITKOVQMWauCxRYZnckYhcY9kKkWQmniKliX9IaWIcwmSRayHQgWPiKDUPO0rJqz4yy4yVVzwfMJYfmPbPdd/qLvqK43SZS9fvHPjGfz6o3+8pX7pWp+P0rdMiY7ibKyAsC53Fpp5FHyr6eKGWyYs4R39b7zjLQkdRn5UWY6goI6N3D0IpcGx0lnfjXoaRiYKVQU+Fs8Z/X4yXwfvr5nqR5yZuUKjXuiwYxzHWtqUM07NUP87Q3d8bh0ohUtFT2Zl+mvefh+sY1uy5kGaGFRbxp4I5FeVlObobRxCu21vXoogTiWK+rWJ9D8sycRQh++O3sPhty9QpjPpM3bIMQy8UfFY3u14PMIvieWjd7yO+12cTxfPLdZ/dOXZXTbgOy1uFDeVZAERRxEc/+lEuuugiHv/4x7Nz507e+973bvT0TWxiE5vYxM8xHpZZfP3rX+ef/umf+PjHP86WLVt4/vOfzzvf+U62b9/+X1G/nxyCvk+5yDhVspfB2WMchcKlYArdt7NQ9FVRoq9ZL/ILCttH52bWTVFk2/a08RIR09d5d2fm7Gmbswx8zygQumXq4QqiE0OcoGslc+koNRbCoL6861MVtlGC5LWA3LWRSQZpjoySnoJIWxI54A/VttXPi4gTY1kkKVgK7XT1/c0QXfbQ3RXlZJKQjJVRYUpatrEtiVaCeMglGrYoC4ElBMl4GWupQ1ZySWoOVjslcxUqTNFSkHkKuxszEF2lU2vKpT2lUbGkOQ2ZqwjH6DqTBVYLcgfaWyQqBLsNUc08X6sNnQlQEcgEkorsnastQWeLRmQgMkkaQO5YZA5kXvf2a+AdlHQmNblSyAwyxxiXmQNWCDKGzAUVOcRVgRaC8qwEDSrpWsZCkLsS1XbIAoVzyMRl0pKFFpD5CnSVaMShFKfG76412rEQnZi85CFtizxwkO2Y3HNACeRSyzzfqo8IU7RjIaOErOwhY8f0lbyrjCn09WkKnmtYXFOsyQQWuTbWsNZ9q3igTxHFCD3gwy7YrRpQ+Chp+nth5RdKIssydekyWXNBAa5rjnccc0ycGGu9y0pEkvatakm/zoXFXYzhLEdXy4gijtBs9+MJBZv2vb51nmaG/ZZcrEPNXj+ne+8U915cJ4zA0ua7YxuFXZwYVh0mfdVa0dZCQMk3x3dC06ZZ1o9N2XZvLZWiLYRt95hCL15kW/36RF02YXVVW64Nro2WEpFmJv5V1AVWZL9rR0FuPCN51Ud0LJCYvpCaWJLu/laJzEHbyvxuRIkZ69mR2cURXxY7d+5keXmZSy+9lGuvvZbHPOYxRyxsE5vYxCY28YuJI74s/uRP/oRnPvOZuEVW7M8VCj267iuDukoHnec9a6WfGdp/+/dXq+qrdnr5CZbVVUDExsLKcuP77TIGoJd/gJB9y6cUIKK4b4UlCZSDnpWiPdtY5sshItOkNQ+R5IhSjgy77d+d50hXAuM7jVMII+KxgLiisJuE6nlTAAAgAElEQVQZQoPVSsktgYoyOls83MUEkWlkJyatuAgNaI0MTd6BiFNy3yENLGSaowKHpOpitRKSio2XZLSmXGTiEFcEZSXQUtCZsMhsQWfCxfEV4bCNXbLIfElUlQTzgnBYYTcVmWviBJ1xGy1BphqZQnNSko1H1JWDVprmjCCr5Mi2ROQQjeaGJUogB3tZkUzGECpkJGEiJGnYiEhitSTpTIi0cjqzPnJbmyxRtFOPdCQl22+RBprMz5GJJHdyQiHJxhI6HQdtmUeuIoiHc6yWRCZFd5KkvmE5CBu7rYkrAqutERpST2B1FEkg8D3j005KktyGuCKoWB6NaYndKqHaKSLXpIGNCl3iIQe76ZK5Cln1QGsyT+HFKVnZQ1sCXXHJHYW9FBGPeqS+JNjXgUyjbcN0ZGSUUmhNFtgoSyLbMSSpsUjTLhMariAWMRZx4d9W0livheUvu778ginYdj83pDdLq+oxGYRRv+mSi0izvt8/y9DVABHHpgxLgYrQ1VLPkhVJ2lddFUwp12i3y3TDxGzTmrzkIjyL3HewhEB341/aVojMIys5qGZEVnaR7YQ8sElLNiINEElGHthYB3LySoDIMkRio23DqoXvIMIE7TtkJRdtS6xMk4yWsJdCREeirW6eQpJCrskqPkhQywoiY/Fnw2VUl0khC8Zi9X8LOqFhQF3lmXYdtG/YpnBNnCMru6imRVZykGFC7pv7iscDrKbxHGhb9sZ1VnbRUiCTHGtBE4/6OIcgC2yzPTXxzNyRgIvViMhKDplvISOLNLBQUQ7Lh/9FPeLL4td+7deOtHsTm9jEJjbxPwQ/1uJHP1eQwmiZAeG5vaxGSn53ltJu5qdtIbIcreO+GmP1HDWFP7bIlA2C3kymiK6PMk76ftfAN+d1QpNnoHN0yRvwDysIY9KhoKegScsO0bBtfPxRRjRsm0TnKMfqZGSuxOpkWFKSjPjIOEdkObJj056wSUqCzJNoCSqy0BKcZk573CIpSWQK3oIiHLHJLXCXMkTJJikrrHZGbgvyrqUiaja5Jch8SVyWWG2f9rhAaEFugchtMkeQlCENIPUV3qIkGhKommFXnXFAKMJhgRxWRmXkGatdA7ktsDoQTsDQSIulTODXQtqLPtWxFq2WS5ZIhNTkkcIdMn7wuGwTVEKSxCJp2wxVO4RuShxZJFXF1vFlslxySAtcN0V6CY2tEr8S0rE9UJqgEtJe9nFKMdmwoloKqQsgkuDkJKnArUVEdRcRS7STk9s2udO1hFNBviwIR0BkAm1hYhihIPNMXkzmQVKG3IY00MhUEo5Ce8LGaSpEoklLCplaRNUuixpWqNBcI6pJtF0zMQ9Xkrkm1yS3PNpbLFJfYLUdMzOugNSXOA27R4Y74zblhyTKkog0J3cstC2xgaziIS3jf5dSoj2b3LfJXQtVt5DNjolh2QqtFMKSaMtCe12GnmPOCxyTAV/xu9m/Rh1nR0YFZzLgJfF4gBun5L5tMuk9m3TIR+QYZt5ltrIVg2XiFVoponEPq5ViNWNyz0ZkOcvHlCjtj8m8LtPPcjLfAm0+x8MOtqvIbUk25pLZgqQsCZQwbM6XlFo+jWOr+PMxqpOa5+Uq7OWQrOKReRZxzUJoEElOOGZYtz/bJPcscw+pmQMqGXa719YQOIg4JZz0CToR6UgJGaXIoh21NrMGAFnNR9VDctcmD2yiURe7mRqFnZKEYw7eQUE87GC1bKIhC39O0BmzYdzGbuUkgcRZzrBsSVK1yC3D3v0spzVpm9idEjS3WThNjd3IyDyJSsxvWuorohELFSpakwpvSR+RWWxYDbWJTWxiE5v4n4tfYGYhzboIrjbswTJzvuihCqITojPZX/+5mF8GjFJlcH59MP7UIKCYWz/dOoQ1m/e00DowOQjasRFpRjJZRQtwZpfJRkrEQy4y09iLRomR+w4i9mjN+IjMw4qMlj+qSnJbYXUsMtfUJ7cV7lJXv53beAsWcVVhdXIyR+LPx7S3CNIAWlMCZxGywDCA4ICkMw6qI9EWRFWXpGyUPlHN+OPTAKy2UQtlXUGG1YFoGPx5SeKD0B6tKY1MBJmnSSqCXEEylCNGI/J7fDoTZp/QICNBPJWQlm3Sku4qm0CPRahZFy0w1rjUiImI40cOsttOmC4vsycY4vjhOebDEnGuONCoEDgJW0oN2qnNQhCwrVwnzCySTDFTXuLB5jAAh5oljq4dAqDmdXBkRju1KXsRQ16HQ34JKTQVNySv1QmshP3NCieMzDFbrlIPPapeiCVzynbMwoiPFJoos9jrDKNTiVeNaHsBuaPoTKeopiL3824Gv7mnznZQdUVWySCROFvaRMtl4rGM5aMVTsMwQLRhWp0tkAY2SWBUXTKDaAjimnnu0RDYTRC5wuoowlGIqyByh6QMMjWqrXBY9dblaG8VqNjB6ljktiApSexWjkhLtKY8nGXL9Ekh6GwL6Iwq0FB5SGJbkiwwPvRw3MVdSIiGbWSmiWoKu5XjLtqkJQur5ZC5itwWyDgnGrGoxGWSqoPVSBBpTmPGQbUCWtM+TiNDRRnhiI1KNFFV4TQMc3aXTOxPS2MRt7ZYuMsKq2qYrJaC1laBVg5RVVDuxsHiqiSzBW49JwnMvWoB4YgksyGpQOrbyEST+gKRV2hPSJKyi0xctISoJijvs0l9QVTrlluGETzzzOoKocs0pm1Kcyki0agoZ2mXg93S5K4kV+AsJSzvsLBaFZozDsH+BFtJ4ppjrPowx6o4JBULD0grDnHForlNYbcUwVxKNGzRmBIEFY8kENgtSVIWZK5Hc9owcrSJh4mtpt1yS6AV5Apy5dPYLuiMO8jUjGVnSaAiidBmnFf2CNoTis4EyETRmdCk+wTej47wk7qR312tNe9+97s5//zzOe200wAjqf3Yxz62kdM3sYn/MvjNmJ13HGT7gwv/3VXZxCZ+obAhZvH7v//7fPGLX+Sqq67qLaU6PT3N1VdfzXOe85yfagV/YkhpFAeWIveML1Gkmck4dk1WMo5tNNRRiqg3jHqhUCkUaxl0Ndm6GpCVHESW05n0KDdLJCMB9qEW6XCAjFLSioPqZMbH6Zv3cDzsEJclSSCoPCTJPEne9Z8u7TLH2C1IfUhLIFLj+067/u7c1n2W4Rift0wgLUlEBo0Zj8ZpMWQCEkG0BbQEEUnimiAfShFNhXY0SUURD2WITJAtSGRsrpnbuufrTocy7EMWyXhCPGyRDqXEwzZ6qkMuYKjaZmG+ApHEHe0wXOowtwuyjoVVTkgjC+Wm+E5KaGcElYjWog+RYnrLIvvtqmF1AsrlDtPVZZ749R/R8h12nzHCRKmOqxJe9Nc3cMx35/jTv72QuWqNYacFwHTJYqTe4uxP3kfHdbjpqTs5t7VI1hZU7+vwxv91ba8LvP8Nj+aRX32Qjz//TG47fZqdE7sBWIx8Tr95D8szAac1NaqlufDm2/j6M49H2Jo8F1h5xmi1hRQ5UW6htSDJFDtrC9wmJ2m5ARPblohSiyixUN31UsYqLXbvHcXd1cK2TO7OcSPz3JJPMTXcYC/jZPOKeCzDqiu0pUmHUsIxBU6OiCT2siSeiVDzjmEnQGjnoAXWQZu0mkEpZclxyN2cYvoAb04hcmGs6p0xInNwlyRJyVjXIlXU/IDlnYLggENchfKsTRIIGkcJnGVIAxd32VBMkWna40Zp1diusFomFmW3FFFNEpcF5X2Szqjpi1pBeytYHZ/WpILcwa3ntCcEIguIaoLWNomzbNE4SqA6hkUlZYuoZnJZVGRYk9WGcBwaSuIsFhn70J7SZJ4gHtLkjiLzDKuKq9BKDIO2WoK4Bkk1R4WC3DWzNSRlyL0ckVvUj9GUdguSmlHA5Y4ZU1pA7kI4liNTwYJUxDUIxzVxxSYtQVyxULFhgfVjTAyndo9FboNTUzSO1iBcwjFIAgdv0ULksHy0RIWK0gFFe1wSDpdJXUFuQ3MGnIYgKduEIxBuyehMCbTQiFyQOxn+rCIaNblD2taIRKBtTbRsmGpuQe5qkpIiGs+Jsu6g3hKS7DPzp2WeRlua9qQybX18Bz3vorZ0aFQdvK8c/id1Qy+L97///dxyyy2MjY3x8pe/HDA5GPfdd99GTt/EJg6LU763lytff/2Kbff80jjHfPcgAH97yUcBuOHpu9h6f51dtx5ccewL/vLGw5b9m39i9p1y0yx/+qcXctUffQmvkx72+N/4s2+t+P7Gf3kGqS85MFbd+A1tYhO/oNjQyyLLMsrlMkBvvYNms9nb9rOI3FZko2UQgqTqIKMMpKC11aHWqiHDmDwwcxllFR8rScBxyCseIkrQVqmXla0di85UmdQ3aqFwWKG2V4krEsdXtLZZOA3DAGSqaU/I7txGDss7jS84twFhk3nGAgBjraA0USrIHY2zrUV4yIdUIGsxlpORRxYt10G7OSJIce/xiKvmvFyBsyzZPjVPxY5Yinw6iU2z4yKFJmw6DI22aFcc8lwQ+za1kSbNlkdYtdCpwCql6BwsJ0OpnEDltMsuY7UW9YrPWLnDoXiYM7bvZa5dZrq8zN3AsN9mzGtjyYya12F2ucaO4QXiXOGplMCKuWdxjB21ReYrAa3YZaa8xFSpTj1xCayEZuJw0fU/WPPsihfFIB77qXv/Q/3h9a///I99zlt/9ZMAfP05x+K2Uu47aZzHfupu3vq3T2VhokycG0XOuNeklTrkWlKxQySaYa9DYMVUrBBb5Bw/aXN0+RBZLlne4lGzUwInYbntMRGELLV8fDehFTrorYJdI4s8VB7ClTlR6DA+3KAd27QCl53jC9Qjj0VVwvNSSn7EcsMnLNsE1Q5JbLF9dJkH0wlakUR1BFmQg6XR0iIaz0lLktzSaGniVdFERjQBzrwi9U3MK7cFne0p0YhFXDPzdGlb03ZM/M34wyXxsMZqGT9/uC1hsWnTntLYDUE7k4RHR2jLJRrSXZ+5IBzPkbHo5tCYOblk2J1jyjJxr3QoQ1s58bgweQwCvKPqcBR4AlpWxcR+hmKUk5GmkjyVRJFCBCmen2BbGbkWMANh3cMtxdTDMvlITCNQkAnkUAwaWg0HGUryIMMZDhFS0xm3cP2EOLJp+a5RvykTnyMXZCMJws5ppB6Zq3GWBdZMk2ZaIh1OyRyb1DczC6TlHPeQJHMkSbXbvuOQjCdYQYp2E5YOBohSyuhIk0bLI88FUmk8J2HZKbNtZoF6x0NrTH/puIRWQLCtadpOC1p+idrUMs2Wh+OkTNbqtEZcolQx7HeYXaoht5i55U4eP8jyhJnSoF7yjjgeNhSzuOiii3jNa15DFEXdCmne9KY3cckll/y4428Tm1iBxYlg3e0fetXZXPeCk9bd991zZ/joK8/qff9fH3wGV33yMr72q8fx1285n9/84gv5uzc+gU+8+IzDXvffn3r0hut43sfu5uzP3s+v//m3mLlrkX+44EPI1SKII8DpsplgKeIfXvMhpg4sbvjcTWziZwUbYhZve9vbuPzyy6nVaiRJQrlc5ilPeQof+MAHftr1+4mhbUFSM1mN0bDCWRaEoxbtMUGw30emZl8aKGSikaNVssAm8y1E7qGFwF6KQELuWsQVSeoLkkCSVEArC60gLknCEciVyTsQWhCOGf9qbnXVBjEktZw0ML7XaCJDNSVquk3SdEBqnFLMtqFlmn5InCm2VetINPuaVVp+QtmP8KyUvckIysvQOThORlKzOKE2RytzGPNatFOHfEgg0dQTF0+lLHseNTdkvlPi6Ooh2iMOe+pDZFrg2yZFueJEhKnFZNBgd2OYo6uHmAvKjLhtvtP22B4sULVDRhzjx69YESUrIteCkooZckIm3AZLic+Y2yTXAjmi2ZLWufib3+cbTz7WqIysmINRmSG7TYTFM975PQBeeu3zuCndyfEjc3ithDvzLQx7Lb7ylBP4XmWaShayTdW5f2iMxcjHtxKuP+tYmrHD/ZPj+FbCg1ePcvv+SSZocPtjJhECfu+iZ7BrbJ4wsxgLmzRaLmLCWLClp3YYqoT8KNrClqObNCOHoJoSphY75g7xqBvv5wVvW9/N9cFf/kd++98vw01jFJpL33MHs7uGuOeJE5RGIjqpzXlfv4vqYsjT/vj73PzkHWydXWL6h0v87ue/wF9c/RTGvBb36jHOGHuIQ5UygRWxEJVIc8nWoI6nUjwrZSH02V5eYiEKYAi2+A0kmgOVCnGuGHHbLJV8liKfiaBJO7UZcdscGKkggLDhMjpRp9H2CHOfyZ2HODBfxQtimtUAckFla4NcC1p5mWhrjmx35wUrJ3SmQQVJL67luanJWREgEomqxcQNG600QxMNmsvD5CMxkWeBgFItpDVlgdLgZbRth5GdiyzMV3BKMa6d0moalVweKeyS6ZO+laG1wLFTWhVj9R47Nt9jr7cnCsvKGC51CFMLie6lRpXdiMBKyBFM+nX2d6os+T7T5WVubh3FxHgdW2UstnwmKk1yBPNBiTyXeG7C1kqdNJccapc4dnieA+0yh4IStpWxuFBCN21EOeHY6TnmmmWaSiOEJiw7nLl1H99pHcXwaJNFUSEdkhCk2F5KWLWRToblZDRnA+ytbcZKIZ6VMl1e5sFgmEbosr26RFxShJlF2Y6RQrPfjTlu6CDzXokR17D6u5fHqdspO4cXcGRGmFncAxw9vEC95DLmtZlwG8yGNdJcMu41GfdbHOyUGPY6bPWXmQoEtsiZj0vcfYTf1A29LKrVKp/85CeZm5vjwQcfZGZmhsnJyY2cuolfMLithLG5BtGMCYKe9Zn7yRLJ9eceD+Nw0rdnueJPv87SeMCHX3Y253/hRzz2E/fwgt8zP7pfftEJzAdlLnv7t1eU26x5cAgQgnbZhbr5/NCuETpNh1xJfD+DuH/O7p2jLMdHps6DaJddlq2AIToA3LtjgslSg4OHKow6HWIsAgwLmNtW5QvPOZlrn30a4/N13v60jwBw7WWncNE1P8CJMv72zA8D0Cnb+M2kd51vXrKT+48d49fednNv21lfeqBfj5Kz4TpvYhM/K9jQy+KMM87glltuYWJiYsUKeY985CP59re/fYQz+/j85z/Pq1/9arIs4yUveQmvf/3r1xzzta99jauuuookSRgbG+P666/f8LmrkVuwvNMMysyDcMioIVrbc0pzDlYnJxw2Kg4r1GgVkDuC1oRZMwHA9Y0uOqpZNGYkmQuZT9fXK0hL4M1DNGLUFNGIUSqkI6nJnpQ26XgCUqPcjMizwc7xayHpiGKs1qQ8HrEc+sxUl9jmLVNPPVItmXAbRLnFhN9gKQ4oWxE5gjC1cJSxuGpehzhTjDgtqjpEkpM4ilbq4quYKSenlMYc8svYIsdTKUN2hyG7gyVywsyiaodYMsOV5kfSlSkVK8JXMUN2Bylyzhu/h7/+pY+SC5Bd5c17/uqxnPyVWR79aSNyeAErLfCxh1r8/pWfWfNcnvTetULufzn3DB5sjVBfDLhLjNFqu+hcslAPaI04HKyXSUKLQ0MlOpFNp+7hlI2fOY0VeSpRbobnJcR1l9lYIaSx9NJll93WMFFi9SzYfEyw0AxIom4eQ2hz3+IIeS7ZX69iqay73IRxNe12h7j6nZeyb2uNe+1xsOCif+7HWgZfFABn/3/3czb3H7ZvBsMxjxjay1ZnmTGnyZS7xITTwBYZtcqDPBSPsNVZomKNMeUuMp9UCGTM2c0Gdw9PsNWtY4uMqh0CMGHX2esMkZclVauDFBpPJngzCc3E42CtxJagyW41xFwqOX54joobElgJd4sxlNScMDbHsNPmJnkUtpVRb/qkseLEqf3sa1ZxVIbXtdRHvTb3uyNsrdQJU4sRr8NC6JNpybjf4p7joOzGJJki04IdtUXuljkVL0LJnLlyhVPH9vF9LVAy5+jaAu0hm4UwwLMSJoMGc50yUpjOZsmctNLAkjnbg0Xqqce0t4gUmnZqM+nXWYoDqnZIyYrY2x5iR+kQQRbzvN+9kZtevIs9p41wKC5TsiIe2lLjEaN7AbjXHuPMkT3UU49WxeXBxjDDXoeTKvuQQrM7GGFXcJBRt8pedwhL5gz7bcLUJskUJ1Tn2Fle4NtzM9S8Dsmo4qTKPpZmPMa8NvfJjCi12FJpMOa1kEJz3/IoY36LO5lgotZgZ2WBkhWZsdd9phUrRAlNksve2NzqL7PDO8Sy5xOomExLfJWwtz3EVLDEsNWmnTtYMufY8hy2yChbprySFaHIKVshTcfDkmMMO22m3CUAbJEx6jT/48zinnvuWbNNa71hNVSWZbzyla/ki1/8ItPT05x11lk87WlP46ST+j7ppaUlXvGKV/D5z3+e7du3Mzc3t+Fz/6dj7IEGj3/PXVQPdfCXYt77pscy1Gnz/P91I6P72gD8749exNz2yobKs+KMX3n/bdz6+Bn2njTE+GwD6L8oAF5y1Q3/afX/vd98JmM0/9PK+2ngrhMnyRHQgmt+61ErXhYA954wxu4zRnniR+5cc+79u0bZee+h3vcn/f0d3PrEaeyjUlSWMXFfneXAR9qaV/3yV0kcyb+99hjmfrlCICOmH0p42Yuux47My6s55lKeN/HD1938bI77yn4e8+/3cOdZk9z/lDFQQK657K9u5rqLTubgZOmn1zD/jQiaEW3PXrGtNtcm2B1hH5txyrdmOfkr+zj5K/v4x386l4nlOrvPG/2xrzO0p8Wz/vg7vP2VT+TgUf81yrjSQkg0ZPcnOP0PwOpk2GlK7gmC+YhmzUzyKLKcp77p+zxw9hjbv79ALBWfYeSw5QitD79E0uWXXw7ANddcw2WXXbZi3wMPPIDWmm984xsPW9kbb7yRP/zDP+S6664DzGy2AG94wxt6x7zjHe9gdnaWt771rT/2uevBnZlh5lWvwQrpzmdkZhJlKCa4zUOmJns5t8FZhuCgJi6beINTN8tf+IeMeqMxLehszdFDCWhBqdahtb+MGorIFl2csQ7xvN9TME3UGhxqlAjbDlNbTDBz1GtTj10yLdniNznYKTFTXsKSGUroniWRacHZn76PpfGAO8+YpJRGhNrmhJv38fT/+z2u/uBlBOUEV6ZIkROHir9/zD8/7DOIfMUfX3sx85USp94yy2mf38OnXn062+9d4MorrsdKcx46ZojPvexULvs/N1OdD3vnhoGF1z685HQ13nvVuTjtlCd+4U6mHljiHb/7eBqTHuP3NfnqJcfTDDyGWm2e946b+NNLLuC+pe3obSHMeTAeohdc8iAzGc5Bis4ELDnkgckRkR1JVsoQkQRLYy1aJKMp0k+R+12Tm5AJZCyRkSAZSRGJgHKKWLLRtQRallklbThG120oZ2aN7VwgpO75ldNEYbspSuaU3JilZsCW4TpnZw+w7ZtL3L1rgkd89yE+ctFZVOyImQcWeOcL/pm7Tp3gb37rfI757hyfO+dkjj/6ILcsT/ONi/9iw+34k2DulDLzx5U56RP7AVia8HndZy9lxGmxL6whRc7J5Vlua0wz7S3yg/o2hpwO094itsyYDYc4FJco1n6c9Op0chtfJjQzhyG7QyP1WI59tvlL5Friq5hO5iBFzqS7zLeXdrCzdIhm6tBKXU6qzHLTwtFsDxZpZg7NxOP02h7u74xhiYxJt47Mc/Td0DrGo2Z1SLRiLjbGjS0yfJVQjkMufO8POPVDezl4Ypnpby3xtg89megMm0DGVO/v8MKL/v2I7TO/q8Qdj9zKV994IjmCxSTgWP8AobZpZy7NzKVmdTj3X+7m9Pfu4fo3HMfTr/w+AF+58ni+/srjWU59lhKfpTjg0cPGYH4gHGU58SmpmONK+5lPKmyx6+yORrinMc6O0gLjToN27rCnM8wplb18e2kHjkw5s/YggYyJcptMwwnX7ufi37kNgO89f5rdZ41idzJ+5Xd/wAOPG2XHNw6xvNPjR8+YZOwHTf7lqjM5ec8s9UmPE/5lH5mrWJrxKR+M2P24EZ5z2XdWtEEcKJamAybuaqxpn0eeeeZhvUVHZBa7du1a97MQgnPPPZdLL730iA+mwN69e5mZmel9n56e5pvf/OaKY+666y6SJOEJT3gCjUaDV7/61Vx++eUbOrfAu971Lt71rndtqE4/Kxg62KYxbvzuJ31tLxP3Nrj4b2897PET+xqUrZDffsUXuf65x/Hof9mYpNTtZLz5iZ9ase3cVedO37PEFb+z9uVfvCh+/z1P457jJjhmdo43/9qnmdtS4eUf+g3K1ZgRu8lsZ4iaE7IYB6Ra8sUXn0wzNVaMpxLaZzlYwiSRtSsu73n949g/V4OlDd3CzxQaoz7//uQx4kyx76gh6K73s2fHCL9x00uQaOajErcctZ1OYrPTXyRtK+66YAvHXXfgp1aviR80mfhBn6XpwSVKgS276/iTMaV2CAPhntKhiCCKmB0bOmzZ1fk2bBWH3X842O0Urx2Dr1dua8WkFUV5PuT0T+3hyX91B2/72JPpnGT6zDmfvpd7Tx/n1Bv3MvtLQ1zyl99n582GoU1/y3Sa1zzvS3zo/Y/i2G8d5Ox3HN71V2Ds3haPu/ceHnfNPTx06hDfumAnj/vs3Yzf0WRpm89ffPwCPB3zhD+4C6D3ogA4/513Ul6K+OaTdzJxa4PKQyEXfaLPMD//nJP5xGt/idee9AVmj69xy0u3c/lf/jtXvvc34DDkbmJvnQv/zw845ZOz6+4//YMPcfoHH+p93/GN7nQ294ec/X8fAOB1X7zusPd7ztvXtonTztZ9UTwcjviy+IM/+ANzwXPO4YILLvixCy+wHnkp8jUKpGnKd77zHb785S/T6XR49KMfzTnnnLOhcwu89KUv5aUvfSkA7s5psumQtGmjrRyRC0SQYjkZ7ZnczBwaZJAL4mEzM2VS02SlnHBcIDTEwybLOa5pvOkmvpvgqIxRv8UemVP1Q5pll6nKMvtLFUpOjKtSAithqkEFJloAACAASURBVFRnKfaY8Jr4KsFXMa3uHP8SzbjX4NjbD3D15V8CYP/RVSbvqz9sW77mzV9g+kdmoDztb/od+RXv/nX27Ryi0g6Znl3inK/cy8yeRc64cQ9v+cun8qbf/uzDlj2IB48e4aanHs1lf9u3Mr65Ywf1js+hyRJP+srV1EOPOFRM2g3ub4yQa8FDrSHiVJEjyHKJFBrXSolSi3booJRxpZRcE6luLPmUDwjatktpjyDs+DhLkHmStKQRczYyNXMopZ6Z2wZAhhK7aVij3cDMgeRYWE3I2hYiA7sOModOar5nTYmzKAgzB7th8gLyZc+sshdK7GXRy2gHm8TW5H5GnkpIJaHrkLVt5mQFrQWLLR+7q9jphA5JrcmhRonxapMkU0SpohM6xG2b76lp9s/V+NAfn8NTR29FZ4Jjv3qA0TmTmf6VF57A+e/7ETdduJPJ/XV2fO8Qq/GZK07l4nffxjWvP4vrLz2Op93wPS589e1HfI7D+9v80Us/ydZb1u9b//sLv8KYaPLS842RcMtlM1z7ptPItGTqrgVeeOm/0Rp1+eGzt3L23z/AJ95xBs/4f76HzDT3P3aUaNQmcSW3XL6dx/z1vaS+5JfzH/KD39nG8kTAUV+c5xm/1e+nN125kwemxnj2W76NFa8d22fctQfneynDP2pz0if2HfHeCjzvN7912H2fuvoR/PD8Kd5wybVr9k3ftsT0bbf0vg/NdnjrYz55xGs96qMP8KiPPrDuvgs/djun/MjEQrbducy23zbs4P+98F1857Xbue+Zo9izOZd8tcm577iX758/zSO+8tC6Zf1nYv8JVSZ/VOdLrziRG559LFde9TUmbzX94dqXncpF/3Abv/uRX2Xy1GV4weFl3RuKWVxwwQXEccydd97J/Pz8ih/w888//2HPn56eZs+ePb3vDz30ENu2bVtzzNjYGKVSiVKpxHnnncf3v//9DZ378wivmfReFMCGXhRA70WxGvceO4EjM5bdgNaoxx2nbDXWfGhjOZpXfPq5PPFLd3LjY49m613L/M4bv9A795/ecA63nD7D1rvqPPd938RrJVz1gcsYcjuISPOcd32H20/cSq4kxeqzm/jJkNmS695wClFu8dBrhhl3mySRxHZz/vVVv0SUW0x1FinfGpI9SrL1umWe/6abePenHst3pnZw99WT3NcZB+C+C8Z507efzvCDbcSJ4OQJde0xdKBD5RsRj/7Kvez6xsHDvigAfu8pn1vx/Yxr9nBwR4XvPOsoXvyr/wZA5WDE2X//AADPekX/x3XnDf0X2qkfW2kZP/IzD3Lg5Apbbl9pwZ7zzvs55wjB/ye+cW3M53D40cVbOOEzK1naDZfuYuGJZfYfW2V2cpjl1EcJzZ/dfiHBcsSO6+e5+A23bfgaSzM+f/fnT+Rlb7yesXtaD3v89K3rj88z/2I3Z/7F7hXbDveiSB3BBz/wGHQFHvX++zl0Uok7HrkNcZzmuI/t57QP7+Waf30kCRZeFHPiZ/bx3afsIC5ZZAhO/95uZr0hAi/G2Z3yo8dtY9vyIvcGE4TC4ePXnEl1tsN8qcwDapw7Lp1ktjzEpDzyb9ARYxYFbrjhBi699FKiKKJer1OtVmk0GszMzGwoyJ2mKccddxxf/vKXmZqa4qyzzuLDH/4wJ598cu+YO+64g1e96lVcd911xHHMox71KD760Y9ywgknPOy568HbNcVRf/4yomUPVI60ciwnw3MT6vsq4OYIlSPtnCxS0LDRfoZ0MoTS5ImClkINxyg7Y2ZkEUdllK0YR6XMhyWqdkQzdZjwmtQTj8CKGc5b7Lz5IPeeO8FyGnDUwiFCz6JTsjnrugeoLobE2uK5f7W+NfR3v/MEvvrk41m2PVKtsGTOhNdA54InffIOXvznZgB/8LXnsOXBOsfeeoBvnbiDN//mxQwFHapuSJpLlkOfmtehEXlUutuqTkQzcchyk2n8tM/eypfPP4GG79FIXHItsESOrTIakceo36Kd2uzYPc8N6hicambmTVI5tpWx3PDJOhbBUAchoFX3qA61aTY8tBboVJqZZbt/ed1BlBLyWOHWItJYIXf7jH8vp75d4i2YGTLdRTOXkRYm1mR1jGItqpnZboODmvaEwFvQxFWBf0iTBGbm3cqejPaEQsYat96NQw0LnCaEw+DWIaqaMsGU7zQ0nTGBu6yJqgLZnecoGqa7VgEgzFrc7iI0T0yojjVZPlhGuhm63V1PoZSi2xb2UIRUOdFcgIwkWmnsrW3iAz4nnrKHODPPtZPaVOyIhTCg6oZMeE3uWR7DVSnDXod2auOpFElOYCc8UB/h1JFZvntwBiVzHjG6l+XEzIw75S1xMC7TTl2kyNnfrnCie4Dx+QZ/9IxPP+wY/e9EpgR7Txpi+23rW7XXv/g4Hv+Pd/Gtl+3gw09/FIujZebCMqfWZinti3jWX3yXu07dwuzTalyTPZIzR41x2cpcbl+YJLBjtpcX8VXCgbDKS7/2dW4f3cpyHvCo2++nOtvhyxecSH685ML33Ea75HLbtinuuGAr0tbctrCNCzq380vf3sPpn93N9HdXvhBe+/VLed7f38jpH1n74/+pVz6Cp//d99dsX413/83j+MFjpxi22xyKy8xFFWp2h5IV0clsbJHjq5iFpMQWp849rQkCK2LcaVKzOswnZfaHVebDEmeO7OFAVMEWOTmCRuIRWBFLcYAUmml/kSl3iW8u7WRPfYiZ6hIHOyVOGtrPt192x08Wsyhw9dVX87rXvY6rr76a4eFhFhYWePOb30wQrJ99u+YilsXb3/52LrjgArIs40UvehEnn3wy73znOwG48sorOfHEE7nwwgs57bTTkFLykpe8hFNOOQVg3XN/VjCxv84HLns/AHuPqnHvmROc94m7WdgSMD9R5rjb5o54/lX/+hyOvWOO8kLEJ59xBrkWZnqCTPQmiEOY6Zm//IwTufOCSe73xgjsxBwH3LM8Rjd1YOMQgi894yTCzIKHSUbefdQo2T7FJq34b8Jh3K4Ph9RVHJyp8MFPn83YjS0Onl3mjI/s5jPnPYLH7r2b5V0+F7/YWNkHjq7SmnA4+qb5FWXsfuQwzUkPcvjG5ccS7VQsBWXO/tK98KDgwWeP0BIOL7j8RpZGAm65eDu/+gffXbc+X37L8Rzz6YMcdfMCC1MBf/rZixizmyykJRQ5w3aLy37jZmZuWeRdnzuPrd9Z4gdPnaKtXG7+7R3YImO5EfTHBbA0GfDBv3w0zcxlxluA9V3/K/DDZ27jrvYWFuMS9Uf7dDKb5cRn6v9n782DbcvqOs/PWmsPZ5/hDu++MfNlJgkJJKCQUqRoB9qBVCeISpeINFolpWBhikZR3RJtNB04pNqNId1aVUZraYVdFpZFWYQWQoNWQpGBXaYkhWG1kooJ+XJ4873vDmfe01r9x2/vfc4995x773v5XpKZ7G/EjXvOPnuvaU+/72+MdvjkT76c2Hp8ZXCMVW+ILq75K7d0+C/Pfx5/830nsZuK1npMdlrzxYs3E7ZyPvP+l/CZ//nFvPK3n+Dj97yCV68/ymMvOsqjwTFOL2/x5J1HMEPLd90r9sjf/zd38Z33/iUPvu/5fO5NL+BCsrxrXs9EHIpZLC8vs7W1hdaa1dVVtra2SJKE22+/nXPnzj0d47xqNF94E6c/8KNkscFvFDEEfsZR0+ex9aN4rRzfz4vEsoo0NWSxR9AUn3mjLWlqaDVjIj/jls42mdOc2tzm2//gr3j4607xyLee5Ft+52/5h/90cTK7/fDo847yo//q79MwGdYptuIIkPFs9FoowPdyjnd6jDMfX+ecaPbZThpo5fCUZXPc5NzFVRh6eKtjfD/HM5bedkRnZcRgENLpjEgzQxSmOKcYJx6rrRG+ztkaRQQmZ5gEGG0ZJz6+lzPsh0StuCgmmLN9dllsP7FGLaW4XKO3fck71HDYIymtvw4YnbLosQblqpoN3kiRLlvCdc34hMUp0KmSiN+/1hz78x6957dY+lKXK3cts/yoWIuztuTpN6McE1uyyJA3NK0nB4xONfEGOc4ogq0x4+MReUMTXRiTrIXo2BJcGZItNUg7EkkMwlZ0DmlT440sOrHo3DE8EdA6HxOv+piRJV41Uru4qBOdtCX7qkkdg5OK/h0ZzSc80jaYsdhNJN8PZC15+0YXNSaWbcObLa0nNKO/M8R4FpsrsrHkcspyiZb2vZw49tDasdIesTNskCUeSluc1bRaY5xT9DaboB1rx3oY5Uhyw4l2j27cYJj4BCZnEAcEfs5qNOTVRx9nkIVspk2OBn0eWr+NV6ydo5c1eP3Zv+IFH1rn5+99IzbSnMh7/Px7/oBb/2qLD/yzN/Dpr7+TV6ye59xomcwaUW3mAS/tXODLg2McDQbE1sPTOb20wTAP+G8vf4mdlSYbzTYuh0eGx3jZ0UukVnOht8R/c+ErfGr5TvyOI9A5TS8ms4bIpOykEQ0j9+CXd45yNBpgneJoo8/GuM253rIIVFax1howznyyXNMKEpbDMf/1K7dw802bjFKfceIx7DYImintZkw7jOnHIbevbHJl1GSc+XTCMVo5Hr9yhJXWiNVoSGY1l3odPCMxFWcuHuUFp9aLsaY0vYTHe6vc0t7mCxdOc7Qz4M7ly2wlTca5J5kSlq+Q5B79LOA7jv8ln9t5PpFJedn/d47A5nzhrts44g/wVc7f9E/y8KUTtBsxS40xvbjB5YvLLK0NOLXUZZT57IwaNIOU/jjkeaub/M3FEyy1RUJseBndUYM48bBWcfJIl81+s7Kn9fsNWq2YJDPE602Wbupy++omD184Sbod4i3HZNsh4dERnf/tD58as1heXqbb7bKyssKpU6d4+OGHWVtbo99/5vrGL/VG+GlGhqm2fe8nv8D7f+0TPHLTcb7jn/74Vbepc8v/+dbfozHO+C4WeyzNIvU1n/+25/HqT53B5JN38z/6Fz+Ad5BYX6PGDcTlly7xZz/1ApIdDw9LHPn86u+8jlBnPDZcu3rGCqy/YInUSbBk7ilsMokVyD3D+TtXibd8/Olw/K8RPPoNx/C1hfTgfZ9pONTL4s1vfjOf+MQn+P7v/37e+c538trXvhbf9w/tOvvVwOlL2/zfP/MvefKmVX71na/lJV+8wPt/TTwiXnj+MlEjIUk9OlFMUkh2zikaQUqWa4x2aO0ITE6QZLznZz7Fa+7fG5w4D7/4f7yeb/rjRzm+3uPP/s7tfPyH7pL2/1fwPcuFK22OHRky6IV0t0KWohilHBcurmBCYTzxlQgaOWNAa0uvG9FoJmROk2Qeo8RnuTkizQ16I5D6z3FEDIxWMvS2R3/HJ9jW7BwP0J2EOPbJhz6MNPGaTxBkDLci0btvB2AkR37czPGv+AyPa5xV6CCn+bghjwxeH8bHNWas8Pui+086CrcVEK07rKfxBmAShQ2ktoZOobEhdaa9ofwHSNuKpSczzOaApTRHb/Y48rCH2RzAaIy3tgwaqUXSG6JvWkM5h94eEFmL7sdSvXAcE40TXOChL29jhsuQ5qjegKA7wltuQu5QVjp2gUcUSxW3vN1Aj2K8XojZGeFvSj3qYFtJnjDn0HFO1vbRqUVlFlxEfMSjdd6hM7FpeCPL8IQh6DpGxzR5AEuPW7GJdHM2Mp/OWUv/jgAby8PTG2mGY43pGWzgyGOpvZAZx+VeCCONzhRWS63vbtOXuJLLPjay7DQisrGP3vIZ3BTieTmj7QgTZWR9n2GQ02+ErIRjroyb5FazGTa5tLHEn1st0f/+kDP9NR67LMFqp9Z2SKwh0Dln+8tc6bXwtOVSv0PoZbSDmDj3eMI7whO9VTb8FqPMZzkYsx1HjDOPJX9EN41IckPbj+knIY8PjrA+ajHOfDSOJzZXObHcY5z6LDdG9JMQ30iG2NxqslwziAPS3BB4GU/srGC0Y3u7ST7ywCmGSwHGsyQjn16U8kR8BNX1uOAvo4wj6wV4O4bM99k64rGlWmjjOAN0+w2yQcDwaJ/capKxx+W4g1pzdEcN+ustqUGxHOGuhHzZHqezNGI4Crjl6BZPbkh1xuFWk/OJh3WKLDdsDSLigWSOGMTy/z8Hd3Bx2KEbiy1vKRyTWsPzljb56ysnGMU+40HAcCti3bOQa7wNj65usbPeprEyJu6GbOcK5VseHp0k6/tsdAOUL/szFuarrOJ8rrGbIS7KUWONTjW9yEclGm+g6eoOf9lr4K6E+H1NPjAEfUU63j9481Avi1/5lV+pPv/ET/wE3/iN30i/339K7rRPB77+S+f5+i+d542f2ete+B2f+UvOrq7y5EuO8PK/vcx/vvMOAExuef1nv8j93/JSrJaXyP/wH/7LwhfFmRet8cW7b+L/veeFJJEhDzWXjy/x0Dc9n4ZJ2Ri3aBcSVOnzngbP3Wq2NWrUeG7iUDaLZyNepRTzNG+ff9Vt3P1fHt+z/ef+0bfz9k98jpPrXcJEbBzv/x+/iwfe8GL+4O//Gkc3xG3uvn/2nXzhG27jxHaXSytLNEzGMPPxtK0MzuPcY5T5nIj6nO0vM0x8jrf7xLlHaDK+cv4Yt57Y5InLR7BjDxNl2EzBVoDX16Q3JQRnA8nqmUnkuU4VeTvHLCfk2yHOOJRnMVHGyqeaOA/Ga0g1sxMQXZbqezoRzx4bSO3dPHKEW4pkCbJOTrBlRPpPkP6s1PGNLkP/Vie1s33HiT+D3FeYxJF0NEkHOmctJnGM1jQ6g+aljHhVPJFMKrW307bUfs59RbiV0bstwBs7rJGaCSt/O8T7ynmpUDgag+9DkuDSDBUGYArWNx5LTfUswyUpqhlBnEDUwA2HqDAEa3FpilpagsEAl+dSZz1qwDgWQ7HnSR9Fuv0qTanWUDAPfA+aYj+iP8SuLYOn0d0RWEt2bIn4WIhOHH4vReVW6lUfjwh2UsZrAXmo6JwZYAODtzXkyqvWWP1inzNv7tBYl3xlZix2jsYGjI+IpxWIjSNZgXBTzknaKhhaBuOjjvaTChNLdTWdynHdO3J0IoxP5XIe8xCy5Zxjt26yudPGFJX70otNiVxPNTffvCnS8KNSN967dcBaZ8D6dhvPs4wvN2kcHzLuhwSthChM2Fnv0FgeM9qMaB0dMFxvceTmHfrDkGTk8+JbL/L4lSMo5Vhujrl4cYWVo30Gw5AgyGiFCZcvrKAbEp1vY4PfSbBFBUWbKbwwl4zMxqG9HJsaXK4ILvmgxC7kfLnGdKrAKlQGjSuK0XGpBmfGiuZ5Rd6A4U0WZxw60dgjKXrTR2WQH09haAgvG5JVizkxIu0HRI/7mARGJx3RRcXg9gyVFKz4WIwdewRLMe5v22RtizoqHnBpLyB60se9vMd4M0KliuD4SPKUJR7OgjKOIMgkB9d5SR+iY4XX1UXdG8kqkbblfgXwuxOmbn2pFeI8iTPSGZVxXGcQH7EE21rue19qjUz/nqw48oYjuiS58fJQtlsf2h/7N9dms/j85z/PJz/5SX7qp34KgJe85CVVTQuA3/u93+NVr3rVfk181fDIC4/x09/3ajqbMWnL4DxIG4bPvvqFfPqeX9mz//t/85N7tv3cL38Mfvlj1fd3fvwf0j/SgBx21pq1c1CNGjW+ZrDvy+KXfumXeNvb3lZ9P3/+PL//+78PyIvkF3/xF/n3//7f39gRXiNyDJ/51jsxyuIKiT/OPda32vzIv/j7vO3Dn+e1n/lb+q0AL7M04knuo/f/72/i5/6X3b7p//LHX8NXGkcxY8sgCTnR6nG2t8zJVq+KUdgZRgR+UYOgL27FFy6tgFOME59k5NNZGsF6g81OE/NYRHML4lUfP4bWOUDBqBfQuuBwBrKGwiRltLJHfMQjHAjjyNrgVMDKV8bgYHQ8QGcOExs65zKyhsbv5+Sh1OIYnNB4saJ5Kad/2jBeM0SXxDuodTFndETjxRAvK9rnMlCeRE5HivYTQ8bHQqKLI9JOgPUUfj/F2xkTXQywgcEMEswoIG8YwktDbNMnvAIqtaBBD2KWU1kXpxU6tXjnN0XSTzNohLj+AGUMyvdwwxGqEYJ1KKVxA0mKqAIf1+0JK8jlje1KIcY66PUrVuGSFEqGAVJbPUkmjEIp+UtSMFpYS+ZBbmW7tejtniR0S1Pwfbz1LjqOQGv0IJaxO0cU5+jeEG8jwEU+ehBjcguDIUtnWpjLWxz7c9ELZ5GifT5heCIg3Mrw+x7+wOGNLdZX5KHC71vStiYPVOXFZcaKIw8nOK0wscfwuGLlyxlm7GEDCLec1G43IonGPcN6YxnVE6nWeo6VL2kGN0lN5nN6FbMeEG6JDWqn1WDDKrKNBmngaD1pGNJEZYq065G6JsGOJukZWpc1o1GH9pOarfEqOlE0txSPmOO4KyE6UWzepom+ErAdLxFe8ogDGN0yovmIz+iUQeUKP1aYcz6uLTYzvxDCmkORrv2+SL9OQedxkYDzUJOsQNoSpmxGIh0vPZmznRixmXmw9sWE/mlf8oRlwsR6twW0LsjneFPsCu3zjtERzbjfojmE9lmH9RQ6VnTOWsAjD4Sxuc0I60G+6bHyKIyPasaJVK8LY0V0GTa3G7S/7JG1ICYCDV5XF/VxHKNWzmikWXrEkDWFZWZNaF2ALAR/KFkL8kDOiy3yJfp9yJpK4oQUZA2xmZlYNAjKQrCti3o6oK3C7xcMLBetgTdUpB1FuAUmlgqIyso1uR/2fVk89NBDuwocaa153eteB8BrXvMa7rzzzn0bf6biyy88zs+//zv4wE9/OyDah/u/7Z8C8N9//EcZtwN+8F/9Q/6vH/1d/tl7v42/vPs03ZWIr0HnjRo1atQADnhZXLlyhUZjkm3sgQceqD77vs/Gxsaco54ZSDPNxa0libzNNM0oobfdRG/62KOiHL7QXSL0Mox2vPNfvZ1h6HPJW8ZLc/7m5Cm++5PvJs48lHJsbLVJM0OaeOgzEdsvjhhfieivhcT9ABPmuIsR3VaO8i1mw+fJkwHhmRCnIT5maD1m6N6pWX5U0XMrLJ+FcMfRPif1MaKNDOsrGpuKaD0hi0QaHh3zCXo5WaSJ1lXlTaSsZMXV4xyVWdqPpzij8QY+fi/FDw1eL8F5GhsYwi0PGyiiS2OUjWhc0QS9HGUhvBLTuAR5y6OxofC7KSiF3xfGZbaGRFmOHiaE3TEu8MRLKcsx4xQdeqhxSlBK2oDuITaHNANnIcvxANUfQRCA0ZDlYh9IMwh9VJrJ99yitIYokmONge2dygahSvtDnkMjFHuHUhAGcqy1st84FjbRbILNQZsJs/D9SdtFvXWllLTn+zI2XTCPcQyeEXvGaCyV5LJc7CZGg9LCQNIMlaSoYTE3ayFJCS50cf0BS1/axhUODnp9G6+3itkcEJ0LcZ7GaY1Kc5xvML0RthHgGh42kGsh3PGJvnQJogZBt0XrvE9jfUSw4wtDHeToOMd5mnjVp7Gl0VlAuC2S+XgNlr+SoqxfRMiHNDYg6DrCrkXlHuOjHlpDsA2NLUd02RCvQtCTNkziGJ7QtC44Glc07XMZ/sDDxI6gZ9loRrSfgKDvWHct1h6RdoOuSPNdIo79RcrwokceKKIrVu6RJY3OXRUx7w8c3Vs0nbOW0VGRlpcfi8l9Tdo2cA5soFC2iN3JoHF5TCcQe5NJHMGVIW3VpH1O8o2ZsUWnAUceHuA8zXgtwMRWGHniEXYV/sDROTMgj3zyUBOuD9F5B2uE8WWRMD0bKDpnU5rrisFJT+x9Hqw+EjM+GtK6KFL7eMOgU2EH1gNnFFlTvAZblyxppGhdzEArVGpJOx5+L2N40scbCSswicUZhTe05KHCxI48nDwLsoYm3M5QzjE4GRD0LWlT4Y0c/kAyOFtPEXRTxsdCRkc0zfUclTmcpwg3YvLIY7+EH/smSz969Ch/8zeTYjWveMUrqs9//dd/zdra1eeGf6biiduOcPnE05OrvkaNGjWebdiXWXz3d383/+Sf/BM++tGP7mIYo9GIn/iJn+DNb37zDR/gtULFmmSzQXDZw3UcvVWDvuITXVQ8dvQoYTMlTTy6Y4MOcgbtgDjxiHdCGqtj4stN0tu2yK3GWsXwy8t4A4UHeH0YnmvR2NQkoxZeLLrNcBPySPT8JobhuEHrvEhIyXlDuGPRccDymQzwWHkkqSKLdWJRuUVljnQ5wNsZo7IAlUuEsU4sQVdhPS0SxiAVScbX6FEq8Qix6NlVbjFbQ7K1tkj/sUNlPjrO5PdxRvPCiHg1JNhORAq3oKytYhH0KKX5RIozBlXYBXRP7AIqy0XM0OA8g0ozVCx6e+JUpHTPE6kcRKLPcul7p0jGlmYwSCAIcIFBGY1TCtVu4UJP4iJCUdQ6LTKN6rTBGFwUoDxPGEEp+ft+IeGrahwuDFBBYQ/RGvBkvL4n9gmlUM7hjELlhVI4aoB1sp/ROE/L2igl4wJUmdtba2EhpmAE3b4wD6WLNTCStiVUUNhiuLyJajVxm9s4wGS5eHrtGJlTnuOGI3SnDUmK1sKgjO9BmuE3I+gPoT/ESzO8TQ937iLmhbcSxRnmSl9sK3GCue0EzjOEOwFeP8OMM/q3Nmn+1Xl0fgqdWHr9kHA7p/lkH5Qi3Arpnw6JlxQrX04KaVkR7hj8fk6yYmhsZDgdsHQmRsc53vaQrLFGtJ7g9RN01sIkjsaFAWlzmaW/3SHcbhGuDxnc2sYfapqPbeONO+hxjhkm4k12qo1OXXV96yTHG0RET+4QHW1jA01wqY/KLNmqpP3QcQoW8k6A8zTeuSssdZu40EfvDGG7S+NyKPawZgjOsRI3xVamNN5OExWnYB3BZlQ9P/SlLUwYYJebqMcv0M4szjeoJCNda2F9jfUV0SPrYAwmPoL1Fc4owjNXWDl2kuX/ukm+HNFYEc9GnTmypoHqmnM01mNsYAjO75AfaaG7YyIr97E3aqNSi3IOc2GT/KSw/X/luQAAIABJREFUUNfwK/apMosNfZRzqJ0+BAH+doSKU/KlCD1I0P0RjGPckSXUKCHK2wRbBn9zKHFDozE4h+k0IVz8TN33ZXHffffx2te+lhe84AW8/vWv5+TJk1y4cIH/+B//I6dOneJnf/Zn939i16hRo0aN5wQOjLNIkoR//a//NZ/+9KfZ2NhgbW2N173udbz97W8nDPd5DX2V0TxxC7f+6P8knhQN0RUGO6IjvPxKJd45sarqIyRrOSpVeH1NHjmpe3CsNA44Ol8xBF1wnngQpE3xdY9XJVI3XtY0tiyjNY03dvh9S9LRtC6KHcJ6CjO22EARdDOSZZ/GelxJGKWvfiUxxDkuLCSHRsEKQPTaSlVsAA0qLdxHLGAUTmv0KMY1ArAWlTucp1GZFUk5d8IKjJF2Sq+gYrtKCxaQZKJft1ak6DKhXRmPUMYnlNuUkmPjFBeFqCwX1jBOxbuolPyNlu+jMW6lXc2jat+5ai7V2JyTeZhin2lvphLT3xf9Vl7uZZ8lyv5m9y33m91/uq1yU2YnfSYpBL7MU6vKjuPWr4hkaS261RRvLWuFkaSZMKckERZSbnNOtjWb8nkcg9Fi0wGJSfG93WPyChbUamKPr4jn1saOMKcrW2IXynKyW4/hrfeg9C4zBntsleRYk8ajG7ItTau4Exd4qO0ebqmFGsYyx81t8ttPYTZ6lQQLoLoD8mMrmPMbsNSGcQKNgPRoC//RS2K3iuOJR1qWCUO0dvdvWSbjLtgpo7GwtuKac3ECp0/Aucuyb+ALS/M87Na2rGUxNxX40lZ/iMsy8bbTWjzvijWjFck8RmNU1MD2B+jVlcl1X8bgKCXn01rU8aOQW1wUwoXLqJPHYGsHOm3wDDby0Ze2sCePoAcxzjc436DPb4Dv47Z3UMePYs+eR3c62FHBLhshDEdkG5t4x49iuz1U1IAklWsoiqp5uMFQvAAL1q0CHzcc4Yp7XIUhLo5RYYhaWZZ4pvFY2koS8Dyu3PnFa88NFQQBP/zDP8wP//APH7RrjRo1atR4juI5m3dC5dB+0mHSggm0xDMg3MqILgc4LXaFqvJaajAjMAk4FP4IdCY5fhpXZHvQt+LTnFh0avAHFp1pTGwJeuD3MnRmULnD76boPMCMc8zIgVY4pdCZEj3vUAubQIsNoBTWfSM6cucgs6K7L1iH/ImeXWVW9ORFYkKVO1wpgZcS/7TkW0rluQOj5Hgf6bdkFSVKibVkE8ZM2iqkbqe1sJLMgqcr5uF88dJCIzp+pUQKVArne5WNAN+IuUYp1HAoElQxfzWIIfTF9WZqDs4rbBfjFBeInhacSHSeqewtE3YxJek7N4mdqNhF4QllreiBx6mM2YJK012/43tiY/HMZF4zzKIcn6yZ+O+XEejoYHJtNiMZezMSKbAco0khEDuLixOJWPcykXCDADcag9HopTYuzyvWoRqh2DqyDOV5Il3muYwvSdCXtiBNceMYFTXk2F4fcot3QaLZXZKKNw6gt7o0+iPYmSpcVETAK2vB81BXdsQTrbg+zJPrBROzqFECwxF4BrM9kH16ha1qNMIfJ3K9pKn8N1rmYq2MM03FK20q9oUiXsaV87JOjitx5mwVS+MGI0mto5SsRyFNy31Q6OjDQMZfjJk8FwncGNRoDFqjmhFuMET5PnZzS9rIMlSeSzxO4E/YxnAk52fLyfYrW8IAU7GHKCf3p3rsPEQRKk1RxmC7vWpe+vIGNkmwm1ty7Ras1I7FVmi7PVyR3QBncXmOHQ5RXhF3VFzzyphJ9gKQNSvWXnk+djTCZJkcPxqB0iithF3sg329oWrUqFGjRg14DjMLE1uWnkgwwwzra8LQEFwZoZKMzuoqWUPhjUUy1KnDGxiCgcUbWqynsIHC7yvGRxTNdSt5gPp5ETlrUQ7x2c4dOhbpwivqLkibFr+boZOpnCCFBKlSizcopMLcoseZ2BTSfCKdWosa5aJHT6iYh5piAMqWzCMXW4FvihQk+STLask2lMJhqiyuzhg5pmQxpYRkVRW5TDEWpxR6GFeSnNMapYsMrIV9AsRLynkG55livA60E7bkF1JO6f4FlVcHvi/SnnUoUzCisZ1IkFrJb6WHVZ5LK0VsBM6hyiw0njfZXh47va1EKZkmaXFOCgkwTaeYhysS7xR95RZsLkywEcixpV3BOmFQzoHviRSZ5ZV9xhVxEmrtSGW7caGHin1Z78Ku4cIANRyJfaJgZKrw9FKxeA1JnIkWL7O00OcDqi9SvAoDGU/JGKalzCxDra6IjcL3YTCQ44cO1emIJ1c8iZUh8CfsCCRGJQxFYjZm4vU2Gosuv1y7qCGsoZTik3QSD2OL2JiKURUxKUkC2sh8G2G1liq3IvX6XjUP5XtiqymkaJckqOUlGddwJJJ6FEG7Cb1+Ze+hEUpsTCtCFeuLK65K3xe20Yyqe0DpgjUPins3DHHDUWFbSoXVhSFupyusbTSGVgviGNUuvNtGY7EpjGNwGrfTFWk/z9GdDvlOF91sYofD6r/yfGw8BkAHwkrtOEYHATZJ8E4ex17ZrGxc1TPB83FZCkrjrKu2Ka2wSSK/AXm/L4yivC7swSkCD3xZ5HnO6173Ov74j//4GW3QnoXKHcH5HmgwxUXpAg/bCmleTLC+xhtmYjh2jrS1ROdM4UoG5E1xpQz6ATqRh7tObZEG2KKsj45zdGrQ4xy/Ly6r5A4XmKJd0IXx2RWqH5xDjTMsITrJUAO5IIgC1CipjJZCjQvjaBRMGafV5KViCzfWPJcHXSyqBHxPHhZ5PlFHKYUyeeVGqjw7MZTntjIWVmqBLJ88zD09CWQDeVCBUGXPQ42KF0mWodLieFf0X6pZygeCZ2RsiNst45j8xApmq3hw5DmuHaGSbPLAKm/q/lDUeZ0mqjeUtssHmXPyoAB5UOVWjoNCJeJB4MucE1F/2GaILtcfxCV3GE/WgEItluaTh16ZcLBwN6xeQp4na2RlmyofmkpJkKALZU3bDTmXRoGVF2b1gNWBOCi0JwZUnAOvLV9Lt95g6iGX5BNX48KV2Hm6cDaIUNtdGXMzkuNBVHhRQ9apN5DfrMM1JS2FKl2e/SLtSdSYOCVEjeIFbCqXYTSyNlCpW0rnBJX7sq6BL2tZXAuVUFTCKBFoPAOEcrzvyXiMkXMWBvKg9zwJ4CwST6rcouIYwgC33ELFbfmtLallypQxssYKF7Skfa9ZOTaotDG5Lsv1pXCZbviSuDLNJi/t0mW7UJ+qMJA1b4Ryjs3UfdcI5Rrw/cKd2qKyTNLXdNpoZ1GdNirP0a2mOD6UakbfEyHJ99HFi1r1B9BuoQNf1IPOVQk48X1RnTWKxJpJWgkjxjblJTuOsaMxyvfE2O17IgCMxrBPffQD1VDGGM6cOYMtJc8aNWrUqPE1h0OlKP+t3/otPvvZz/KzP/uznD59WqSDAlof+L75qqCzdJpvfum7SFYbVRrpdCnAaUXjfG+PgTJbbmB6iUjRmbz5UYq800ClFp1khQRfqFuKAC20FrVO4ZJaGbKcEzfDUVHLonAhdYGPSlJcM5ywikL6LNUtpaqFIKgS5TFLE8t9QST8RjiRxMtjSpfBUhouXRPLNBZlu3rKiF3+VqpVrBVpNgpRo1j+l+qXLCc71sG7JMZO14xE6ipVPOV1Ukr8s66tAFGD+KZlYWVKYUapsDrrMOMMG3qV6s10RzhjyDsBppdIGgxfV4Fj5f5OgYlzbCDOBnqc4nxDHprKoQHAehozyrCBRqcWGxpMPxX3ZE8kR2fEMcHflr5t5KHjDLM1xLZD9M4Q146wDQ9zaVvWoEh46FpNWasyXUjgF0F7qlJ/ERTnowzsixORxDNbsSPnTaTUyj0ZKgZRscLymi7djEvp2NrKdRqlqu1MOTxUbsKwS4Tc5a48i7Kd6TbK7aVUXbDpXUxi2qFCs2usu9yXZ/efHofWkySSnif3a+mMoJQ4Xhg1WZdZYbdwE5cLYarf6X0t8jwoXceLNlU2YeXON7vaLFWxu1zBSyeUUi0Jcs6zHNcK5blQnnOQ+7hg3QRBxT7VOBWWE2fYZijq52Ise86ZX7isl2NPElmfoGCy/aHcl0dWJo4jac566/6nVla1dJv90Ic+VG1zhR48Lx9MNWrUqFHjOYtDvSzOnFmsx3rGwijiY5EYq30Jt3dKXGXT1Qivn5AtFbpMpfA3hyTHW1ijMOMcnfroJMdsj3YZKgFxMRynuyRlVSaNQ/Sc5FaS4hXHlCkz1CiGRoDqjcQtrtMUG0iaY1thYXfQkObkKxF6mEpKg9yKjr0/mgTCaYfzPfA06WqEGWcTV9qC7ZQBfiKFeGSrTWlzGFcSkAs86b8RiKujc9jlJro3FGnEV2RHW+g4xBmNSkNhSllO3vTQq21UmpO3Q/TAKwIGLbYwfOs4FanMN5DmUv40FnfI9HgHvxuTLoXoNCdrBVLKNLHVZ3GDBLvWAiWSU3okquwC4kHrqv0BsrYvSdK0Ig8bU+7GhTHZCfvIIzGgWl/ckPO2D9NCbSZODOmK6PVxjqwjKdmd0ejQx4YGFHBiBRt6mMiH3JEvheg4w3kG04/JmwHeercylON5Yk8p+yqvpX6xzTlIldgXCluT80yhWy508SApVoyu2F51HRaM0Hkyt9K+oAaxSLSF7WvyX9xXXVS4+VqqoNEyIM4FRlK7eEYYbbEmpExYaWnrcE4k4UGCUmLkdmEA2gn70qayb6npIMuSCSsl0ncUioRfuo9bCnscE3derau0Hc4zlXOGGsbC5ku2ULpPF0FoeEbWL/QnDL+04xmN0+JSXTG8IsAVpXBOTX4zYqdxxpM+wwCVChMoWYsz027SCkJPzmmx3s4vNAGBJ+vuaTFglyymGQqLiHTFpGwoLuNO6yl7UXFfNPwJk2yGk99hYhv1zYQ5HqAlOtTL4rbbbpNrx1ouXbrEqVOnDnNYjRo1atR4juBQL4vt7W3e/e5385GPfATf9xkMBvzhH/4hDz30ED//8z9/o8d4TVCZQ2UOf5iTN+SN6Y9yvF7C8HQL52vyQJKBCZrEy5JmOGuaooiQJbAWp0WStEX6DT3ORVKNRR9tI3+X+2uVKqPUb5Zv/eINni9FeFsi0SfHmpIobJiJhNoppDoHNtDQ9tGpxYwy8sjDM4q8KVKzcg7ri2eJ9bUcXwUZWpynqrrfONBJjjOavOHh+QbnS+pylOjvdWZxfgeVWrLlAN+IZ40zGutpbBBU9hiBwQwzktVG1Z8NCo+b0gPNKHTqi5RbSlhKoWwDneRYT+Nf3CRIl1HdIfaIsBQ1GAtjidPCw8zDNcQl1Vvvkq+2q5QmemeICz1c6E/cgktvrNI10DdSFtU5bKdRpFe36EaAjtNd0pVKc/mulHhdOYc6JWkaVJyRLzfJmwUjaYh3l7KQR+JBly43JgynFaCsI18TzxzPuSKwL5QAsKR0zS0k94YvrLNkCmkmaTJswUxTM7ENFcFaGPGwIRuL66uz4jq51BTvLs/AOBEPHRD33yIFi0I8alTpXuwcalzq2q1I3HEqbTqHStRkvFBtR5tijIWkXvZTzJex2O7UqBhzEEy8yUo7ms132xJLKXgU77ajlW67akoi1qpaD5UwadNZcYeetpVN29LSVBhG6VVU9lt4/Kn+qPpdEj3a6tw4M9VnULjd+n4xBknmqLK8YFq5sI1ijqWdQaV55WZduldjDGqcCRO3Fp1ZYWVRIJ+VKjylChuppyvmpKrxT+aryuBJpSrH9TJNvrjdF+1M21/m4FDW6XvvvZfl5WUef/xxgsLn95u/+Zv5d//u3x3m8Bo1atSo8SzHoZjFpz/9ac6fP4/v+5Ve9dixY1y+fPmGDu6pQGU5jXNdVHeAW+lU3iqMY/Sx28giUwXW2VAKxQTdHKcnetqsabAnWqKrBpxfeDw1PZQDlYUSMGQ0bjlEJ7aS0k3JNHLRlVtfpB89zkk7Ps5rV9KsNQrb8SeeOiU7KNoTBhRI9ovlhjAGhRQ+UbKfGWWYQYKNAmygKx28SXIp1BIa8Q4q9JZZJ6j615nFG2ZYT5G1ijQaFrJOWDGTYGMgNomk8DJKRZIx2wOggw0N3k4ikrZS6FJn7QkrQSH6ZL/UnyvypofXT7GbW+g0xcUJOssqnbwexyKRpSk6lIRveAa305PYmW5PJKXcgpOkaiRFrMq0BGmK1CJxgnMW3fNxqQQu6VYkpVyVxjk7Sb9R+NK7wmvJgCQ+zHNMt4c+fgQ1TrFLkTAWI6njXaH7ziMPb2tY2KFybBG3Y1da4rFVMpfKxiSSuo08VLnOoYfKcindWjAekpR8OUK5BmZnJLaskikVSShLqTFvBfg7/YktQUtaDddpVrp24rRK3lfGd1Q2k2LOEqPSEAl4VNg7RkkVz1OlzJ5Kx2JbDbF5AflaG7Pexa600Jt9mWerUXlC2chHjbNJcGluJ20WHmKSWkRXpW13lcYFkdbbkcyrTNUCuOW2BCXmRVqY0KvGXtoCbKvwamv4E4+xwNuVdFOPUlkLUzCbMpYmDMSTqTuovN7yk0cwl7ckzmM0rjyRVFKk71darsfCDqq0kvZs4alUeS9OeSi6Io1K6b2YZZO20ikvsdITsYwzKtPcFDFRsihukngySas2VZLCyuJn6qGYxfLy8p6qeE888URtu6hRo0aNrxEc2nX2e77ne/iFX/gFrLU8+OCDvO997+Pee++90eO7diQp6tIVCbUfjDCBj+v1cdbSuDAQHfY4ES+e5YisFRA+fkUkjsAD58iXIuK1AOckxYfppcIurBSMxyiU0xXzyMNJIrk88nBaiR2gYXClGjjQ+P2MtO2hU4e/HYt0E3p4mwNcKFHGeBq9JQVp8rU2eUPYjPV0lSqkZC6mN0ZtdiFN0VFD/P6jENMfi1SRZti1DjYwmO1Rpf+3gUGPMvQoFsk2z8mPLUlKk0FCcqyJjqXsqrq4gVdI3dorSqUqhev2Kj08/SEmakgMSXdYxXLYlRZqlE4VGpL/Ngox59bJ0wy705MUDUXqBmddlYoAZyWNQilJ5jmsO1yRBA1nZf/ReGKnKD1bShQR5gDOGGEsAMOhfC7bKfssJVlXtLG5PUngZox4uliH7gZV+gdlTBFlbdHNCHa6mFCS/OmWSJnJHSeLOTl05oo4DsT/HWGJJQsEwNfYcHKbmn4stinABlIcxzYMuFDsRqawU5XtL7VQvZEwmoZfxQHoMJVrbqNPviweeXlLVMxewcxKG1DeDqtYD5VFwiL7SeFJ5ipbXslCTZyLXaxgGlnbx/riz+8VMRDZ6m7blmp4lacbzmF9U8TKaPQ4R8epZD7ohNKn3xFp36jK/pQdaaGTHD1Ki4SclqwTVvennHuNGYfkxRrq1FZjtaEn6xmIna7yoPM0qhXgdT1s4TmoMin4lZ6UdOzGmMoGYSMPvdIhWwoxwwA1SsUDsDecZBcovbOKtDFuqSXsxPMm9iArEeMYjWtMxWPEiaQkGScS91R6jhXJIHEFuyhtO6E/6bNk3dMpavwiu8L0/TIHh3pZ/ORP/iSNRoMf+7EfI01T3vGOd/AjP/IjvOc97znM4TVq1KhR41mOQ0VwPxuxrNf4pvCNIhmaIh9RIYGatVXRNfYlbbKKIsmpsrVdFA7RknCt3cIeWyFv+ph+LB4KRaSqCyXXjR6lqCTDRn5VgtT5pioFavpj8k6R6K3wSTc7I9LjHUw3ltxEgyG0mpPkbmX8wGAo44kauJU2qj/GHmmjtweTaNU4kSImRZETZYxIua2mpHsuE8mtLssaFGmuWV6StN6Doeji06Jg/LE10WOPRtiTR2V8zmHPX5xI+lAVWbGjMbrVRIUBtiwdOpObSrWaU5HoIt24OEE1I+zWdpUIrWITpTQ/nYNq+jNUCeTm7jO13+xxezDNHuZ9L8el1a59qrUoo+3LfrSqzoFLEkmRXaazBtyLbiu8irIqJbrzPDAKG3h4WwPy5agoYJXiQkPemJLplMLrCsvKOqHYrMY5zhebCQ6xl2mFt9EnPbmEGRQxRdN3emHTMWPxspNzM7HzlLapifsMOF2kx88d1isYtaKwyRmUdSKpR2ZXVHbpyVcVkUJypqncCbtNJXknSlhR2Y4NtIxZTcZWjqHyyiu261TsgpLoUxgJMLFBFLE65TxMnGO9ovjZbIR5sRYlQxL7kdmzPjgqlmfG2Z5sAmXcjxmmwuYGiWQfGE08J23gocs4l3FWJfq07Yac/4KJ581gsl9mySMZl9O6KJBm8K4MRStSzEX3x7jQF1vjOK2SjqI1ajDGNXyJhSoYEcAV9f88tQju//Sf/tPc7WEYcvr06SoOo0aNGjVqPDdxKGZx++23c/78eQDW1ta4cuUKAMePH+fixYu8/OUv58Mf/jAvfOELb+xorwJL6gjf5N0z2TAlMaogKKJDCx/3Qt9sx7FIkIVOG2PQK8tVYZkq+hMkC2Uzgl5fSjIGwcT7oRGK33mWiSdE6VNe/LnhCLWyhNvuAkhRmjKFMUwyWk5HjBelFFUzEgm+LD8JuCSdFDiBKvsoU9vwPJTWwiBA2iv0/67IWgvsylapylxGucUWKY1nURZZKVNGy1KrSXrkcj0LZrfrXBSFaar0yGXhljnpkqcl++m2D5NaeXa/wx431eEeBjPNgHYxj1l2M7Nm5tiafLBWznvBZMvsvG5UpCc3Wq4l34dOS3TwmRXd9/qWnLulNrYZoDeFkdrlpujTd/qy5js97PNOkXWCSu+PLry2Ckk3W2ngdcfY0Mf0RqjckZzoVLm6AMwwRcWidyd36GFMdrSNHqZiW9sZ4pohpHnl9w/iy29DD+/JDeyxZZGAQx/bMPiXegVD9yQivPDgsUsRKhPPH9tpoEYpthWKl1juqutUp0X0vQWnwfpG8ncVrF6Ke2m8rWFlvyjzaklWA4msxyjpa6WFGidVNgM1jKWvRiBR5M2QbFnyxKGVeDcC/uYQMku+2iw8KTX+1oi8GWAGMTb0yTqBMBlf2Ngk9sntzvEGu3KXAVXWielSv04XjLDhFfFLutJGTLdf2r+qPF1T/ZTMsbSllv1uD35/IbM4lDfUO9/5Tv7xP/7HbG9vc/78eba3t3nPe97Dvffey/b2NnfffTfvfve7D9NUjRo1atR4FuJQzOLYsWNcuHBBvGEKpGnKTTfdxPr6OoPBgNOnT7O1tXVDB3s1KJlFKfXtkiyni7nARAKckXxVWdwFJr7KVSNaip3E8URnPZXDvjqmZAkw8QnPcymTWerqC+l8WsKeHU85h6roi55EmbqCHczq1Wf19kqrSs9fSsa7+izWxhUsQHl+tU/JXBZJ+Iu+7xrTnHFJmcyp+U7/nz4/U/PY9/dFbcyu65z1mYuDxrYA1fmaWQvdbE5Y4BRznL5mSh/4kt2pdksYYMEsXbeHsxbdbomtrdsTRuh51X448RbTJ49jj62gN3Ym15914pWTJGQ3r+E9fnlS2jTLcCfWRPIu80CVsQLNSGIVhkMpoDQcyTjH40mcSlnzpix2FAa49Suopc7EG6ewD0phJ29ScwEmc48TmfdY6lQQNYo8UwX7zjJoN8VOo7Uwo3Prci922pN4jF5f5l3cxy6OUX5RtrbsK8vEbpmmlRbAlYWkAl88KpsRrCxVebhsEZOiL27IvJaXZHsjQF/elPUdS3xMfvNaZT/AOZwxlY3JDJIqc3XemdTUUFlRMMs5VFrkjot8zDCRmLGNnnhuhn51zeXNoLLLqMyKV9aoKAMbeJNSs1O50JR1k/gcpdhK/sNTYxatVovPf/7zu7Z94QtfoNmUFAbP1DTlNWrUqFHj+uBQBu777ruPe+65hze96U3ccsstnD17lo997GP883/+zwGJ8H7LW95yQwd6LSglZJezSxqc1u9DIQmXvvql9A3ARJe/V6LMYTis+pBSpnNemtl8SVRKLE503pDP6NWnpH5ySuViGYMg3/Pq+L16+WnWkBZScSntWlw2xZKm12uqTUqpf2r+e3T9zuKsXrjPrH1hz7ym2tnzf1aSn+fRdJht89qY3mfWG+qw7e3DMqprz+pd23bZaGbHNrPN5TnEtijBWdqnksrWZnv9yvbmklSk9KJcZ9Xf5jY6zSROpajRIpK02MA853A73Wo7iAQ5W7KU3ELh7eashStb4u1V2MFcoXt3RfS9VG6UGh4ujmHHibeeLjKpjiRK3BX2rJIZV3EuxfXn0kzaGY4mdjHnRJrvD8Se5/uYRojd3pFTWEZKFzYx2Thhbk6Pi7EyabO0+yklc0oSOQejsZwPJ2WKXZqhfA9dZAu23Z6sWeHhp6MGdntHxlxG/7ci2NoRu2YcC0PzfbHXbBfnMI7xRkuVXaLykCxtnYNhFatjAh+30xNbYeBLlbskwWuEk+hvQDdDyW1W1scoq/0pBSstTG8k38sqhLmFI3Mv5+q6OBBvf/vb+dznPsedd97Jzs4OL3rRi3jwwQd5+9vfDsB3fud38pu/+Zv7tvFHf/RHvPjFL+aOO+7gAx/4wJ7fH3jgAZaXl7nrrru46667uO+++6rffvmXf5mXvexlfN3XfR3f933fx3g83nN8jRo1atS4cXha4izyPOdFL3oR999/P6dPn+buu+/m3/7bf8tLX/rSap8HHniAD37wg3z84x/fdey5c+d4zWtew8MPP0wURbz1rW/ljW98Iz/4gz+4b59L6giv1v/d1Q10P1vBzH/5ee/nWf397H77bVs4nsOMuxjvPM+deZLwrv4XSfHzJN6yn2sZ06L5zEruc2IdDo15NomrPfapYt76F9vneWZNY/Za23eMZXvTTHnq9zJuRQW+sI/ptgvWoEu7G0zsWWXeoMJON+862WNjm517+dUYbJKgC9ajvCJHVpLsGsssXJ5Xx5TzLOc03TYg7KKI+SltbRVTKddmwT0xbcfbl8VOe8AVa+RKr8FpD8oyrmbqPOtGWDGS0j6JKWqYjyc2GNUGnFXVAAAf1klEQVRsVrFJLk3RUYRzVvJ55bnYWpJkl72zYkxQ1foGJscniTDJIBC7VPm8akZyTZS15AOJ8t54wV88tTiLzc1NPvjBD/IXf/EX9Pv9Xb999rOfPfD4hx56iDvuuIPnP//5ALztbW/jox/96K6XxX7IsozRaITv+wyHQ2666aZDHVejRo0aNa4PDvWy+P7v/37iOOatb31rZdS+Gpw7d45bbrml+n769Gk+97nP7dnvwQcf5BWveAU33XQTH/zgB3nZy17GzTffzHvf+15uvfVWoijinnvu4Z577tlzLMBv/MZv8Bu/8RuTDbPS7WEwI104qyf/meii5fPMfuyWfKr9pm0m83T/+43toMjjeV5B8/TxM1LurB1nbp/z1m+RN9FBnxd9XzSva8W1soprxby+FtlDZmwYssnNveYWMc/K5uMsKFfZoSbYbY9zeQ7JZBw2LdhFJu3YIpOutK322PNKZjFhEhOJfT4z3u2V5zJbzcVZB1m6e+6Ay9KKJUy3aZNkEqnv9nrYTdvdqnxi5diKY+bax5jYJF2+d9s0pm1tNinnlk+8+JB7qbTxlLYPN22OSxLZlontsNp32mbprOQpm4Lt9XbNqWSHZTzT1EJKu0m6y8vRlsxwyo41PaYqV5p1qJKp7INDvSz+9E//lPX1dcLSLe4qMU/TpdRuiv3KV76Sxx9/nHa7zSc+8Qn+3t/7ezzyyCNsbW3x0Y9+lDNnzrCyssL3fu/38ju/8zv8g3/wD/a0+a53vYt3vetdgKihatSoUaPG9cGhDNwvf/nLOXv27DV3cvr0aZ588snq+9mzZ/eokpaWlmi32wC88Y1vJE1TNjY2+NSnPsXtt9/OsWPH8H2fN7/5zfzpn/7pNY8F2CvRztPNT+k0K+lxavuu/aY/T2/bz89/dt/DjLlsb/p/2ebV2hHmjX96jNP9zmtjut/95nuYMc2Ov/w+O99FmN5/+phF6zKvv4OwaP/DMKVpzLteZtuZthPMYJrZAhMmsIjNFPtMx8pUUv7M9VdJ+vlEcp54FE5J0jPxNNNzmWYd1V8pVRft7ZrDTJu72ivGsouZTLUx3c/0HFzBXub1M9t++X2PfWiq/11rM6fvSvrP0j1rgbPYKSZQrqMt2caUxO/yHFvYJyrmVhxfnT83xRacncx16vvs52q8U+26ON59nou+98OhmMW3fdu38YY3vIEf+qEf4uTJk7t+e8c73nHg8XfffTePPPIIZ86c4eabb+bDH/4wv/u7v7trn4sXL3LixAmUUjz00ENYa1lbW+PWW2/lz/7szxgOh0RRxKc//Wle9apXHWbYNWrUqFHjOuFQL4s/+ZM/4fTp09x///27tiulDvWy8DyPX/3VX+X1r389eZ7zjne8g5e97GX8+q//OiBlWz/ykY/wa7/2a3ieRxRFfPjDH0Ypxatf/Wre8pa38MpXvhLP8/iGb/iGStV0aOynU573fWq7y+dvr7BIR7+oj0W6/ykJtNJXzzKRw3gqlW0vwmHsDPPa2K/NKQ8rYGIPWWQ/mJ7rVMT4nnas2zWeRZ5De6e4e/tC+8wMW5B1X+CtNXsuFmFOP+Uc95zXXYep3fOd7X9e+7PXz7xxzfY1s+9c21nxe7Vuc/oobXkyt8nv1RzmjHmhHaa0V5ReSTNrMM+TsBrDnO0w8dSqrq/9mOSsDXF6nwPGXgwEMLvmvytbwtRn7XvYIgPDZIy7r9lpO4vSavc1rvQutlXadKZtPvOyLOz6bc51stD7bnpJnqspypfUEV6tXnfjO9rPoHuY4w77spjXF8x/UBz0spg+dlG714DJyyJfPL+D5jrdzoKHxGQqh31Z5Iea18IHwmHP74I+9rhd7/eymIdFwsn090XXwNWc76u5ztT0y2LOnA56WUy1t+dlsR+m9z/ABXlPn08BB52f2QSYV/eyMLteALP9zmzY/bIo2j7oZbGvO/bUcZuv+PJTc521dvEN8jWf6mOexDnvBj4MA5mWzg7T76J2Fz3c5rGFRQxo3kPigBu5Gve0lD7VvlyoZtf+ex4Q0xLt9HjYK0nu6nMfTEv2845f9HKaGvjez4vY3T4vgYUecOU5P2yb0w/o6TEdwJ4qz6J581o0z2oO8xni5CW4+5qfm+tsQV97WMCCa63sZ55wMfug3vecHoalz2E3C18YU+tQ7juXJRa2iul7fJEH2uz6VN5Tzu4dR7HvLIuYHf/sPA687mdwqJeF53l7vJdK5LMTrVGjRo0azzkc6mVx5syZXd8vXLjABz7wAb7ru77rhgzqGYFFdH8eDrJPzNtnus1FTKP8vqjvaYlykb56+vfpPhaxhXl6+dnjFrU/9X9a/zzxkFmg/z3seu2n6pheD65OgrpqNcV+0ugC3f7s+PaMeQ7DXHS97ZHEOZy6ZdYGdCBbLOcwzfQWMb6Zc7grcrroaw8znJnzLnYyvU8pOc/WRS+Pm7GRzWOrFcrxTH/fTwuwa7j77zu9TtMqx2rec9j6vFiteXMpYzTKtqevr1n15h52NnP97RlXNb/9r59DvSxmK+Hddttt/PZv/zZ3330373znOw/TRI0aNWrUeBbjUC+Leeh2u6yvr1/PsXztYFaSPkCSXCgBLmI0sD9b2a+dw+47T3Kbx0DcjEfZtAQ5b6wHYT8pfaaN2ej7A8e/H/bTcc+2M2895zGIw3yf7nN2XWcy2s5tZ5GBet5+M7/tsnHM0/MvYJxz9fDz2tjV2T4sedH1Oa+Nw9xLszjM9befnXFOHwd6Uc6u3UHznmGrk8j2fRjbIpZ2Nff7FA71sviBH/iBXTaL4XDIZz/72blR1DVq1KhR47mHQ70s7rjjjl3fW60W9957L3/37/7dGzKorxoOsh3M7nM9cTXS/yIcRrKabe9q5nKtbGV629XYgq62/UX7LBrL1fa3SCo+7PFw+Pkuuv4Osm3sJznu1+9cHf3Euw1n95fKp37bZUPY7z46zLgOg4PY00E4LLu72jEcZBuZPm62rf3O2zRzOcS+e77vdz73waFeFj/90z99VY3WqFGjRo3nFha+LH7rt37rUA0cJoL7WYPD6DOvJ6u43izlqbKFg8ZzPcZ6GCnuWnCjGN/1xvUe441az+m2DntNLPC+2VdXvp831tWwsHlS/I3AvPtlkWfZYRnK1bKv6XWdd+/uN8bZ9q+HzeJDH/rQgQcfNt1HjRo1atR4dmPhy+Izn/nM0zmOrx4O0vPfSGn1mSAJXwtreiZK8U/HeK61j6thb08HDqPjv5b74iDd+SKPn8N6ii3AHq+tG4nD2gf2s2Ecxm4wu+/sGs1eT4tY23W02+3DAcXr6X3vex9vetOb+Jmf+Rnisvh5jRo1atT4msK+L4sf//Ef52Mf+xh33nknH/nIR3jve9/7dI3r6cO16Pm/1jFPP1tjMW6UzetaMS2J7jeeRZ4605+n/w46dvq6mT7uqayJmonYvprr8jpdw4tqYeyq91H+P+xcZ8/RonO23714na+1fbPOnjp1ij//8z/n1KlTPPnkk3zrt37rntQfz1Q8bVlnv1bxTFCn1Lhx2M+4usg4vWi/2XZnH3DX6vI6297VtnOdruE9CRqLthcGJ17Hvq93W1uvPLMw6+y+r9bBYMCpU6cAuOWWW9jZ2bkuA3rGoJaOrx31i+K5j1lJ+CBvn4NiJ/b7/Vqvp0WePoc99jpgUbT6vrmW9rNVHOa5dD3jVA6JfeMssizjM5/5TFVDe/Y7SBW9GjVq1Kjx3Ma+aqjnPe95C1OTg7jOPvroozdkYE8VtRqqRo1D4CB10X7fYa9kX3yeW3NjHhNZ5CV0PeZwo4+dbWPefK6ln2tQqc1VhV0D9lND7cssHnvssafceY0aNWrUePajVtrXqPG1jKv1hpo9doE0XWZErdpZxCrKY56KkfupeOddD33/orEf1v4we8w1GOqvR+nYg1C/LGrUqFGjxoGoXxYHofaYqlFjvv59lh1chb9/FYNwLdL3fn1cS1vXu//ZuIjp3w/q+1q9up4Gj6j6SVijRo0aNQ5E/bI4CF/r8QTXi1k9Wxjas2WcTxfmRUbvl+fpMG3B7lxOT8VecUA/h8L18Iaa9YBa9H0ek9iPXc1GzO/3+w1GfWfUqFGjRo0Dcc01uGs8i3E1Utz1kvaeLQzt2TLOpwPzvJlms5wuyhg7jf32OczxV4Ovxvk7yOur3OdaMls/g67HmlnUqFGjRo0DUb8snsm4UfrIZ5C0UuNZgCnJeVeG1Xm1FGazyk4fP2+faZvF1eCZbFuaXaer8XCatV/MrtVB+bluIJ7BK16jRo0aNZ4pqF8W1xvXU+J5NjKAZ7LEV+PwWBBxXdWOWFS/YlaKnucVNC/ye7adqx3fVxsz86oiqqfnvYgxTGNRfMYidrKonRuA+s6uUaNGjRoHon5ZXG880ySepxtPJZL2q4Fnyzi/GlhUM+GwEcqztoxZNjFv7Z+N98+c+cytnrdovQ6KsdjvGr3eMSr7oL5TatSoUaPGgahfFjVuDJ4tEuKzZZxfDRRSqzLm6hjYrAdP2da8z9N9TR/7VPDVYIszc5pXF1wZI2tZfJ533MK1O6jvpwH1y6JGjRo1ahyIp+1l8Ud/9Ee8+MUv5o477uADH/jAnt8feOABlpeXueuuu7jrrru47777qt+2t7d5y1vewp133slLXvISHnzwwadr2M8O1Hr3G4OD1vW5vO5TXkxVbYpZHfqsd8+sx89BeZGm9yl/v1YpeZF9ZVG/Nxoz3lFlJbsyJ9bCqnaHyeJbtj/9+WmY49OS7iPPc37sx36M+++/n9OnT3P33Xfzpje9iZe+9KW79vuWb/kWPv7xj+85/j3veQ9veMMb+MhHPkKSJAyHw6dj2DVq1KhRo8DT8sp96KGHuOOOO3j+85/P/9/encdEdf1tAH/QKcqmLLLJsIOCKAhiIDG1VgW1UtxIS4sWFVEsVsWlbYJWq7UqlbTa2lqjdcOKiUmBilAVLZiCuEBRwSo7MoqK7CACw3n/8Od9YZhhZnDgDvj9JCTeuct57iBz7rl3zjmampoIDAxEfHy8QvvW1dUhLS0NISEhAABNTU3o6+v3Ztz+Rx2upAYiNblXzAvJloS0nsQdR0zt+A0pyatiaffeJXs5S67vSV7JrKo4rrJly2gpdXmG8To91nnqxd0nnyoikQiWlpbcslAohEgk6rJdRkYG3NzcMGvWLOTm5gIAioqKYGxsjCVLlsDd3R3Lli1DY2Oj1HIOHjwIT09PeHp69s6JEELIG6pPKgvGus4Pq6HR+arCw8MDpaWlyMnJwWeffYa5c+cCANra2pCVlYWVK1ciOzsbOjo6Up95AMDy5ctx48YN3LhxQ/Un0dve9J7fbzJ1bglKazVIrpNGVj+CDi0RmfftX0cfzRrXieTIsh1zyPrdKpJR8njd7dvdiL4q0if/S4VCIR48eMAtl5eXY+TIkZ22GTZsGHR1dQEA7733HlpbW1FZWQmhUAihUAgvLy8AQEBAALKysvoiNiGEkP/pk8pi4sSJyM/PR3FxMVpaWhAbGwt/f/9O21RUVHAtkGvXrqG9vR1GRkYwMzODpaUl7t27BwBISUnp8mB8QKDWgOr19RV7T8vrq9+9svm6G01Wst9Ex+063JPn+hN0PKbkFffr3MvvqA/HSZJatqzxrl5Rpre1ZGtF8ty6e04pa5vX1CffhhIIBPjpp58wY8YMiMViLF26FC4uLjhw4AAAICwsDGfOnMEvv/wCgUAALS0txMbGcreqfvzxRwQFBaGlpQV2dnY4cuRIX8QmhBDyPxpM2gOFAWCYhiG8NKb1TWF9NDaL2lHn81bnbOpKxrd5XvUR6HbbbvbvtAzIHpFWVfn5+N3LGl1XMpvksjItDWnbq/icqz2KZT7zVeMna4QQQtQFVRaqoC5XsH19r1Zdzlsadc6mrmS8Z9zcDJLbdvfd/47Hk3zO0XFZVfhuVch6viOLouM+ydpP0ddViCoLQgghclFloQ5U1SKgq2miKtKu1LvrOSxr9FRp6yTv66viW1CSvcpf1+v0sH5Fsp+ExqCu3w5T9NjdtSjktfBUhCoLQgghclFloQ6oRaB+1LlXtTyqyC5r/CcZZUntT9ExS8f+F5L9NFSdXRV68jfZ8TmEtOcnivZal2wpyGqxSdunFz9L1OQ3QwghRJ31Sac8PrTrtKDaqZjvGEp7+vQpjI2N+Y7RI5S97/XX3ABl50t32UtKSmTuN2ArCycnp345oKCnp2e/zA1Qdj7019wAZedLT7PTbShCCCFyUWVBCCFErsFbt27dyneI3jJhwgS+I/RIf80NUHY+9NfcAGXnS0+yD9iBBAkhhKgO3YYihBAiF1UWhBBC5BpwlUVycjJGjx4NBwcHmXN1q6MHDx7g3XffhbOzM1xcXLB3716+IylFLBbD3d0dfn5+fEdRSk1NDQICAuDk5ARnZ2dkZGTwHUlh33//PVxcXDB27Fh89NFHaG5u5juSTEuXLoWJiQnGjh3LvVZVVQUfHx84OjrCx8cH1dXVPCaUTVr2jRs3wsnJCa6urpg3bx5qamp4TCidtNyv7NmzBxoaGqisrFT4eAOqshCLxQgPD0dSUhLy8vJw6tQp5OXl8R1LIQKBANHR0bh79y6uXr2K/fv395vsALB37144OzvzHUNpa9aswcyZM/Hff/8hJyen35yDSCTCvn37cOPGDdy5cwdisRixsbF8x5Jp8eLFSE5O7vTarl27MG3aNOTn52PatGlqe3EnLbuPjw/u3LmDW7duYdSoUdi5cydP6WSTlht4eWF64cIFWFlZKXW8AVVZXLt2DQ4ODrCzs4OmpiYCAwMRHx/PdyyFmJubw8PDAwCgp6cHZ2dniEQinlMppry8HImJiVi2bBnfUZRSV1eHtLQ0hISEAAA0NTWhr6/PcyrFtbW14fnz52hra0NTUxNGjhzJdySZJk+eDENDw06vxcfHIzg4GAAQHByMuLg4PqLJJS27r68vBIKXfZq9vb1RXl7OR7RuScsNABEREYiKiuKmrVbUgKosRCIRLC0tuWWhUNhvPnA7KikpQXZ2Nry8vPiOopC1a9ciKioKgwb1r/9ORUVFMDY2xpIlS+Du7o5ly5ahsbGR71gKsbCwwIYNG2BlZQVzc3MMHz4cvr6+fMdSyuPHj2Fubg7g5cXSkydPeE7UM7/99htmzZrFdwyFJCQkwMLCAm5ubkrv27/+uuWQ9i1gZWtPvjU0NGDBggX44YcfMGzYML7jyHX27FmYmJj0y++ct7W1ISsrCytXrkR2djZ0dHTU9laIpOrqasTHx6O4uBgPHz5EY2MjYmJi+I71xtmxYwcEAgGCgoL4jiJXU1MTduzYgW3btvVo/wFVWQiFQjx48IBbLi8vV+umuaTW1lYsWLAAQUFBmD9/Pt9xFPLPP/8gISEBNjY2CAwMxKVLl7Bw4UK+YylEKBRCKBRyLbiAgABkZWXxnEoxFy9ehK2tLYyNjfHWW29h/vz5SE9P5zuWUkxNTfHo0SMAwKNHj2BiYsJzIuUcO3YMZ8+excmTJ/vFRWlhYSGKi4vh5uYGGxsblJeXw8PDAxUVFQrtP6Aqi4kTJyI/Px/FxcVoaWlBbGws/P39+Y6lEMYYQkJC4OzsjHXr1vEdR2E7d+5EeXk5SkpKEBsbi6lTp/abK1wzMzNYWlri3r17AICUlBSMGTOG51SKsbKywtWrV9HU1ATGGFJSUvrNw/lX/P39cezYMQAvP3jnzJnDcyLFJScnY/fu3UhISIC2tjbfcRQybtw4PHnyBCUlJSgpKYFQKERWVhbMzMwUOwAbYBITE5mjoyOzs7Nj33zzDd9xFHblyhUGgI0bN465ubkxNzc3lpiYyHcspVy+fJnNnj2b7xhKyc7OZhMmTGDjxo1jc+bMYVVVVXxHUthXX33FRo8ezVxcXNjChQtZc3Mz35FkCgwMZGZmZkwgEDALCwt26NAhVllZyaZOncocHBzY1KlT2bNnz/iOKZW07Pb29kwoFHJ/qytWrOA7ZhfScndkbW3Nnj59qvDxaLgPQgghcg2o21CEEEJ6B1UWhBBC5KLKghBCiFxUWRBCCJGLKgtCCCFyUWVByAAQFhaG7du390lZL168wJgxY7jOXIsXL8amTZtUcux169bhwIEDKjkWUS2qLIhK2djYQFNTs8vQx+PHj4eGhgZKSkr4CabmuvvALSsrg66uLvejoaEBHR0dbvnKlSs4cOAANm/e3CdZDx48iMmTJyvemUsJGzduxI4dO9DS0qLyY5PXQ5UFUTlbW1ucOnWKW759+zaeP3/OY6KuGGNob2/nO4ZCrKys0NDQwP0AQE5ODrf89ttv92meX3/9FYsWLerRvm1tbd2uNzc3h5OTExISEnp0fNJ7qLIgKrdo0SIcP36cWz527Bg++eSTTtu8ePGCGzXV1NQUYWFhXIVSXV0NPz8/GBsbw8DAAH5+fp2GgD569Cjs7Oygp6cHW1tbnDx5EgCwdevWTuNSlZSUQENDg/uAmjJlCiIjIzFp0iRoa2ujqKgItbW1CAkJgbm5OSwsLLBp0yaIxWKunEmTJiEiIgL6+vqws7NDeno6jh49CktLS5iYmHDDVcg7p7///htCoRDR0dEwMTGBubk5jhw5AuDllfrJkycRFRUFXV1dvP/++0q/5x1bJq/KioqK4sqKi4vDuXPnMGrUKBgaGuLbb7/l9m1vb8euXbtgb28PIyMjfPDBB6iqqpJaTllZGQoLC7uMiFxdXY3Zs2dDT08PXl5eKCws5NZpaGhg//79cHR0hKOjIxhjiIiIgImJCYYPHw5XV1fcuXOH237KlClITExU+j0gvYsqC6Jy3t7eqKurw927dyEWi3H69Okugwt+8cUXuH//Pv79918UFBRAJBJxo2G2t7djyZIlKC0tRVlZGbS0tLBq1SoAQGNjI1avXo2kpCTU19cjPT0d48ePVzjbiRMncPDgQdTX18Pa2hrBwcEQCAQoKChAdnY2zp8/j0OHDnHbZ2ZmwtXVFc+ePcPHH3+MwMBAXL9+HQUFBYiJicGqVau4q/3uzgkAKioqUFtbC5FIhMOHDyM8PBzV1dVYvnw5goKC8Pnnn6OhoQF//vlnj9/7jmU1NzdzGUJDQxETE4ObN2/iypUr2LZtG4qKigAA+/btQ1xcHFJTU/Hw4UMYGBggPDxc6nFv374NOzs7bi6HV06dOoUtW7aguroaDg4OiIyM7LQ+Li4OmZmZyMvLw/nz55GWlob79++jpqYGp0+fhpGREbets7MzcnJyXvs9ICqmyrFICLG2tmYXLlxg27dvZ19++SVLSkpi06dPZ62trQwAKy4uZu3t7UxbW5sVFBRw+6WnpzMbGxupx8zOzmb6+vqMMcYaGhrY8OHD2ZkzZ1hTU1On7bZs2cKCgoK45eLiYgaAtba2MsYYe+edd9jmzZu59RUVFUxTU7PTcX7//Xc2ZcoUxhhjR44cYQ4ODty6W7duMQCsoqKCe83Q0JBlZ2fLPafLly+zoUOHclkYY8zY2JhlZGQwxhgLDg5mkZGR3b63rwBg+fn5nV7ruP+rstra2hhjjNXV1TEA7OrVq9z2Hh4e7I8//mCMMebk5MQuXrzIrXv48CETCASdsr4SExPDvLy8upQdEhLCLScmJrLRo0d3ypuSksItp6SkMEdHR5aRkcHEYnGXMs6fP89sbW3lvxGkTwm6q0gI6alFixZh8uTJKC4u7nIL6unTp2hqauo0BwZjjLv909TUhIiICCQnJ3PzMtfX10MsFkNHRwenT5/Gnj17EBISgkmTJiE6OhpOTk4K5eo4OVZpaSlaW1u5CXiAl62ajtuYmppy/9bS0pL6WkNDg9xzAgAjI6NOV+Ta2tpcq0TVjIyMMHjwYLm5gZfvw7x58zpNXjV48GA8fvwYFhYWnY5rYGCA+vr6LuV1fNgt7bw6vqdTp07FqlWrEB4ejrKyMsybNw979uzh5m+pr6/vVzMWvinoNhTpFdbW1rC1tcW5c+e6zM0xYsQIaGlpITc3FzU1NaipqUFtbS33ARMdHY179+4hMzOTm/oU+P/JrWbMmIELFy7g0aNHcHJyQmhoKABAR0cHTU1NXDnSxunvOO+ApaUlhgwZgsrKSi5HXV0dcnNzlT5feeckD5/zIVhaWiIpKYnLXVNTg+bm5i4VBQC4urqiqKhI7oNqSZLnt3r1aty8eRO5ubm4f/8+vvvuO27d3bt3ezSTG+ldVFmQXnP48GFcunQJOjo6nV4fNGgQQkNDERERwU2lKRKJ8NdffwF4eWWppaUFfX19VFVV4euvv+b2ffz4MRISEtDY2IghQ4ZAV1eXu4IeP3480tLSUFZWhtraWuzcubPbfObm5vD19cX69etRV1eH9vZ2FBYWIjU1VelzlXdO8piamnLPEPpaWFgYIiMjUVpaCuBly0/W3PVCoRCOjo64du1aj8u7fv06MjMz0draCh0dHQwdOpT7HQJAampqv5mm9E1ClQXpNfb29vD09JS6bvfu3XBwcIC3tzeGDRuG6dOnc5MQrV27Fs+fP8eIESPg7e2NmTNncvu1t7cjOjoaI0eOhKGhIVJTU/Hzzz8DAHx8fPDhhx/C1dUVEyZMgJ+fn9yMx48fR0tLC8aMGQMDAwMEBARws7cpq7tzkickJAR5eXnQ19fH3Llze1R+T61Zswb+/v7w9fWFnp4evL29kZmZKXP7FStW4MSJEz0ur66uDqGhoTAwMIC1tTWMjIywYcMGAC9nzMvLy+vz94DIR/NZEEKU8uLFC7i7uyMlJaXT8x5VWL9+Pezt7fHpp5+q9Ljk9VFlQQghRC66DUUIIUQuqiwIIYTIRZUFIYQQuaiyIIQQIhdVFoQQQuSiyoIQQohcVFkQQgiR6/8AtPbKH/UBDfoAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax1 = plt.subplots()\n", + "ax1.set_title(\"Peak tracking\", fontsize = 14)\n", + "ax1.set_xlabel(\"Measurement Time (hrs)\", fontsize = 12)\n", + "ax1.set_ylabel(\"Plunger Gate Voltage (V)\", fontsize = 12)\n", + "ax1.set_axisbelow(True) # pushes grid to background\n", + "fig.set_facecolor(\"White\")\n", + "\n", + "len_x = len(tracked_peaks[\"time_axis\"])\n", + "data_cut = np.transpose(data_raw[node_r])[:, :len_x]\n", + "ax1.pcolor(tracked_peaks[\"time_axis\"]/3600, data_raw[gates], data_cut)\n", + "for tracked_peak in tracked_peaks[\"tracked_peak_positions\"]:\n", + " length = min([len(tracked_peaks[\"time_axis\"]), len(tracked_peak)])\n", + " ax1.plot(tracked_peaks[\"time_axis\"][:length]/3600, tracked_peak[:length], color = \"r\")\n", + "#fig.savefig(os.path.join(savepath, \"peak_tracking.png\"), dpi = 400)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-12T14:34:51.062006Z", + "start_time": "2022-09-12T14:34:51.040011Z" + } + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'remove_jumps' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mpeak_no\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mdejumped_trace\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mremove_jumps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracked_peaks\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"tracked_peak_positions\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpeak_no\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5e-3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0msaver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"{node_r}_peak{peak_no}_trace_dejumped\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdejumped_trace\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtracked_peaks\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"tracked_peak_positions\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpeak_no\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdejumped_trace\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'remove_jumps' is not defined" + ] + } + ], + "source": [ + "peak_no = 0\n", + "dejumped_trace = remove_jumps(tracked_peaks[\"tracked_peak_positions\"][peak_no], 5e-3)\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_trace_dejumped\", dejumped_trace)\n", + "plt.plot(tracked_peaks[\"tracked_peak_positions\"][peak_no])\n", + "plt.plot(dejumped_trace)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-04T14:45:14.695642Z", + "start_time": "2022-08-04T14:45:13.152080Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-14.227767080950168\n", + "-2.983231237223958\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "type_of_fit = \"bilin\"\n", + "if type_of_fit == \"lin\":\n", + " fit_func = linear\n", + " guess = [-1, 1]\n", + "elif type_of_fit == \"bilin\":\n", + " fit_func = bilinear2\n", + " guess = [-2, 1, -1, -3]\n", + " \n", + "sampling_f = tracked_peaks[\"time_axis\"][1]**-1\n", + "noise_calculator = AnalyzerTimetraceSpectralNoiseDensity(dejumped_trace,\\\n", + " sampling_f, fit_func = fit_func)\n", + "\n", + "noise_calculator.welch_segment_length = 300\n", + "noise_calculator.guess = guess\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_welch_segment_length_dejumped\", noise_calculator.welch_segment_length)\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_fit_interval_dejumped\", noise_calculator.fit_interval)\n", + "\n", + "spectral_result = noise_calculator.analyze()\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_spectrum_dejumped\", spectral_result)\n", + "saver_overview.add_info(f\"{node_r}_peak{peak_no}_spectrum_dejumped\", spectral_result)\n", + "\n", + "fit = noise_calculator.fit()\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_SNDfit_parameters_dejumped\", fit)\n", + "saver_overview.add_info(f\"{node_r}_peak{peak_no}_SNDfit_parameters_dejumped\", fit)\n", + "\n", + "f, s = spectral_result[\"freq\"], spectral_result[\"spectrogram\"]\n", + "saving_path = os.path.join(settings[\"file_info\"][\"savepath\"], f\"{node_r}_dejumped\")\n", + "\n", + "plotter_SND = PlotterTimetraceSpectralNoiseDensity(saving_path, [f,s], fit)\n", + "plotter_SND.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-04T14:44:51.295056Z", + "start_time": "2022-08-04T14:44:51.283082Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'popt': array([ -3.13346752, -14.22776708, -1.04706232, -2.98323124]),\n", + " 'cov': array([[1.46591041e-01, 4.95146684e-01, 6.62740958e-10, 2.77174613e-02],\n", + " [4.95146684e-01, 1.68926684e+00, 2.27044854e-09, 1.01669378e-01],\n", + " [6.62741827e-10, 2.27045147e-09, 9.83040160e-03, 4.28267557e-03],\n", + " [2.77174613e-02, 1.01669378e-01, 4.28267557e-03, 1.11725527e-02]]),\n", + " 'fit_range': [5.547893813049984e-05, 0.019417628345674943],\n", + " 'sigma': array([3.82872095e-01, 1.77132290e-14, 9.91483817e-02, 2.52965129e-04])}" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-23T12:07:16.530839Z", + "start_time": "2022-08-23T12:07:16.101296Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sigmas: [0.1371519 0.29667078]\n", + "Fit params: [-6.50419589e-01 8.54793336e-08]\n", + "Bounds lower: [-0.78757149 -0.2966707 ]\n", + "Bounds higher: [-0.51326769 0.29667087]\n", + "Fit params: [-0.65041959 1.0000002 ]\n", + "Bounds_lower: [-0.78757149 0.5050441 ]\n", + "Bounds_upper: [-0.51326769 1.98002589]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def func_power2(x, *params):\n", + " if len(params) == 2:\n", + " return params[1] * x ** params[0]\n", + " else:\n", + " part1 = params[1] * x[x <= params[3]] ** params[0]\n", + " part2 = params[1]/(params[3] ** (params[2]-params[0])) * x[x > params[3]] ** params[2]\n", + " return np.concatenate((part1, part2))\n", + " \n", + "sigmas = np.sqrt(np.diagonal(fit[\"cov\"]))\n", + "\n", + "print(\"Sigmas: \", sigmas)\n", + "print(\"Fit params: \", fit[\"popt\"])\n", + "print(\"Bounds lower: \", fit[\"popt\"] - sigmas)\n", + "print(\"Bounds higher: \", fit[\"popt\"] + sigmas)\n", + "\n", + "original = fit[\"popt\"]\n", + "bound_upper = fit[\"popt\"] + sigmas\n", + "bound_lower = fit[\"popt\"] - sigmas\n", + "\n", + "for index in range(0, len(original), 2):\n", + " original[index + 1] = 10**original[index + 1]\n", + " \n", + "for index in range(0, len(bound_lower), 2):\n", + " bound_lower[index + 1] = 10**bound_lower[index + 1]\n", + " \n", + "for index in range(0, len(bound_upper), 2):\n", + " bound_upper[index + 1] = 10**bound_upper[index + 1]\n", + " \n", + "print(\"Fit params: \", original)\n", + "print(\"Bounds_lower: \", bound_lower)\n", + "print(\"Bounds_upper: \", bound_upper)\n", + "\n", + "freqs = np.linspace(1e-4, 1e-2, 1000)\n", + "\n", + "plt.plot(freqs, func_power2(freqs, *original))\n", + "#plt.plot(freqs, func_power2(freqs, *bound_lower))\n", + "#plt.plot(freqs, func_power2(freqs, *bound_upper))\n", + "plt.fill_between(freqs, func_power2(freqs, *bound_lower), func_power2(freqs, *bound_upper),\n", + " color = 'black', alpha = 0.15)\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-03T15:50:33.512157Z", + "start_time": "2022-08-03T15:50:33.449755Z" + } + }, + "outputs": [], + "source": [ + "saver.save()\n", + "\n", + "ovw = saver_overview.additional_info\n", + "\n", + "saver_saver_overview = Saver_json(overview_path) #Save your saved data to be safe\n", + "analysis_key = f\"{bcv}tg{tgv}vr{vr}side{side}\"\n", + "\n", + "saver_saver_overview.fname = saver_overview.fname\n", + "saver_saver_overview.append_to_file = True\n", + "\n", + "saver_saver_overview.additional_info = {analysis_key : ovw}\n", + "saver_saver_overview.save()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T10:04:06.758690Z", + "start_time": "2022-09-15T10:04:06.738274Z" + }, + "init_cell": true + }, + "outputs": [], + "source": [ + "class Plot_formatter:\n", + " def __init__(self):\n", + " self.fig_facecolor= \"White\"\n", + " self.axisbelow = True\n", + " self.title_fontsize = 14\n", + " self.xaxis_fontsize = 12\n", + " self.yaxis_fontsize = 12\n", + " \n", + " def format_fig(self, fig):\n", + " fig.set_facecolor(self.fig_facecolor)\n", + " \n", + " def format_ax(self, ax):\n", + " ax.set_axisbelow(self.axisbelow) # pushes grid to background\n", + " ax.title.set_size(self.title_fontsize)\n", + " ax.xaxis.label.set_size(self.xaxis_fontsize)\n", + " ax.yaxis.label.set_size(self.yaxis_fontsize)\n", + " ax.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## with errorbars" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:28:38.404391Z", + "start_time": "2022-09-15T12:28:38.379372Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['0.0tg0.703vr0.703sidel', '-0.5tg0.442vr0.129sidel', '0.25tg1.429vr0.699sidel', '0.75tg1.104vr1.104sidel', '-1.0tg0.212vr-0.209sidel'])" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample = \"P35B4_post_analysis_wjumps2\"\n", + "fname = f\"{sample}.json\"\n", + "\n", + "overview_path = \"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\"\n", + "\n", + "loader = LoaderJSON()\n", + "ovw_data = loader.load(os.path.join(overview_path, fname))\n", + "ovw_data.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": { + "ExecuteTime": { + "end_time": "2022-09-15T12:28:40.657339Z", + "start_time": "2022-09-15T12:28:40.156217Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0\n", + "-0.5\n", + "0.0\n", + "0.25\n", + "0.75\n", + "[1.1074864086875394e-07, 1.5738048009669492e-07, 7.843926372053899e-08, 9.816732413453718e-06, 4.471046976622739e-08]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "class bias_cool_plotter_werr():\n", + " def __init__(self, data_dict, y_maker, sample, y_scale = \"log\"):\n", + " self.data_dict = data_dict\n", + " self.y_maker = y_maker\n", + " self._build_x_axis()\n", + " self._build_y_axis()\n", + " print(self.y_axis)\n", + " self.fig, self.ax1 = plt.subplots()\n", + " self.ax1.set_title(\"Total noise power vs bias cooling\")\n", + " self.ax1.set_xlabel(\"Bias Cooling Voltage (V)\")\n", + " self.ax1.set_ylabel(\"Integrated Noise Power (V²)\")\n", + " self.ax1.set_yscale(y_scale)\n", + " self.ax1.set_ylim(min(self.y_axis), max(self.y_axis))\n", + " self.ax1.errorbar(self.x_axis, self.y_axis, self.y_errs)\n", + " \n", + " self.set_dpi = 400\n", + " self.pf = Plot_formatter()\n", + " self.fig.save_as = \".png\"\n", + " self.pf.format_fig(self.fig)\n", + " self.pf.format_ax(self.ax1)\n", + " self.fig.savefig(os.path.join(overview_path, f\"{sample}_integrated_noise.png\"), dpi = self.set_dpi)\n", + " \n", + " def _build_x_axis(self):\n", + " x_vals = set()\n", + " for key in self.data_dict.keys():\n", + " bcv = get_bcv(key)\n", + " x_vals.add(bcv)\n", + " self.x_axis = sorted(list(x_vals))\n", + " \n", + " def _build_y_axis(self):\n", + " self.y_axis = []\n", + " self.y_errs = []\n", + " for x_value in self.x_axis:\n", + " y_value, y_err = self.y_maker(self.data_dict, x_value)\n", + " self.y_axis.append(y_value)\n", + " self.y_errs.append(y_err)\n", + " \n", + "def integrated_noise_power_fit_werr(data_dict, x_value):\n", + " print(x_value)\n", + " tgv, key = extract_lowest_tgv(x_value, \"l\", data_dict)\n", + " if not tgv:\n", + " return np.nan, np.nan\n", + " elif \"sliced_SND\" in data_dict[key].keys():\n", + " mean = data_dict[key][\"sliced_SND\"][\"integral_mean\"]\n", + " sem = data_dict[key][\"sliced_SND\"][\"integral_sem\"]\n", + " return mean, sem\n", + " else:\n", + " return np.nan, np.nan\n", + " \n", + " \n", + "bcp_werr = bias_cool_plotter_werr(ovw_data, integrated_noise_power_fit_werr, sample)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## all samples in one plot" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-31T14:23:31.841972Z", + "start_time": "2022-08-31T14:23:29.528542Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax1 = plt.subplots()\n", + "ax1.set_title(\"Total noise power vs bias cooling\")\n", + "ax1.set_xlabel(\"Bias Cooling Voltage (V)\")\n", + "ax1.set_ylabel(\"Integrated Noise Power (V²)\")\n", + "ax1.set_yscale(\"log\")\n", + "ax1.set_xlim(-0.5, 1)\n", + "\n", + "all_y_vals = []\n", + "all_y_vals.extend(p35_b1_y_axis)\n", + "all_y_vals.extend(p35_b3_y_axis)\n", + "all_y_vals.extend(p35_b4_y_axis)\n", + "\n", + "ax1.set_ylim(min(all_y_vals), max(all_y_vals))\n", + "ax1.plot(p35_b1_x_axis, p35_b1_y_axis, label = \"P35B1\")\n", + "ax1.plot(p35_b3_x_axis, p35_b3_y_axis, label = \"P35B3\")\n", + "ax1.plot(p35_b4_x_axis, p35_b4_y_axis, label = \"P35B4\")\n", + "ax1.scatter(p35_b1_x_axis, p35_b1_y_axis)\n", + "ax1.scatter(p35_b3_x_axis, p35_b3_y_axis)\n", + "ax1.scatter(p35_b4_x_axis, p35_b4_y_axis)\n", + "ax1.legend()\n", + "\n", + "plot_format = Plot_formatter()\n", + "plot_format.format_fig(fig)\n", + "plot_format.format_ax(ax1)\n", + "\n", + "fig.savefig(os.path.join(overview_path, f\"AllSample_integrated_noise.png\"), dpi = 1200)" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-31T15:15:29.664830Z", + "start_time": "2022-08-31T15:15:29.457957Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[-0.5, 0.0, 0.75, 1.5]" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p35_b3_x_axis" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-31T13:51:02.747899Z", + "start_time": "2022-08-31T13:51:02.734233Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[-1, 5]" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "min([[0,3],[-1,5]])" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-31T13:54:28.716182Z", + "start_time": "2022-08-31T13:54:28.704762Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-4.0, -0.5, 0.0, 0.25, 0.5, 0.625, 0.75, 0.875, 1.0, 1.5, 2.5]\n", + "[-0.5, 0.0, 0.75, 1.5]\n", + "[-1.0, -0.5, 0.0, 0.25, 0.75, 1.0]\n" + ] + } + ], + "source": [ + "print(p35_b1_x_axis)\n", + "print(p35_b3_x_axis)\n", + "print(p35_b4_x_axis)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Initialization Cell", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "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": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "384px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/qkit/analysis/semiconductor/scripts/Peaktracking_analysis.ipynb b/qkit/analysis/semiconductor/scripts/Peaktracking_analysis.ipynb new file mode 100644 index 00000000..c7d44af7 --- /dev/null +++ b/qkit/analysis/semiconductor/scripts/Peaktracking_analysis.ipynb @@ -0,0 +1,1280 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T12:47:34.420162Z", + "start_time": "2022-07-11T12:47:34.379989Z" + }, + "init_cell": true + }, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T12:47:41.743709Z", + "start_time": "2022-07-11T12:47:34.421969Z" + }, + "init_cell": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QKIT configuration initialized -> available as qkit.cfg[...]\n" + ] + } + ], + "source": [ + "from qkit.analysis.semiconductor.loaders.Loaderh5 import Loaderh5\n", + "from qkit.analysis.semiconductor.analyzers.AnalyzerTimetraceSpectralNoiseDensity import AnalyzerTimetraceSpectralNoiseDensity\n", + "from qkit.analysis.semiconductor.plotters.PlotterTimetraceSpectralNoiseDensity import PlotterTimetraceSpectralNoiseDensity\n", + "from qkit.analysis.semiconductor.analyzers.AnalyzerPeakTracker_Daniel import AnalyzerPeakTracker\n", + "from qkit.analysis.semiconductor.plotters.PlotterPlungerTimetrace3D import PlotterPlungerTimetrace3D\n", + "from qkit.analysis.semiconductor.plotters.PlotterPlungerTraceFit import PlotterPlungerTraceFit\n", + "from qkit.analysis.semiconductor.plotters.PlotterPlungerTraceTimestampsDifference import PlotterPlungerTraceTimestampsDifference\n", + "from qkit.analysis.semiconductor.plotters.PlotterTimetraceJumpsHistogram import PlotterTimetraceJumpsHistogram\n", + "from qkit.analysis.semiconductor.main.SlicerPlungerTimetrace import SlicerPlungerTimetrace\n", + "from qkit.analysis.semiconductor.loaders.Loader_spectrum_np import Loader_spectrum_np\n", + "from qkit.analysis.semiconductor.savers.Saver_spectrum_np import Saver_spectrum_np\n", + "from qkit.analysis.semiconductor.savers.Saver_json import Saver_json\n", + "\n", + "import os\n", + "import matplotlib.pyplot as plt\n", + "import pathlib\n", + "from qkit.analysis.semiconductor.analyzers.AnalyzerPeakTracker import Analyzer as Peak_hunt\n", + "from qkit.analysis.semiconductor.analyzers.AnalyzerTimetraceJumps import Analyzer as jump_count\n", + "from qkit.analysis.semiconductor.main.fit_functions import gauss_function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Choose the Data" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T13:55:57.674313Z", + "start_time": "2022-07-11T13:55:34.650050Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Specify current bias cooling voltage in V: 2.5\n", + "Specify current top gate voltage in V: 2.864\n", + "Savepath: /V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/20220223/190224_2D_Peak_tracking\n" + ] + } + ], + "source": [ + "#date_time_string = \"20220212/231040\"\n", + "date = \"20220223\"#date_time_string.split(\"/\")[0]\n", + "time = \"190224\"#date_time_string.split(\"/\")[1]\n", + "filepath = f\"sftp://tp1435@os-login.lsdf.kit.edu/kit/phi/projects/nanospin/SEMICONDUCTOR_SYSTEMS/data/{date}/{time}_2D_Peak_tracking/{time}_2D_Peak_tracking.h5\"\n", + "savepath = os.path.join(\"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\",\n", + " str(pathlib.Path(filepath).parents[1]).split(\"/\")[-1],\n", + " str(pathlib.Path(filepath).parents[0]).split(\"/\")[-1])\n", + "overview_path = \"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\"\n", + "\n", + "configpath = \"/home/ws/lr1740/Dokumente/Doktorarbeit/Sonstiges/sftp_config.txt\"\n", + "\n", + "saver = Saver_json(savepath)\n", + "saver_overview = Saver_json(overview_path)\n", + "bcv = input(\"Specify current bias cooling voltage in V: \")\n", + "tgv = input(\"Specify current top gate voltage in V: \")\n", + "saver_overview.fname = \"P35B1\"\n", + "saver_overview.append_to_file = True\n", + "\n", + "print(\"Savepath: \" + savepath)\n", + "\n", + "settings = {\"file_info\" : {\n", + " \"filepath\" : filepath,\n", + " \"savepath\" : savepath,\n", + " \"analysis\" : \"plunger_sweep_timetrace\"},\n", + " \"meas_params\" : {\n", + " \"measurement_amp\" : 100e-6,\n", + " \"voltage_divider\" : 3,\n", + " \"IVgain\" : 1e8,\n", + " \"in_line_R\": 40e3},\n", + " \"authentication\" : {\n", + " \"configpath\" : configpath}\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T13:56:02.557700Z", + "start_time": "2022-07-11T13:55:59.793841Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done loading file, formatting now...\n", + "dict_keys(['demod0&4.r0', 'demod0&4.r4', 'demod0&4.timestamp0', 'demod0&4.timestamp4', 'demod0&4.x0', 'demod0&4.x4', 'demod0&4.y0', 'demod0&4.y4', 'gates_6_16', 'measurement', 'number', 'settings', 'static_voltages'])\n" + ] + } + ], + "source": [ + "loader = Loaderh5()\n", + "data, _ = loader.load(settings)\n", + "print(data.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T13:58:24.776999Z", + "start_time": "2022-07-11T13:58:24.762278Z" + } + }, + "outputs": [], + "source": [ + "demod_prefix = \"demod0&4\"\n", + "demod_idx = 0\n", + "node_timestamp = f\"{demod_prefix}.timestamp{demod_idx}\"\n", + "node_x = f\"{demod_prefix}.x{demod_idx}\"\n", + "node_y = f\"{demod_prefix}.y{demod_idx}\"\n", + "node_r = f\"{demod_prefix}.r{demod_idx}\"\n", + "\n", + "gates = \"gates_6_16\"" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T13:58:26.285770Z", + "start_time": "2022-07-11T13:58:25.269029Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEJCAYAAABGw1qNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOy9e6wlR3U++lVVd+99zpkzfmDseBiCzSVhDPEDMCRckCGxbIKEiOxIAWMJW4YYFJJYiUJuJEQUotjYf6AoElIci0cwkUBEgUCIcYiILd1wpdhOeAjZEEMYfjY2Y4/ndc5+dHc97h+rVtWq3vvMDHg8McxZ0tY+p7u6urr23uurtda3VqkQQsC2bMu2bMu2bMszIPp/ewDbsi3bsi3b8rMr2yCzLduyLduyLc+YbIPMtmzLtmzLtjxjsg0y27It27It2/KMyTbIbMu2bMu2bMszJtX/9gBOtpj1NVRnngnoAAQACkAAlCGSHXHtFJ1DeQ4AglN0Db/rAHgFqPgeAOWB9dNmAAAXVLxQwWgPDY+Zq3FmPQUArOkWDtRm4sdY03MYBMxDHa/XOOLG2GFa9MHABY3WVxjrHloFtK6GjfdwXsN5WjcoFeC9BgJgKg+FAK0DtAqwXsM5jeAVlA4IXtHY4/PCBDrea4CfPQB1Y+McKQQoKATUxgEA5n0NpegeI+1gg4JWAZ2rEALgnUZVO1hr8rwD0NrDO53v7RVU7WlM8ZieKwQD6D5/XgsSAO2BED8K+Hhcx+Zq8RLtYnsfEBR9nirQMb6Pr+jzROxD2fQnggaUC3k8WgGe/kn9aJUeTbuQxhe0eA4FQCn68qk40NjP0uflY/yuFZQL1OeSeVEB8JWCtiH3rfJ5Gm/8/sd5KPo/hqRrtVreftAPt19o6+NE83mei6KDwd/Bp8uh4qTyXLLwvHJ/4Sh9DdrU6w779+9f9tjHLW/41TU8dcAds91Z574ed99999O617NRTjmQqc46A+f+PzcBYwf0GogKbXRaCwCwnUHwihQsUJzzTqHfbKB0ACYVKeCxA+aGFPNcQ/cKZq7w+iu/DgDYsCPq1xuc0UyxVrX41qFz8ZZdDwAAfnnl+9jwDQDg/5v+Av7v1Yexrjs82J5L1/sxvnLgArzm9O/i0e5MTOwI3908C3t27sNIW3xv87k41I0BAAdmqzi8sQIAGI0sppsjBKdw2pkTVMZjvWmxUvd4arqGQ5MVdBsNmvUO3UZDzwAQeK73aNZ6dD9aBdZ7mgersfv5TwEA5raCdRqV8di9fhgA8NC+c2C0x/pKixfsPIhD3RirVY+9h86AdQaTw2OcffYRPPnUOkKvoWpSDqs7WkwOrhBYtwboNKrnzmCndZr/nQ/W6E4DVp4AggHU4PeqHAHB6IiHqxVMH6A7UhK+UfBGwdf5Ou6D21dzD9coBE3XulohVAQos7M0qnnsyyiMD1In2gF2RaHe9FBRefuRhpm52I+HNwpuxcRrgdFhC28UtAuwKwbKBigf4BuNYCJQGFJyuqX5CZVK/SvPz6ShbEjn/Eij3rSw8V7F3NgA03vMz6gxPkifpZlahErH+1gEo6HbuICoNPyogrIeodLpvHK+6DeYjGh8rVtrFtoHoxf6UTb25UqU0Ru08IKNSF5F9WQM4Nzyv9s2dzAa0bmmBro+H7eW+mroO5XOLeuL7xnH8ORZ/+/CnP648tQBh/v+5eeP2e5Vb3p6YPZslVMOZLTxUL2COs3BeUWLyMrDdgZV4+B7jZX1FvNpg7BRA41HXcUvYgXYeZyyNUuWAK/2a49Qe4TDNVyTfzw/Nz4CAPjRfCd2jQ+hVg4HZqv45ZXv43/6s3C6dgA6/E9/FsaKvvyP2NMx1vT3Q/Nd2D9fw7qZo/UVvrt5Fo60BCqtr7BadTjUjXF6M0fvDA66NQDA5PAYwWooHTBrCcSMonHtP7gDK6sdWq/QTWqg11A9KTe/RnZVt9FAW4UQrRrUHrWmedh0DUaVw6Rt0HlSbP28AsYWq3WHM5opDnVjfPeps1AZh9mU7t9aQxaSDmQRxnGi14BT0Kd1cLM4v72GWrXQOsCNayAAbkTKutmgJsEAvgZQk5VjxwQorlGohPXpazrHFolyQGiAegKECuh3kML0UcH3OxTqzQA3UtBCV7kxrdZDBegZ9W/HOoGUbxQAmg8GhDQGBrtGwwNwjQIahWrq472BaBTCG8Cv0phMRyCSvr8RfOyqhukIaADA1ToBFPcBAJUNcLXObSoF3XmyOtLYMjiFSsM3OvnRGSTkeYDmQXcOodKwzSieU1BWwzcGyusEVEEr+FFWNQls4Is+ET/XpeDCIsANRue26ZgZvGvRl18851z+X/Y17HdbfmI55WZSKSDUIYFLNbaw0xpV42A7g2ath/OaVthTmp62pffRyNJqe+RoJe5UnsEpWTZBkyNprWoxsSNMoiUDAIftCg50axhXtEp6pDsTrxs/hYfdKua+xjzU+K/ZeVg3c5xupum6s8aTZMUcacfYbBsc6NYwtQ02bYPTmzkA4OBsBX6TVmt6Rw/vFYJX6OcVxqsdDbNv4PuBX8UpqOieUjMDfWZcma4rKKfgWwM9cui9Qe/oB/mc1Qn2H9yB5jlZCRjtMe0btL5CpT1m0wYrqx0BWpzD4BWC1dAjuq4eW3QgS4ldZHXt4FYtwkaNMHbwhgDGEVahW6f3iHnQlgCHjgXYsQLmBCwsvsmWjNIESgQKSNZF0IAbRaU9UvT/mCxYgK7vd8S/LfVfzQMBRuzHm0BuOK1gV3W6h6tLq4aPW2hoR/9rB3Q7NKpZthpcPO4N9emj0tQOCVRcHT+ngSFjuiDAKB8noIxjHlX0d8fzRP3bFQPtAhCtJoUMQGxFBa8LsKLrTbqHX62gLFltpo8WXxXBR4BFsnykpWGMAIHYNlkdEmhMCRQRFJXzJcCYZb5ELIIR9zUEt6chHgFt6I/d8GdUTjmQYWFFa+dVUsSmdugmNVbWW1KKtYcZuRwzAKBWLZQO0MbD9jWq1R6uNwgmACMHzDWggUenZ+D/2vEkHp+fBgBYr1o8b3Qw9nIWnnRr2G/X8YgLyYIBgLHu0QeDOjr/a+XwfzbOwIt37EPrK/z8+kH855Hn41C3gv2zNazWZMn0zpDFEhWibw0wqaDWLIJTmE8baB0wbnoCSgCq0+SmApCGMAp0bTwfAChH7sPNaBHN2gaPHdkJAJhaUgz12KLvDbACTG2DWU/H10YdNmYj2HmFan1GczfKP+C6cujaMfQqjdOsWKyOO8wOj1M8KBjAjwNwmJ7NxLHa1Txu1wC6U8kV5qO+0i6gXyPA8PHbrqM3ht1o1TwkQAomWhkI6bxbpfZVC/ho8dkVut6OgdqS6wwg5dqtKFQRSDiGgzqCgQ/JqgEANBQ+cjW19TUQWpVAQVmgW1EwLVlWpiXrK1h61xFA7FgXQEL9s8VCz1eNMoCwO09xzChaEwwg3EfQCsqQWy9oRVZRTVZLFduYaF25WkOZAO1Cej4txhNqjXpi4VYrsqaqoyt+AgtD7/FUiCCV/i6u00v/DqNFNadaizCq6HrpCpTgti0nRE45kAkBCI2Hiqt8VdEXTOkA1xtUYwvnNeraofe06q/GpCkq45Kbx0OjWu2hTYCdK6D2wEYN3ZOiW606TOwouZP4/Xmjg9i1dgbmocb3p2eh36nxSP8cfG36AgBA62vs73fgu/ocAMDu5gDmtsJT3Y4ELP28wtTW6J3BFA1W6w7/54kzo/uOlaWGtgq+1wgmoFlr4b3C4Y0VqLlG21YwUw1nAlSvUM3iqvi0kNxXDFjoqA/rDGbTBtp4HDlMmpctGwbp1hps2gbTvkHwCi4oIiN4hemcjoWNmmJZAKabI6D28C250nyvsTEdJ/CjDwcIOsDXcYxskfQRgGIz3wBmTuDDnwMcWS1uJLpzZKFgA8kKcY2CckgWjTeK2gDpXcfrlANMx/dW6HdEJWooNhR0do+BQ12NQjULsCvC9SViEnzeG4VQCaJJFYFHM7hFtx9bLQ0BlIlAwtYa38u0FOchKytbfxwvMi2BjV/JFoiUUCnAkoXDwBEqcknqjkDIRfDimBSDE0CfjR9p6NYnoPJGJQsJANxIw7QZ7EorRCMYA9XaBWskGJPjO2m81L5o41xxTDmHMKoQmgrKdgvWD4PbiZKAgDbYYzf8GZVTDmSkJICJ76Z2sPMKK+st+j7GD6xGv0kreDuy0JEooI0ngIkutvbwCMqEGMCl1fzOag4rQOaH7Rnpb7ZeHu7OwXfbczCxI+zv1vBz4yP40XxnGuPEjrAxHaP1FfbP1nBouoIwrfDYYbKQKuMwtxWBidWop9H/jrjK72h1aTsDNIA2AaFVsPOK9FSnk6sMAFlkIOsFJtB7Q/PTWwPfa/jWJAvu4IyIBmz9WGcw62tszEYUywG50arVPjHfsGoTm83UDnajprkDoOYGZr0lN+ZGDP6bDBpmDkTiHVwDVJPoKotdMwmALRlvFOxqBIdo9WhDQMDWix3Hvh3Q7YyKuqe+7GkUuwEAE2PMukckCpBLSgozvFxNipjPB5MBwosYku4jsJkMKHycxyb7UC6y2jzQrynUkwiQPp5jUBNuP742aAXbALUjtxu5IUuXlyQT0PwRnnmvEkEBoOemWIsmhl1sq4UrDgACIrgB6HeYRIpgq6eYuwgQysRYTlMBiISEaI0EY0oQqXR2wbFlZBTgQNe7kNuz9ehiPwNLapnFsy1PX065WQ2R7qtqnxhkvGrWhkClnVOMhim+fL63cbXnFFATE00bD6M9tRs7hF7BVzngv1qRs3t3M8HEjvCqnf+D+558Af7q0SuwWnX4bnsO/ntCVsvUNvjRfCf2z9dQ6bxC6+cV9s3X0TsD7xXUnMbdthV6YwhAQPEUE33roc7WSajJausmpHlHMwUHwERqcDXJbh01M5k1N4nWzigAKy5dDwB2WiN4BevyvYMOaNsK9WkO7bxOMZb5tEGYVqhOa4EDDcKaI1cdAKvJkmK3HAC08xp+syZLjNHDk/XgVoBqkw4ZEOCoHnC1sFD4szYAelLKrgFi6Ar9DurP1wxguT272lhZQyyU2RpSLl/DFhBbOK6JczoLhaViugC7QoDhGkUAOQvwNZKFlqwhV8aTeCySVccAF3TpEqwnIZ0Pht1ZdB9mzLlIOPCruojP0L1UtHzI6uHYT9CqiAEhsvIkYYGttKDJLVjEkgSYMRFBgpsbaVQCPPJ4DGAUAkwGCSnMGGRQcoHAQ1oiRgEuJPKB/FxCihGVFo/CqWt5nGg5KSBzww034Itf/CLOPvtsfOtb31o4f/DgQdxwww343ve+h/F4jI997GP4pV/6JQDAeeedh/X1dRhjUFUVHniAqL8HDhzAW97yFuzduxfnnXcePvOZz+CMM844rvGYFUsB8pEjBlakMtvOJKuGg73BK+hIt+0js6xZ69HPK9RjS7TmnmjPasYrppCskTOaHMDfsCPs60/D3FY4Z7yB72+eif1jcoMdbsfY6EZ44WkHcHi+kq6Z9TVCrzG1NSZtQ7GVVhE9uc8B9GDJP53AoifgMB0FdbvVCuiICWdaABs1qikpX2XJQgCiuweKAKZVpNxbBWeiC63T1CaSJzigT4BA+TDsKvOtwcFDazTOqYGPLK7qUJUUp3c1lFcwhzXcqkeoY0zIKVQThX49wI1ppc9KPmSsgzdAPQdsRefrTaAf0fP4hpS/thE8+OOZ03P7BtBdtj686JetAkl9dmOyanyTc2eCzgpd9/kaC5VYbNxuKAwCrPS4jV1RaSx07xw7YgsoSbxfNSeg4dgQWz/VPKT+2H03OuzhR0RKCJ1KLkMABTBwKNL0ZNnw8VBRX8oT+BSAqHPcCdHaCRUABvKBpZTu23oCk4rYd/y3ci69A0RUkHRrBhOVSAEqvZOVE29QIdOwjQTVbOUESGA6cXnqHsA8nLoxnpOS8X/99dcfNcnolltuwSWXXIJvfvObuPPOO3HTTTcV5++55x58/etfTwADALfeeisuv/xyPPzww7j88stx6623Hvd43Cwq3GlFq+eOXEC+18kdZqc1lCPWTogvAMkFBBDoeKfhekNtedUb265WHfbN17Fvvo4fzXfCeoMfteTm2jdfx4HZKh6dnoHOk9tp3tUp52XSNpi0DTa6EdRGhcPzFXJXtSYF4gEk95WeGGirYOakRNmiASLwRHBQfQYOsg4UTJdXrfUGAZG2Cr6OimqiUoyGYw5wFP9xvaHn7wH0Gm5WYW4pPsOJnsEriqkcbqA89avnCnpO/VUTokrrnvrk2JJukY4plwGU0Iz+TBTjEFlb7CYbvEvx0b2mHAFGELrF10iuJyCCh8svKcEgxWEk2YCBRlpV8m8gu+sYaNyYLIxEWOijW25MK2/l6Xy/Rm20C+kdyNemV1Sk3B8vInyd41Bs1UhxtRpYGIosF2TLQ9l4/8G1GSzFNRGQXK2or0YlwJKfB4MOs878qCLm28jQMQkMVaZVh1G0dARZgPsIRi9/xeu539BUJU17ZIp7PJvkhhtuwNlnn50W4QDw/ve/HxdddBEuueQSXHnllXjssceWXnveeefhwgsvxCWXXIJLL730ZA355IDMZZddhjPPPHPL8w8++CAuv/xyAMCePXuwd+9e7Nu376h9fv7zn8d1110HALjuuuvwj//4j8c9Ho436FanGAR6Ck77zRphSowzXrkHSy8AiYmmdEiAo3QAnIq+cvoxVNrhifkOdN6g8yYlY7a+wnTekOUyHeOxyU7sfepMdH2Ftq0w7Qlc2jb+P28QNOWY+Ah6pgUlT84NMcV6iqvouYLpiX1lZiKWMAfMTEG3ipJFO1LspiPXk5nTap9ZV2ZTo5pQW76f8oBuNXSrYGYKplUw0wjOrUE1VTAbBIDTeQN7YAy1UaVYjW4VdKuhevrbdASEulX5M4nt1MyQdRMVI40zxikC6FurM6hIhcWAEWLcxQlLJNTxZaIF52IQf57dXQlEwS4pasv06XQfna0dfte9oEmLd+4XYMZWaQlR/s1yYOT4jzzmm+xaS//X9KwMfAxeZHGUVlnQGQDy83AQnywPfhHAhQQaQAk83E+okIAkxCoJDEJMDSdSBV1LxIj82VECbFTsJoOaBB0+zwDE7i8GAz+qirye4btvDHxjCrBJ/SaiAcewytjP05GAgP44Xscjyxbs733ve/HNb34TX//61/GmN70Jf/7nf77l9csW7M+0PCug+uKLL8ZnP/tZAMB9992HH/zgB3j00UcBAEopXHnllXjFK16BO+64I12zb98+nHsuZcWfe+65eOKJJ47rXiEgrcKDDpQXYglMEquq9mSZ9MI6AXIMB9mCSOVP4irfV2QF7J+vwXqNI+04JU9+fzMD7UY3gu0MDmyuou8N+t7ATmsc2FzF5OBKshD63sDMFGZtAzutoacmKmdNr6mBnhrURyifQvlyJV5Fb51yCqaLFoKNSpaD0JbcRrrLbekh4/8RGFRPlk81i/04ojmrTqf7mQ2D2cYIGDuYKZ3Tk2jpObacyJWnLFBN+TgDH4EYQGBZTVRW8JpcYqqPY3J5hc5cVlbgDDCVCNazBWS6SCAwQvn6xXiOTN6U8RBf5Wt1x+yvMpbDit2NM4gU30Pxv+5pPMpHWrYr3XBp/HEsfH8+xp+b6ekcU7W3subIukBS9uziUj7AtILxxrTqpgQYJipwZQQJZkCOAwH0GZM1GArrppwLun8wFLdxa00ElJJeHYbsspjkGYwmi0Ycd2tNBlOtUn/00ilJNMVkKp0tGLaclsWA/pdl2YJ9505BFJpMoNSza9zPisD/n/zJn+Cmm27CJZdcggsvvBAve9nLUMWM269+9avYtWsXnnjiCVxxxRXYs2cPLrvssh+r/zvuuCMDVCALhdlKCURiWZhQk4un2hBfWpeBBLUnRtSUqLfSlQaQxQBNSY+rdYe5pefgXJaD3SraeY2mtuRaiuQC35Jl0q+abEUBQE2KuJ3UUBsV9JzcXHpO1oBdIQZYMNGNERWO5ppbHqinFDBHyEFa0xEA8UpfKrGqJcVQcVzKxNhOPI+QmVZmmn/4Zq7gxoHckH10gbU6UoORnoncYHFKq9hXVPK6ZVdPVlJaBOGZOgxECnMM/LMrTVoJ6fOL7rHkMhKBdAkMTH+W5wphl36b2wwlaPoMkmXEVtQoApMv3XNFqRufGXAy2M/PlIC8zfeSbQFhMdUoqhUsG6/yMc9Gq+QK7FYia64PJWhYyscJGnDsNvNlTInygOgaTmY1R1mhS4vKRcvCjTTqjT4ldVL1gFDmx6TriF4tc2hoXCGf75giXX4plPWw6zWqmcsWEdOXJVPtBMT/Q1CYh2Mr/ieffLJwY91444248cYbj+se73vf+3DnnXfitNNOwz333LO0DS/YlVJ417veddx9P115VoDMzp078fGPfxwAEELA+eefj/PPPx8AsGvXLgDA2Wefjauuugr33XcfLrvsMpxzzjl4/PHHce655+Lxxx/H2WefvWX/8sManbc7xi4U7FpIP2pOSlO9ApyhH30P8t3Phb8WFSwqBBOg5gYYU/a/nilSeE4hICRwsTF62juD3lMOCR03UDMDj3hNjEn0mw3MRgW/Sr/63mpUDgiWcgl0XPVzzIUZZEDplmHrhBRJVNY9KR8zF3TcaA2wojCzzJbSLtKE54DdEcHBAUXxyXm0OqJlUE0U3HqAnmqyWKakRKopijwNHr+vqT+2ZiheBABZYemWx0j35GuVB6yhFTyTAbSllTy7+JJLqxeB/x6wgllm5hlQkhtLKH1W4tU8WyiSLiznnS0jdsExqFfT7MKTbraUV8NgH+NEDIh2FXGhwWAf4CIRgN1zHFuS4MqftQYAN7jnEsUp3V9S2GXG1sewdlxh+axRBYSlhTpBbj/T50RNY0sA4moDMhbCABGqnDiax6xh4BG8TtdzhYFq5oq+JIPONxpKZ/cdRCkd/j/JSSSZPfe5z/2J3Vg333wzbr75Znzwgx/Ehz/8YXzgAx9YaHMiFuw/iTwr3GWHDh1C15Hm+MhHPoLLLrsMO3fuxGQywcYGFTSaTCb48pe/nAJeb37zm/GJT3wCAPCJT3wCv/Ebv3F8N4tBaOXyqlHFeIqOiYzakmuomhIY6V6lcyxqZgiQ5oaSC3VWlByXODRdwaxtMGspOXFuKxxpx2QpGUdKrNNUWHNiKG4xoSA6u8FUp1FPAD2huIduoxIOUVnEd2UpBpNiAC4DDAevOf7Az246YpppF3J8QpAAgPh/L6wdn48roeRMn8FLzSmmoxzAlYsVn58LFxdy30ZYUtxGd/RMKfAe+0kuQS8IDp5qmukux5boM433iRYau89Un+8tAUYqyEIxR4uCXVFS0Q6vY8AFyhiJdKXJvn2TXWPD2A8QAXro8hr0P4wBLbjnhHuN5yMp2YGwhQLQZ5fcYTaPmwkDoYoxmhHRs5mkkPqK1yfWoxWuQBHLoXMhxYaAbCW5UU7clGCRni26vfL4qWqBq8scIFfrRJ/m//n6Ze8/jfK2t70N//AP/7D03LIF+8mQk2LJXHPNNbj33nuxf/9+7N69Gx/4wAfQ9/SNf/e7342HHnoIb3/722GMwUte8hJ89KMfBUBxl6uuugoAYK3F2972Nvz6r/86AHKx/dZv/RY++tGP4ud//ufx93//98c9Ht0Kei/iD2cWg9y9glv10C4noyW/eJuzwEnJKahWwY98XI0zfRSx7H6+58ZshKa2QEWxnY2NlXQ9j0G5GNzW5A6j48TE0T1npFN/DBYhBr7Zp8/UVc69SAo5xjC4jY4xkmFgGojWQF8qWAR6Lm/ontrSNS4qD90T65PHWpR2X8LMMqJ4ro6Kh8HHRfeWjoDCx3Un3ICxX1RReY6zsucxV32Ol0ghCnbpiuLrGKB4Turp4vX8vE7GRRiwRI007lPOA7+7sVgAdAReCeS78nN0Y0o65WvZIgKiAhfH0j0GsTndi2eNlGJlkbLwWZgOzX2HqrRW0ufXLXeDcRVsp1W+F5a8GyRac7p2pBNA0PxRfguf43I18uPwMXbClQvYOlI2IKyoXLnaqMRgM70X8Zlc5ZpF1nI7EUIU5mduPf/www/jF37hFwAAX/jCF7Bnz56FNpPJBN57rK+vpwX7n/7pnz5jY5JyUkDmU5/61FHPv/rVr8bDDz+8cPyFL3whvvGNbyy95jnPeQ6+8pWv/ETjUW6wUonfMc4R0G32UWuXvUOmU/AxbpMKSrrcpxarU07U5LpnZuxhHQX60WsqsiksKeqf3DjVpgI7mi1bIT1ldzOgYJ1W/w6A9hlAkospWip9dGFUAsxMH2Bala2BXiQNtjEQr0GKyFNfzRHBQGujYmzKWA6frzZVcn3RYAQw+FIZslsvVVQGuaU4yZByMYT7y+e4E42X3Uj5uZ2MtSHGnsZC+RvpIlQpUZIsOpX6kXTi/N2JbrAuwI0zU4yVOIu8ftn/PBfVjJIzjYhTyRgLUFp+/L+szQao9Mxlfk3uf7iQUI6UMKzIa+FxijgLx2wAJNYYWzI6fm9STEaAlYznyORHb6RlIWKZraA/CyKCtDzgQiQQ5GOyThqNMZe6kZZRqGgrBTkGTi4NlRJxp5JsALEYejbIsgX7XXfdhe985zvQWuMFL3gBbr/9dgDAY489hne+85246667jrpgf6blWRGTOZlCPxIq/6Jb4W+PsQ3yYWfzXreAii4MXvmmYHeKGUQqtBMuBa/gvCnzarhigCFyAf80UozBUvBc+vurmUpuIeWB0AyUagTBBC7pBx2p1HNyhenBymxIteX9V1hZcmJh7jPHXtw4KiOxaqc+sgJnq4ePE/NOxBEkc4vHHvvhVXlqq0slLum/6f7im0wWQZ4HdsElxSzmgplSwxU/36cI3kertt7I7idZWobqeZVAL4EjxUlcgO5i7IvdTgNXWhpfcvctWg7swvRy/AJsE6Ghy5Wi6d6x/JGIN/DnD+GuM21OppRt5fwWTDKmVA9YWRwH0gwSS9xRHPtxsuyMCOCnPXsGgKJmAZR4mV1soVJQXb42tZfXapW2TfADsFk2109HAoD+BFkyyxbs73jHO5a23bVrF+666y4AR1+wP9Nyyg0nHpwAACAASURBVIEMkC0HVtDBIFkzQ9eQ7rNbjXe9BCBiEwqO82Vsvk4mIgKgCsUANFcWdgrVNFoswpIKA+WffOnx3tU8K2ZpuSSFyODoQupHtmHloDwpEc7W1kvua+ZZkZu2BCZWlMwqlUqN2/tVioEkBTgYTxrf4Fk9KGDOloUyZbt07cDNxc+mXQkAQ6U3vC99kGUOi3aBalxpVcyfnFvThbSHjYxrDS0Rbkurf/q/mofiOjcux8jtJBNO9gWohfsU4BTHPxxzio24AGW2jj9IV5ruqESMFQqbPuMQrZtyYcP3SzGVwT34eyvBnOM+oVLwXlKPaf8b32h4T/2lr48lN5pvNPTMLbVqUl8mb4WgxHYFfF67QEBmcgFPAMBk6fRsy48hpx7IxN8Du3O0R6p/BNBeJZxbklxBwk/PGejcRzAo4jGuiUATC1bKsvZcUFM5YrCxQkqr/sisYnADyhJMSVlHyyL59Jc8pvTN87MkELCs7GOgVq5ohXIdWg5czJGtA85IB3JZE3anADmYn+7P4DhQxNoFOKMKEANodV1Qdzuuh5UVAyuyrsnXk3to+cqfnye53kQf8Ww5hn6hm3SeQTG5lmJfDMJBl8UtE8CL50+xkngNEU2yAmZwkmBhDecW0edHVq1KNcyGQnvsaOg+goKsBuEzMAPAsFiwrEGmLKBRxlsokF+Ci+JtCHg+hNUq59ojJ2uyyza5uCK4cAVoZXMtOElhVl1YauUkppoWsZgu34OFc3S4YGeqajCgPD8d8VCYD5ODTiE5JZ/ctMjUVI2UbwGUbKUFpRdjI8EEskLAroPseqsmua+i/IsOcMxQ6zSwZokiXIm+Hcci8j2rCd+jHI/84coAPSsNk1bCagEYGFyA/D+LDBBz/zJWMQQvjhdI11U1z6Am3UcMGAxkANLqXkW3lR+4NExHJf6TYjIKMuhs4nVMfKC5LBlOGiEpNCDHKag8TqYPc1uav+UWEM8RP48fgAVfL63N9DwDhpdh60Jadj678LifbKHlvjVCsgA42ZE/XzlPQQOqzYCkhaLVWzyfJAOkOKUDPALFcORiRXx3Uv4O73OjKc7hRkQG6HfQu7I5qRMoYzmFa4w3TBNWR1HcUri50FN73fliTxyar+zOBGi3UL5e7hLK1/80s8uejXJKggxAPxq2ErSjpET4uFpb4sKR1ynBSvNin5K0x4gBUaVNyIliXtQ/8yDwiZZLiu3wmESmN1OIMVhYsRJL1sbQDcVuM5QrdfKLZ+VlV/IqFiiD1wkQkJUfB6u5H3bzkCsvFMUSk6IduHHKseaVPitPD06UjRabKNcilQwHuiWbi1bE2dJxOlo4Zsk4pJXHzCumFcdYgx2rQrnzfSSgSdAZJlpyvMKNsntLupDy/Ga23zAu5Gu50gdQD+dDFd8DIDPEOMeFlTsdQyHS6ksAEi0Ybq9cgIaCRwSPPhRWDpAtG7Zuhsw1JhUYG5KrDchj82KPGXaRhUrF+GmOnzCwqWgtDq9hobiTABT+/NgFZ5C2JtCdh4pA7FHGcp6uBCjMQ33shj+jckqCjBI/jLQjJCvDxNqJx13OXZB+/BR7sfmYN9H9BlA9MSTvHKk9sW8LZJUAESSXx7jP4dgl8A2VeNHW08pTYzEfghSiVKDlqjpbMOUzAijop0N3EjPC+JxUhuxKGsZkkvvPUaIhA03O1QnJsggmK1xvcoyD+10IOg8sAx6/BAAI5R8Gyp/nYJlwYNy0IVU/lpZekcSoS9daiidF15KJrkHeNE3OpyxMSawrAeSWxs8xtqEbki0KN1KoOp8AYyth0DCRHEDPxPNNbapZWLgGIFebdL/xTqDpcxxQoVOVhrQLaCgsGbYqwuAzXbqxWh+D+QxOMQajIljomNAp+6BtqVVy0SW3mQ8Y0pq35SeXUw9kAv0ATIwRDJV4kdGOqBD5R+/oejZPpDXE/ysHaE0MMhVL66dbxxIyuldwdUjusXQtA4YYl6RFy0C3zO8o6lixG4pLjkjWlRcWjgtQLoD2jA8DPzUrmRIQ+Nwy4ClAxJX9ANltNwxESzeWBAgeXy5tH5LCdSIHiO+jXbk6luP1UEcFYu0AWyuoGchK4H6rDOqAWGD0Oe4g5zbNj4xhiecHULqK0uJkMR6V+uiyBZMVeL4/1RvL4yjo1sKiyKVwGORiX9FCYAXMFgtvuBaKz6S0WupDvti0TJnSSuK5DRaJaCBFggVTlkOK00RLqMpWTP7OROE5sbmPMj6Epe4vBjPaYDDk+I+YlxNpyZzqcuqBDABE5ZwUuc1+Z1dny8KwG0X60WNVXg7Oy3hN3geYG4e0OZcHKK6hKbhLiibndLgaMMJdM3RpFC6tSKUdJtwVri6flROA4geuOEYTg6nDle0wlyURBBwpWKnkUxsLGLtkRT9Q0gwEiTYaYwYwOVbjY24MW1ralc8xzLuQoMDHJK12WTKmlMIiYkuOA+CDGmC8NbMGKfphbS4JolyAcigSJACaE97BkvuQeSPLZFkcmXfWBMhdxrGRfF+kDcuA5RYNg8rw+1f0kSywMt8EyL8j5QL8ioaeZXcVAwc/F1uk9igK/WgWhaQqMzOsAB1xbQFgie4MVG0EmQEz7URaMj6c2u6yZ0VZmZMpSnx30s5/HGz35blhO6DMSYAW5wZuK9Vp8B4siCX64RTQxwx+mymVy+5/LCkATuS2sAxXiVvR9HW36BoYxmESvVlYQpI8IKUIvguAScygarH9kOWWC0IOYiHVICYjci9YssWUV/2mD0XCKZc1YcXOfZSWyXIlk2JTAxaWacPC2ChxNBSKPq+Uy3vx9RIwsxtpyTgsP39un1iDRYytJEpoh5SwmNoMguQLiw47BNIMHNyer0njMSpbYT62Ea6zZcLxlVCphe+XdGHJ0jMSuPLnqNI1w76VDYkcINlmnOB5onNktuVUtWSw3L0xZPnIwDogFSaKbHa2evhccqE5RdsIAAg+Vnge7GteKoTl8Zmha0wm8A1pxsd63mVS+MEHsRly5fjkouOsb5bcnqv5xtyWGMTnZywC4jafo+dTxcp+SGCQVpi0Uvg8j4n7LQLPUMlFJQFwoRw9JxyaRUWT6MRLGGccyOZ7DQFIxniky4zmneZtmbXDQveM8QZe6ECMd8k8SKES+kvyhMTKXoLIcMdKJZR2atMQgBAjsKSL8zF+do+S2ZU8BsKTUIIlua7k94qFi2Wq+BtSXfk55fktv1vcTyIFRDebN5loUDAsTzDQBCj02xTmU0uK+Ea0QDwrKlmA0YG2bWW6bodk+yXF6aNbTWThp2x8m33t5HZTADQBScwvCQbJN688YONxBqpKUHMle0mCiyz5LgFKO8A2ACLQJaZToxbop0ORlGG+z/HKsAyLjCkBKNxlAFK9Kd2J8iYLLrysFJdJmg8BGBwPGPbHYCL7Vp1QSIPcD0k04POJKp7K7pcZ9MNVO7sTCwvTlgArQY77GlZHZrLJwtzEfvTAfSctHfSli+x4XUKF0haVApIlw+cbEecQLLCtZBg/lK6uxbaLfTHlWCcrifNyQgEu+XMtF0RyLpZ937blxMgpCTJAaUFIYeZUCnALJZ4U+CBHhf9mkDAdQDtlZpaAitWfIfJNOE8n3VtjYdUvd2kc1sbq18s8leI5KsAPgMGNVHTL0A/7WPkA7HoKplSMkq0mY1J2sGNjukaCOgephRttGLDl/BWAf+zZPVJYMYUyEfcbKHuA9iuRLrvMHotzEzfgYrdZNQtpfxRJB5d9Du+Rx68W5jYptmi5MOtLAgTPB8d8+FkW+hdWjHIiFhGfU85TipFw3BGkXBO92+fkx9SfHPcAYPhZjur2Yusm0oaZZTaUZMl4stZM6nu5gmfmWDovLJ6jfZdTfNKX3x0lPgP5vG6kT2gcIUBhvmwf8CUtfxbllIvJAKU1kNhd0Z/NNcKK1Xi0bLaK0+gB2ORrpOIsqac5HyO/cuf55YVLjItIpv1HfCYB5PuU/mop2TrhMS4v9S7be5OVUlH512dKsbSghpWHlwkr86HPHWClGo8NXHh8bWIicSFFW7rt5DvPBz9LEdwdgoXNr6KPY8RHFvJOfFiqVGVF4GVzkvsLxTgoblgCvYyLpD60SvOaSAVdfoYUWxPAcTTX0EIsZghACbRjrkkM+KuB4jd9KH4vHJ+Rkn9LpcKXn92PkyRp+sxIW/Y7WHacn2U7LnNi5ZQEmWHJkEQJPhqDi7O3xYp5GDsZStq3xoF24tQhAYNySJUBeL8Xjrks61fGkHxDL75WvksFtyzIDAgXiizxPtJER93CXbHMQlmmuIfX8NiGO1byda4uA9NyJSuLHi6TZYp8K4XPMRhpCeV9SwRwVWVfUuFnYsJi0Nk3aum8StIBK1q2JuXnNKQ6D8kKw/IvLAt5VGKsHI9RriQflNczUOfXshhO6t8N3YD5OtoWIzPO2EIhskxpES1Yem4rIkleaBwtf0W24+fSbuv2vrDKSmDb6vu2LT+ZnJLusqFilsrTGxR5BwvFDiOlWXlCaI+oPAv6cGzal5ZLOh+JA3KnyPT3Etj3TaQ4x/iMLI0/JCtwTIN9+cnlpal8RyqpUfEKlMcU3S07uOYTCiWXnqNadM1Re1WAinxudgEymHIhytxmidKx+fhWK8tlLikGDN6LZOgOkf2zlKVTpMWx3HJZ5n7ZSmS+E++1wuMcPge7odi1JfuQVgBqlVyeMnelpJeHFHjX0d3oERK7DFswEdM9ljzvsphYSRrJ13K+jSQCcBvZ5+J8qbRVcmLBCbD4cfJXeK+Z4b2OBiJD5t2JEH/cGf8ncBObZ5GckpbMUGQJmeEuhnw+Ba5FEJ5daHy8zFNR8PXwxxq/vOKwawAuI+Oa2I+AfrYCgslgY1dzPgSf4/GmXQxjLEG62oKhvjmXBRDK3OTMaml1cL4KC/ftm9KCWbY9L9ciW1aVoLAOB32kApgL+7IzQKlCMS+TRXdMSNbK0B12NFlI7txiWTa0FKQrdZliHbrAWHLxTyRrRwIJj2EIUgttOAlT1nkTlN2tFK3MfZGbhyV68aAKwML14ns0bJMrSmf3mbSKZMl9vrfpfUFdLiwuXX4Ht3ym43EJDzcuWxJXezbIDTfcgLPPPjvtEAwA733ve7Fnzx5cdNFFuOqqq3Do0KGl195999148YtfjBe96EW49dZbT9aQT02QSfXAUCo5ILq2uvz3kGLMM5a24R2Ai8zcL8p/OHFMAcqRFeFGQjnEWAuCiNPofM6OyjFzTMlXdI7jNQlYqqzoWfjv/IPeep5y23ifaIGkcig6+7dZccs4DZBB0okqyXKcRa2zQZCb8yVYOK9FxkiGGd7p2oJIoApw2uqZt7JcpAzPywoEy1xXw3gb19uSFs6ywP7wOYZMteI+PtOch2NLDDDhOivcdCKWJd1RzBpb+DzYlXkMl1IwKtGWaczZzSbL7pfnS5ch1RejDch4jKGi/52gWsuq3PI9UeoHeTSyzXAvmWeinEwICn0wx3wdj1x//fW4++67i2NXXHEFvvWtb+Gb3/wmfvEXfxEf/OAHF65zzuE973kPvvSlL+HBBx/Epz71KTz44IMn5PmOJackyMhgumRzsTtnuPKW8RkZk5EKXbb3lVjRD+M4Ff9I43sd4EdUMj9t9azyPblumhdjBGJBT4jqAy4q74EVxuNcFjvhFa0kH/iaLB25bbFd0WI8pDxY4S/t16FQMHIe074hyX0WFaQAjqT4bMm8WrYNsBTpVuL/y/1O+LkXrzteIXdhSaxIDC1e8R8lFuYaZrGV52WekfxMthJ5/VGZVdFdlcYs/x4AsWSZ0fi3thiXWTIce+FX4eJDacksPotcLJQgwQmWWzH2uO1wATXsTz4rP9+w3bO9nMxll12GM888szh25ZVXoqroy/Arv/IrePTRRxeuu++++/CiF70IL3zhC9E0Dd761rfi85///EkZ8ykJMotVaONx4RJl9xRQgglfrzwHjAd9sTtNbCWQcmt6QYnVBBAJENQAYKr84rL5boziE5P/O7GjIY/Z1Qp2rFL8ZsjoWiZscQ1/qFwav2B6mbLPwjWnxUvGF+oSbCRraEg9LlfRrOAFUIl944fso+xm2prJJS2KLefDlgC4rJ+ifUGH3brPxYTbDE7HAlOgtLqWuf0KAFvC5sqkhxJYZPB/6DKT9+YKx9yG2WULrldhKXDMZmly6MCFtxVgAOV37lguTyKX6PT3giW/pK7ZiRYfKczHej355JO49NJL0+uOO+74se/1sY99DG984xsXjv/whz/E85///PT/7t278cMf/vBpPdfxykkBmWV+RCkHDx7EVVddhYsuugivetWr8K1vfQsA8Mgjj+BXf/VXccEFF+ClL30p/uqv/ipd82d/9md43vOeh0suuQSXXHJJ2mb0mHKM79DQytmqDZAZYYCwhjiewWw1n1/kpotfak/WjK8C3DgkgAEANw5wDb28IZcagw/f264RsEhwseMMEqk6gQjwMptL2ajsK3Z/5R+aaxZZZPxcfF4KWzbsmkvtBUjL+8tikHLekrutKX/8UlnKemeygnG56djQhVYCYGpzHFYAt3M1zZusLybPD2tyDc9JFtviM4m+dAbPo8UEtnL3LQUbU4IDXV+CR5ELU6mF1fxWWxgDwq0m3GzD88PxLK2ZtsSCWMYu3Ap05PvQojwaEEkLaQi4J1ue+9zn4oEHHkivG2+88ce6/uabb0ZVVbj22msXzoWwhPyiTs6zHpNd9l//9V/453/+Z3zjG9/AoUOHcPrpp+Piiy/GG9/4Rlx66aXHdZPrr78ev/u7v4u3v/3tS8/fcsstuOSSS/C5z30O3/72t/Ge97wHX/nKV1BVFT70oQ/h5S9/OTY2NvCKV7wCV1xxBV7ykpcAAP7gD/4Af/RHf/RjPC4wJMhwQN/FQoiyhlgwkcklYiFcvFL3pPyLagDDW8UNzgAg1IDlvVPkrDcearOKLiY65OuQwEjm17hR3LNmkLQZeC8ccSxX0UXaCVG60gpFXwFmRn9rF2DrkiVm+rz6rOZ5wy9ZRdrV2Q3G1/I9Ct+8K88N5yNReC2VASGG0KIFxdclpppg6YUKgM0lTViJyFplwCD+o4n5lZJUk8sOqawNV3TWvHnXQiXm7DZz0eLiagbLLBdOulwGipIa7f2i9Z3nMwCmVKpDkcUpvaGtrWn+RK2wwQp+6HqkuRCuN+FaWqaYlaPviRF9yD6HfZelaEpJZYBszurnttk1WQKSBH2OPbFFw8fTM4mtAvjeP237yXziE5/AF7/4RXzlK19ZCh67d+/GI488kv5/9NFHsWvXrmd0TCxbWjJf/vKXcemll+Kaa67BI488gte85jV461vfite85jV45JFHcO211+IVr3gF/uVf/uWYN1nmR5Ty4IMP4vLLLwcA7NmzB3v37sW+fftw7rnn4uUvfzkAYH19HRdccMEzYuIFDdTTUvEVZewtvdj1o3y0LritYJxpdpF4UK2ymkBAOaCaKZh5LOniFJ0zAW7VC8CIVOJRgBuFFM8Z0qy5jA0zjdyY7qP7bL2w1ZBqnQlCQHr2LYLdzF6TMRQ5XynfRzDEZKKo7H/Y51AkaSBdV3FMJp+Tf2dXm+hnaVZ5qcCHSkrGHBJApedkq2JrS0jmzkjra1kip3QLDrPPZbvFmIKMyQ0sJfn/UrbawqEFWRY/O1pG/9b0Y6SgfrFJmGDMLat3drTxAyjAYTg30hKTxVGHluCx2HScL/TTKHfffTduu+02fOELX8Dq6urSNq985Svx8MMP4/vf/z66rsOnP/1pvPnNbz4p49vSkvmbv/kb/PVf/zVe+cpXbnnx/fffj9tuuw1veMMbntYgLr74Ynz2s5/Fa1/7Wtx33334wQ9+gEcffRTnnHNOarN371587Wtfwy//8i+nYx/+8Idx55134tJLL8WHPvQhnHHGGUv7v+OOO7J/M0Qw4O2B+7zCL2qWDXZcBKLyjrXFhhtv+VGJ2MopyGpbZNXQD7FylIsTakDpmMMyDqlNGPtUfsaPeNWbd97UDoAiKnO+Ib0xW4s3A2NWF1sPrlFUBl5YNDJvg91lHOSXolzJBnONylTqWCmBYy5ABMJY9sbX9OL/pbiRym5Gnm8RDOZ7yHwbFv4MvVFAQ1TiVJbFqqId54YUFgkAWFUoeGPDQs2w1A9fG7PqF9hmS44t72dxNc6yUEcrWisssuzMcFdKaa25kSo2GCtW/kLRl9tI8Pcnx2VkZj/fjy2i4VbHW/ZnS8tGMswkxXsZMAwtzvR3VQKMzI0q2gzKx8gdOKUczRp8tsg111yDe++9F/v378fu3bvxgQ98AB/84AfRti2uuOIKABT8v/322/HYY4/hne98J+666y5UVYUPf/jDeMMb3gDnHG644Qa89KUvPSljVmGZs+4ZkL179+JNb3pTirdIOXLkCG666SZ87Wtfw4UXXohvf/vb+MhHPoKLL74YALC5uYnXve51eN/73oerr74aALBv3z6cddZZUErh/e9/Px5//HF87GMfO+Y4Vn7u+fiFt/0h6g1SXnLLYK4HVm+QZZAot9GNpTugPZ2KVgIxQVIoLiBbMpu7A0yn4Bqa3mqmkqI3MwAamL7AQu/oEfaPYKYxODkO8KsOempivwE7fqDRnQbYFapw3BwG3Aoplf60gGoSf1QB2JEt4nQ/7QL6tfyMoyMedqywst9hck6Fap4Dqe1OnYCCn390KGD+HAUdqd88b94o2DVq0xyhefQNUrHRoKMVyLt8NjGh1JUU0mpOQCuTCQEaZ7tTwzViP3gBfNWsBMthIUve04X7XRZrqjdLsLArClzOnz7j8jp2r6YaY25xAzOgVPg0Vg+7oouN1XhsPGY5XjmeepJXNNoB3Q6d+qtmtCkXb4Q2XLFXMx/nXrD0+gxQ1dTDruq0xwxXYV4AgDgfdpzpxNpRLpO8pkhsFfMmj8u2eV5DAizeQIzGnQHB9B52xSzEkKqZK4gffqQXN2MbXANkl/Jw3xkuvAkAm/v/Hg888ACejjzvpafjdz7z2mO2+9x1P3ra93o2ylFjMq961atw/fXX461vfetR3V1PV3bu3ImPf/zjAChAdf755+P8888HAPR9j9/8zd/EtddemwAGQGHl/PZv/zbe9KY3Hff9mCXla7WwWjfzqJyQN7IaVgZg68f0pUXD4qsMKtU09s+3CdEiWIltWwMFApdqomAjxZmpzkB01Rkk0KqnCm6FrJyUHGrZymFlQON3YyD02boBFt1ow/L0KtKhk+UQc3G40sAw92Yo7FpM883z1uW+hwFk15ByZ0Bg9t6wDSDiQNHqGu6+yW0cx2Li57yMWZesqDh3iaqOxQrI6XmiNcPvWAJeVechA4DLiAw85qJPAziotBkagbXI7eFaZKxQm5IxVboPF1fnXI0ZKKnDciOvYsxb5MVwBQElrZtGpU3KZOWBZf0N3XGuEdUoltCmZZWCIXCkHChh2ci/l1lb7M6Tlpa897acODkqu+zaa6/Fxz/+cezatQtXX301vvCFL8Da4/AF/Jhy6NAhdB0tdz/ykY/gsssuw86dOxFCwDve8Q5ccMEF+MM//MPimscffzz9/bnPfW5L5tpQVIir6wgQ1SykOAZvGsVKWCptgNqYrowtyIRNuXpHAHQrzofoi49tm8MAujz9eh73YGEXT+PTiwtpKgeMDvEqDGQlDdhtuVYajZPGLH/oWZlql8/JWlluXPbJbr4EOFvEViR12W0xR7JfAIlazXPNymlYqWCoQGU/Pib++boEhqFbjZlwMqYjx53ICxrFORYGteHCZFgpm+rLqeKYG9H4Fu49+PzSs3C7OgMTbw3A+/osu29R/SFVhcisNc7BoWeV85Npx74piQLLirjmCg/lXHBSKMeZluXKSJeb/J+3RE5/6+XEhFQrjS2ouE+MpFxzH7Jf+Vp49gHYnsiM/wCcsGTMn0Y5KsjcdNNNuP/++/G1r30Ne/bswe/93u9h165d+P3f/33853/+53Hf5JprrsGrX/1qfOc738Hu3bvx0Y9+FLfffjtuv/12AMBDDz2El770pdizZw++9KUvJaryV7/6VXzyk5/Ev/3bvy1Qlf/4j/8YF154IS666CLcc889+Mu//MvjHg+zolKFWrN4nJUzA46SZn5cUQ3jC6zc5fFUFLHLfZheEAR6DeWV+DECwQSouYaaa6DTgzItsY+OrKVqoorxF+NZksPD+87rnv3ufG3chEpjId4kYzoMzinT3y0CLZfbcYMinvw3WzOSXAAglWZJlo/L4JLAZouEU/n8ssLAMlCQcSN5f34uBh0WBidum2rBNXlsy4TbyPtLYJDjkSA67I+p5wslbhh8zeKcSHfnVvXmqF25RbS0uBhshqSGYV5ScX5JRQXfcM4N/b+sBM6ycdH9IiiMdAbmSLNeWkjWlnXhlpEahmNIC5sl20lvy9OX4yqQecEFF+CWW27BzTffjHvuuQd/93d/h8svvxy7d+9eGmMZyqc+9amjnn/1q1+Nhx9+eOH4a1/72qX8bgD45Cc/eTxDXypyAy3Th8KVwko0GAAuu9X4Oi7rL11HuiO05r+VA1aeBOZnApKPqWP+TDWNQXsTkjVTMNs6nSjMbhSS0ubxMYgpSy6zAggEG00J4JJ046ApSXP81GLdJt1T7EQyxpbVHhuOma91DEYoFYkbU6yL7p+P87OYuGGZ6QPsVkwgUwIag5RGCYQLNO6mPM5j4DkpVv+mjP9sWZxTWLleBMf5nlvJ0PXK1wdT1pRbBgpMSggG8F6l+y57diYH2BUuyrl8PMsU9bBMSx7TwIITrjc5PtnWD55TI4PAQn+mVPYssmpBQUTQCkAormELaBnwy/tS7IXce6GSlP8c1zlRcvz7yfxsyo9VhVkphR07dmBlZQVVVWE2mz1T43rmJGQWFADoSYCpw8Jq0HRhQYmyZVNNkVlNS26hXQDmNOuq6AAAIABJREFUKloL8do+JkuyhVQr6FbDV/k+wQDwSCwzgNxn9YQC/maWlayKLj8/4nsC6HOg145NfpY+oBcxJtMHNCKYXM1zEcLhb6GYqz7Pj+4XV/vD/B0JjM2RUDDXiqKknPwag+XeKBiRYNev05zz+IY//zQOEXOSQJPmVl5jgDDYesCwZZdyOUJyWcnn9yLWYly2vmRekARpAMBcWEFDEIxzkHZpFZaWaxS0qIad6dBYeEYZG5IAwVaSrcm6YxJAdollZV08t2CxAUgFStOcR2tAjkmKNwoq0c6xIDIXSIltx2UeT+HaGmW3GM+F3ImTN2Ub3i9ZoQ3HX0oQTG5I4cbblhMnxwXXjzzyCG655Rbs2bMHV155Jdq2xWc/+1l873vfe6bH94xI0MSOksmX7AoCqKxHc8QnRdFsBDQbtBqs4jYA3LY5EhKYSAsJIJdWPY2vDTpftUjt6yMK1aYmpIoxG9Mp6FZBz+lVH1ZFf7zHSROtAmWB0UECryK3x1EF3noiAsgmuwh1R75uXr1VM4dq5tL4mRGmhZuP+0yWFLvfeppPuVdONck/1moW4sZVYcG9NDqSJ2xYu8zMXJH3A5RVDVLMQbo7B65D6Z6TIokNsg8+znGRBXBiFqEL2d0nxpH6Y+AUeUTs3hrm+Mg58TVZksO4DbsKgUXSxVJCwwBceR546+1hrThZ1WCYYe+lUhfPJQkHss2wOkJZqWG5my3Pb6yNV6vC9cU0fhlz4/iSTOTkMcj+7IpOcSmOTSkfGYciUXfowtsmAZwYOaol87d/+7e488478e///u94/etfj/e///24+uqrsbKycrLG94wI1w8zluIQklaqHGcIRyJAm1dcQSvoLq9SCxeXJzBKSggB1bRUUkYAASvkagr4kUquOFuBoF+4ukaHHRCqtHvnyn4H11REoe6oD3cagRmDSHPEg/cwAZDyJUwfiN450gQqpxnI2lZ0PYGPRb62ammM9cRjdpZBNfPo10S8SBNgzGLiHCm+HBdBBAslaMxy7gD6TMAuMZ+VBiWyBrjxoCSNzF9Cdm9JtxqDhrQqiSAA1Ch99kweYLdVYWECUPN8T29K9qE3aiHGN3TPmS5XS2C3pO8zGCyzimXiK9+3OC/iMkMwHbru2MXHMRUAUJHkUCXa8JL4iMgN4v/zuUVCBpCtISCOaRZBWG4dzewxm6tjJ6uiyi6rYakeN2DteYRkpXif3XJy/BIgmXUYTKaZ+xoILVVqkPNzIsQHhdb/WE6jnyk56pPfdtttuO666/DJT34Sz3ve807WmJ5RUQEYH/AZSDoP1aiUNrm636HetJGPv5icFQyBia+zW4RzbRiU5CqOV/3aBYyfIgWmXUA1A0YHFBXJrLKiVBapKgAQlaMNWP1RdteQ1WHga1KKpgswvcLoUEj8ft3FVWGdNd34oEO/Q6dn0nGPdN15KEvXVfMcZ6gnISlc3jDNdGTNsAWYy6AQEIwOBbSnkwIeHab23CdZQmXcQ1kCZEq+jKtqrWIsKGSwYuaesDgZdBnIKH+HCAfahUTj1i6gH6sFs107ui8rftPlEj7DRNzhd2BoKUk3GM9H4Qr0gowwCPpLWbDO4nO7JidWMplBuWMrQ75faZ2IZ0kVDZYz5o717DzG4TXsZpSfF5ABZkgQUDbmDSHnHzFTjXOX5GaCfD83UjBtzjlK7LvB8ziRrsA5XrRQCGl+QlUC07acGDkqyDz00EMnaxwnTaQ7qznUp+qwIZb6SFnQnQfGZGan5DWQEuX9watZtoKaSZmUV0886gmVyQdKn3vKSo/72ddTpP1p3Jioz+MDeZym9+SOYrdV52H6gLXHffKvu4a2F65m1Mg3GnAB1ZMO/XoFu0IaQVnAtJTAp1sLZUeRJUYTU296KKthV7hmGc0LP6vuPJoj5AevZh7eZT837SpKddeqmYcdmwwIvGFWrTA+4oqkPNWRv1zH4H9mqNG2wUO2Fwsnh7IbcFiNAChdSZK9pQWBgL8XQ3fjQjkeQaxIyZixCoR0CfHYOXFx2IeUrQLyQ3ebrwE1QYp78fjYOtpKcnwsV39YlrS5rPinHKOsD7clAaPYbTP/zZYMWagi+95mVxUTGphI4Gr6fVlOhBbJsZxDlCzGYbWGJifUFqWKYns7LmNhy6zErT6Xn0QCFOwpHOjZEq+vvvpq3H///Ue9+P777y8SJH8qJCb8VdNozXQezaEe44N9smzM1MK0pMibIxb1Jr1oBR9SjGF0hNrojl6mD6g3PZpNj2rqYbqA8VMW46cs6olHNSPLoZpSGzMnC6GaIAFOcwSoJ0A9oXiKmQPVRpdiRNUswEw61PEefN+1fQ71pkP9oyOof3QE1UYH3XlUGy3GT8zomWcO44M9mn0bccdBmoNm3yb0tKNX51HNPbnIZgRs46d6KA+sPNnRvHQZzFae7LHyZA/lA91/02Flv0sWTDWjvtgC2vFYR/PYeujYl+kCmkMOo8M2g1nMAK836T6mD3n76UiflvEXqj2FRKuuZqEADnbBLd2lUyhMzjexwjU3jAtxe9OFQplKmrWrs+sumJxlL11qBfXbDcYoxsruNQlgyd01sLhkDCjNi8v9hxTojv3Zck7ls/C8S1r7MstJuib5c5BCFR1UAQqpLlxVsvQk0YKtaHYJulGO13BOE5CtFM4pYvAY0t9lDTq2Xl2j0K/l7TBkm205MbKlJfPud78bv/M7v4MjR47gda97HV784hdjfX0dGxsb+O///m/ce++9OP300/EXf/EXJ3O8T1uUDzAzh3ojaw0FIHiN8RNzhEpDtxah0hgd6KBbCz+iadJGoZop6NajaZGSxPyqhtzf3EQFbGaiPIbTiW7KY6hmtBlYNQ/wtS5oqM0RUQ6kpZV/s0mKWXWWwLD1i7WWHN1btQ7GesAF6K7D6uM1WWrRLaZsgD40wdqjmo5FS0a7AHQeJrJ2CERdtGIczU9HbDTTZffcypNdHK9G6IhIIOtg6Y6sJ2VDKgPCc5TLswQ0h3rMnttEkAgEavNsCZk5FhQsuyurWUjKPZUM8dmtKcW0patL5srItrpHYqFx/pQdq2RdMOWd/5b6aRk7cdlYlAPCuIwbFTTvSLOvZqF0xYp4iwRBKZxgLK28FH/0ZZCc75t3dl1kkxVzO3i+FKMaKOkUgxHsP41cZYID8ezilM/VrcUYX1+6CvlvZnky64+TgJP1F+/JZZUAotmbeY4V5tidWqj4fSIkYDsms1SuvPJKXHnllXjggQfwpS99Cf/xH/+BQ4cO4YwzzsBFF12ET3/603jZy152Msd6wkS7AN2WlQuC4+xhWm7p1kK1jgoTRprwaP8M87NXRcAyAkasf2R6n5VnrJ3EbetNC1drrO7r07l64pM7rhrnH+/4oIcsXqjbPgEXxX3I0qo2WuiuQqjErzpWZFDOAQ4JQMyMNICyHuh6+t/GZ3Q+gZOZWqjGxHF5itu0FtXcQ0/7WFZ+BN05AFUxj35UwUxtyr0hlxoBimk9eDtl1YVCGZsIfKEiwDN9JGRMOri1Jll/yhvKt5mwEqC6Z6YNKZ/HtKSIOdGUVuhIrh6aG5Xqr7maA/ikjIekBOmOYkCSibPyXQbfuTyOzGkKYzkGAHXuX275DeTYGFBaD5y3xe4eBiAeK4tUqqmMksnWmRG06KFbieNiaaxLknOlSBcilwRit56UZM21tIBgV7LcpI3jOADlAvExi1zjTvZLLsBQXNvvyFtvMG1+IU/K5Jdv8udG5/I8bfPLnr4cE155l7afFVE+KtLOIhgD5Ry9R26PmfVQnUWamqjs0t89B9Z9KmcBYVVoIPmcdWsRTEy21AoGZAGwRUBKgQBqZT/58MntZFN5c91FkGj5vg5oWwKJCJYMkKp1gI2WTFTc6Pp8jsVaOm8ddNsTwCRw8tAdYKKVZmyA6mwEDQIuMyMwqDdM0S9bTlUEC91Fq0crGrfYc4djQGl+nE+AZWYuxZSU9cn6I/edKhQkKyzlysRJTurkuAm7RgAUSXcpmK4ppsUEDmnZSIVPY81gpl0QFhudr+ah2IeGRVZZkBUJjiYS2DIDEgXjzHQhBcflvZJS5riOyWNjGdLGPWKeUp+JGam+W0vPxGC2LG7BQM9UZlmUsxtpsmASW5Ov4YUYFXLlua/mHjL7nundkmgg50GOgd1uDHhF8ivvzloBQVQy51JMviEX9racGDkFbTgKcivrhevIZ2vAmXjcpuMhZrkp55J7SFkPcLXWRqPaaJNbTYGUpmodlBF5ID4q39YCLVCLon5m1sOt1LArhuIpI/HRRFAJRidFrFoCiFBpqE48Qxs1eQQXadkk4LEOetoRuHRk0fB1cl5YlPWoJzbPV+ugnEOzr0vzpqyHH9XQbQ9va+jWonFirlwgq9AFhFEGJ2V8KpqonENoKpjWoznUQh88gjA6I8aiHExfUfygy0HgvPshCneZslmhLm5WlsGF/g+x2GlIFgLHdiTgMKDxNQCRFThGxwwnikuEgg01LGMv4z0A0bPZXcYxCICSPRko+flSMU9NStwMEinpne+blb4WVkyKQ9vBWt3k9hxIH1o2EoCGz8l7c2WQjvTifnFseczxDxHDksJV0E2X87eA7CqT7rMFivcgJiOPy78lGElQOhGWTAg4Ye6yG264AV/84hdx9tlnp2orBw4cwFve8hbs3bsX5513Hj7zmc8s3fbkvPPOw/r6OowxqKrqpFV8PvVCXCG7kORLWQ/VWlqtT2dQrQW6Ph1TzkFN28jI8nHFT4BhpjZZFXraJ1ebco6sgM7SudYS+HTUntxdHrojpV8dmmP8BKW2m0kHM6GYEKyjGMvGnK5tO+iNKY27tTRW56Gm4tduLTBvCTzaLrVB1wtwiRaMdenF41WO3GN62qd4DV+v2z7NYbp/10NPW7K64jhpTl18/p6IBfK97fO52KfqLKpD82SVqdahmvloGYWcENoR8YKLfBIoBHLrdSERMkxP7rR64nPi6EyQKPpIx7ak7MhVR49bT3wEER+vycoVyNUVuC9uz1RrGe/g+BAr6Goen6MNS+Mp/Iw8fhaOXXDAnqo1iOB9JKEwQPK1ugspzgdENyw/r88vHXOmiIWYi6bKhFppCS3snunzGHlutYwduUyhJgYmuYZlwU4uwjpkhrlGFVt6DwP6wRA708m6eM3W1mJizQHF9hTPZrn++utx9913F8duvfVWXH755Xj44Ydx+eWX49Zbb93y+nvuuQdf//rXT+qWAqecJaN8oJVzGxXyaERKNwXMY8P4P9q2WM1I60RHa4eskz7FFHhFn5Qzi4sWUWuhDFkeBiC3UDzmRzV0l5drqqOxKOciUERAmMeBVuUvKMTnUnzc5udIEq8P1kJFCyawxRPvwb81ZT1ZUpOO+uD+rAUq8fXh6tyWUjjDqCJrCViYByViQMqJ8TsH5QwULGA0UBkCIAeYjTnMc0aROk7Xulrm/Mh9SDTkzowc4+F0Rx3dXbyHCV+jWw9tNJpDDvPnVAsKlMZLLk6am1wWxQs3UtDEnqtdzs1QNit8ztNgIYBUkbW36PqSe7eoiq0ypN1Dq7mHG5kIwnQNEyc45sfbITebOd4HUPxBug+5VD9ingqRNoSLzMb9eaBSYq83Oo0JyG09x0siiURaIXK++BmHNd8W6wbmPBg+tlDFWgT+uQ0fz4m08h7572cKYDwUuhNEYb7sssuwd+/e4tjnP/953HvvvQCA6667Dq9//etx2223nZD7nQg55UAGIRAAsLKsosKuDB3jdyC/Iyto5RwCKJYDVDF+E8/F1X0CmLZNilhZnd1QScF6BGNyXMQ5aFe2SX2zlSK3WpBtBu3z2AlA1PD/UZMBSwqDVGtyv9HCgXU5fjO8zjp6VuuAyi2CtRz3SOxdLc9bB4xHgDE0f9bF+WRLxqO2AXJTK4AUbdCZoZaeM5IXXK0jZTtrEW/yxlSUBU9tvaO2zaZPsaHhLoqS0Uf3NNF15Ys2qgtgZwFbColhFq0dYhoCamfeboESDHOFBuVCast9KhtQcd+WrK1CaRvakExu4GWADCaR7Tf8m8fqVky08AK0UZkdGHPJDAiAGAAR/6/iZ6CNAhL7MAb4I0FGDfaD4bFRH1jqMmNXmKyfJ+voAYuJrfLaIdWcK2wM2wHZkkIa+bNbeKt6ADj33HPxxBNPLG2nlMKVV14JpRTe9a534cYbbzwp4ztukPnXf/1XfPrTn8YTTzyBf/qnf8IDDzyAI0eO4Nd+7deeyfGdePHsIhMK1h3jXVgFatpCNXVyFQGgVXfXR+XoBlYDt4nnmjoqVDqu+T7SMqmq8n+2XOLfwdpsXTEwDiQM9/1Jypwtm9KCKUCqFUvOeK6wokZbtJu3AoQG9y9AqV0EKdlHJQBuMkU92UmMuMhQS0QMkO9EWQ8jdlRkEkZSipFsgVUG/BCJBCVJQjLjmkOkuaTlxCLjK8qTJQEgAllIYwiVgmZWYOdJcUelGwx9FVnxjg8wWcSjEqt8fiY5Dp5Z3frinjweeiZqb+O4AGJrSdagbzRReMWmXswETMmmLlPJQ6XgnS4AR7sA78qxMmhXbSj64nvzOIoxWxpnMBX0/8/eu0dLUpXn/59duy7d1d2nzznMmRtnhosoOAyCZCTIT0BivGAiCJhERJEQZSmyzM2lsFgaYhJEs7ISo6jRmIjmgsaoqAtUAqi5CeRrADWAOMAMA3M7c+59qfvvj11VXV2n+nT3mRkYYN61enV11a69d1V376fe933e983UbMoz1LKSz6Rd5OTvStia/NRNuiraJkX2RKDAebnyDSuSaLBgzL1793aRrK644ooDCgT/+Z//yfr169mzZw+vfvWrOeGEEzjrrLMOWP+9ZCCQ+cQnPsHHP/5x3vGOd/DVr34VgHK5zHvf+17+67/+66BO8KBIXgMoeirv2s4tpm7OiJ5dWLPAZZndGlNybhYYEoAJcmNmPqeaR7I/CHKmqmX+iXlwifdFRW2gAxzZ6/CDblNZtk3eLJe9XzJzjb3GW0aitoOoxPQf30/JD4n2qLs+oW0inIDA1lPwCSpmyuxT2mKHMAGkZIXsvtS/ZsqOCS4hWWQ+p2w4Ogw5vaUhm35qLtXjc7Rm5zoVe05PWYKRJhAZYEyp8GF3/FGS9ierKektSCpBJimBZK6wV2BpMaEhTNuImJ6fMB9BZYIwmj5RGN8TYhJJqCESkNYy1HMn7NDRY7A2kgqUceniBKwTgMJPHqailCiT1UVTQHbDLlBJsj1kM353JUENOyCUBoSaHfpyXvKU86SP5D00idMxFZ9/sGViYmJFvpI1a9awc+dO1q1bx86dO1m9enVhu/Xr1wOwevVqLrjgAu65555DB2T+6q/+ijvuuIOjjz46tfWdcMIJPPzwwwd1cgdFwkgt6nmTWOY90RQi30ckJiBQC2rbUSad7JN69ngvjSBv5goCtQgnC7Xjdp+fA4X8/iWaSl5yC3lR+8iLr9PzEYa+dNzMWCK+LxD7e5Jj7YwpMWkLhdeS3s+sSTK7nXzO3osgQJ9ppiQAQdDRIOmYMxLyhQiCjuklZrUJGaI1VcwNEIOR2TmeuVey5aVMvSQjQgo2CfMuZshpTZdISqT0U8ZgOq84oJfMXKSXxCupx/QgTlIKKojVWPDVQh10mwSTgGCt6RFZMr3XIRI576i5uEtZgQmQACk1PQk21ppu3N5UZJQMpTz5nGyHViceSppaBzjc5DvUusYTQYbSnwCzq2LQkjYJ1R86ZkDhhymNWG+yJPVPli6u5trtrM/WQkqzG8TbGhlGX9ChKyu2YmeMXlkh9kdCOGA+mSI577zzuOmmm7j66qu56aabOP/885e0aTQahGFIrVaj0Wjwve99jw996EMHbU5ZGQhkFhYW2LBhA6DsegCe52Ga5nKnHaISqSf5dMHUuxZgoXffknRhJPNknVB+ZeaHkwBBfkFNJdM+AZaMWa7LBJaVLAjqsje4xH1FXnxdMWiknzNaRQIuXdfpdcx6CbBGeWBM3vPHkj4KgDe5D8mxJdeZ60vkz2878cIedPu6AHRd+X6CAM3Uu8gWwonJA0BoGcrcNh/7m2IgEq6fApaQEq3pECU09EQZyzjJEzASfkgUmxATEkhCv05YhopB2Pl9aI6HVlFaV7JXtjpxQnorSANmQc+YBEk1N83xCKGL9q2uVWV3iHStQw2PKfSJZpLMm2aUobP7yBhkI5mAV3J+0A22yRxiwMlqh2ECZPF4CnwzsVsWHeo+ijATSS39rhNATuaeULllK0CEsisANBscm5aj8Dp+HNlWDDMtiNLM0UUp+7PZFbIkgUiS5sQ7FOXiiy/m+9//PlNTU0xOTvLHf/zHXH311fzmb/4mn//859m4cSP/8i//AsBTTz3FO97xDm699VZ2797NBRdcAIDv+7zlLW/hda973dMy54FA5qyzzuKGG27g2muvTff99V//Neecc85Bm9hBlZwTPCuR7y8xJxUutvntfJ9BEGs8GZAoMi/1kCwIJp9FPOYSkJBLn5JS0CiYa6q1FLVj6T3JmxQL/TiZuRTe0+X6z4zTdd89X4FjYmJMY39y47YdtKaRxvyI3Ly0mDShOUn2xTDNfJCw5BLyhXDo8rFl45wIwvSYCKQCO8tS57odWndk6UvjjYIwpqR7REGQmvm64oQyi3myL5lzugBnWIxd1wRdmhNOB5SKziPRXiyWzDVtl9FwOuP5qQYHCoy07Bgx+Gqx00NR/+MHhsw5+fgoAkWmSX1RngLeJBI/WxeJbmMv0ClFkM1OnZYHD7sZfVrm55ekdcoG6mbLNhTEmz6j0qvK8B133LFk3/r169Ny9cceeyz333//QZ1bLxnYJ/OGN7yBz33ucywsLHD88cczMjLCt771rYEGKQogysrMzAyXX345W7dupVQq8Xd/93ds3rwZgO985zv87u/+LkEQ8I53vIOrr74aGDwAaYlEGRCAjkM++56V7L5ksS0AiMKF0w+WgMWSJ/fcU35Rv8lim/Zl5L62GHgOiOTvS2YeSwgRvc7P39PlZLn7nrwndOtGs7vP5PsIAgUA7RxNuxegJ/Trrhih3INEQkCwrC7NKd1O/W9Op69YEu0qP6awdAVGbsb3oWux1iXiANmwS/tISCpahq2Y0L5FEu+UjOuiiCXJ+c1Whx0VhIiEnAKdvhy6WJBIqYCl0UxJKNnr0ZrxfC26zJZAem3JtWZz4iG1Ls0otIyOZuj4irYOaWmGpKBYNo2P9JIYne6UOdDROFV8UXeWhsSvk4CT3hCYjRC/JFJQ6qQqSlhzHDCJDiCF+dkoA4HMunXruPfee7n33nvZtm0bGzZs4LTTTkPTBvOQXXbZZVx11VVceumlhcevv/56TjnlFL7+9a/z0EMP8Z73vIc77riDIAh4z3vew+23387k5CQve9nLOO+889i0aVMagHT11Vdzww03cMMNNwzODS/SRnq957a7zGd5AClo208GabPknAygLAGcAc5Jzot8D6Eb8Ty8rmNd15HRnLr8N73mMggYJZI1GRaY8Zb0kydqZOOAUtDJPBQkoNSLpJD3hSX7C/xgahw3ZtiZ3cez8yoCtyBAOFYKXsJRmlDy29EW2imBREBq6qMR153u0orj3x10wDAFzfj7sKz42roBMG2fXEf+PubveY7WL6TsxI5lgSozL/wgBbku0fUUCLviyBLiDJk8Zoby+SSgA4oIIDO0cOgEvCYBokl2h2w6G8WY62Qm8MuqL8MHzSLNrJ4U+MsWVjuArpnnrQyEEueffz5CCE477TR+4zd+g9NPPx1N0wZO83/WWWcxPj7e8/j//d//8apXvQpQhILHH3+c3bt3c88993Dcccdx7LHHYpomb37zm7nlllsAFYD09re/HVABSN/4xjcGmgtR/wyr/bSCyPe7wCF9yu+zqObPW7J49npl2haat7zsXLwuwOg5F89PAQZA6EbX56RNV9+5sXt97jXHfH+9xlki8SIexYSN5D5mX0s0zORz1ofUaKlXRgNa4kdy3O4FNs6YkL4SSeaTtM8CU3bsrr7jVS57TgIMmYUWx1ELdLPV6bPtdPftuB1gddxOdof0eDxWo9lpn8wpu93rt5a/nsx1d4FqMq98v2lGicy9bDvqGl2vk3kiuba4rd7ulJrQmp4KmvU7AJPUUpJeJ7uD5kbpeQpM1OdOtoIwzfSc1kZyOxkM0gzfcZ/GYmeMAyFRBH6o9X09V2Wgx+C77rqrcH8SZbq/cvLJJ/O1r32NV7ziFdxzzz1s27aNHTt28OSTT6aEA4DJyUnuvvtuYPAAJIDPfvazfPazn12yP/tUnn9CL2oD9DUDdT3ZZ0xAA/l1+klB2/6A6C0Fj3hfERgJ3ejf5zLHs0AjDL0vKObvef68yPOVnydhwkH3fUhjk9zOPe4CjtzDALEGkPUxtZ3UbCno/q56khSKiAw5kkZ2kU0DYhOgShb/bMaDLIjJAq0r+57XRvLvmOl1pfsz88rOu4ukkp1v9rqyLMAEGJL55jW+LPhkj+fFX3o8ydqto3w8yUKvxWy1bMySdEI0SyOMcwhmE6RmY3mMIMKr6mlQKpBmTA/j+6xlymYUFXV7vkuj0aBUKiEL/L/9ZFmQSShurusuobs9+uijHHXUUUMPWCRXX301v/u7v8spp5zCSSedxEtf+lJ0XScq0DoSdtswkg1qqstVQPFTdx50svvT8XuYp3ouvFkfxzKSXVyzi+yg5rAl/cUAkoBJHmiG7m8FPp9BzukHQsDyoBx0FsWe9zrn8ykC/Ch/LD6n0JyZe9DI/0oL2XnxeVmgi2ItRi3wOfNVr7lm2H9LjmfnkDm/Czgz15fOO7Od+ghz+/LA1OVvLBhL6DKlt3eRV3S9G1jjvhLRXOWTCoMIXA9z1iOwtJQSLRsukWbFbQMV9DnnKf9NTKlOAkqBNHBWc1SSV6ADSpDGGxkNv4tSfSAE1GrUAAAgAElEQVT1igiBl7/mQ1zCMOTmm2/mH//xH7n33nuxLAvHcZiYmOD1r389V1xxBS984QsH6mvZFeyJJ55IB0y2QS30GzZs4Lrrrlv5VWRkZGSEv//7vwcgiiKOOeYYjjnmGJrNZte4O3bsSAOKBg1AWiI9zGVF4NJTejyZ9Xpy7zqnD9gk88jPZxCNpd/+BGyWA5zlNJ9nWpb1B2UbFn0//TTGQc/JaFVL2sbAE+X3JdsZE1qevZhdqCFzPQW/m55acbbPzPhFRJcl15CdV95Em2lTFMS75HjOxLYECHNgmj3elc2h0US2aoCh/DMxNVxzYz9WQomO3xN2XVKQMBv7Y2QK9ulOJ8O6nqTWyZAYhB+mMVXPVznnnHP41V/9VT7ykY+wefPm1P8+PT3NXXfdxdVXX80FF1zAW9/61r59LQsyycJ/xhln8M53vvMATL1YZmdnsW0b0zT527/9W8466yxGRkZ42ctexiOPPMJjjz3GkUceyc0338w//dM/AYMFIPWSgZ6ehzi/J0DlF4A8Y6vARNfLbLe/spyJrKhtIllwyWpHvfpfbuyiMfL9D9JHr+9q0O+w6GFg4O8h9/0BaUAryTkFmldi9ivqZ4nGlF/Mk329iBFF0qt9sJSJ2HWtmfmmmnXu/CXnFhzvArZs+x5zTSSp85SATZJkNc1q7vgIO0zbaplgWq0ZZ3doximBMgGzSZmJZH9SMyot5pfURZJCZQJPqOTPU6z5t3/7Nwxj6X9xfHyciy66iIsuugjPGyyYaKDVLAGYhYUFpqamusxYxx57bN/ziwKIkgm+613v4sEHH+TSSy9FSsmmTZv4/Oc/ryan63zyk5/kta99LUEQcPnll3PiiScC9AxAOthS5GsYGKD6+FQG1Vpg+QW/3zmDSAJIecDJ9zFMn71ApB8IDXKv9+chYZh9/cypy/r5Mgt8V5uiSS5D9CiaY/432evBJ92f/x57nBv53pLr6eVv66lZZo73A8mEHk1AGogr5+PyojGdO/tZ0A3OqqRGDDIJKAUOkW2lmky6v+kQ1uxOhnNQrL5s1vADADJRBN6zjMJ83333sWHDBtauXQvAF7/4Rf71X/+Vo446iuuuu47x8fFCECoSERU5PnLy4IMP8pa3vIX7778fIQRRFKW+kWAYx/UhIHXtCE63Xv+0jLWc/ybvdxnW55H3uRxoyfpyer3n5zHIPFdyXvK5nxlvpWa9ous6GFIEBMOCRF7295r79bHS/pf7Tfci2ABoa1al5TeifTOI1cqH2olPyqw3BYlhscuKlZcSGWLmYTYVVJbWbZfJZ5HIkkX2rvr3/a69Un3RWk6+8e192znX3PG01nlZTk499VT+7d/+jfHxcX74wx/y5je/mU984hPcd999PPjgg2kOy0FkIE3m3e9+N+eccw533XUXxxxzDI8//jjXXHMNZ5xxxoov4lCQg7GorKTPAxZIeQAlWeTz70Vtku2i686DYBEw5Nv1Ao7l5pBfMJcD4X6Lay/trTCmaBmQ6zv3Aejhg4JBfu79/G7LnTfIfc7uL7yHAzAQCyXLmAuCTmLW5XxmWb+Xrnfo5lnz9HJJaBMiRdZvtgIWVS95Njr+gyBIw06+/OUvc8UVV6RmslNOOWWovgYCmfvvv5/bb78dwzCIooh6vc6f//mfs3nz5oEcP4eqDOsAX06GXQyerTLIU2/RgpU9NghgJbISP1K/sYrO6wWmg56fH7vfOUW/lWHNib1MjMvNuwjge/XRq99ewFmk8WbHHUhjyjPs8lnBoUOOyNGuge7kt/lj2T6T/TLoHiOfV/B5KkEQ4Ps+uq5zxx13dIWA+EMGkA8EMqVSCc/zMAyDVatWsX37dsbGxti3b99wM38WyaAO75XKSrWXQwHAllt4B1noDtRYKz3vYPTZq10v0Fpu4V7O91W0yA/rF9tfWQ6I+4F1L221s92hdUee350qaMk8uunmQBddO79ddG4223phnNWBkAiCqD9l41CKzLn44os5++yzWbVqFeVymTPPPBOAX/ziF9Tr9aH6GghkzjzzTL7yla9w2WWX8aY3vYlzzz0Xy7KefQXLMjKMHXpQE8WSPnr4ZAbxwfQCtuWeXp9OGUTDKDKVPZ/lQIHzc+E+9ryGAlp0KsvlwstTsHPU7SK2XnZ/2naQfHvPA7n22mt51atexc6dO9NqmqDCWT7xiU8M1ddAIPOVr3wl3b7++us58cQTWVxc7JmL7NkgywHHwdYU9sfxfyhoMsk8DkSbw3JoSxQEXZkrDupY2QezIFj6oJajX2eZbtk2hW3zY3nFGs6grL5hJELgB/3DO5/5f3W3nH766Uv2vehFLxq6n6EDWzVN421vexvvfve7qVQqQw/4bJSsbb/ovZ+20bf/Ff6gk8DKQwF0Enkm5hIdoCfPA9XPoSzJNWavtei6n6l7kc9xl/3cL1dePyLFcv0sd/xQko9//ONs3ryZE088kb/6q79acjyKIt773vdy3HHH8ZKXvIQf//jH+zXeSSedxCWXXMJHP/pRbrvtNnbs2MGf/dmfDdXHQJrM2972tsJ0LpZlMTk5yRvf+EZOPvnkoQZ+NkmR6Sz7PqyzeNgxkz7zgNLLfv9MyjMxlwP9pJ0ssMv1m33CT7YHOS9/7tMh2fGy88y3yR7vyruXu67s+U/ndcDSh7peZsZBNf4iFt+hKj/96U/53Oc+xz333INpmrzuda/j137t17rSu9x222088sgjPPLII9x99928+93vTvM9rkR+8IMf8MADD/DAAw9w8803c/HFF7Np06au2mL9ZCBNpl6vc8sttxBFEZOTk0RRxDe/+U2klDz44IO8/OUv54tf/OKKL+TZJAcEQA5ARH8vhs8gms2B/DPlxxvGl7VcnyuV/AK63BN5FARdT/bZhbjvHOPFOH/eoACzEk1hmHOKris/3+z1F53XC4x6AVZyzkq0pCXz6EOe6PU/LKKbL/fKntPr+P5KFIEfyL6vfvLggw9y+umnY9s2uq5z9tln8/Wvf72rzS233MKll16KEILTTz+d2dlZdu7cueK5j4+P88pXvpL3vve93HTTTdx7770MmrMskYFA5uc//zm33norX/rSl7j++uv50pe+xG233cbWrVu5+eab+drXvsb111+/oot4JuRAP233XBQHfMrL5ysrOj6IZvN0PIk9HWMMzOLKmX7yC2hR27xkF8pBFvH8WFmw6Qdo/eayEsmOnX0tp7ksN/4g2tsg9ys7j37g09Uut7jnAaBrjGW0mEFB4lDSYPbu3cuWLVvSVz5z/ObNm/nhD3/Ivn37aDab3HrrrV25HYHCzPVPPvnkiuf0yCOPdH1+4QtfyAMPPDBUHwM9Ut9999388i//cte+LVu2cM899wDw2te+lh07dgw18DMp+/OjGordlQ3qKmCurCTSv2ge2ZiQIv9QPn4hf2yl4/eLxdhfMO83v14LaFajWM7sU7SgFpmG8u16LbJZU1OR6WxQM9Nyprhe+/pJfuxe5w7a5yBg0+/+Fl1Tvu3TYY57Oky8YdifoDwxMbFsxP+LX/xiPvCBD/DqV7+aarXKySefjK53L+EHKnN9IldccQVbt27lyCOP5CUveQntdpvNmzfTbDaxbXugPgbSZE455RSuvfZa2m2VM6jdbvPBD34w9cM89thjyxYlOyx0wCb3pynSXvqZ0wY1t/ULvFup5P1SyfaBGm8JkBdoLNkn47wfoddTcxZ8emkfRX0UaQhFkj+efYovalt0Tb36LTqv31x6zXlYTSoPlIMCXP6aBjElHpbl5Xd+53f48Y9/zA9/+EPGx8eXmK4mJyd7Zq5fidx1111s376dL3/5y/zar/0axx13HM1mk5NPPpkTTjhhoD4GWq1uuukm3vKWtzAyMsL4+DjT09Ns2bKFf/zHfwRU+udPfepTK76QQ0FWqlUsqxUt96cq0Gqy7yuZY2Fal14muJXko1omBUsvhl32+EqCGWGp5tHLAd1Pe8j3Oai/YKXHB9FI8seK2vUyAQ4q+7t4D2NuG7SfQTWr/PkHSrPppzkdUJNmJAgOUOXLPXv2sHr1arZv387XvvY1/vu//7vr+HnnnccnP/lJ3vzmN3P33XdTr9fT4o7DzTnq0oA2btzIxo0bOe+889J98/PzA/U1EMgcffTR/Nd//RdPPPEETz31FOvWrWPjxo3p8S1btgw690NKllRgHKL9wGPkCjZFvj9UXiRh6Kp9n3F7Bpb2yCTcFUOwHxrIgbBnD5w6pocpajmw6GXW6ce2yrcr6nsQWc4XUzS35UyA+zOPQ1kGvd4i8D1YZranmzU3qFx00UXs27cPwzC48cYbGRsb4zOf+QygMtq//vWv59Zbb+W4447Dtu20XMuwcs4553DRRRdx/vnnd631ruvyH//xH9x0002cc845XHbZZX37GormtGHDhi6n0nNFlssKOyywrMjPkWg1Gf9Nfk5dms4QoFM4//h8YegH3R7dK5dZr2STg/iNlvOX5KWfuaaf+acfAO3PQj+MJrWScfZ3fs+UDKtlLgfevfrvZ0I8VO/bv//7vy/Z9653vSvdFkJw44037vc43/nOd/i7v/s7Lr74Yh577DFGR0dptVqEYchrXvMafv/3f3/gRJkHvjrWs0QGYXStRLqd7HqajjzvehO63p3qIvujz5vSdH3pH6lHXY8lKeL7ANKwmsjKtLn+2RWK4n+GGSuvFQzDqnqmzFAHWw71+RXJIN9ZP5PW/jw4HKx7FgaHUmay/lIqlbjyyiu58sor8TyPqakpyuUyo6OjQ/f1vAWZLsku6lk2WCzDAM6yi7Yu+xdtypvUiv5kMehkgXJZX00OkBTA9U48uFw//Y71A4VBQK1vpuABnlwP5GKxv47zwzKc9NNEBvXfHJYDI4ZhrMivk0hfb1QYhtx55524rtuv6bNbpCz2leyPbVaXYJnqlS+wlGg4sc9G6HrXdtf4uuzML/s5Mz9h6OplWeoVf06kl/mt6Fheljj1k7EGYMal5rE+YwyaELTrWI7JdbAkzzQ7LAdXnmv3OIogDLS+r+eq9L0yTdM4//zzMc3nSLFrITp+jV7AAj2P9Vq8l+xPFsekRkUWIGKQECUrbhufl4BSdjxd7wBJQiJI0p9ngSY/1+w52cXY6JjwkHLJ/IvMV0Wfl9yP3Bj5/vrJQBrOgPEqA413iDp2D8thea7JQPB51lln8aMf/WjFg1x++eWsXr2azZs3Fx6fm5vjDW94AyeffDInnnhiyoh4+OGHOeWUU9LXyMhImhTuuuuu48gjj0yP3XrrrUPPq5cWsUSjKACkLKj0fEqXUpV9LVlqYS9Z3WADHdDJaie67MxDl1Cxl+7PXEPXPOO+UnDJglb2OqTs1pi67ksx0CAlwrKK+8t+zvcXg1AvDajocx64uo7HjtuioMo8eAwLJv1iTw7LYRleBFHY/3UoShRF/MM//AMf/vCHAdi+fXsahD+oDORsOOqoozj33HM5//zz2bBhQxd/Ohl8Obnsssu46qqrepYGuPHGG9m0aRPf+ta32Lt3L8cffzyXXHIJxx9/PPfddx+gKrUdeeSRXHDBBel5v//7v8/73ve+QS6hWzILbFaLEPE7fpAu8F2Fj7LO+qwPJ7Od3JnI8zugkpWKrUrKZqv6xWMW1iyXEqTWre0k80s+Q2eeCaj4re5rzFCpKVnQaKa+nyzY5H0qiQM+FV2C3zkn8rNU6HhfhinX66/TD2iy+5ekE1kmHiZPBe5FDd5fEsDBZG49W1lhh+W5J1deeSWapnHnnXfyoQ99iFqtxkUXXcS99947cB8DgUyr1eKNb3wjwIrSx5x11lk8/vjjPY8LIVhYWCCKIhYXFxkfH1+SLuGOO+7gBS94AUcdddTQ4+cGU++J5pClDidimZ0a4WQWSl12qub1ME+lwxg6mAaRrpRFUeRntyzQM4uJrqv+S1anIqAuiXQNkfh1/Mx8gyD29+jQaHYv6AlglaxOedkM8SAhGKTaUqZMbXbB746nKfDB6DkAAvALtJkY6LqqGcJSgkOWxl2yiBrNpX31iaEoioEZNNCuaIEvCqg8mCBwGGCeYxJB9CxjlyVy99138+Mf/5iXvvSlAIyNjQ3tnx8IZFYa0DOoXHXVVZx33nmsX7+ehYUFvvzlL6Np3Za8JM10Vj75yU/yxS9+kS1btvAXf/EXjI2NFfb/2c9+tpNsTmT8FImZqkj0AgBazn8TBAjL6tJ0QssgsuIFz9QhUEc1AKkp8PA1CEIi20L4oTrXNDpgZllEUiJ0qUApywrTpQKYjJmNxJyVgKTMXaMuVf+WiajXIFnEE40oAZjkmvJaTKL55O9bAn4xOCSglWo1OSArBOkEJLIa4wrNXf3iLHpF1RdJkeZ0MCLDD8thOdTEMAyCIEitV3v37l2yNveTgVs/+OCD/Mmf/AlXXXUVoPwlw2bj7CXf/e53OeWUU3jqqae47777uOqqq7pSFriuyze/+U1+4zd+I9337ne/m61bt3Lfffexbt06/vAP/7Bn/1dccQX/8z//0518LlmgQb3resd3UrGVhlCxu5ldJQtRspb4b7pAKyOhbRBaOqGVLNxC7auVCG2ToFYi0jVC2yIydULLIKzZhLapwMKyQGr4oyUFNpYOdrnrFdmqTeJ/CW2L0LbS+abbycsyCS1DaUh2DEiWWeyvSTQCy+r4dxJyQt4PkwC2ZXZMf5apmG4Zs2H2nqWv5J5mAEzoerdZcADppc1kjxcF4iUybJ6tfgCzUnLBSs47TGQ4LAdD3vve93LBBRewZ88err32Wl7xildwzTXXDNXHQCDzL//yL5x11lk8+eSTad2YhYUF/uAP/mD4WRfI3//933PhhRcihOC4447jmGOO4aGHHkqP33bbbZx66qmsWbMm3bdmzRqklGiaxjvf+c4hnFEifeKPbKujCaSLpa4W7RQ49EKNJ2GGpY72DFMsWTBDU+KX1SuomES6lr6Ciklg6wS1Ekih9lsSpFBtLV29YnNbZOmEtgKIpI/QMoiSxaWkQCm0DULbUABpGiBFN/nAsghGLAVQKXDonTYUmMXia4/mFhS4JfsSEE6BOQbGhLadSFbTSoAoe09z7LklhIUhpCgbwHILcBHoZM/rBUz5fUWfVzLvZO6H5Tkmoej/OgTlkksu4WMf+xjXXHMN69at4xvf+Aa/+Zu/OVQfA4HMhz70IW6//XY+85nPIOM/w8knn8z9998//KwLZOPGjdxxxx0A7N69m4cffphjjz02Pf7P//zPS0xl2UI8X//613sy15aIJlK2ViRj05HUQGqdp35Q/hRLj01LiVaReWqXuUUyGw8T7w8sjaAsCcoSr6Ljjlq4daXdOOMmTl3Hq6nP7qhFUDZwVpXxKjGgxC/Z8pTmU1bmt6BWUlqQJWNtySCylabj1Qy8mpp7MFLCr1mENVsBql0mtC1kw4UgVGCkx9cYi9D19Dry9Gmhqz4VuKhj0UiFaKTSuY/Q0RKzQFyyuu9Rsp29Z8nnFBCXxhf1ozoXmbYGlV4msLzW0sts1ot0kOzr5UsqGnO5+Q2SFuWwHJYDIW9/+9tZu3Yt73nPe7jqqqtYu3Ytl19++VB9DGSL2LNnT5rWP7HNCSEGrlNw8cUX8/3vf5+pqSkmJyf54z/+YzxPMYbe9a538cEPfpDLLruMk046iSiK+OhHP8qqVasAaDab3H777fzN3/xNV5/vf//7ue+++xBCcPTRRy853lNERzMAlOkoESlioBGxvyQkkhEicR5LiRYEyo+Rdc5DN1sMpem4IzpeVd2j0gxoTohTlwg/IjAEXlVgzfm4dZNIV+1CUyMwBSJUC7Sx4BGakkgX+GX1HkqBdEL8son0lB9HBBLhh3hVtfiYthmDl4Gxr9G5VilobqhiPwGBraNLSWgZiISgkPhosqQHywTcuA8dGYNyck8SSba1oOOfoVLu1haTxTDxOWUZeImZTcqlBAiWUquLyk/3ApflFvh++wcBrGH775XsM5E8YPUiJGSPHdaGDlGJOGQpyv3kgQce6EolMzY2xv/+7/8O1cdAIPNLv/RLfOlLX+qiIN98882cdtppAw3yz//8z8seX79+Pd/73vcKj9m2zb59+5bs/9KXvjTQ2EtEAKZBaJtEsfNdc/x0O9LUj0FzA0JLR/ghmqP2RboGTdkxRaH6IgiVo79mK9UwXkDb4xp+HOISmBJrXhAaEFoaTl3Dq4E5r+OOaOjtiFBK9FaIO9JRMCNNEOmCwEx+pJLAFCkYhYFGKAWRJpBeSHtMLTTlvTqhqeGXRde1RprAGdEo6xpOXUcfswnKBvqsqhUkYl8OUiqqNa7S4mIA8MsSbaREJDW0pqdMb4BsuKnvSXPie5NoNjHLLpISzYkBIXmCj89JgBxdJ6yVOip2yeodCHqIVDQcRmvKA0Jek+ll4lsuH1ev/F7DJo48mHKYlv3slDAMmZmZSUlV09PT+P5wuQsHApm//uu/5jWveQ2f//znaTQavPa1r+XnP/95T2A4pEUTsW9DLcKhFFCWaEGE8CP8svpzS10QGBp6KyCw44XQjxCOheZ4hJaBFigtQi2UuvJ/JCa4ZotIIwUZgKCkIQIIpcSrqWOtVWo8ryIwGhGuoeGXBGG8yOhlDS2ICKXALwnMRkhgCCDEL2tEGhgSQlNgzkI7rh3nVXR8W6O5WqO6TcM5wkL4irPVWCuwd1u0xyTlvTqRLvBWKV+LNRMTLqSW+l9C20JzHLDLuCPqXkgnJLB1df8AMPHLEnPWUSY1UAAdhKkGFekaMX+uSzsk7kP4HX9TZOkIx+8y5fWSYStxrrRy5zAZtvv5gfKax3KLcL++iuRApLvvN69hzs1rXM83wBHPUgrzH/7hH3LGGWfwpje9CSEEX/nKV7j22muH6mMgkDnhhBN46KGH+Pa3v82v//qvs2HDBn7913+darW6ook/k6I0A00548sSzVHLnhdvh5ZGYAj8UEMLwAdEqBbnsCwRoYWYCZQ/hG7TWmjpCDcGJMvCrYFbU+MKD7QA3COgvAecUXDHQgg13DqYCxAagkgDr6I+gzqnNaEhQvAtCA2NSCrNyK+AbIMzJpFt0NwILf7vuqMSZ0SjPQ5u3cSpS6QTIb2I9kSEV1VA1zjSQm9F+GX1J7C2K99OavpyPUVIsMsx6QCccR1r2serynS80NSIpMDRSkgvRPgRmhtAoMgIga0jmz6RrSGCkFDGpq8gVFoREJnKHBfYOoYTENmSyMrE9mQSfXZ9pwUBpFBcRqCXLDG77Udp6kFkGPPasG36tRuWft3LvLdcPNFy+59vAHOg5OGHH+a3fuu30s+PPvooH/7wh/m93/u9dN/3v/99zj//fI455hgALrzwQj70oQ+teMxLL72ULVu2cOeddxJFEV/72tfYtGnTUH0MzA+1bXtoVsEhKUIQlA28qsQva1DV0FshXkVDemo5cysa1lxIoEEoNcLYVBVKgd4KUie87of4NQsRRkRlQWDFpjddLZpeHbTjFgHwf1ZFBOCOhsiWhl+NiEohQUkjMiJ8WxDEfnK/EuHV0gnj1iCSEOnqPShBaToGHR0CEyIN3BENd0Sd5SxqOHVwjgjxbaXxtMeVJuWPe/hlnUgD4UNjjUS6CkiD2Hwmwgh9pgmmgTtqYcUxPO1RDXMhojVhEBogkhhKT/mZpCfQWxqyFaR+psDWceo6huw8zckY3CNdJzA0zDkITUlgaYSmhrSN1Lxn9EnmuVz1z3x9ml5tsp/zx/u1X0n1z2dKirSoQc/Lnt+rr15glCUr9PMxHZZi6ZcBJZEzzzyTb3/72wds3E2bNg0NLFkZCGTOPPPMQie/ZVlMTk5y4YUX8oY3vGHFk3g6JZLKge5VlEYQSkFoKP+GX1aaBEBzjVqQ9Xan6otfElhzEuEbsRO+RChFas5yxnWkYxHpAsMPcccDyppaTN1qRGCHRGaIX9UI7BCt6uGsA6yAwJFoTYkIILBD9Dn1h2ysjwhWu2gzJqEV4tUEIhSIQODbEJYijHmBXwUyMf9KgwF9okV7rIJbBy1+4Bd6iFcRtCbAWNSUn8iIAaGsrk1vBQS1Eprj446o6xJhRHOduoeap8x9UrlyCDzlb3KlQLbBbAg0N0KWJZEUhKbAHdERYYR0Ixrr1eJdmlHmPxEaBGVJKJW2yRGdHGlG3hGfT2mTLGg5TUeVNegUb0vPz6e0yRAKemlL2f61crmn9pTfd1C1oWHMd1kw7AEYiRSB0DCU8CJTYL7Ncp+fcxIJOMDmsgOWAaWPOI7Dv/7rv/L44493+WKG0Y4GojC/8pWv5PHHH+fss8/mrW99K2effTbbtm1jy5YtrFmzhssvv5yPfexjw1/BMyCRgNaEjjsi8CpC+UZK8QJbgtBUi6dngzMOzmjcriJwRsGrang1PdaEZOrX8apSMcZq6sk8qJiU1zSYHJtlcmwWeZRieK1ZP4tbD6msW+T4I3eDFbB69TzC9mF1G3/UR6u7eBMe3oRHUI7QSz6hHaCPtxGrHKJVDu1JH3/cJ6j5OGt93EkHtwbO6kC9xiO8CY96rZUCjhdfl1nxcOrgV0OcOjTXKVBqj6OuydJoH2Gk9GqvmgCzjl+JcGN/km9Da0K9vBo010JrNYSGuqcJgcEZ0XBGNAJL0Fol8arK7+SXBM1VEq+qANqtavFxRXTwqhpOXRK9YLI78DVDExdZ5hoFANKvjEGvJKfZRbJHMtR0X4G2kwBWup2r9ll0XvbcZec8YH8DZ8BeZtFP++7BXBvE7Lecr+k5DzBDyN69e9myZUv6SrOUFEhRBpRE/vu//5uTTz6Zc889l5/97Gf7Nafzzz+fW265BV3XqVQq6WsYGUiT+d73vsd3v/tdXvziF6f7LrnkEt7+9rdz9913c+GFF/LmN7+Z97///cNdwTMgyuchUl8JgF8Co6kW4NBQfpAOKwz0RtxQU6lVCY8AACAASURBVOYi4UNgCUAtnOaiWlCVc17tE2HEKese51XjDwJwT/VYvs9xHGE32FMb4f878jHWl2ap6i5uKKmXWniBpG612WjPsKut7F6Pzo0zXm6yNZigYjusH5ln3imxc6pOrdbCDyRhKFgzssD2mfXo40q18EyT0dULrK4s8sj4KgI7RIwIRABHVFrMVauIUZd2yyK0IrQYaN1RGWt36pJDMwYEW5kN/VEf2TYISuDVI0IrMXtJ/HJEaEWAhr4o0ALQ2xqtCUEolbbk2epGtiZU/7IN0hOECx2gD0oCryIxGhGBKVg4tkZ91/SSND+dAFgJftBdaRS6fDnZ93xS0Hxp6/x5qSQUbLnUT1TYvse+ruNDMueWlKLOAUzeH1VUyrpIq+k5v4IEpfsTaPq8lIiBNJmJiYnurCQ9JMmA8pGPfGTJsVNPPZVt27ZRrVa59dZbeeMb38gjjzyyklkDKlfld77znRWfDwOCzEMPPdQVHAkqM/PDDz8MwGmnncaePXv2ayJPl0Qy9muUwRuJ0BtCgUaJdFVyY4DxqyGaL1JmiFePEJ6gNKs0HKMBgSmINA1nNDG1KTaYV5WsLc1jxE6LV43+H48tjvOqiYdoeQanjTzKz5pHMmnPcKL9JPcvbmStNce21hEArC110urYusv0qM1kbQ6AVeUGrIL1lXl0LWCqXcHWPcK6x7oxxRjYTY2q5bJ9Zgx/3EereoSO+rMbMqB9pIe+WwFMVAoJ6mqe7VELEYJXBRFoeBVoTILRUFqJLPs4a0G0JFE5QOixOXBUEBkRkRniorRAa59Gu6kARTrqHnu1iMgQxGFAaAG06yBi2ll7XPl5StOdhwG9JbpLI6T52Ry1Hcf25P/Gad60JK9cJpu2upjc4hcEad40UbI6dXtiWZJTLWOmA7rLIOTa5GVZP9EylU7zWbH7tQtbrZ5aT5GpbTkT3CDkCVgKcIe6n+rZJkUZUBIZGRlJt1//+tdz5ZVXMjU1lcYdDitnnHEGP/nJTzjppJNWPN+BQOass87it3/7t/nwhz/M5OQkO3bs4LrrruMVr3gFAD/5yU/2qzzn0ymRphhffjki0iLceoTmxxTaAEJDLbq4GlR8wrbEq6sFNrBD/IqkPar8GF5FKL+OoUxpiUhHaTmnV7dyaulJAB7xxtk8upMNxjQnje1kk/Ukx5p7GNVaGCJkQl9gQs6ztzzCXr+WgtMOa5zjrN2sK80xaU4zoS/wv82j2GnWOcaeAmBzLWCXU2fqyI4au2ZsgfWVeUasNg83TTaunsYLJdOLNrbhMrp6gTm9glnxMPSAMA4Wc8YtAlMBqgJY8Gohzpi6B2OjDdq2gedLwkBQsdVC3ChZGEaA50l8XVdpMvaZtCbAX+PityWRGSLLPi3LUvcYcGSE0CJEYJKs4F49ApTPSQtg8UjBEUl+OSkzmQXin282aLMr4DPJhZbkQ8uZhZKNJG1Oo9nJVJ3TdgCViy1uH7WdDnBlNaw8cCWfc8lGs9rPEh9QRlMqlKw2t1w7lvqZurNqGz01nq659DoGhcSKQcx2vTSy56rjP3mIOhBSlAElkV27drFmzRqEENxzzz2EYcgRRxyx4rH+4z/+gy984Qscc8wxWJZFFEUIIYbKWzkQyNx0001ceeWVbNq0iSAI0HWdCy+8kC984QsAmKbZN+DyUJFIgjMeEVRDkDE1WQoiM0yfyoVUgZGaERIBvqn2a1aAEwjMecXikpmM174dgQaRLtAXFfBsMPZREmqMkvB4w+j/Mqq1+IWlnkBONZssRD6rtBJeNM2LDclUuJtZY4qFUOXuGpXqKX3SnObU8uO0I4OX2ttYZYwzKpspGHmRZGNthllXxbZUdRddCzC1gHWr5igbHmU6f+yjR2d40DEx9ABdBviohau5JkQ2NUI9onVmA+OeKlHdY3GjiTUtOLo2R9M3sHUPN5RUdXUTnrJGMGI+c9MzsQ2X7dY4YmeJyliLxlyJar3N+vocP2+to3qEui5dBsxNV3BHQ6UJSqUNCc/Am/Aw9hq4dTpZqoNQJRAFtCCM42no1nTid5Gt0VOUC03GC1piArMy2Qd02Ul4nT033k6SfgoUNmaTpqYlFLKi60SO051JoWA7nU86xw5IpVpZQS2fXiUTUrNeyUqBLgs4wwS0FmlYXQCUIVz07Stz3mFNZ3ApyoDymc98BlDZU7761a/y6U9/Gl3XKZfL3HzzzQNnZimS2267bb/nPBDIjI+Pc/PNNxOGIXv37mViYqIr3fPxxx+/3xN5uiTSY4ApBQgjJHQksuqp6nSBQDNCQk9DswKkERDQ+aMaJR9vFFoTJQI7Bh5PENSSxUog25LWuhBzRmOD3qIddb7gUa3FeulzTvX/mJBtFqIIA4ET+bQjAyfyaEeCUS3Ai9QfdULOUxI+hvApCZ+9wQglzaMkPAwRMCqb7PVrTJrTUIX/nFJmTT1e8G3d5bh6C0vzWfAtTC3ADSVrSgtMjVSwDZfpVididOSYWebnbHUtWkhzMqRSb9NYMGiuixg1W5hawJjZZHe7hhuqxWx9ZT7t97HFcUbNNnvtKo1xyfr6HF51ES+UrLfn2TE2ih4v8OtH5qlaLk/JUQgE5ZqDafgslMtooSCYDBBaRGibKs2PnuGqSI3IVDE9McWgo93YZVXuIAGIbEkEqYGbWdiSXGuO2yEV6LpKieMHnRxsaRaEWJKFO+lDSnBcRMXuAgVAaUGJBqTrioGV1NeJtaYEnLK+pRRQ0muWXceWtM2BW1SgZRX5nIo0q8jzU7NhWqk0p3V1aWEFJsQiGYSZ91wTcYDSyhRlQHnXu96Vbl911VVppvwDIUcddRQzMzM88sgjtNvtrv2DysBxMnNzczz88MMsLi527f+VX/mVgQc7FETTQ0TNQxoBYaBhVF0CT1KyXVoLFpoM0c2AMBBYlk/TkwhN/ZUNPYASBEZEVPNBi4iMEByJZgWEjsQdB2REezLgSFnjPld9MRv0BfYGJfaGIbOhTTsymJANNkjB/3kGJeHzY9fmVLPJ3jBgV6Bsq6NakzsbL2aDMc0LjWkM4fOUN8aEvsAT3jg73HEszevSagD8ePHXY1ABaPrdT/O24WLrHk3dZzHoHBupN7H0gIWWWlwrlkuj1lmUdS2gojvYupWOs7Y0z/bmGJbms96eZ0RvwwRss8Y4pjrNgm8x65aV2W9sFj2mdh9XneIXrGJkwy7mnRJtX6dmqoXc9XQmx2Z5aq5OUFZz0dwAJ6Y3l/0QZ1UZa3dTaTRJPrW4dILWNNNFN1uvR5VSMFSKmyBUwCFjcLHL4HqqfVIvLZt1wC6rc3C6yid0JJfUM61U2qmVA6TnJaQFyBAZoLuPxHwWg1S24F56flowLlsET3ZVMU2K8SWaV5QBzCLWnFatqDkmhAhdByNIwSeda56dlgBSvh5TDwBKgUpKcNo8XXI4Lqe//O3f/i0f//jH2bFjB6eccgo/+tGPePnLX86dd945cB8DgcwXvvAF3vOe91CtVrHtzlOvEIJHH310+Jk/gxIGWgowoSPR7JDIi5NDygjDCAhCjcCTND1J5GlIWy2wraZJrdZifo1O2XYJQg1DD3CkTsV2cEs6Lc1CM9RittVfpBY/eC+EOhOyzd5ApVwZ1Vr8uL2RJ/R5vrHvl3hRZRejsklJPMkj7gZKQo25EJTj80t8d/EE5gKbumzSDg2edFQ+obreUu+yiReoP/Wib2JqAbbupuBix6YtM5Q4oZ6avLxAMlZWfRgy0YA8DFlh73p1AS/cuBsvkFiajxtKdjTH0GONBmB7U82lojtsb47xospujjDVA8n60izt0ADGqck2J4zswQnVT0/XAjbYs8zEbIsRS5n61lXmmXXLjJotmp7J4uQIWhBR3uuledy8sRLNNQbSKSkz5ULHfhlaOlqzTDBSQmu6Kuanqe5pUDFVJmrilEBxhgMtCPDHbPSZZkdDcrxOmhwnwFljU3pqAZEUncNOCQhhrYQ2G1MR4+zWncqofgxm8UILGSq221mUM8lIgQyAmR1/kdUBT3wfLDoaV2JCi6usiuxir0vQy4hEw8tXKYWlvii7DHNx+okEtKTsECPy7bPVTzPtllRGzYzbj4F3MOQwwAwmH//4x7n33ns5/fTTueuuu3jooYf4oz/6o6H6GOjbvfbaa/nqV7/Kueeeu6KJHkqiGwEV22Fup9IUAk8ShYLmTBmhRbSbJkKLUuDJZ0+19ICReuJPCJEiomR6SBFh6QqgpBbieZKFUOcJXyUTa8ec4Nfau3gimOXH7Y082FpPyfZwQp3FoMTdM8fCKrh/cSPH26qUwQ53HCfUKZU8trZX44eSbeERrC/NAtDwY23ChG3uKrxYs6hrbeacUgosTd/E1l1m3TKP7xtn85pdAPihus4EXLJiGy4vXrObnYsjjJptbN3lieYoZmyK07WABV890SZmuB/tPZqXHrGDhRhME3FCnaPsaaa8KkeYizzWVGyXCg4V3cHSfKZcRVyo6Q4LvsUGW13jxtoMj7KG5moNzdXxKmrOWqDTPkJg71aZAUQcSCrCiNDU0JwSoaUTxRrO4gsUb92a89EcDX/MxqsZlJ5aUGmCZAW3bqI5Ps6qMnorgIZIE382jq1gLIb4YzbCD1V6nDEbY+8ioW3i1ywMNzY7+SHeRDUFM4iBJUtAS7SipOx2xV5CaghrNlrTIRqJc7n5AeFYh0GUJhydX+zWGtoO0fgIYnoeRjJ8/SDoaE4VOzYRZkEioxn5KruFlsQmJcSHuAqqqNgpWQLomAuzlVNlp9YSftDF2kvYeJHjdDHzelUt7RU4WiTLZaYuSk46bKqdoSQC8SzFs1KpRKmk/suO43DCCSekrOJBZSCQ8X2f17zmNcPP8BAUgQID0VbpXKJAIFxNkQBcjagtiWy1UERJZH2z22ZctVwWHZNm28Q0fAUukUCKCKmFmIZPEGrc2XhxqpEAbDCnedQX7ArqjMomO9t1nPAFbFtQZqZZt8Q988eyu11LfSq72iPUdIcHFjew4Fs0fZNRs0U7NNjRHGPMbKZtAXZO1QEwVgcpcCzGmowZSvY1K7SmbPaOVCgb8ZN9JFK/zLH1aRZ9k6ZvsGexytGjM2nfzVg7avrqfti6m5rL3FCqeB+rTcO3sEx1DxNNx9J8SppHw7cwRMC42Uj3gzLvrS3N44eSeb+EqQUqjki22dZaxf0bBNYszLxIYs0mM9JwxmDuWBN7T0D7CPVzNhdVFoHQ0lVmBk1n8UgDsxGnxhkziCbUNeitiNbkCF5VUnt0gdaEjtEwCeKsB95YKU0CGhiCsK4yGIggwljw44SqVTRHbcuElNB0VXqcWLHxx2xkw0VbaMemvaoy2yUluR0Pf8xGc3yVxy3je4ribODe2hGMXRBZEr9moi+4qm6NqaNR7Sr3LWdU3SFJrEVBWsZCm/KJRiqI+Qbo5W5zGyhtK6655I2VsKaSNqpaaapdWZZKdJoFsUTyZrxSTDWv2B1GXNZHlNQwml0+q0CvwNGikgcryfO20rQ7z1WZnJxkdnaWN77xjbz61a9mbGyM9evXD9XHQCDzgQ98gD/90z/lgx/84ND1nQ81iRA0HFNRaINMRbpssFRTVwwnLYJApNpMNpOqLkNcT70HsXO/4ZgEoYYuQ8K47Q5XaTKrjAWecMd5Iv7cjgzcUPLQ/BoWXIufz6noRCfU2bFQTzWQWbfMrFumqrspWCS+jUSTcEKdXe0RZRbbo546mmMmeDDdslldWaTlGZhagONLRFvDCyV1rU3LM2i7BhUrY6KJpeV0fA0JiLQ8IwWvZF5ACjxAavqyND8FkYZv4Wh6CoirDGVK2+XU0bWAI8xFqrLNVJy0raI7VOOcNVtqj/GtjS+ltU5gzmr48VR9W+CMq1xw5SmVlUFlG1DJQyPdwq1oVHb7KrNDogG5imUo2+CXIkYe85g/2qC6XcMZE7QaJq1VEhEY+CWNKP6XOGMCvQGRplISaa6q32POuSxurKC3QxY3VjDnfWTZoDVhpJmvI10g5yMiS1eAM+8QVGKmmh+mmaiVjylKSygkIhsuXkVHt3T8mhmDm4kWF8AzZz00N8Crqe/BkCrzdinWtuS8Q2RJ3FGLctNVxfCcxHTldGszdlnljTNV9gosC+zYPBib35LS3WKklmpfKjN50Cl/oSdmurgMRpdJkI7/KCl1vh/lrAdNeTOIHBSAOYAU5qdTvv71rwNw3XXXcc455zA3Nze0RWsgkPnLv/xLdu3axcc+9rElnOvt27cPNeAzLb4vaTXNDqg09JTKDKjtWLuJzBBhhB0gMkIcXxJEgoVmCd+VqV8miTMJA4EfxFyn0GA6NgE1fAtdC6jrSgtp+BZbZ1dhGy5t10DGVOcHp9cgRcRUW53X9EwWHZP1I/PsaVSpmQ7zYYnpUoWmb7Jjoc5kbY6diyOsq84z9lM1j6nVVcq2S2OmTLOu/tQLsdnCnNVYdEx2z9So1xS9uNFUGbXXbZ6n5amFym0YGdKAga6FeKGk6XXAxy+pa92zWGV1dZGn5kc4enSGGdfmBdW9bGuOU9EdptwKNd1h3GzgRZJ9rhpvyq1wlD2NIQK2tVahawFHlafS+7cQlNhgTCtqs4xoHxkQxRmc3XqIGHVxF0vMHqcRlIFIBXK2xxUYALQCiV8iTaIUWKAvEmcfEISyhDMOrXU2XlUlGm2Pg3RV7Z7E1NFarcwe9k6hUhBJE70dqWqkVZVTrrlGw6mb2FMBjbUabkWBvnQjrKpOaU+b1oRJGWhNmBiLAaFpYCyognTOuI7esnDGY43ICZW/ydTwbWXia00YhFKl6DHnQ0JTxFmtjU6iU1uPC+SVsKbbBCNWWv7BSMyETZdISsJVVfQpBfpJBu5gRBEl5o82MOeqiCBEOAFRTVdaWqyxRbVSqnWFpoYZxCa2pkskLfzREubuhbQsuD7T7Jj17OQLCePy4jZsK/jT5mSQIM9BKNJPd+btZ6N84AMf4KMf/SgAZ5999pJ9g8hAIPMP//APK5jeISrZKnUF4AIocHHjP4Cnpe2iUDA/ZytqsxebJbSQ5qJFFJ8rZESjaaHJiIWglPosLNNn2q1gaT5OqPOLxVVMz9s0LBPPl0w7NpqMqNlt/EBLHfhtX2d+zmas3KLtGjTbJu2myd571xIe18Bvq69w3+4RpqwqG59Qj/n7PI3m9hp6U6MF1Fctsm9vDbPiUX8sYu9RFWjqTC2aaA2JlmSgDiVeKDG0AG3GxN+osdCyqJcUMWDvfBXflVglj1rZ6aI/75gZxWkbuCPzNH2Dbc1x5UNqjjPrlvFDyYxrp1oRQMszqOkOxLi1yljk5421VHQnBeiStp7K6gaNuRICcMfVqq/VXQWkdQO/KhAhGAsKIAJLlVOIdJVwM8nwACA88MsgXZXuJjLAGY2YfpHEGY0gVAlHnVGVcSCxRvqViFBXZRGkK9Cb0FwjCA2DxnrBwgaZJgwNpQr61WOG2txxgup2iQgsIq2TpDU0VcYJvSVorDXxKgJztvO3bK7VMedDQMa+KBNnRENvqZQ7i5NqzNJ0iFcVGIsxyJhKs9MCCSigCy0Nr6Lh1k0FNjFAeBUdEXS+xyRJqvTC+B5qeDUD6YS4owblnU2c8RJ6nGk7zGTXVoQJVaDOW1VWhfEWTLyagd4KcI4cwZiJC+TF/qvIUgDk1s3UZbVcRoKiz3mw6KJi51PpLBNcejBERDxr68ncfvvtSwDltttuO/AgkyDYc04SYPBEChLISP0ggjidjKshzG5dNwy0tL0XU5yFFqXgpQAoYFtzPNVIZt0yq0uL7GzXGdHbKt1L01D+Hi1CTpn469o0NQUijWZM2ZURTJvsMEYVScHTqDxoUpqG2ZKNJmHGqKDvNvEmPKwptaqZO+rYO1UutoZhsDA3hgzADQXjD8yz5xU2pT0Sv6pBCNasmvu+ZiWlLhvzAl0LaTdN5splbMPFbRhEvkbL03DaRpqqJgpFSvXePjPGqN1iZyAxZICuhexrVthHJTUtJpobwM9m1nLi2C4eWxzHqer8bGYtZ67ZylPNEWzdY84sUzI9vIrKMqBV1GIhYxo0tg+OJJQRrhFhTku8CY9oWkcEAreuctBpbTW2v85ByIhoyiIccwlLCuHaExHBKo+gaeKs9dAcA68eoS/GWmpdjRuGOkE9wJnTaa9Ri31gqSwSXg2CBRUv5dUjmrEHQjoqSanZ0Gis1ajs0mPzW3zc09Mid7MvMrBmYkAMSBONehWBCDWaa8CaU3ngjGaSikfDr5Au+Ho7SrUaVbwu/p6kShHUXC3RmyZeVREl/Jg1quotqdpEYjFSiVYrOqGl4Y7oOHWNwFC/6aRia1JNNrBUKQy3bmCYajy/rOGs6hS704IIv2apAndzbnyNIV7NINLFUADQBSbLlHXIp+JZNj5ogPIQzwf59Kc/zac+9Sm2bt3KS17yknT/wsICZ5xxxlB9DQQyy6V1/vCHP9z3/Msvv5xvf/vbrF69mp/+9KdLjs/NzfHWt76V7du34/s+73vf+/jt3/5tAI4++mhqtRpSSnRdTxPITU9P81u/9Vs8/vjjHH300XzlK19JS4QuKxFEnobmaESaSiGTaiEhajsQYMapZaBjWgsEkaF1BcAlGk0U+3d020v3NX2TubaiIDu+xA81FR9SgsZMGTkVP4UZoC8KnGmLdpzUK0o0i1qA3lSU6mjBQC5qVHZF6K2I0QdVwbMF20DIiPI2A21K5Terbq9TfcqnsUanuj0GxCroO0y0XU9i7apTeSoulCbB3qMW7J0vGqFSb9NqmoyqjDiYW0s49Sb1UoC+U83PrwcYeyTO0YopVNpuIl319O7VXNq+zt5mldFKC8eXzE1XVKDrooFW9bBKasH2PIll+fw/fxI/0NL4mVu2noRdcvFMhx8uvAApIiZGFll0TFZXlWnHC5TWpcuAhYW4iqeu4coIWfaJDB1/3COwAsSUhbZOAXDF8nEcnXB1G12GeDUVL+VPq+wE7SkDo+rijuuEdY/Ajhl7qxaZm64QVgKMqoszrhNJQANnIlAacCDQW7rSpsY9rGkFYI1jPaxdBnpT1fZxKxqNdSprhL4IWqDKTTTWR1izgsVJde9Le1WiUc2PTYBS4I5HRFKAIC7nDe0A/CoIxfugvDde+E2BdCM0Ly790ASvosqCu6MyzkDe0Ua0IOoyEQZ1RajwKgK9FaV1jQDaYxJ3RGDNqn/E4nqB3jLxKqqirFPXaU0IrDmN1iqNZLnxqiIuoRETUuYUSaK1SlLO/V2LgkPzvpt89gJh6F3ZG4p0iKTPfglOn6/ylre8hXPPPZdrrrmGG264Id1fq9UYHx8fqq+B7uoTTzzR9XnXrl384Ac/KCyYUySXXXYZV111FZdeemnh8RtvvJFNmzbxrW99i71793L88cdzySWXYJrqR3jXXXctSfB2ww038KpXvYqrr76aG264gRtuuGFgFS4KBcIDjDjKP87RFRodk5lox05ip5PMEVTkdcI6w4or/XkawgiJHJlqJqGmsXNxhLl7Yof+6gB3jY5p+GyfGUPfbVLdocw6zbUR5jwEloa5oBYCLdb+NU99Re2FEqEEaw7qv2ig755j+uXrsOYiWhM6tW1Qmg2hocxao1sdrCfnKT9h0F5XIbS0tFZLNL/A6MMRjbWC0a0B0o3wqnECzCmTRV9Dn9UZedzl8X3jCjw8nemWTf0XKq2/25RUngLniLguzLRypAsPGgsm+6ZLiLbGHs0GGaE5GqEdYO3S8SuS5qi6LmuXQasS0RhzoanjrtGxSy7tHVW0jQvse3Qcah4vO24bi76JoQWMmsrckjW7VS2X2WaZMBQ0/TKrxhbZM6cyUTeaFn7dY9WIApmGY/LCtXvZPqMeSgwjwDR85j0FWEE15Ihai2lPYpZ8vHjxsfQAs+KlDMKFkk1ohYRSUl6jaGTtpomzIfz/2XvzKLnKOv//dZeqW3v1nqTTJCS0QgghMUSCzsAo/BDkaMAdBlmMGmFkBhQPwznIGeA7LriMIjAyKAbIOODoUREMixIjiAIybKJJCCFbpzudXqtrvVV3+f3x3HvrVnV1pzsbhNz3OX266i7PfW511/O+n+39QS+JAt1Cl/gfCSXKlDttQpmwsJjCEkbaxIiYsCOMXhGuOTNhUUhX/w/zUeEG1AZl9A4TyVSwNAv9aAMKKrIuYyYNZD2E3m5658kVp0FdHCLDEsUO8f9kht2ECZANGdl5MHA7sRbbxXdBNkEpy6CVyXWqqDqU2oTF5iY+SKaIU9kOQRlxQTxGHJRKiGKrjBmC0W7x+RXbZBHDclpnmE4PI1uVvP8/v9ioK8Mjue8r4xURXIwrClWr+m+2/xjnOH/9UE2g39WYO5DBf7vqcj1ckE6nSafThMNh0uk0TU1CnHFkZISVK1fyox/9aMpjTYlkVq9ePW7bI488MmW9stNOO41t27ZNuF+SJLLZLLZtk8vlaGlpQa3XfqrDAw88wPr16wG45JJLeM973jNlkpEcV5hSBtOUUfMSRtQmPCI6VkoVsc+I2kQGJApd4t9UKchU4rXPRV49ja+uRpJtrFyIoV1ttGwT5+bLCvlwFD1qIO2KkOiDps1lyimVWL9EfLdO5mhNdJu0hI8dhAsi0aOTLWooFWHByLqBPTRCfHcrkmGTfi1CxxP96HOavCpubccoDI8ix6PE9IrXItpMRbArBskdOkolTPLVUaSBES8NNdc5g4KlEu+ViG4doZhtomOnzZ63axT748TaIbnTJr5bFEbm5ggGbt5YxpYllJkqFSfRIDIo4iL6LIPmVyRKLSrhrFjI0q8KcqokQBuWYKdGYaZNkThFJYZakDFeTqPEbUJ7NJqPL4iMu0g17TlraMTAk7rZLjcTUkz2hAzmpkYYbY/SHC2iqSazOse8DLhZCaFw3RQrMic5wot9s0loZcoxlYRWRp07QjKsCkbTCwAAIABJREFUU0qEsCyJUEJ8pq2xPLFQmYql0BbN81KzEBgtKRFaI8L105IoMJyLUbCiaJGKJ3+WThYZcVxaZsJCl2WImCDb6HPKIIXRZxrYio2smdgFV/zThJCFUYhAxMTSFIgZRJM6uiOLJIcsyi2qcBs6LttyOixS9BXhgjOjQvDUjOC56CoxkDRhARluJ3Vb6PApZUEE0aSOkdCwQ4KgsIXLreQ8zBpxG90RmFXKkJsjXIM5VbQML3QJLTxFFw9Uye3CfQl4ccB8WFiEuTnQ5tbLOMWinlSOFkbS9RqhU7ukezU4Xu2NW6Pjk9Jp1ApCimjV7La62qCG2nNHKF5++WWPYACam5t54YUXpjXGPn+S73vf+2r6Te8PrrjiClasWEFnZyfZbJaf/OQnXqq0JEm8733vQ5IkPve5z7Fq1SoA+vv7PeXnWbNmTdpq4M4776w2ALJFnCWcAWSnpXJOPI1po+KpKjIonsqL7RLhLJiD1bRtL7zouMe89GYnHiGVHXeaYjPjWRu1JMiiElextofQ2xQiwxLtLxQJDeQINceQTAtlrEQ82oxaNAkNFrFiYkF0q9SjUYXIngKYNnJBxyrpaFuFhlE82QG6jrZjFLMoLBlleFQUuYEognNSR80ZSRSjQrg/S3hnxav6tvv6AYj1d6AWhDtDn9MElkTzyxnGjm7C0qDtFQNtSHyhZd3gqN86oqKGhVyoYKsJ0UOmVSY6ZCFXZKIDKk2vlcjO0Uju0CmMhgmPii/4yHEhIkM2SsWmaYvN0EKFyCDE+030lIxSsdFTkijYtAxU2STvJFPMjIwxXI5TthRSaom3pwc8JYGu2Aixo8qk1BKD5Tht4bxX7OmiO11kViTDlmgbC5t386rczqy4qNVpDhcIKSbzEsPsLIgv2XGpfobLcSGZAxTmiL/RdlqYnx6mN5+iMz5GSDbpB97ePkBGF0H3kGISUQ36FYtoyKTYHyeadnr/VBT0uTbheMVTti7HxH3EItVEjnCyTGWuRWtLDkWykWUbKyIhyzb5iky6JU/ZsXyLJcXLyJOKCnKLjll0JHYUFStmYsQVLNX5v3XCW25nWEuzsbsqdER1hqI22BLlZgs7ZKOURbzJjIkyAKvNkV3KypgRm0pKuPmMGFhxE7kiYYSEp2CsW/Ie4gqOUn1qm7Cqy2lnElq4WlfjEobqCJjGY57ititSSkQTYqhauJoirWlCYcGoSttI/qJRVRH1QN42s7rNMGrrhg4ADtdiTMuyGBkZ8UIRw8PDNR0yp4IpkUy9dEyhUOB//ud/OOqoo6Z1sYnw6KOPsmTJEtatW8eWLVs488wzOfXUU0mlUjz11FN0dnayZ88ezjzzTI477jhOO+20aY2/atUqj5y0OUehFCVaN5iUmmUiYYlQ3sbeLb5oRqzqY27ZYBMeM3B9x5FRi1KH+PIqBdlTZ3YTBSjLaEMyequEokvEdxWQdbcCPEayR2bgRIXkTpvQQA7GcqiFonhSy2SJaiFRLFfQBSmAsDK0MOFYCDlbAl3HzmRFpowj9xF/2YB8EduV/0BUUXtChK5GVUkn/EoRE2BguEbi3j02OlAh0WOhFCtIhkXq5TTyyG5ks4nwIMSf31kVjCzpyJ7KsVgU4gUdKxlBPSqBpUB6SwUjJhPuz5IElGKFxHZTpLICSiXlfD42SrFCUyhOrF9HyZcJJzUKs8JEB6vE4ieKzsgor+faWJDaTUSukFBK5BylAbcOxy3ydKV3/IirOhG5wjFNg8yNDhFXdS/FPOmkic2NDnkZgu6Yx0T2ULJDqLKJJhsUKmGOSQzQ5TSbW9TcR7asMT8xSI8svpzHJAbYMDYTEEoK2y2ZGaks7dE8A8U4/WNJWhIFQrJJNFRhqCDuszWWJyybGKZMc7TIjj0tdDlK2Hk9TCxSRpFsippIc3cVHF4rhFFCJrJiozRbtCQKDIwlCKkmeTlKx8wMpi0x1J8inCxTHhafm5yokEwWyRdE64bWWJ496WasWYbnFi7OqGZhammdipPhWJbDXo+hghrCjorYlamZouhZsbEAezSMaVVFI4djvmzPtFPYGQ4hpZOePI/QmCtX623A19LBqBKTYYCmeVp2tiojFWr7AlHSq2oLruSOJopV5YK+1/YJRxKuvvpq3v3ud/PRj34USZL43//9X6677rppjTElkunu7kaSJGxbLL6xWIx3vOMd3HPPPdOfdQOsXr2aa6+9FkmS6O7uZt68eWzcuJGTTz7Zqy7t6OjgQx/6EM8++yynnXYaM2bMoK+vj1mzZtHX10dHR8eUriUZwj0T25lDGw5TiatowyVyc+KkXxmiEm8nvaXkFa+Jym1h32tDOvLyGJYimp1ZIecJyRJZQmpBxFNMTRavRwpC7gOIlg2ksTzh0Q7CO4exh0a8ZlogZNvlbAEy2Rpz3TYMKOmohikkQEAUw5mmRySS09PErhieLIblWDT+9E1JDWGji3MNwyMfSdO848OjOspgFgwDqy1NosfCzmRpetXCiErY+QKSaQo5EXzZOW5ANl9AHtNIZEvifTiEFQtj9+0hXK5aTu69aOVKVQJlLE8kKWRd5MEM4UKU0JAoCtxZaGJMjwh3lZPebVgKg8U4ekJluBynMzJKxoiSUktUbKGzZlgKbaGcJ2cDkDFEeLk70k9PuYW5sWGyZoS0WiShlDyyiqs6u/U0JyR7AbxjInJFZOTJBkmlxMLm3SyI9rJVbyedKLIg0uvJArmuva7wMPmYRlO46BTSWnQnBh2h0TLZssac5AhzY8NE5AqbwuIxf2ZkjN2lFKd3ie6GNZ1T09AWyTNaFpl/TeEibY6SQm8mTVOsSEorYVgyTeESbdE8g8U4nekM8xLDaLLBM9JcjmkaZEdKkGEsVPbGdLu2hltKdDZlKFTChBST0USUiqEQ1cp0JHJeGruRlkloIunDaJEp6mEvWaNcUTm6dZjesRTlWJliJoLkxDQrRZEFqKZ1rGQMFKHWoAKUK9XWDgi1A3SnLsdRMJDKhiCScAgUxdsOBnbYtd4UZIds7BbxYGNrIfG/HFaF8oIieWoMQgT1AKJRIOkwwMUXX8yyZctYt24dtm3z85//nOOPP35aY0yJZCzr4Jarzpkzh8cff5xTTz2V/v5+Nm3axPz588nn81iWRTKZJJ/P89hjj3mZbitWrOCee+7h2muv5Z577uHcc8+d0rWUCmijCCFD0ya0ewwUmdTGMpgWbS9mUUYK2HsGkWd1QKFIbJs411YUQhkJW1WIDIEZlr3YjTYM0QEbyXlC00ZsGMlUfcXO4h/uz1YbbIEXQ7ErBlK+gJVzdEhCprcdqMmocbe5xECpcfMoT2rDqQ/w1xK487KNCjLVdFFp0w6v+lvWy6TKgsBi/bpIGnCl6usbbZlmTRdGSVGwx7JImoasOlpU+YIgKTeoC9Wulg5xabuigpj1ctXNV9LpHZtFuaIyKkfRdXHdAS1BxVB4PdpGTC3TW2qiJZwnb2hsys3ghGQvW3LtjBkRZkUyXhsEdxHdXUoRloXEzXA5zqxIxiuUdc95PdfGTE1k7OUNjWErzlA5gSqbGJZCd6SftFLguew8xowIi5I9lOwQJVt8DguigqAGjCRzo4NEpAoZM0ZTuMjc6CBNSgHdUumI55gZGaMrPMygkeSktKhKjEgV2kI5NLmCboUwYoo3n5haZl5skKFygjFDWCKuokJ36yDzE4NO3dEM73OZnxhkuBxnbnSItFJgsElYTKfO2CKuJ1fIGFHmxoZJKiUe2Hki7zpqG7MiGSJyhd5SE1tDLRQqYbrTg4yWo5wwa4v3+XRGRvnrWCe9+RRLOnopWwpGXGG0HGGxk64Ylk1epR3TsbrcmitRi5USagOqjKWFQAthJDXksolckLEV2SMdMy7aP8gId62lic/cVUuQVRkzGkKywtiyRMh9AIuFsTQVZUzHioUxoyGUYgUzGkJ1vBh2rEH/oTcBRkdH+cxnPsMrr7yCJEn86Ec/4l3vepe337ZtrrzyStauXUssFuPuu+9m6dKl+3XN448/ftrE4schiW5dcMEFrF+/nsHBQbq6urjxxhupVMSCd9lll3H99ddz6aWXsmjRImzb5uabb6atrY3XX3/dy2AzDIN//Md/5Oyzzwbg2muv5eMf/zh33XUXc+bM4ac//emU5iKXbdpeymMPjSANjVSDiqoC+SKKaQo3lGlCQbigXKui+PZ24T/ulEhtN7FlxckCk5ArQgcrvquIokfFolzSPXLwyGZgGNswxrX2tY2KcFu5FodDJDXEUFdU5t9ef2wj1AgB+o71yAqQTNHrxL2+rIUxi0VBxgh1DHN0tOHcPDiEYVeMag8WRcHOF7CKRfFE6rs/ORr1jpfGcthjWfHaJ0U/lolhV2RsS0LOi3vIRyzUYZUNQHsq5zRNE9l8IcVkdzjNQDEOxHkt00bOkcnJlKLohgJVnUkAtuTa6c2niIXKzEsM82T/MeT0sCfx8+pIO8mwTqESZkFLP6PlKHFVpy2UZUeh2TvOlRLS5AoVW8x1l97MbG2EdjVLyQ5xRssGRs0YSbnEbG2EttYcaadBXUIpCZUDYGelxdu+q9JMazjHbj3tkSDgWWhxVfdiUnNiI6TVIrv1NLMiGSFQGh1CkyuedVWyQx6ZtavC1VqxFRJKzGuWN7C5lXPe+1fa1CwRuVKjO9cVHqan3OIRaU9ZzHVJeiddMZFJ0BbKkTUjtIWyRKQKydYSWTPCjEjWi3WFZZOmsOh5tGnWLCTL1XNzSgFmhYkOVJB1UdSJI51jhWXksoWqykhlA6MpImp+ogpmVEEpOv/rTh2P1OxYXFGFULYiVAjCCpWkKmp+QjKmFkPRLeSy81BX52nbJxxAgcwrr7ySs88+m5/97GeUy2UKhULN/ocffpjNmzezefNmnnnmGS6//HKeeeaZfb7eRCUqk5W11GNCkjnqqKOm1FFtKrIye8tC6+zs5LHHHhu3ff78+bz00ksNz2ltbeXxxx/f67XrIesG6kgBy32SR69ZzBgyqsQwPCoWOyfWYasdNP8th6Ukie3MYSkJZBMkR+RQMmzUkQJJ3UAqCyLxVxlLIdVrItWIEBoRi7fPRySuS8yvKluvHlt/TCM0Urr1WyO2UfHiPHZfv9NuuDGR+a2mGhedKawe2z9uxZiQ5FyCqR8n/HoERYfCLItYj5NuXZFF/Uc2we6WOPOX7qRiKmTLGqVyyHvtqiS4haOSaqFGDDZunYPUprMl3IYiW8xIZRnOxegtNDHcEmN+epjnNnYzmhIEWyqHMEwZTTV5LdNG/0iSnmyaM2dv4rWhNjrTGX6RXQLAwubd7Cw0cVxKJFS8nmtDkw3HcgmRDJXoKbfwQmUuC6K9bCgKt3DWjJA3NG/R36U3c0xkDz3lFnoKzaRTRXRLZU8pgSYb9JeShGUT1fnx9xECEcPSLVU0rTMjZM0IuqWSN9LEVZ13xLYzYCQ9UilZIforaUpSiIwZI7lVJvH/lbwYVVopkFYKJJUSTUqBkh1iwBBxlHfEtvG63sEJ0R42yzMYrCS9412CypgxuiP9jIZiHlm1hbLoVoi0UuCl1sWoRSezMhpDGy4jGaCnVfS0+L4Z0apgqVKRsXIythynklQJZQ0qCQVblignQsiuAGnZxl3ubFWinA5jaTKSaWNEZE+HTrJszKjiERwT5xMdcoyNjfHEE0/UdCR2yzxcPPDAA1x88cVIksQpp5zC6OioF1bYF8Tj1RhoqVTioYceYsGCBdMaY0KSeUtJyfhhmqIp1QQWgn+Bdbe5Lqz43/aAotD0Wgh51wBRpy+Jpamou4ZEJks8hrxrAABroif9Bu1p/aRQL9DnV5hthOnIk09EPjWEVedW81s2UyEt/xg1BOIjSP85/vv1H++eA9CywaIclwlnZK+GyJYh0WdSystowxKvhUQFox1y0sYjUZThEFiQ7JXQnUxMI2YT3a0hWZBFwyrIVGIWOytJrJBIZR/UFQb70kQHZTbtEvERKyM077RhGb3FIrJHZugYlZ8XFsOmBJs7o8iZENGjx/jNnuOwdIU9s8QTfUQ12MBMnuw/hrZont2xNM8PdVExFZJHCeXq3+w6lq5khowe8ayTdT1vY2NKXH/jzpkwD3rzotX1q5l2RopRinqYY9oHCcum1357RiRL3tDoy6fYYYnW3G7ShKt5F1EN2rqy7NKbPfeeboX4ze7jWNTcx/NDXcR3W+TMCLt0oRS+JdfO8ubXwRSWS8VW6C2JDzYiVRh0CKddFcTx1Gg3xyb6GSonODbWx2AlQbfWT7ua9YgtJJlkzQjtalYoVDQpSCaE8jZ6KiIyDOMKaslGNm3KjtBpJQnRAagkZOSyLGp0IjJGVKLUKjkSP8LLYKcAp8W4W1TqFZyGJSqJEEZEZFXKFTDanAeSQ0gyAwMDLFu2zHvvT1gCkYDV3t7Opz71KV566SVOOukkbrnllhoi2LVrV01CVldXF7t27dpnkrn66qtr3n/pS19ixYoV0xpjQpJ560rJWCLoXgd3AfS7o8a5oTJZUBXCTk+O0JbdoJeRW5qqmV1j2QkLufzE1Wixnsz6OFQNliYkMqMyoRXTaIy9NYXy79tb7xDbNFGLNtpw2XnKdLL6LBttsEhkj4oVVpArEayQKC60FdDbZOI9IpU2vVVkEwLOAmZSTskYfTLaKOS7ZJJbq4WFSCGhtGyCvEMs3M2viYJDyQTVUV6wNA0zEqZ1k01pMEypDUqbU9hRGwkY3SAEZY0mg11qM63tWV7ePptt6WYyw3FsQ+Z/jXdgmAqFnEa2IGIrmVZxzUxPmrFkjFS6QHhLhFfTbWSzUaxMmOiMvAigZ1V6tRTbhloojIjzYs2CrIv9ceKzcvTsbKWpI8voniSJ1gL6xjSD7RVWF95FPhNBjYiHiJZUgYGhJAO5BMVCmO7X8/x1rJOBYpyeISFtFFPLIvU7186S9E76S4JYflM6nr5cigUt/bwztZXBSoI/75hD+Ghh+f1lZJbXXuKUxBb6KyKhplvrZ93YAk5tepVCuySKOctgOc3pDE1CqUAlKQo4VcfxYMtCOy6UkzBDIfRmCSMq/t56E4THIJQTSgeWUi2IdFUu3DHEbwnZAD0iedugtv3PvkKaYjFme3u7p2jSCIZh8Pzzz3PrrbeyfPlyrrzySr7+9a/z//7f//OOcZOzaq4/BY/UVFEoFKbdqHJKMZlyucy///u/c99999Hb20tnZyfnn38+1113ndfQ5nCCF/Ru0ATJ0ks1PSX8T9pWLi+yqEoi3uK52fYMVrO73BhD3ZN/o1jI4YCJyGA6501n30TXjG3LiuZdmk+DakA8LMipJFZMo+k1oWzs9HNDH5bRxiziu3SRsebUrGjDwvWT0E2SbVGMqEJsj0R0oIySL1M4KkEoL1NqFbG3zDzxt4v3G8hli3JKxVZBGzYAQUbJHTqSpaGUJBJ9FgMnKoSz1VoQdVQllJEov6wRDUPmOIlwj4YRtynubqHcpaNt0zBiYpF4Ki6SFNIbFSoxhcw8lY4tNsNaC1LIJlySqGRSxDJOEaTejGRKuKkfRUdFPLJHIU8CRZfJlNOkX1UYe3uClq1QyobIlxPEdigUnHvcMxwh0qdQSmuE8hLK7h0893/d2BELOVFB6YnwBN2c9rbX+PNrc3kp3omecbTuEmWMgSimLfFapo3ePU3I/RrbW5sZzsUwLZnycISmRUX+YL3ds6xeyXbSl0+hyeKey82igBNEAajttLGRDCGh4yYoSqbYZ0YglJPQ06J2VW8CvdUChOySWwjqZnipefGwgCTGBFGwKlzf4ni9SRx8IEjmQKGrq4uuri6WL18OwEc/+tEayRf3GL9CS09Pz7T7v/ixaNEij6RM02RgYIDrr79+WmNMiWQuv/xyNm3axPe+9z3mzp3L9u3b+drXvsauXbumJS/wZoBt2+MsiYk66DWyLOycsEYsvYRMZJyLDaoxh725hg4nvNGWlDzgpHynkjDsJh44WlZjWeSxLGE9jVKMeA29YtEQpiaLmiQgNja+f7y2q4Lmpqs6146XDWJhFb0tSihbQTIdJW2nCDW6dQTLUTCWTZtie4jQUJ64KpHcYSHrBpGuJKntBkrJTaEVT8+p7SblhIxkaqR2iuZqRhTGFI3YbnGcXIHRskhgiJkiG1LdoJJ+LY9kxTxXUL4TErucQsic6KXjuYAiCtqojN4E8V4FWxbbmjdWsOUQzZtK5PIaUkXIwKQ2iHkqJbHgGjGJWB/YmSyJ7TJ6i4y2SUXRYTQd4qlt84i9qlFqD6M6z03q9hDGLJPRv7YizSkQfj1COAPbYjPRBhSMlBCS/dNf3oYUM5g7UxQT946m0TMa/c1JzHRVCaDslMxYEVuIm4bFa+8eYxbEDMI9GlIFKmlbFH4mbIgb6KgQN1CGQ17hKCAUuyuSKFQ1JayIjd2mYwJ2QUXJKhhN0ys43CsOQILuzJkzOeqoo9i0aRPHHnssjz/++LisrxUrVnDbbbdx/vnn88wzz5BOp/fZVQbw0EMPea9VVWXGjBl7VWOpx5SO/uUvf8mWLVs8eYHjjz+e5cuX093dfdiRzESY1lP6BO60+pThRuMHfcX3DfaY4450rEhve0mv6l0pCspYTmQIKgpKPIYV07D79ogMQbdZlltvpIWrrwFURYyXUZG0MJrZjDwwgqyLbDFpS4/XsljS2pB3jaAoCqHBZqSBEbSxvJf+PfP3ZaSCTjhTFW21ZQmlWCFmWCh6spoWrkpIpkZ6m06pOYRSsZGcWqCm10qYmiAzWTe8YllTk4kOKsimsPJKs+LYqoRctrxrqUUTuWyit2poQ7poYranQKsVRR0toSVV1KKElnE7fIr4hJYxyB4VJjIiihVT20zKwzLJnWVKzSHifdD/zjjasCC3eK9zTdWmNKAQytsUd8dJ9FqER03KqRCx3SDvkCinJUI5mdEFCttcM8+UiO9QKM1QsVpM5HQZSbEwK4qQzdFMjIos2m5oJnJIXK+jOUe2qFFsV6gkZaQ2HZ0Iytw8EdWkENKIxMoUwVNXAChmNSTFFvsyEVpnjNERF72QjIRCPhSla7bI7jsQyWUHErfeeisXXngh5XKZ+fPns3r1au644w5AZOqec845rF27lu7ubmKxWENJsKngP/7jPybd/8UvfnHKY02JZGbOnEmhUKjRsCkWi/vFkIcjJgrKT/Y+wIGBax1OlMItqSFRc+Nm75V0ZL2MtEdkC1olXRStujBNbCehw6/wa5d0iAgJEnlgBHssK7o9gshIdN2ffYOioBVRT2TrOvboGFJEQ1JVJKeoNuReU3VEFx2plIQqi6LXcAhLC9FctlDGdE9SSCkK6zjcm8FKRoS6tmGi0YK8exgiGlFFEV0px3JEnWZhimOtmakIyoj4PCQziTJS8BqTqfEwsl4hti2DrShCZaJczVKS//gy8TPeQXTrCGaxSGJbzqtViTkk1vlUiOjOHPqMGOFRR2aoUCbclcLSZJI7KpRaQygVi67fOfI5SZXkTpHFpfcqmBGx/DRvtig7Qp7RjwwQkk1GilE6Ejn25BKoirhmRHVSrw1x3jFNgxQSYf5amQlpIXRabFE4efZORstR9oRF0oVpyRzdOuw14xsJGaiKRUc8xw65mWRYpyOS46jYKK9m2mmKFelOi8Z5f532f2oDHMAU5iVLloyL21x22WXea0mSuP322/f7OtmseKjbtGkTf/7zn71g/4MPPjhtxZUpkcxFF13E2WefzT//8z97Pr/bb7+diy++mHXr1nnHnX766dO6+BuF/SGCfY1RBNg/NErhhrpYl/uw6hCSmxXokVKdt2xcYoez33ZjbiHVq+sZd7yTBSepIYjUFcai++TnfV8xV4Axb6DEol4iiQxIprCG7JKOmk4it4mguN3Xj5xPegoL8m6E9eUkn3ifw/AYyjAeCSqmJSSIhkdRXHJ0jg/lC06xq4HsWGaya+WZJoZpEt24W8gXmSZKoUx414DQDXOIUu5qQ84WiPolW/IFYrrbiExFsmKEtg941p3SlkQulImO5YkOtGOFxSfrNjEz42GkUJnO2BhprSQUDCLibxiWTQpGmK7YCD0FYR0mVR3DUpjXMURMrTAjkuWviZnMjQ0TltN0RHK0hPNCHQG8dPLhcpyWcB7DUuiI5NBkg7fHdxORKnQ6Ab2usLBkDgjJHIb4t3/7N0BoVD7//PMkk8J3ecMNN/Cxj31sWmNNiWT+67/+C4CvfvWrNdvvuOMOz1STJGnaWQcBAkwVe0vfbuSm9Lsx9zZ2jTJC/Xtfynmja9i5xqnqtlHxClflaBQ7Vx1HGhgWqgeGkyrbN+hJ29uZLLKzMFsVQygluC5C1+2aq40ZSD7lCAApL9ocW8ViY60v573tWn91ood2JouVE5YP7lzzBaR4DLuko2zvF+oN8WpHTTtf8I6R8hAaHnOkhoqQTqJs6QVVwRwcQmlLozjiFvJoHko6UkuKOQmxuM9PDJI3NBYle3g1P5POyCghyWSwkqA5LAj3xMROtpQ6OCYhus0KZQSDtlDW66pqWArHJvrJGFEWxoTiQI/aQskK0RbKMVPLeGoKEaVCyQrxjth2L6X7SMeOHTtqanHC4fCkivqNMCWS2bp167QGDRDgUGO6adN72zeVNPL6LMSa7XUWl1vk6tUPuVaWux29hqD81pOfxNxt9W7D+tbC/nojK5ebtH+9pIa82q3q/HK+86sWoey4IsEhNJ+4qpdZ6cTP/OQs+QRbbdNE2b4b2p1+AZmspxgeV3VPkWC3ISyQrKExVE6gWyr/N9DFCa27AXg5dxRZQ+OEZC9toQqDFSHds0sXlk5c1T2rJ67q/LUwGxAqBImQ0KcTxJX0tOeGy3GykQiPD7sFh883/Mymi8Otn4yLiy66iJNPPtlTXvnlL385YV+wiRA0TQjwlsHBcl/uzYqaDkE1KrpttPghiRAVAAAgAElEQVT7F/lG47qp9v6xbNNsmJY/0TUa7Ws4d786gzuvUgN3I+OLaYGGMkm2rkOfqHT0rLSxLI9sXcCMVJaBXIJls3ayZsvJZLNR5nQMM1KMUnqhhcIZwtp5JTMTw5TZkW2mOz3Ii3s6Ob1rM7/espCoVqYzNUbvWIoXCrOJx3Q+dPTLAPxm93G8PT3ASDnGMYkBfrPrWNZJb2dBSz/bs83EVZ3/2yUKGlMHiGQOV1x33XW8//3v58knn0SSJFavXs073vGOaY0RkEyAAIcI00kSqS9KbXTOZPHB6RDuZLJE7utGVpuf1OrHajT/esuuEfQdSba3hZEGNZ4sHIPUF0GyYJvejhqrICvw3P91AxDtk9HbbMZm6OT0MNktzbySmIX8coJc2mbTrCi2JRGKGJQrKr/YJnrVG6bCQC5BPhPhb+kZNMWK7P7LDNY3NaGldfrHkqj/l2g4v32BZFf79Rxu0HWdjRs3ks/nMQyDBx98kAcffPDAaJcFCBDgjcOhTCqZyrUmqx2b7LiJjh3nXnQIK7FdQs9ESG2zGTs6ilOihJRVUXaGiQwJtQWA1g0mhTaFTCVC5a8REiUYeG0OUROUkkRe04jvkNFboNxiYA6I5c6Ii1YdYcDcorE7nSL9qsTIQoVyOUp4WCEyvqTqiMS5555LOp3mpJNOQtP2rTQ1IJkAAQK8ofATTny3RXRAQsuYhMcksnMUQlmQTYnooIFk2BgxJystZxADkjtN9BYVtWgjmTZmWKJ5s4G+RSU/C1peNRmbq9L0qnDVjR0dQi3ZlFokYv1OZX/GIDIsM/p2hXivTWy3cO/lD9A9Hq6WTE9PD4888sh+jTFlkhkaGmLt2rX09fVxzTXX0Nvbi2VZdHV17dcEAgQIEMBFYrtwo6mDOSozU0QHhKR/JaES2VNELpQpdYp0Wm3rEMoMkeqt6Bbh/iyWFhLtyZMRLCVK6ysV1KwOJIj2CDVtW00T7c1TaY4gGTa2KqEUDKK6gamlSPTohIYEveTfnG1lDhne/e5385e//IVFixbt8xhTIpnf//73fOQjH2HZsmU89dRTXHPNNWzevJlvfetbPPjgg/t88QABAgTwQ/nLFvFC01D3DHoKC5qqeLVCkW3iELNYRNkjiibVVBJraAR5Rhv28CjsMIgm4qJg1jRJbK82yosPj2ENjRAOqaIzrVu/ZBg0v2oitTSJMQDefgBu6gAWYx5q/OEPf+Duu+9m3rx5aJqGbdtIksTLL7885TGmRDJXXXUVP/nJTzjjjDNobhYpgcuXL+fZZ5/dt5kHCBAgQAN4IrNUU6AnS8H2lCBcvcBM1ksqsHL5cU0AARjLeqriMoBOTY8jeXjixIQjDQ8//PB+jzElktm2bRtnnHEGUJWNDofDGMYBFpELECDAEY36PkRujZC/7qg+c83/28rlahvoNUhAkIzx/Ytq0sArRqDm4WDu3Ln7PcaUSOb444/n0Ucf5ayzzvK2/fa3v90vP12AAAEC1KO+j9Bkx/hfT6qcvpf07nrSsvQDn1p2uLrLAF566SWefPJJAE499VQWL148rfPlvR8C3/72t7nwwgu55JJLKBaLfO5zn+PSSy/lm9/85vRnHCBAgAB7wZsthftIxS233MKFF17Inj172LNnD5/85Ce59dZbpzXGlEjmlFNO4aWXXmLhwoWsXLmSefPm8eyzz/LOd75zShdZuXIlHR0dnHDCCQ33ZzIZPvjBD7J48WIWLlzoyVPv3LmT9773vSxYsICFCxdyyy23eOfccMMNzJ49myVLlrBkyRLWrl07pbkECBAgwCGFU4y5t583I+666y6eeeYZbrrpJm666SaefvppfvCDH0xrjCmnMM+ePZtrrrlm2pMEuPTSS7niiism1Ly5/fbbOf7443nwwQcZGBjg2GOP5cILL0RVVb797W+zdOlSstksJ510EmeeeabXqOcLX/gCX/rSl/ZpTgECBAhwOMI0TZYtW8bs2bNrmooBrF+/nnPPPZd58+YB8OEPf3ha1fn1sG0bxSdRpChKwxbPk2HKUv+N+kRrmkZXVxfnnXfepH660047bVLlTkmSyGaz2LZNLpejpaUFVVWZNWuW17MmmUyyYMECdu3aNa4bXIAAAQK8WSFxYGMyt9xyCwsWLGBsbKzh/lNPPXUc+ewrPvWpT7F8+fIagcxPf/rT0xpjSu6ydDrNAw88gG3bdHV1Yds2v/rVr1AUhQ0bNvCud72Le++9d/p34OCKK65gw4YNdHZ2smjRIm655RZkuXZq27Zt44UXXvD6WwPcdtttnHjiiaxcuZKRkZEJx7/zzjtZtmwZy5Yt2+c5BggQIMAbjZ6eHn7961/zmc985qBe57XXXuOpp57ii1/8IqtXr6alpYXm5ma+973v8cEPfnBaY02JZF599VXWrl3LmjVr+OpXv8qaNWt4+OGH2bJlC/fffz8///nPx/WamQ4effRRlixZQm9vLy+++CJXXHFFDUvncjk+8pGP8N3vfpdUSsh/X3755WzZsoUXX3yRWbNmcfXVV084/qpVq3juuefGdZQLECBAgDcLBgYGvIfhZcuWceedd4475qqrruIb3/jGuIdwP/70pz+xePFi3v/+9/PXv+5b27WrrrrKa1S2dOlS/uVf/oUrr7ySWCzGVVddNa2xpuQue+aZZ2osCIBly5Z5xZhnnXUWPT0907qwH6tXr+baa69FkiS6u7uZN28eGzdu5OSTT6ZSqfCRj3yECy+8kA9/+MPeOTNmzPBef/azn+UDH/jAPl8/QIAAAQ4abJDNvccx2tvbJ30Qfuihh+jo6OCkk05i/fr1DY9ZunQp27dvJ5FIsHbtWs477zw2b9487Slv27aNE088cdz2ZcuWTbtp2ZQsmSVLlnDddddRKon88VKpxPXXX+/FYbZu3UpLS8u0LuzHnDlzePzxxwHo7+9n06ZNzJ8/H9u2+fSnP82CBQv44he/WHNOX1+f9/oXv/jFhJlrAQIECPBWwFNPPcWvfvUrjj76aM4//3zWrVvHJz/5yZpjUqkUiYRoU3DOOedQqVQYHByc9rXctb4RitNUQ5gSydxzzz08+eSTpFIpZs6cSSqV4oknnuCee+4BYHh4mP/8z/+c8PwLLriAd73rXWzatImuri7uuuuumtbN119/PX/84x9ZtGgRZ5xxBjfffDNtbW089dRTrFmzhnXr1o1LVb7mmmtYtGgRJ554Ir/73e/4zne+M60bDxAgQIBDBcnc+8/e8LWvfY2enh62bdvG/fffz+mnn85///d/1xyze/duL/vr2WefxbIsWltbpz3fd77znQ1Tle+66y5OOumkaY01JXfZ0UcfzR//+Ed27NhBX18fs2bNYs6cOd7+vQXU77vvvkn3d3Z28thjj43b/vd///cTpsutWbNmCjMPECBAgLc23If1yy67jJ/97Gd8//vfR1VVotEo999/f8PM4L3hu9/9Lh/60If48Y9/7JHKc889R7lc5he/+MW0xpLsaSY927Zds/BPFoB6MyIltbBcOuONnkaAAAEOA4ws3brfCUPx1qM44Zwv7PU4c8P/vOmSk373u9/xyiuvALBw4UJOP/30aY8xJUumt7eXz3/+8zzxxBOMjo7W7DMDSYYAAQIEeEvive99L+9973v3a4wpmSGf+9znCIfDPP744yQSCZ5//nlWrFjhmWkBAgQIEKAxJER22d5+3qqYkiXjxmPi8TiSJLF48WLuuusu3v3ud/PZz372YM8xQIAAAQIcppiSJaMoCqoq+KipqYmBgQHi8Ti7du06qJMLECBAgACHN6ZkySxfvpy1a9fyoQ99iLPOOotPfOITRKPRQKYlQIAAAfYGG6QjuL/jlEhmzZo1WJbQov7ud7/Lt7/9bbLZLF/4wt4zJgIECBAgwJGLKbnLfvOb33gV/dFolC9/+cvcfPPN/OEPfziokwsQIECAwx42SJa915+3KqZEMhNJO69ateqATiZAgAABAry1MKm77PXXXwfAsiy2bt1aU4T5+uuvE4lEDu7sAgQIEOAwh0hhfqNn8cZhUpLp7u5GkiRs2+aYY46p2Tdz5kxuuOGGgzm3AAECBAhwmGNSknGD/f/wD//A73//+0MyoQABAgQI8NbBlLLLAoIJECBAgH2EbSO9hSv694YJSebUU0+dknrnE088cUAnFCBAgAAB3jqYkGQOdg/pAAECBDgiYINkBJbMOFxyySWHch4BAgQIEGASlEolTjvtNHRdxzAMPvrRj3LjjTfWHGPbNldeeSVr164lFotx9913s3Tp0jdoxgJTbgazevVqTj/9dI499lhOP/10Vq9efTDn9ZaApChT2hYgQIC3Ng5EMaamaaxbt46XXnqJF198kUceeYSnn3665piHH36YzZs3s3nzZu68804uv/zyg3VLU8aUAv9f+cpXuPfee7n66quZO3cu27dv5xvf+Aa9vb1cd911B3uOARpAUhRsp5eP/3WAAAHempAkiUQiAUClUqFSqYyLmz/wwANcfPHFSJLEKaecwujoqNfN+I3ClCyZH/7whzz22GOsWrWKs846i1WrVvHII49w5513TukiK1eupKOjgxNOOKHh/kwmwwc/+EEWL17MwoULa6ykRx55hGOPPZbu7m6+/vWve9uHh4c588wzedvb3saZZ57JyMjIlOZyKCFHo4fkOgHBBAhw+GNgYIBly5Z5P43WV9M0WbJkCR0dHZx55pksX768Zv+uXbs46qijvPddXV1vuFr+lEgmn8/T3t5es621tZVisTili1x66aU88sgjE+6//fbbOf7443nppZdYv349V199NeVyGdM0+fznP8/DDz/M3/72N+677z7+9re/AfD1r3+dM844g82bN3PGGWfUENB0cFDdV5OMfSCvK2tV5QVJUcaNXf/ef3yAAAEOLiR7ak3L2tvbee6557yfRrJdiqLw4osv0tPTw7PPPuu1RnbhV2Xxrj+FLOGDiSmRzNlnn82FF17Ipk2bKBaLbNy4kUsuuYSzzjprShc57bTTPIHNRpAkiWw2i23b5HI5WlpaUFWVZ599lu7ububPn084HOb888/ngQceAIRZ6CYnXHLJJfzyl7+c0lwOJeyS7i367k+9ddOIFKYCSQ0dqGkGCBDgMENTUxPvec97xj28d3V1sXPnTu99T08PnZ2dh3p6NZgSydx2220kk0kWL15MIpFgyZIlxONxbr311gMyiSuuuIINGzbQ2dnJokWLuOWWW5BleVLTr7+/3/Mzzpo1iz179kw4/p133umZoJPBXezriWFfIYXGh7zsimgsUU8Sk12nfh6SotSMLYXU6tzVkPjxneNe60BZT0FCQ4AA04CTwry3n71hYGCA0dFRAIrFIr/97W857rjjao5ZsWIF9957L7Zt8/TTT5NOp9/QeAxMQVZGlmVSqRT33nsvd999N4ODg7S1tSHLU05M2yseffRRlixZwrp169iyZQtnnnkmp5566gEz/VatWuWZnimpalFJioKkhmpiGt42o7IPd1I313gMfC5FSQ0hRTQkZ+z6a9UH88eN5982wetG83a32aZZJSh9/xIG6s8N4kIBAhxc9PX1cckll2CaJpZl8fGPf5wPfOAD3HHHHQBcdtllnHPOOaxdu5bu7m5isdibIgt4UpKZPXs2F110ERdddBGLFi1ClmU6OjoO+CRWr17NtddeiyRJdHd3M2/ePDZu3Dip6Tdjxgwva6Kvr2/a83IXeHfBdeMU3oLv7gPMXG7fbiweg8Gh6jVDKpLTxlpOxLFyeaSQOo4Y3Lm58JME1MZUZC0i3HL1ZOmcb5smcjSKmcuNi8X4j3f3WXppn27VJUA5kcDMZPZpDP9YLiEG5BXg8MeB6Rdz4okn8sILL4zbftlll3mvJUni9ttv3+9rHUhMao7ccccdbN26lZNPPpmlS5dyyy23MDAwcMAnMWfOHB5//HFAuME2bdrE/Pnzeec738nmzZvZunUr5XKZ+++/nxUrVgDCLLznnnsAuOeeezj33HOndU1vEXfdYnWuLSmkVl1bftdT3e+pXMf9QVFACyNHo9iG0fAYP/m5c/K7uyRFqbF86knKuxa1brSGc1MUZC0yLVeXOz83tlTvlpPU2mtO5HacqjsycMMFCHB4Y1JL5txzz+Xcc89ldHSUn/zkJ6xZs4Z//dd/5X3vex+XXHIJK1asIBTaewD6ggsuYP369QwODtLV1cWNN95IpSIWxssuu4zrr7+eSy+9lEWLFmHbNjfffDNtbW2AiAedddZZmKbJypUrWbhwIQDXXnstH//4x7nrrruYM2cOP/3pT6d0w353m2tZyNEokqbVbEdRkKBhhthEC9+4J29FQU7EAbANQ7jPEG40u6R7x9Q7AOvjLeL8iudaGxfPcUnJmGBBridS971vHCki7l8yKpNaEZ6F5xBUPVzylLXIlKwiv8XlXjNwwwV4S8EGybDe6Fm8YZDsRoGPSbB161bWrFnDD3/4QwqFAoODgwdrbgcFabmV5cqZ1fhIRMPOFwQBGCa2rgtiMU1BPKqC6XN5uZDUEJZemrQoUjnhWKThMfFGL0M8CqoKhgF6GTtfqJJYHTl57539dkn3rCsppCLFY1ijYzXEYeVynoXhHmcViyhNTdX7Au+eXdgVwyMZK5fzFnwYv8jLWsQ71j9nb16pJEZvH0oigeXEozwiaRAvqolJ1cXC/OcFZBPgjcDI0q0899xz+zVGKjGb5Yv3Xnk/ov9yv6/1ZsS0ove6rvPnP/+ZZ555hv7+fhYtWnSw5nVQ4bmTIpp4qtc00MKgKkjxmLcdLQyA0tSE0tTkuYlqXEV1mVzedkURTy/xmPhxYCVjgmgURVw7ook4jaII95xLBJomftRqHEfSNM+KwDCr7jTHCquxTPyuNlXxZbU1Nl5rrjOZi82NK5mmN6b3WYL4DN1787ntGrn0vP2NLDP/vQTp2gECHLaYEsn84Q9/YNWqVcyYMYMvf/nLnHLKKbz66qv87ne/O9jzOyjw4h2uxaAqNQs/4Lm27JLu7Hee7CtG9andWfzkaHTSrDBAWDEAigQlHVxyAdDCnlUFDYhArXN1qao3HxQxN0kV9+SSE9SSkkdmqkOeiu985xpinNrFfVwMyvfb+wzdOYEgPzUkSMjn2hv32/kb1Medav4+NE4DDxDgcINkWnv9eati0m/wDTfcwJo1axgeHuZjH/sYv/71r/m7v/u7QzW3gwNZxq4YXqwERRGuq5hWGxtxF1fT9OIntlGpWjG+GI4b41CamjBHR6tuHlVGKjtP8H7i8D31Y5iexQSIxZk6onHJT3XiN1pYkKN/cVcVMJRqQoFzPIYirpcviPeKIFTPTejOxb1fx+pwYy+2UamtH3KISgJsZ764rxVxLY/YGllWjsvPs6wiGrivXYvHdVf6iUav/0MGCBDgcMCkJPP000/zla98hfPOO49I5C0iRSI5C5vjHnMXfy8wV1N/IntWAIBsmp6FgyEWebukI1F1S3mLc8XAioU9U1HSncXftCEcAvfJxSUa75p1lgqIBVetusnGHecjKo80QGwr6VDSxbzr4jySpjmWh1obE6Ka/OC9d+MlLlEZpkd03nWdz8SbW6juem6as6aJGBHUHkc1Q81PYJKmwb6mkQcI8AZDsu0jOvA/KclMpjd22EJyln2/i8z/NK/roGnYmuvGqSt69AXlJVWFCLVuL8dlBeLp3g5XScxWZWzNqQHxj+lOTVVrLRGoWci9eZsOqejjzx93uxFN3F8mW0tciiJiRYaBPTyKFG8S2/OFaro1tfVCHvG4bj3/hVziURp7YF1CtEu6yLRzLUEtLD5zHxHZhjH+vt9ECOp3AgSYOo5Ih7eUTvpiMGJRtFVZLJqqihXTkExTPH1oGjjroaSXaxdqw7Fs9HI1GJ9Keu8l3URyFiMrFkYulLEVGduzJMK1VozrDlOVWqvD/94P183mj6tMtDB7rrK6sd0MN19ygUekjcZSFZEdpyrjXVhqrVUjaZogFJ91VWN9QfWzcs5xU729jD+9XD23bnGfKAMuQIA3FWyEB2NveHM+U+03jjySkSWxmKXiSLqBrcqgVp++bYdgwEc89UE5te6/QQtXn+pVBUxnIQaPUDBtLM0tAJWwGV8f453faHH3E9JEVo7/tbuw+1xYNfN2X/vn7ke9y6tmjmqVaPzjqQqUK05igXCnSSAsppJeTbLwu/3c62thiKtImayI6+jlqsVGbRGsSyr+VOtDiXp1hQABAkyMI49kQFgMhuW5xMBHBg5cH6pHNODEcRwLSM/WutrcBdSJj0iK4gTDxy/hYkxfTMa1hPz1MVOBF9yvtYY8uETgjum60/KFalq1qlav7342/nEMpdaN53fJ1VtiftTPo37OhH3HhasWSzpZnbc/IcJBPbG8EY3bDoSuXYAARwqOQJKRhAusfqu/sLCOcFwLRMaxdAyr1lWlyGCExbiqM45hCovFZyW5cRkPhllrudRbSPXHqQ1Ixd3nvnbhpl67qE8I8MPNVnPvx7ddMnzxJz8meq9UrTjv+v4MuPpz/ftU1UvvFvflewhwxT0bWC71NUru8RMdtz9ktF+q3EEs5wiFXbO+TIi3qLvswEkpHy6QAEWuXeyplX2o/4eQTCe24izUwsWmOlaNLNxpWm0qMKoy7hq2KtdmmZhmNUvLhUsGerkmHjEO9RaEn2zc86G6cPvn5u6rVxlwrQz3tX9MVanW+tTcp1pLGvlCdZs/S67+OP97Va1+fv70bh/qZXD826G2Dqe+Zmky3bRGBDUZbNOctDj0cNNaO9zmG+DwwxFoydRinHVRB1tRqqTj/0KGQ1XSUGQRi3BTk51F2vZlWrnFVt5vl2zcuIppNnaVufv9pOKSk2uR1Fs2OBpimSxSa7MglYhWHd89Pl+ougCdlOJxROAnqDrrYtxnUn8/7hj17+vPN0VWmq2pItXbSR0X+8UDwd4UAKSIVk0X34u148JvHU1UTFtveUylVYLfYqp5vZdYzuFk6RxOc33DMVXtsvHe4bcEjjxLph7lBnpaBR3JsMRPzdO+XBOrcX/bqiwIxjnGzViTdcP7EVll4ny7gSVVA0+FwGdF1H2hvRiJe6xLPO55Lmn54yGGUX1fTxqGWRfb8QX3/UkD9WP451xvGfmhKNXPKByqUVdwCdv9/LzP1hcz8xQCfArVnkKCX0R0AoWAGqVrn+K1t38SS2mc1VN/ns9i8nc+9WSHJtFuc48DxmXO7U29ejJLbKLzxh1Xp/Ad4M2NlStX0tHRwQknnNBw//r160mn0yxZsoQlS5Zw0003HeIZjseRZ8lIPreVa1UUdDAMpJjPHeQVS453eTWCu92zjFS5Jm1R1o2G542DG4h3oTiJAW6WGI7UjUciJlC7Hxz5G6OCQpNIC3bPAWG95Atiu2EIV5XfWnOJpD6LzJ+koNZltjkxILukizTueuvPtUjM6nsPpuUlV1haSBC7k+rtkr2rKFCzELqqAIqjOVfSsYrFcWrV/gLZekwkygkTC3rWtzOABot6/bgNsuMmsnjGXXMvi/+UiWYyN59PDXsqOBgZdm9Z68hmfIbqPuLSSy/liiuu4OKLL57wmFNPPZWHHnrogFzvQODIIxkX5UptkNowoVCsLqyKArpea8mEQyLtuS4rzT3GJRiPaBQJqeykMqOAIiFnS1haAmXMJ4Ovl6utANzU55KvIh6nVYDrHnPEKSVnu3uOSLcWC4sns58v1oxlG0atokC+WHs9130GdUTj/K53tbnvHdKzS85n5p4DnivOI3H3c4ZqASyAqiL5Pj+5oHtjewWuul5T7FqfkKC0tQp1ap8sjovJrBwQLje/2rV/X80Yzt9Bjka94zwpHk247eyKUVPI2ohw6sefqhCon0TrCXKi943afdsuSevVz6a+XUQjd+GE81KUCbP/Jjp23H29FUnmAOK0005j27Ztb/Q0poUjj2T8/lHTrC6eULuguvt88QRblZEKRbG4u4oA/i+FaY23fLwnefGsbiUjwqoxLaejpW/h18vUO2b9zc1qpPWNStWiqd7auJoX2xAWjWQ6Ui1Uicku6UgJVdQNuSQT0WoJRdPEa4dUbMPwqRWY45ITbKNSJSB3zq71M5YTsSHXMoPqe8d9J7nkHovWuvu0sCjQdNovAEKNwY1NRWrFQKvEGhrXmsArEnXn7FeTbiDMOY6cVMctpihV3TV3EdfC2Ll89by6xAT/59SoP9BEPYPq0UhwtOY+9hbD8jXtq/ldf9xE2yMaOK0uJjq+EeE06hn01oc9pdKEgYEBli1b5r33t42fDv70pz+xePFiOjs7+da3vuX14HqjcESSjBeH8QekI3Vpzf4vT4PgtqRTDfgjUpur+4X7xw5XSci1ZDCddEZ3u/MU7xKAt3C6+51eL35CsiuG+JKadXL7ilJLSs5cbfc4Rz3a+yiMClYuj0zV8pGNeFUFwE0YUFVh8WiOxePI2PkJzZWC8RYPP5G4710tNb9rL1+ojQfVk5Dv3Bp9tHq4MR61WkRa04iuJputKvAp+SyqGtUB/wOGRxTqONL3q3nbPqFPT+TTtUTr5BEmbHPQgOTsur+bO1+v8V3duY3eN7LivJ5Kuao+n6sR5yc7T9S0xkqavOsqTEJQda7BIBYk0N7evt/9ZJYuXcr27dtJJBKsXbuW8847j82bNx+gGe4bjkCSscTTsaY1zqhy4xMNgtieBeQFvuWqq0qvOwaQR/Me+QhiwTnWqFbAg+f6cp/mXSIBqlaIUfEWOPfL7n7x3QZqSoOFxD+OC3/HSs9l4r73P+G7sRxVEW4qN4XZI04f/J9XXXq1Z1WAGMtvDYHXUE1ys9ncDDmXWHVdSAGV9PHKBQARoTUn1ZCIVqtmEI9WrS737+kc6xaceuKe/rEVpUap2pUeqtluOMrZLsk51pbts+gkXa82h/P/3Rst/vXipK9xc+wAABdtSURBVO6c6y0xRyevptFefUsI/7mO5VVj9bgJDz6Ly2uOVxfLqrGy1Orx9aiPZTWy1GA8uQRq2/uPVCrlvT7nnHP4p3/6JwYHB71Ow28EjjySkaSqO8wPt3ix3hLwp/dCbe2IWx/j3+8P8BmGRz5+jTRME3ssW0MA3pc3ZHrbAM8K8VsunqyK0zHSfe8Gvf1wCWXK7gnTrHW7mb771cs1c/Uvxv5ru2ToiYv60pftki5IxydX48WXTCFDY+s6EppnNXkkDHVSNqpHSJJuVGNEWljozblk5/XyUcaP4ZKFf8FzilM9q7Junx3TkEqx6r1p4eqxsaiw+pxkBH/fH7k+llS/yLpuPp8F5B4PVC0z1Ud2NdtV32ev1hCod82QWUuk7vxcBYihkfFE65+jr/22P+ZUc0yDJAuvbYSTGei3jDzyequqbdv2+HXlIGH37t3MmDEDSZJ49tlnsSyL1tbWQ3LtiXBISGblypU89NBDdHR08Morr4zb/81vfpMf//jHABiGwYYNGxgYGGBgYIBPfOIT3nGvv/46N910E1dddRU33HADP/jBD2hvbwfgq1/9Kuecc870JtaooNE0x335x+13FyX3WHdB8J1rq7LQ33LhNhID7KERrzUxVAnANk0kQ6kJgMpaxPsyNiKRejTMiFJq9b7GneNbELxrRKqWBJQxczlUTWs4V+9cl9B8bhxJVb17lZ3xG83ZW3CcxceNbLntoOWw7759GWtebZLuNpdzZX/06sLpWqeNuoLW66/VPzQ0OFbSDUeVwKds4JCxrcoiecLZbzWLJ0vZL/QJtcTkIyKPaPzb3BM1nxSPS6J1WXyS7zxM09cIz7XetKpqhKoIDb9MthpjdDufqiq0t8BIpuo+9cOJgfldkn5XooTPUnPO9ad3N3rfSEYoQC0uuOAC1q9fz+DgIF1dXdx4441UKuK7c9lll/Gzn/2M73//+6iqSjQa5f7770eSJnpkODSQbNuegjzo/uGJJ54gkUhw8cUXNyQZPx588EG+853vsG7duprtpmkye/ZsnnnmGebOncsNN9xAIpHgS1/60rTmko7M5N0zL6j9gmrhavC5hhjq/ulVBTuTrVVx9n/Jdb0ma8reM1h1qXgLhIo9NIKZyTSc32RpnAdLdbiRurGcSGDlcl6A28xkUBIJzLonzQlrPHwZW+69+rOP/LUjjVJ6XXJ196lvO2a89el+/oYhLIhCUfyG6utCURBHfQuCgkN2LgG5LlSo/h0VRSyw/lYQE332bqKESz7OtT2SGRipHutYPxM+1NRv8/+ferVQvkLZiFZ97aLepeie5/8/VxWsmW3IPf3Ysxx3ys7dnmVntTdX5+0cb5d0sb85jd23p9pfyT3Gufa4jEY3rujGvfxZgq67tKMNY/OWxp/vG4SRpVv3O06SDs/g3R2f2OtxAzP/uN/XejPikFgy00m7u++++7jgggvGbX/88cc55phjmDt37v5NxrbFF85JGwa8+IgUj1UD8RVRQ+IP9kqtzeKL4v9i1Rc3+gLY/uwvyWc11Qdsa6Y3CYEcrIyc+nFt0/QsCGDSzJiGlpHjwpMUBUqNz5noPO+1j2CA8Qu/H6pSK+0D1dcTEYxLLu4+v3Xkr5dKJWrPVeRaMsPNOsRb+O0WQSxSLFpNw3aJwTB80jm++/FUsTUYy463sNxMP3SfZeYc4x/Ty8arq33C9wAEQBjiMTE/RzAWENafM65ccKxBX1dVl4BsVa7Gl9zPLh71iFPyWfuS/1znOH+fJkmNCeLRDvxytK+1N0EywoHDmyomUygUeOSRR7jtttvG7bv//vvHkc9tt93Gvffey//f3tnGRlF1cfw/O9su3b7Q1jwgWowhbaQWoUIpRkAxEVAkjUg0EF4kqAjRoFGjkURFE9EvJhpMbDFKIibiu0AEIkTgg6kgSE0kfmiIICI+ofgsfdnt7Mvc58PMvXNnZpdOcV+m2/NLmu7M3J09e3dnzp5zz/3flpYWvPXWW6ipqUl73m3btmHbtm3WjpTxS0qkcSoqoMdiCKiqPZ0zCKBEqhqCkRIKaHEgWGafYxNMGSW2ci7dkQbiF+VIUvG1pfXSTGa8Ek5nMpyL3dWWV5zxX+O2Y7Bu4ObNlYVDUKKa8V9L2qNM24C4pcat9A4Yx0pLHDJBpiPi422yM+OVhFw41XSAYs6UHDGpkjIEP58aMN5TuEw6f6l4DSG1EzRuwrx8XkkG3BEQf08AhEwPt8PpTMMBK81YHjbKyzn8/Q1EwWqrjHFFnkrkP5qiUhGGHD3yqIp/Ts4lKqQlJlwFIqXZvx35olSaeSthLlZ8JSuzZ88ezJ49G7W1tbb98Xgcu3fvxoMPPij2bdiwAadPn0ZXVxcmTJiAZ599NuN5161bh+PHjxuhqJkctDkTXuY7qNnGHHRtUAxQsmTCnoPnF4j475jkCEcKqcQoNtBjMX988Ycg3RhOQZ0jTy3x6jtRaccdvZmuGogan0VSt/7z92AuRQ2+8qZmRrBJ3biR80H+lG591qmUsc1vyHwfYO2Tij3YQNR4zah97ImFgvZ2sixRVbmx03QMcsTBtfGEE5OiMvHL35QyYqGg+BPPheEQhPyRJHsENWBf5kE+Lz8GGPZxMVhVNRwlj8ZDIat/TGfDaqusKA0wrokxIbhSeBxzOXQ+cdkPjL65PLnDV5FMumgFAPbt24fp06dj/PjxYp/8+LHHHsPixYu9vQjTjRuV9AXiDkeu6BLN5YlxcmmtXIoqzWERzoZfoGabVH//iJXNuFLRQN5sMCvOACndWGLZZRscH4hZc3vkqEeoE0hzkQZi1ho2vHQ9mTTHIIL2JRPk+TvcqZmOz/i1b5b+Ro3XVbSQUFRAVTmEtI4plSNr4XEULWmPdvh+MYFYd4mtAgDiCSjIUBRink9Wq7DUKVLQwyEE/okYbWuNZbj5Okpi2XA+D4zLJwFAVYVxjBcdpFJAMGRsh0MiwhP2qyqgBqCHShDoi9rTkqUlRnSUgUxyPFfC+ZzhtCeyh2+czOXLl3HkyBF8/PHHrmPpxmkuXLiACRMmAAC+/vrrjIJxLnTmmrB4xcoreZ/kVMQYjlSSK89bkZccTnsuYliwRNJVWiuXwQakuS9M06AMlhrja85F1wDrhwBnULOkfeQXTSZtKVAmjdHJE2QNZ2Okh3RtEAEAqZ5LUCGVc//Ta1RkpaRiBcCV5rMVMQBWyolXvfHiAu78eDk+d7zy+5TOraSMVJ6SCok0oBKNgSWTCGgJMRYJSQlb7x9AwJwEy9OPQsw0lTIrKJNieXIAltZc0J4adK5Ai9IS20qxSjwJpVdzSdM4VQMyPc70nKEUuWUVgkxt/j3MXck6isiLkxmq7A4wHMWCBQtQXl5ue240GsWBAwfQ0dFh2//888+jq6sLiqLgxhtvdB2/EvowowrRTsjoG+mzgKpCl6qt5DkpyggadxkJiEmpmca0UubYGZ9/I62ZIxQPTJQSU2InZUUlijmHhz9HCYWAZMyuYqCq1s3YjGJEaaZ0c2eX+4znyHI9PLrlC8RJFV7y+cRjGS1uRmeqLXqSJy4KByl/p3lbnhJLmenEQatKTu/vh9obFlWDwd4B0Z4lE8KBKVKRjFIeNiaa/qfGcFwD5utJP6zkqIo7WL3SKDRQVN0SQgWMpciTuvjMhiv4yZIJUbEoPxbHPKz/k0mFm/j35MXJfPLJJ0O2WbNmDdasWePaHw6HcenSJdf+HTt2XJUtTNfB2NWtDS8qz6QLVITjTm0qilqyjkhrpulbW4GCOc9GVmR2wqRjgbIy6IOa5cjMqAlwFDuY8z70WEyIYCJdMQS/eWqaJddTUW6m/EykMT05QgLgKB6RoidIE1WltmLGv1NHzjFfyaasACvKYs5qvaQ1PimiNQ22schUfz+CWtJynIBV9aeq9ggKAAY1YwDYTDMqtVVGFARAUc3IhwupSp+LUh5GqudSZo02x2RQXnpvve+StO3S4aXNVcHgyp6MJnyTLss3V+MEnHNEbOM6WppaXSJrDKVz5fw8eYFFpnQIYH1mcjEGHzvDYPpCB3lirPP1A6ExtmPyzVCWCuLHbHI+gF2uhz9OJMGgWdEXrB87tvc9xEC1q50Z2XAlCQEfQ0rXXiqyUORScj7+yOe+SOlDeRE9hUdgQdWo5JMiNiWoArXVUP6bFKoAUFUgVGqftJlGjUAWRBXVb04dt1DIri0H2ObpuNKxVMKcNUatkyFGJl5+HKSb93M125nWdnFOPBWRrUPCR3ZSzIyU+H7+C1uPxYwlA6Tj6da0SSftz9s65VkynYMvTeBMIdmiQPOGK+vjAXBFbMxMw+n9A2L8kSWSlvPUYN2opTSgSOslHcoPpo+wjWWmUkC4DApfjkJUcKa5bY2x9wkAu6MIqghUlIvzyP+VUMiutpBtRnkJMzkZoqjIVpoy03mGclCZjsk6c4qqQtcGxdotTokh2Vl4kce3Sf2YN1bu8GQnKKI0yR6nnc4IzXkeWeaIaYZjZP0Ox8cFNuEozoCVwpSrMwVSKg+ANcYja8nJSJI8zmPpCm9cx3gkxSV+IGu+jV6nkG3IyRBEHkg3KTWj03CoHQxHBWK420Odz7lfTgvzNKOzWovvD8CSBlJU1aUszh2aENpMpewSPoA5B8dK79kmcaaT5klJ4qJyJGWm3gDYHYgc7cht1Cw6GcaGPZG5mCAnQxA+Y6QUjWRylnK6UG4jt3ONb5rRjlpVaY8kevssoVN5tVXAeCzL54ilwuPGc/hcJlU1tvlYFteXE8uKO+ZDZUrJEVcF9SRBEDlh2FMEACuSCZcZ0j6X+6xoQ8j8SDpz8jaXAwKsfen07GTMCaKuqIfIGuRkCILwD3KazJyXZK1tpNtVsR2q5+K/U3tOmudknMfhSGTlBOdzsgBjbETpFWYbX2mXEQQxyjH15DAQtdJbmmZsD0TNsuikJf0zEDVSXb19hkrCQNRyRtGY47matd3bJ5Vgm6/Dn8OPOecP+YD9+/fjpptuQn19Pd58803XccYYNm7ciPr6ekydOhU///xzAay0Q5EMQRD+gc/TMQfg9VgMqsbHZMwS6AFH+TNfgO1yHwBYiwWqpioDV13glXViMT4A/0TsSgrOheSyRDbG2VKpFJ544gkcOHAAdXV1mDlzJtra2nDzzTeLNvv27UN3dze6u7tx9OhRbNiwAUePHv3Xr/1voEiGIAjfwBW22UDUJc8jz28Rf5qxX57fwvdBi9smabKBqFA3sJ3LjJDYoCYcldAk9BHHjh1DfX09Jk2ahNLSUixbtgy7du2ytdm1axdWr14NRVFw2223IRKJ4MKFCwWy2GDURTJ6eRz/m/x7oc2wcfHiRbGMtF8gm4bGb/YAxWpT9q9XrzZ5XWzxSty+sBU9PUO/h1gshpaWFrG9bt06rFu3TmyfP38eEydOFNt1dXWuKCVdm/Pnzwsx4UIw6pzM5MmTfbfEaUtLC9nkAb/Z5Dd7ALLJK/m0af/+/Vk5D2PMtU9RlGG3yTeULiMIghgB1NXV4dy5c2L7zz//xHXXXTfsNvmGnAxBEMQIYObMmeju7sbvv/+OeDyOnTt3oq2tzdamra0NH330ERhj+PHHHzF27NiCpsoAQN28efPmglpQAGbMmFFoE1yQTd7wm01+swcgm7ziR5uuRCAQQENDA1auXImtW7di5cqVWLp0Kdrb23H8+HG0tLSgoaEBnZ2d2LhxI/bv34/333+/4JGMwtIl8QiCIAgiC1C6jCAIgsgZ5GQIgiCInFG0TsZv8gtD2XP48GGMHTsWzc3NaG5uxmuvvZZTewBg7dq1GDduHKZMmZL2eCEkKoayKd/9dO7cOdx1111obGxEU1MT3nnnHVebfPeTF5vy3U+Dg4NobW3FtGnT0NTUhFdeecXVJt/95MWmQlx3ow5WhCSTSTZp0iR2+vRppmkamzp1Kjt16pStzbfffsvuuecepus66+zsZK2trQW159ChQ+y+++7LmQ3pOHLkCDtx4gRrampKezyffeTVpnz3019//cVOnDjBGGOst7eXNTQ0FPS75NWmfPeTruusr6+PMcZYPB5nra2trLOz09Ym3/3kxaZCXHejjaKMZPwmv+DFnkJwxx13oLa2NuPxQkhUDGVTvpkwYQKmT58OAKisrERjYyPOnz9va5PvfvJiU75RFAUVFRUAgEQigUQi4ZoEmO9+8mITkXuK0slkklYYbpt82gMAnZ2dmDZtGu69916cOnUqJ7YMh3z20XAoVD+dOXMGJ0+exKxZs2z7C9lPmWwC8t9PqVQKzc3NGDduHObPn++LfhrKJsB/112xUZSyMsxn8gteXmv69Ok4e/YsKioqsHfvXtx///3o7u7OiT1eyWcfeaVQ/dTf34+lS5fi7bffRlVVle1YofrpSjYVop9UVUVXVxcikQiWLFmCX3/91Ta2Voh+GsomP153xUZRRjJ+k1/w8lpVVVUitF+0aBESiQR6enpyYo9X/ChRUYh+SiQSWLp0KVasWIEHHnjAdbwQ/TSUTYX8PlVXV2PevHkuza5Cfp8y2eTH667YKEon4zf5BS/2/P333+KX3rFjx6DrOq655pqc2OMVP0pU5LufGGN45JFH0NjYiGeeeSZtm3z3kxeb8t1PFy9eRCQSAWCoCR88eBCTJ0+2tcl3P3mxyY/XXbFRlOmyYDCId999FwsXLkQqlcLatWvR1NSE9vZ2AMD69euxaNEi7N27F/X19QiHw9i+fXtB7fniiy/w3nvvIRgMoqysDDt37sx5KmH58uU4fPgwenp6UFdXh1dffRWJRELYlM8+8mpTvvvphx9+wI4dO3DLLbegubkZALBlyxb88ccfwqZ895MXm/LdTxcuXMDDDz+MVCoFXdfx0EMPYfHixQW75rzaVIjrbrRBsjIEQRBEzijKdBlBEAThD8jJEARBEDmDnAxBEASRM8jJEARBEDmDnAxBEASRM8jJECOeLVu24NFHH83b682ePRsnT54EAGzevBkrV67M2La1tZWkSohRTVHOkyGKCz4jGwCi0ShCoRBUVQUAdHR0YNOmTXmzZc+ePaisrMStt97qqf1zzz2Hl19+GV9++WWOLSMIf0KRDOF7+vv7xd8NN9yAPXv2iO0VK1bk1Zb29nasWrXKc/u2tjYcOnQo5+rVBOFXyMkQIx45ZXXmzBkoioLt27dj4sSJqKmpQXt7O3766SdMnToV1dXVePLJJ23P//DDD9HY2IiamhosXLgQZ8+eTfs68Xgc33//Pe68807X/tWrV6OyshJNTU04fvy4ODZmzBjMmDED3333XZbfNUGMDMjJEEXJ0aNH0d3djU8//RRPP/00Xn/9dRw8eBCnTp3CZ599hiNHjgAAvvnmG2zZsgVfffUVLl68iLlz52L58uVpz9nd3Y1AIIC6ujrb/t27d2PZsmWIRCJoa2tzObHGxkb88ssvuXmjBOFzyMkQRclLL72EMWPGYMGCBSgvL8fy5csxbtw4XH/99Zg7d64YuO/o6MCLL76IxsZGBINBbNq0CV1dXWmjmUgkgsrKStf+OXPmYNGiRVBVFatWrXI5lMrKSiHUSBCjDXIyRFEyfvx48bisrMy13d/fDwA4e/YsnnrqKVRXV6O6uhq1tbVgjKVdTKumpgZ9fX2u/ddee614HA6HMTg4iGQyKfb19fWhuro6K++LIEYa5GSIUc3EiRPR0dGBSCQi/mKxGG6//XZX24aGhowO6Er89ttvmDZtWrZMJogRBTkZYlSzfv16vPHGG2Iuy+XLl/H555+nbVtSUoK7775bjOd4QdM0nDhxAvPnz8+KvQQx0iAnQ4xqlixZghdeeAHLli1DVVUVpkyZgn379mVs//jjj2PHjh2ez797927Mmzev4CuKEkShoPVkCGKYzJkzB1u3bvU0IXPWrFn44IMPbOvKE8RogpwMQRAEkTMoXUYQBEHkDHIyBEEQRM4gJ0MQBEHkDHIyBEEQRM4gJ0MQBEHkDHIyBEEQRM4gJ0MQBEHkjP8D2giHquSCCIsAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotter = PlotterPlungerTimetrace3D()\n", + "plotter.max_cond = None\n", + "plotter.plot(settings, data, [node_timestamp, gates , node_r])" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T13:57:52.558080Z", + "start_time": "2022-07-11T13:57:52.417993Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(data[node_r][40])" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T13:58:01.396661Z", + "start_time": "2022-07-11T13:58:00.568600Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEJCAYAAABGw1qNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOy9eZQW1Zk//qnlfd/uhu4GZAmr4JCIgIJKjEkUdRw1i5GAmbgwAQ4xxG00mSyDw9FjklHxzOScmJCZxLgETNxiNBoHiYZAMlkG9GfU4xc0xIiCIvvS9PJuVb8/7vPc971P1e2qtzcb6eec93RX1V2eulX1fJ7t3uuEYRhigAZogAZogAaoF8h9txkYoAEaoAEaoPcuDYDMAA3QAA3QAPUaDYDMAA3QAA3QAPUaDYDMAA3QAA3QAPUaDYDMAA3QAA3QAPUa+e82A31NXuMg+MOGqQOXEus4v86Bcex4ZuJdJQ/PMevpApZ6ZcdsXx4zHwGfF8fcbqD+Nja3G+2XQy6n/nquKugiQHs5AwAYlmkz6gxy86quZkJRa1BH1ztUW9R5R5ihvpRecqisyg32VDvF0DOu5wP1atW5RcUL3VOe+CmFZr/lwDX+OlQ+oGMeA89X9+bQCZfGjtsvcTtl9TcMHDhUJuTxFOMKel66XNE1zmuiw0y2ZJ6mewlpLJm3jFcGAHQUM8Y9Mc85t2yMBd9DoexTu8Qu3YufofIlz+Sfbsel587lJd8IHDgZVUaPhSjjdtC9UBf0+CLfhpW4HXpXQ/FKIxDlzccL8TpGiIas0m5Az8wxvynuT79mTqUTejX196TrmI8VAFDntWPPnj2dM5VAF5wzCHv3lRPLDR99NtasWdOtvvojHXUg4w8fitH/er06qKMHz0JFfIC55rxRt1TwjOtaGBHJegGBSfFwFkBFiKGVhp2FGPPR4RnnnQ7Vvlsk8CABcPb5Lxj9tpRyir9A1R+aVYAyyM/j5QOjAQCXjHnOqPOh+tdV3SBrnP9j2/sBAB9p2AIAaHQLAIBN+dFUXoHL2n0nAAA+OuSvAIDtBQXcrcTLXw8PBwBMadqpxsRVX/Brh0cAAA4U6ox+97U3AAAOttSr8jlVvu2wao+BunlYKwDA99Szasyqsa7PKGm4t22Qar9VtVNoySLbWND/A6iMM4N9o6qbHaT+Ft5pMM4zhSX1PMaN32uc7yip51liMCDexjUeBABs3jkKQAX8G+sVz8c27TfGosFX/W09MJTaU3y2HlTXR448BADYvbdR8UPvHwNHw2DVbut+de9aecnT/RZc+COUglJqy5j3Ru9u0yZ1vtCsztfvouvUhGORlXyeBXfukPqnnKF3t0gAWzBRKsiq64FHfzNme7Jf2a7fQcfUTuia/XG50K+ASPtwek4dodF33f7ozeW3Phh/wzXQ3n1lbPzVhMRyp13YPTDrr3TUgYzrBXBIaDvN6qUqB6yBKnJIW2ZQ8bOqXEAfdX2j+pg72pTQClvoy8iqehmfXlYa3VKHGOZB6m3nD9uRmjODHf89SFZENl6NfF+dEj7vdDQBAMbUHVDNOGUtvBlU/lZUwn8Iq4QoGOfrHFOwbisNUedJpd3cMQYAsKdDCfNGT1k8bLkwuBzKmyDC1xt81R8L1iFZVb9IAnV/WbXLgpUFOwN0e94ERc8xx2TP/sEAgPqGAvXroNBKz4eFMj3/YJAaA37uDEJuibV508Lh55JxTWF0uKzq5ei5txKPBQL9Ij//OvXcGzKKN1YGeCz+uleNnU8WUHubea95smC0xcV/CSx5zLTSROfdZtVfub3qPeSxaFA8sXVVrqOxolsuK4wH3QqyLXSZjhkUQH/Z8inVmeDBIOBL6xBmO1yPwUqDDQ1FppWO6VaKg01Fj/vTtzlYHWcOhyjnHINHJjLKNUCFR51U7F066obTcYAwQ8KDzxGo+CQEWMtjcGGwYU2XXTpac2wzhzGfV8esjWtNMkdCjYSV1qTlU2gzLR0WJg5xPMinfslq4L9MB0tKk91XGIQ63/QBbCOL46w6pY1vKSsQ6qCvnN1iz7dPBFABkSGe6W4bXqe+dmnBMLgcJkG7r6BAo62kjg/TXwYXpv3tiufgsOrfHazGOmCrkf6ywK4jEGFqK6p2g2InYcYyCzD6266eizvMHKNyI12n8gE9P5eeX5HBg4CR6ZgGNSYMdNljTDBiS4Z5ZeD16TyDCgOkBsq8+YJoS5oAmPnK0PvLI8PXq11jGXK5lQlcWEEKyZpmMGFwKZs4h4IyoiBwFmSoavDR58vkxiTwAD12fSyIDWttGdHjZGBgy0eXJ1DhfkLG15xwx+acyjUCFfY0cF8MSD1NAULkw2JywfcoHXUgU01SILHFIQWaRx8ma8RsyeiPn0DDo49d+sRZW2QN1CV3Sol89X4DgVeR3HGs7eXYjcZfmvqzvU25U/5u8G4AwI4O5dtoJPAZm9tf1bvSjneThbCnpKTENvoopeXCxJYLx1oy5GvI0Bf5Zovi4fjByh3GAnNCo+r7/zs0HgBwoKDAY0+76p+1eNbeWVBrC0UIdnYtOmz90XW2IlkDr8vSfeRNKecU3IrbiM/xLedCs6/qOqgKeZRN9+hhYU0x728fajLOt5XU82XhX6Tni3q+ruq1F03X1aCcGqOWdnKD0nvoNypXl36PcqakZwu6QEDvNphj5tWX0FCn2m5nq0fGD9lCqaPzB03B67GlQh5F+fowKLkFM7bDgjwwb1WDQ3EQu7uoHH1aroiTSLcau7wkaHG/ZQ1KYaQu6VegzwZBMQoyvQM7RxcddSAThkBIbi1HaMls0TDxx8zCny0dtmRYKywGphbN5djtoQP/RAGhBYOLSx96iWIuDFogLZNjMvzhsMuJrQd2y/BfprG5/RgzSIEBWyivtynQKTYpHrYVjwEA/LntWKNunr7EPUWllf/VVXGFcdl9qj2KQ+wtqOsSTBigWdAymLRBjRWDzZu7lCVUcR3yvZKWTq4rHlsG4OwgintRPY7lcByLFQCvzUWZ3V7Utt9OLpxmEqTCvQTxvFAw++ZYCVserDQcOthgVON7lsoKu73YqmPLhseAEzn4PeNEhbYOs5x205IVwvErfn8YPPk9DoouWtoIXNx4t5XOaeE6GWERsIVB4KJBSTTDFonHlgsNjXyXUebzdGga5Rqc2PoAuevKwqLhYy4vLZvAcyptcB0eCtFHddxJGGZdohAh8mFMVsFRQkcdyMRRBFzEMQsH1ijZkmHNVPvIyT3Bgf4SuctckVDAQkmDi3DH5Q+qL42z1ELP/IBYA27y1RdcEiDzVn6o5p3PSYtlS0GBxl/z6i8D1h5yb8k4DxOXY2HFFgyDy4E2JexDcvm9fbDZqM/AyyClwYPGLtNG2WFUXrNNgt4RYwbWnHms8mqs+Fl51XUDqe0KC4fBhUGJj7Pm+1AkkGDeWZhLi1S7AIWlpEGKLBi2WBwh+Nm9ptsNhCuQLBUGIf2eEvjo94fvr8ODR++udg23iAQAnVVmggGDRchWAI2732rWk5MiZEKAtGTYumAQ0oKenrvLiXTUrrRY+FjzSf0VmsxvBsXK/yV6JTm+45n5PZGYzQB1j446kAmrUmd1Oqf044uPXQswEoT5DjNmo7Vwrkd/WRjpvllocZCTBCWDDgsV3Q5pqCEHqulpMQAwsWUzLqu+GgaC05r+ho27lYVyx/bzjLIMLn9pHWW0xQDG4MIBfo4bMLF2vrNDud9Ya2fLgi0KJrYsip5n3DsTx0c8CiiEGdPqYOLzPOY6qE+UYyuFjr0ORwsgv5V4K5l9RrL8WitWEACUya2GetNtKoljecwbgwn3w9YBj0WGEk/4fZJpxTqxhADb52zHfXSeExcIREuuabFJd191Xzr2xZaiRAd63Pw8yuTi8w/TeSrGoMOgUBbZYdJ6YNKgxBYRG5MEXhyyI0Na88MgFUmxFu1K95wRKxJml816AnrGkjnaqU9AZvHixXjyyScxcuRIvPzyy5Hr+/fvx+LFi/Haa6+hrq4O99xzD6ZPnw4AmDhxIhobG+F5Hnzfx3PPqVTcffv24ZJLLsHWrVsxceJEPPzwwxg6dGik7Tjy6pWU4Q+NYx86k0mkNLNAlBZOINwq2lKhekWRVcaWCp9nX71OdeaYjAhMVxhXYkNaF5ylxMQpzTuLzdpiGFWn/AyvH1buqT11ppvrIPnxWwqq7nHNyi12sKPeaJu1bwZmdodxRpWOlZBFoVOQi2aQmkmPOR1rACiagOCRj5+j2oUGGtuCmZmntVLS0P22iuDSbZEAY+2a57docCHetaCl47In3GraQqJ2REIJg0lFkFOzFLOTbjK2ePYfUMCux6yNAFxkUvkHKIbILiuS8GyxeQcJJBs4WzGsWFV0Dwy8xUbOLguNNqUADiOWiPqbYbeYb9bLECgV6ZjHnt1p2mXFz53BQVhQ/AwDHfMhfiQ2xuM/nHI0I04CIVs21Vn9PQEyAYCOMHmezHuV+gRkFi1ahGuvvRYLFiyIvX7rrbdi5syZeOyxx/DKK6/gmmuuwdq1a/X1devWYfjw4Uad5cuX49xzz8XSpUuxfPlyLF++HLfffnsqfjiVkzVAnXXEGm3BdIOwZSLdXqU8fdQSbER70g3CxGAjJws6OgtKMm72w1YJWxMNvjlf5p18xVXFZTileXtWATK709i1w9q3nMfCIMLxAqdF8c4gpF1INGaeCJYz6WQLBuRWAnAWjOyWsbyZesKcEPB6gqUABgQVgGKtnH3wmRbVRmGYOuHm6bkTWDBQsiCWGUsaXPgWxXNjt5nWtos84ZSSF0pmrIbHKhSxQp2qfJAAnEGJ+GSLK2wITX4p5Z1dXwEq2Vl8jubkwuXUYR38pneXs8b4efB4i6wvTTzhUaY4o/PjyLvO14UbToOQzEITMly2Ww0y2gri9OgjSP7HKew33ngjHn/8cbiui5EjR+LHP/4xxowZE6lrU9h7m/oEZGbPno2tW7dar2/atAk33HADAGDKlCnYunUrdu7ciVGjRlnrPP7441i/fj0AYOHChTj77LNTg4z0vbNwKTdSFhgXFBaNtnyIQum7Z8HK5z3TnSZBJcKXmPfAwkvP26DrPn0duzoGG/WzYjJmPvB1sPhgliwViqW87StraN9hEawmwchaNoMLa+U6pZh44yB2JR2UBDoJr1JHvDWm75nBhpIeOHsppEUNGBjyQhP2hBuNhRCXZ0HrFQAcNq/JjCXvsEvXSTjrALB5L1pgaYvXbEcLQhLUxUEUa2sjXinAUG6kQD09m9K+OqMez9/RzeZFggr1yynt2sUo5ojorDi3ApqhGw/qRdJHuC3kGYzUYVkIey38EyZpypRmLehZv6NPSixIUbGYGLAFqDBp/hvNY0f0U/2/dgGK9OzeohAhiolLJaSjOIX9a1/7Gr71rW8BAL773e/im9/8Jn7wgx/E1o9T2Hub+kVMZsaMGXj00UdxxhlnYOPGjXjjjTewfft2jBo1Co7j4Pzzz4fjOPjiF7+IJUuWAAB27tyJ0aPVLPTRo0dj165dqfoKQ1Q0zqL5Eep5EzY/NYMJ+e4dMblP98F/xYxsJqnN83UNPkIjDvzQ4IvjJEwMCIPJsmGX2KTB+3QZdoOx64/BRafVEnFcYV9GXedUV3kPLOQ5fZfrsWtHC/R858vjZQ6ZgVs5CY/JF0KIBagr3CsMIFooBRWtlgWZa06xiVii0mevg9B5sxyDkna7sCuHtWu2tqRgbKHAf46Qk94njywV7XYrmsDNFrV2HTJ/dM8+gxnrUHq+rcjoQkWIM6hXrB86z25HPe+Eyxmno0ArhpIFu7T6GFz8hKC7J56VtEakxaIVhCBaT57TEz2ly61fSMV4ilPYm5oq7vPW1lY4jngI7zL1i+FcunQprr/+esycORMnnngiTj75ZPi+Yu0Pf/gDxowZg127duG8887DlClTMHv27Jrav/POO3HnnXeqg9CpzIQuxgs4TWJ5F/74WaP0W+I9tqFMheV5NJz902ammmrLRQo7ZoO1dvoYGFQ4DZjdLnLuyf5Cgw70ZjOUfk2uwg6RrKBdg2R5FBvM+BBE0gILtDwFwdl9xhYJC2ptoZCwKNWb1p8eexKUDACuXF+K/jJQcCBar2kmBTlbNG3RYDQLMj5mQacTBKT7k+MDUrhzn8yDEJjsxtLHHWwpUQUK6FfStk3LupKOSw0IvrSri60NnsPLfAjB6+arZ8QLi5LHX77SIgFAPy+2OEXgX67/JUHGRjI7TcduBD+dBvSr6pVMAx1O2R6vkUqFfI7dpTB00BEmC/7du3dj1qxZ+njJkiVaqU6iZcuWYdWqVWhubsa6detiy9gU9t6mfgEyTU1NuPfeewEAYRhi0qRJmDRpEgBo3+LIkSMxd+5cbNy4EbNnz8aoUaOwY8cOjB49Gjt27MDIkSOt7Vc/rNzEcdoi4I++NIg1R7Oe4wqhwhZLmSdN8nkqwB+UyKwKaZhL4EAtgxc1wJYRgY5LoKI/YBbIvFhlyXxsvGaWnpcRmPMwVBkz00mvDShcfAy8nIbtEXgEDTQniFxFvHIOB+45BsICkYWS1ERlthiTTHV1Bejo83zM13kmOGvm7E6rEhSapw4+JougXVgict4Ep+my4CLvpBbuLPxtiz4ywHKcSWS5lSnY7raZ7jqHgJTjIGzFaWvNAqiBcDE54lkgqB6X+Lgf31tlrMx78sTz4ARKT4CObo+zrAUARpaNEd9SINotWbLKNBiJfjuzZOQcH18mgrxLKWUjRozocpzklltuwS233ILbbrsNK1aswDe+8Y1ImZ5Q2LtCnfsy+ogOHDiAQkG9vXfddRdmz56NpqYmtLa2oqVFZUW1trbi6aef1llnF110EVauXAkAWLlyJebMmZOus8BB6IYI3RBOWb3kTtEEGKfswCmrZShCVwlet8ol5pYcuCVH1/PbHPhtDrwO9ZPlJTntnvoVHQVcHR7Q4SFsyagJdi4AF5o/r6B+zFdbRxZtHVkcaKvHgbZ6tOezaM9n0VZUv46Sj46Sj0P5OoSBgzBw4Htl+F4ZTqA+Jqfgql+H+rmtnvrlHfWjY75Ht82D2+bpeplWlY3D5XgM3LwSVB79EKqfUyJgEMf84/b0M+Ef8esW1C/01M8tq58eow71k8/UK4SaF7ccwi2HkXHltvjHpK8X1Y/r8bGKpEfLc9+6nyL9iEfmh8feb3Xgtzq6PBz10+PD99IR/9PvpeCT+62819G6PK76eYqxcEvqp+8pMH98z5XvS/2yLerH7XM7TJVvy3SRcb9+3nSl6fdQ3GOQMQGG+eL2je+O6vA7pI+pbOD3b1dZGrr88svx85//PPZanMLeF9QnQ3rZZZdh/fr12LNnD8aNG4dvfOMbKBbVm3XllVdi8+bNWLBgATzPw9SpU3H33XcDUHGXuXPnAgBKpRIuv/xyfOxjHwOgXGyf/exncffdd2PChAn42c9+lpof9q1H0mOJtHalNV0OSpMGSimhrlg+hrUvrW1x6quYK6A1KnZZUbkgx0EY5kPGANTfyrL4Zrs8qY9dY/ArcaEWnhEv+pT3rGMdwjpjt5dD96y16qJpDUS0bNYSeUxJIMgUVR4TrxA/07wyZvSX4yTCAuL6btW6VDIDKaK9s7YtNNxI5hK7xdhy4OfNi0NyGi67qYS1xRnQcuxsMWHbmEqKTCbkjDDhegKiAXztOgyiZQG7+1KPCS//wu+LiIlod5kYS19YoBIQmCrp4WZ9W6xHj5lw27HCAlRcrrY+e5pUCnPvdbZlyxa8//1q9fQnnngCU6ZMiZRpbW1FEARobGzUCvtNN93UazxVU5+AzAMPPNDp9Q9/+MPYsmVL5Pxxxx2HF198MbbOMcccY6Q510KRQK8k8dFHgsvCNRQpR8cMXoGI6ciZ5zIwLIPaUujJSZw878Kro3k95argPicZ8OKc0iVoATJ2T/iHzWBySbhs2IWo5xgI8ABn/XDcgE7z3E4JEtotxoK5YK5txWtV+RaQ5CXe2X3Hmm31NX2veRMgGQQgBC/zkqU5sNqVx4KM3WcMPlmznhR8/JfHttqdZZAlnpEkWPUckpg0YnYN6czFsvlOamCSbi3hrmTyRDxLukdldpotNsMuQbm0i1xxgPmFzqyjFSDqHeO6fK/dYtSlJpMMkiaQ9geKU9hXr16NV199Fa7r4thjj9WZZW+//TauuOIKrF69ulOFvbfpCDcOaycnqMQfOOXTFR8Kk4wfaF2EtWShLXE7jki31B+uCARLocIBX73ciehHt8drXJFElynR1SsN6HsV2xkwSaFQmbBoCmDtv26vCO/q+lrwZc3yEaEjgDhiVQghwsTgogWqaFdSNXBLEOc9TVjIhEKrt60kLHnSEwU5lqNXCrb1a7av40fCMpLlK1mGZj/SMrNaalX/yxTiSFtyLKTLyQJwmmzzm3R8SJptAuhFjMX2nPXaZJYU6jj+I+Mk3m3+m2mJ77OrFAIo9pAlE6ewf/7zn48tO2bMGKxevRpA5wp7b9NRBzJAjJYjBJ8WMuJ7SHKbVLRv0w0S0d5kNgvPz5CrBWt3ntmPnLyp5+GIdGS3ak4KZ67JNFeb1SYnqMkPUmuB4h594R6LuLksWrkuz9p4WYyFRYBKN1nkfD6MrHflCiHDFFmnSwhSrd1bxoZ55hWIvQTwku0GYlXgiOAU9Wwpubb7cotVVrbgWU8AtrkKBSVZU/J58JhL4a/do55Uf0R/CfzwfB1uR7rT3HKozWjeN8b2Tla/ez0zu+XopqMPZKreGumm0MtzWV5k3ktDztmImN3C8tBxC5EMINNCbbEYPXeBwUYsKimXaqleeLMyUdQzeJKWRiB40IJPgIrYQkVTRCAK7V9q8Ul6XUSQS0FgE9xi7J0grAhSaXkyj0L42LR32be8R5kizRYOW2Hs8rNlMXniPZL9hRK4xbPU5YmvslhYVf4PVKw62/ykSoxLHcv9W+RxIRvtE6heJTmd2E5SUmz9V7UQ2x4Q/V57mwI46DiKd0I7Ku9ca6RSULnivPDhStePTBVlkgFbOQ9CWxOiPFs00n2nV7qVaZpi6ZZAb01Q1T4vnUP7sej0XPHkpXZf8dmb55kXmR5rGwPrBDiLxsx7tkuBGxUm8YKd61cLHXlNnrfN5ZAWigT/JCC0WURMbPVJwJRuMtm+5ItBsqyXjOFypkspzlrQ2xWLhAsptLmutFA80YdM5GCqxH4iLKjrpP0F0k3aHhr3VlnCh/gSCQGyPc1nMUy0lnTdqncvIedigFLQUQkyTFrgRjRBOi/nHZTM6525JeLacyxZbIFYhJBJWjoVa8MELe354vNVwlBrzXqVAWpbTNiTvMosJGn56HtMmGQnwSYurbT6uj4vrQ50rrlqV5V4Nl4hRIm3vJfPy5bRJIU4nxdatHYRtpvAVtmfxLRcbBtsyX5tVgVTBfTM8tK5I4HcRaiFeGUCsrA4RYxG9ql55TiRRchrd1jRbF+2V3aF5WOLsVhAyqYoRFZj9hx4eXP85ThK3nuKQjh6P6ejkY5KkKm8eOK8NKPlxx7Z1U+U1xqlWS/qgjD7ly4e3T2DlhTkvFwNHUY+4yBGiNlWE7AEnbtazhq74esJAjTSHgtBmkDLYBO6nWulFWHjxMR34gVW1HKh85bnwySXrWeyuWVkRpcsbxOwgXB/JfGvgYMFOpyIxRCd2MmWpNmnVjLEeVuGlgahpFiLAG7bWmeV+JVwi1lchfL9MCxbC7gMUO/Q0QcyYeXD8oSvO0mAWmd4E+mPXpj0URQw27PFOaRW7mqrgj4Sscw9U/X+NhwPKmfMD0tqa5FUYuZdjI0trdoWCLbNZ0iy+sQUJPuqzMLKrLTD9xsi0LnJHJsR4yWC0NZlhgRF5oBYwMgKEjbtX7ikpPVmc0VJV5OsH1eHAZefQ8XKMq0zFtrljGmdSd71agoEBkmhCL1zpXB/JlHFLUp8M1+0sCorhNV8Mi82ly1Tdap7wiswQCno6AMZQL85la1Zzct6cp4QrOw+k1q9J012yyJ/ek8MIWCjQsnkU/JdadgEG50WXLWgol4vK2dqrnLegr43i7vBNiHQdl6mhUYCuAkuChk/kSDiWIDZEVq8UwojAjVSJyEtV8Z55Jycsm3iqAAfj8CN53RUeJb3QPxYs9FMAR7JqGJXqH5/K7EbuYp2KADMFTzrvmVbMPuOgI6QLDqmIyyRuNWSjesJUt5qUXXmfuX0aLnhmZYH6WI3aSkIB9xlRxU5MXLG5quX2n1SPXle76lh0Zgg+tGU4FLSFgyTWGa/4hpzq1YndgxemNLea1dJAqm0YOR8jQpfLLxkLCAU11PwUIi3YPR1GR8QLhz5fCLWk9aaZXlL7CXBErHP01GUaNUF8YAR+lHLMgLK8lvguTnS5cjxSREHKgs3VdQKM5+fTF7Q7WRMMNTnSVmScTDJryQnCFO7WKvbHPCodZ+OOpCpJpvJb8vqsdW3BbWjwoL+sczslpaRrBdxq/HKALzfTCBWi/bihSrQSXxBLIRocyEmucE4G0iXt2isXQW1rtQL/Yp1A9iD2UwV91ZAf6kdvle5UrSgJMHqlE3BLgW2zaLR1y2CXgOw3HCsE161q8/Sl9USEX1IAHa1i1LwxmMCk1cGEVuqcmL/DPwWy6uaZHJCT1swuh84KA6kMB9dZI0jCAsikB+OWG7Eto6TnA0vJ4VEhAeXF6msMmU6Mnu+ZAqpiruuYslosBBLZei+LVp6SZRngJMr1sp6kcBtwoxxyU/Edck+d15QuiTmGgmho+dj6HXE7EJGks0VxNRbVp4ka5q3xSUl+fSExcaWXFAF/J0JX9WXCQJpKfK8LSCgY3u2uUuivm0fZObT0dsxi2dWij8P2MFFugoHqHt0VIIMU63ZJTKLKBL4TYj1RDbDSvC9S4GvQUbseKhdHWK73uqMskhfFh94JHCfABpaq7e0x4JU7lxoa0+fZwGaINhZ82WwkYkDSS6SOJIuHrnjJJPU1iMCTsSzSjomF+8Wi7RvU4bkfidCa5eWUzXJeSa6L5HKLOtGLAhLH0mWUuS8UALKlKShx97irpMuTO1eE+X1dgntYSRpwWYJ1qKYpKEQDjqsm9mYJd+LdFSCTKK2zVyVaWwAACAASURBVMJBZAvJdbqSltzQ33NC6nPZM8/rbWEtiQEVS0q4pHiHTwk2iGrFeiMvOevc4spjCixur8hOhbbsMgugVu5B3lPnIBG1PkT7hi8+3UcczQYLjPMy0M/l/IIqx4LSZp1Z1/2qkWwCmCkueUI+bx2nyprAau2rYIKLLcVc8mCLsdlSjW3zoZIAoDMrJAKkQvoNWDC9Q0clyESyucSy49pdlrBIX0Rg2rRuy/mklOkk0nu3i216A73acxRcZJKLdM3J2IptoywmW1wrsOyfHuEn4hISvnpxnOTaTmPJBDmaZxQTs+iM0logLBhLdbXN6tNxB8ucEdv7JbPLMocJ7LLSygijSS5+PGBKl5uktNq+LSXd1g4DtC0FWj9PDUbx7QTCbVrNi22ZoUgfA9QjdFSCjG3Cl+2YSQfmLduzWoWPSG2Wlo5OPZbzbARFZzvHB9eNOiLZwAYakfMJ8pFBRKc+i1iNbbn5pCQKFg42a6Eyb4P6J4Hgy7kvPv91ohorWySDzZuMzlLvnHQfCWPFQkv6/m3viw2IQ/GMJLhU6se7vKpJA6womxSr0X0kZmrFg4AECZuFY+NXUmQbDj4WfBi8JFgsPe0uC1LP+E9YWvwIpd7bSecIJqdsWju8k57tZ6vvBCQ8+cfXA/Ond3kU5eN291P1HTiBgyATaqsl7rpiHrFeonKW3HKu+vG96PPMg29qk/q+iTc+DrLqV86oX6lB/eTOhbKeHMPAcxB4TmV8aHdIORaR50B8luqd6DwUbsNzjJ/kSY9/hFezvI3XIOuoH53X7VjG0PaeRcZAlJMk3ydJ1f1L3tx8ADdvD3zx2HG90HUMgHGCsCahnFRe715K5fSOql3sL47k80g6359o8eLFGDlypN4hGAC+9rWvYcqUKTjppJMwd+5cHDhwILbumjVrcPzxx2Py5MlYvnx5X7F8dIKM3FaXyfaR6uv0sfOWsvJ8RGiwYOQfkdzmlfu1gYoEoQqIVYFJDB9O4EBv5ctbStOHVM6pX+AJtx3xqsGBQEqXE/fCx6Wc+tnGUgts+vEYcD3uLwImxK8UwJLk+erjWoVHtC3107xrgWvekwRELTCFoNT1LUArgbycdVDOOpH3S45Zqc6JXRdNb+McI5yVpedYhXc55+jkirixlKDDJLeyTirP5yWY1f7s1E+OeRrqSp00FIYOiqGX+EtDixYtwpo1a4xz5513Hl5++WW89NJL+MAHPoDbbrstUq9cLuOaa67BU089hU2bNuGBBx7Apk2beuT+kqif43bvkC14bc2oEqZ4UuA/siyJBbhs6b22dhmYIsthWNxsgR9CBzn1nBk6JgsoyJlxhsgYOOaxTmWm7Q4iqx6IDDx2p8mkBpl5pbfhlWMnyDYr27W4uJxSZfXdQMwb4j45dsHLucjxL9WbgXzbXCDbPJtYU7KqH9mOjbTrMTDdb65YAka/39JNWIhLESa3VZ0Zp2Li2Eg10KShiPvKi78uEwqAqBWapp+eID1epdrutS9p9uzZ2Lp1q3Hu/PPP1/+ffvrpeOSRRyL1Nm7ciMmTJ+O4444DAFx66aV4/PHHMXXq1F7lFzhKQSZpz3S5IKbeVlcGIYXQsWVUyX4jS7kk7G8RSWEVWxHIT4LnyTiZsPKRcgxD7FxZqSTOy2NBcnl6vTukZWwjW9oK0PEtqc0cc2ENnVcyZoDg47SxhGqSa4jJwLskudy8bcOtilIiM6kQW86axm2LDQpAlmuW2eaKGOd4fonF9RQNuJt9RSZZijk7vMMmLNlhOq1bAKWNDznfJehGuq91AmcvUZAyhXn37jcxa9YsfbxkyRIsWbKkpr7uueceXHLJJZHzb731FsaPH6+Px40bhw0bNtTUdlepT9xlcX7Eatq/fz/mzp2Lk046CaeddhpefvllAMC2bdtwzjnn4IQTTsC0adNwxx136Do333wzxo4di5kzZ2LmzJl6m9FE6oY7V7pNmJJ85rI+E7sUbPEGfSxjBuSi0v0G5q/iDqwSNhxj8UKEXojAV79ynfrpPsm9xsTXy1n143tgdxuXr7izzHssDVI/jvXomI+gUp368T3JMZCuzcqYKvdKOaN+OobAriS/2q1lumrYDWWLrUmSz4nr20i3L1x+kXZFXMtGfK86ZmOJ6TBF3HRVvMqxsLmlIvEl6RqkelyOXYSRe7S61czyNpdxWjddGtIuY3pnpEvw3aIRI0bgueee079aAeaWW26B7/uYP39+5FoYxsRunb6550RL5vnnn8f//M//4MUXX8SBAwcwZMgQzJgxAx//+McN1O2MFi1ahGuvvRYLFiyIvX7rrbdi5syZeOyxx/DKK6/gmmuuwdq1a+H7Pr797W/jlFNOQUtLC0499VScd9552sT78pe/jK9+9as13C6ian/1JYulUdkJ0bzOpDVXzqjKmeWka0jvnCjKMUU2R7PxKzZDY8umVIWkVn92lpZKOewbPEoA4MQCBiw5F4eJ70WmQltdkHKvHlFOurC0tSjGRlqTTHGgz2Ph0Uq9OtU4E2+JMHG2mQz+sxUlLRxp0XKmnC0FOuL+JLIBWNIqwrZnXg0WnKIcZF3zmsUKk7zaFueUkzwjrrtSvCUiAaOyoGu6eTJ68zVetFSmsFe1I5fQsVlpPUV9sZ/MypUr8eSTT2Lt2rWx4DFu3Dhs27ZNH2/fvh1jxozpVZ6YrCDz9NNP49/+7d/Q0tKCs846Cx/96EfR2NiIlpYWbN68GfPnz8fgwYNx66234oILLui0kzg/YjVt2rQJN9xwAwBgypQp2Lp1K3bu3InRo0dj9OjRAIDGxkaccMIJeOutt3rdj6jnG1DcwTrp0iJAXW3am9cdAS6R9mzL3MilWPg4IwQw8eO3V4RZZfl5+rjruA59jA080VCk84qstXJOHXvt6dJwAyH8GXxKtI99wGMntpbWACxmx9viFxEXVFzWEI9Pe/SawXNklW0GB9FOZAIpnec0bEu6tvSYJKYwW+p7Se5eiwvL6EO7isyUcLkPjBzfyJiknP9iI9u8HNukzOgKA6bbT4JatSWnt9dOmXp+pNCaNWtw++2347e//S0aGhpiy3zwgx/Eli1b8Prrr2Ps2LF48MEHcf/99/cJf1aQ+eEPf4j//u//xgc/+EFr5WeffRa33357Isgk0YwZM/Doo4/ijDPOwMaNG/HGG29g+/btGDVqlC6zdetW/PnPf8aHPvQhfW7FihVYtWoVZs2ahW9/+9sYOnRobPt33nkn7rzzTnUQVj6kyLa34lh+7JHAfMKugNq9I+IR1rkiHBsgELJ9A3rbZfaL8/miqSkHHuDzagW8pTPz7Ir5JgQ+so2wjs06x+CtMveD2hfzYnRshpgrxb/7EcuSYy9yA66y2DteCny+ztaF4TYSEz2ZZ22BJAT0IyxzPMGywyXX17ETsVKEjKkwaUAW8Skur0FGXI/0nzMBQmb5qUJ0LCdjRrb4NnmzJsXwhGYGNFISXBG30laCJbguE0cSrYySCRz6PgR4yXlXsX2LvvojXXbZZVi/fj327NmDcePG4Rvf+AZuu+025PN5nHfeeQBU8P8HP/gB3n77bVxxxRVYvXo1fN/HihUrcMEFF6BcLmPx4sWYNm1an/DshHHOul6grVu34sILL9Txlmo6dOgQrr/+evz5z3/GiSeeiFdeeQV33XUXZsyYAQA4fPgwzjrrLCxbtgzz5s0DAOzcuRPDhw+H4zi48cYbsWPHDtxzzz2JfNS/bzzef/m/AAAyLeqcDCJL4SHX3+J6HMyWIBPoD0z9zQ/h9s1ytsC/1LBcEZg8PI6sCtrOuZxVx9UWDPPFriFGrLZjVWPuYNVpuEehhtdmdsoWT9Cgbs5t84g3dX7wG6p8oVmVL9VzZpbiIXuQ7pG2PmaNsthMvLaKD5newsHbxGkBJgw6xUHxzyh3SElUfob1e8poHaUkkEwSyDeRq0hmtonnmTugynccQ4JOWF3y/WEBVxqkzmcPme8Vvx9yAVatnPCaWsI1yPX0xFcxJnp5mw5TgbDtewNUxovHomxZXkYCLy+1b3NTygmtkWxAsUSP5DEpRpY5bK4IIIP3PFcqdvl+Sx9xC5GWN9+P5557rnNmEmjstCG4+uEzEss9tvCdbvfVH6nTmMxpp52GRYsW4dJLL8WwYcN6jYmmpibce++9AFSAatKkSZg0aRIAoFgs4uKLL8b8+fM1wAAwrJwvfOELuPDCC1P3V9lDhTOVWFh3rsHwx129nS0QDUjbtD5pKXliBYAkYqEkwcRvI74l+2GV1l0v2sp7RhUGFRb+JV8ICXGsXYLakjEBL0M8MciwBRRZJFS0U1mSxRxbBvRQrHIQAfhO3Gu25UTkMkIR7Z01XJ1uK65ry7E2DVi6VSVF3h+2iCJp351bVHpV8GJ0kcikFGCbe1JagUm7eUbqyxiM+AaTsgUj1pp4f+Jcjmmsmeo2B6hnqNPhnD9/Pu69916MGTMG8+bNwxNPPIFSqefz/Q4cOIBCQX1Bd911F2bPno2mpiaEYYjPf/7zOOGEE/Av//IvRp0dO3bo/x977DFr5pokJ1Qft1uqZCxx1pbfHsJvD/V5/dOzkFU5md3DWT0yU4brc7aXnP2uebJM5pSTNJlvniDp5tVP16PzevJdVVvZg2RdFFz1E+R2OHA7Kvfklhy9lYBqIDB+XE5PfqPj3AEHuQPVGVz8U9lpcjJnJCOK+6ex4zGrjGUYEWhA1RjRM6g8k2gdrxgamna5zkyxtk2O1NmF/OPJmZbnGuFR1NOTLTPRRVSrx8KWvSj51GMVGQN1XC1kk1ZQkBNOE/vmLD/KqGNeOIMrqb48r9vx4n+2MeX+JP9xdZhkliEfp52/lEQh0GOTMY9E6tSSuf7663H99ddj8+bNuO+++/DP//zPuOKKK3DppZdi4cKFOPXUU1N1EudHLBaVinrllVdi8+bNWLBgATzPw9SpU3H33XcDAP7whz/gvvvuw4knnoiZM2cCUJlon/jEJ/D1r38dL7zwAhzHwcSJE/HDH/4w9U3L7B8ptKTbRJZnVwHbAbY93JlYW8xwXET43m3vl+zftv+Ijn/ETHyzWktFmnwX8D3E980JAm4ru8vM60zVcaBqqmTKxScMVBITEEtJVl4kg4+epaufRRjx8zs6iGy2YZuca4sDaXcZu0dlJlQ5/n2wzZ/iZAdpJdrGWlo0TBHXVKHiioq6H8061rk80rWU9FwscUpb1qDNCpRJFDbLlec2SfdYZ7Jbgkic9dUnsYT3OKWajHnCCSfg1ltvxS233IJ169bhJz/5Cc4991yMGzcuNsYi6YEHHuj0+oc//GFs2bIlcv6MM86Ize8GgPvuuy8N67EU53sFqvzCFpPdFQJbv8DSN54xhYsrhJTN3aJ9/Yg/z+3V71Z/O9iDKYVW1QoAPDNfB9551ruwZqxCnspxCjNnmVU+ZtE3jZEMTjOYsNvMKsDF2EYEtAX4mUIxebNub2XGv9x+WYKELZsraSUGSbZy2vUnBT33ZxGIbGVxLJBJ3rscc09sVuYVQz35MS3ZFC4JbMyKDZClsI+ATbbz8rb0cBsIxgFGWldcT1P6/WTem1TTjH/HcTB48GDU19fD9320tyfkhPZHqsoui3worRRQF6nBthfZtgyJvK4Dsm1mO1rIpWRdfxwdZryiEmxVf3mTM6dYxQMBn5unYLcfz7u+RxasItuMXWiZVjPQzwkGUhjpjaH4XkX6tgYpuu63c+DeM/kB3yMF/i3xML6ebY2Oqt9Bc4N4jkjCd299T+QSOvK8EP7WeTSyvgWwOXHAlg1niyHp+6ja2ti2qoFOqGg031Umve0F4iniUrNYHDaw0e1YgFbfm+VjsW6TUMWH9DjoexLPszq7rP/mmR05lApktm3bhvvuuw+rVq3CO++8g8985jN49NFHMXv27N7mr1dIu71ENpBtsqWenMnZPXnO5qIgNa9tRe1mW8wP2BdbA0jBKIWI/I5srgl2RXF6Mmuy7N/381EgyhwyA6x6TTP6wwLJk2tIMZjoezHvMbI1NH3Q2Ra2LMz2cwdMXiVpQLW4CqXFU3FhUnnWkH2nyjVDANlSojYyoo76K7MDJRBL3qQokiny/J4VWbgJrZ2fG1um7C7je6pMBlXnSyI7itvhTDEZA6lO75VavNdO2YOD2WJFLPHzy/E7xssICQEtrT5bBpcNKGW7TDJ925ZKLcv7pPxUg5kVyCyu4AHqHnUKMj/+8Y+xatUq/P73v8fZZ5+NG2+8EfPmzUN9fX1n1fo9ye1XOZeeffW2DZO0j12sv6SzlvIwrus9OgpmRk+lvc75Y7CKpDSTgOessqi2H20/IpR5gctcvGuvxPcu5lVogXZQT7RQxURspX6P+qecVdd1unbB7L9MKdA88ZUBIXuIJ4lSOSE4JaiwINbL1tPGZH57GU4zZdKJ7Yk9sSgjH5cQ35efN8cqQ9ZS+3CPyqnj4iDXKMfPj0GgPWM+0IrgN9uXsSStMFhSmZki7xnn6nhRV7Fty2i+57KYt8QUeScFKEjXVJLbTca55HV+f1gtsAXl5Ryl6m0frLEtBq5eyioLQgd5ufDhUUSd3vntt9+OhQsX4r777sPYsWP7iqdeJScE6vaR20SCBW2f67CWL4RNAwnOzGH11ZbqSXiVTPCRxC8zg4Zc/Zc/eDlPR4KXbX0lmVpdtxfEn6PPsUaX28eWDPHGabnSUmAA7nCMYy0ECJgb3jHPVyyLMv316J7Nj58FukfuOJ6Lws9Ax61ICJYz8epn3X7VT3EwJzJIiybQY6Cfb0n95fFmYouWXYFyXxq5MZu+h4L5Hsngs36+JLj5XvNDTJdf7qDZruSP25MrEsjUbD1h0dQDVIaZaz6HyjcggE7O3REgIJUKCYyVuUPEikiOkCnq2l3H5xFP0oq0LVoqlz2qBpgkMDGyHTsvOkApqFOQ2bx5c1/x0WcU53rKHqCJib7pNgv5Q+KlK6Qfm4QW6thdVgmwAtDrM2kBKpbG0O4QYTllW02hIS0q1qAzrepYuuuqXRaRGdclswxbEFLR0m4LAri6feZ1r2gK6ohLicaGx2LQDnUst8XVAWDtgixTOU5HovO7CUwafbpnE3Q0KJIlo63IfAkObXSjhXGZxu8wg45LbfK9Ce07MN2jzCvfY/ZQJZNNlaN7LZv3WtlZleoXHaM8x6Ek4Lsi+9EhwK47RK4ukVXoaLefY9QPsk5k9YoKAIs4ZIIglhNS5XyZpNUQdDu2NdJEYN8VYCYpKTnDLYfWOT9xc2p6kkI4KPXkngRHGFlBZt68ebjhhhsSl5W57bbb8Oijj/YKc71CQdS1okGEXTUCdIqDySXEgrONfPpZ9eJwe9q/zdoaCcIgawopJnkcWFJbHb1UCgvOwODPJ35KDWLWfsaF32a6nYqDzFRkFhI8O13HlQ6ZvLB2r5MYWgpUjoW+qsgC1GtV1zOHlUrLlk+JdFTmZ9DOsnFPmXdUx+WhKh0uyPlGe167Yrg4WDFcsZjU3+xOlYIVjm2ifgP9fLM7Dxv35BYU+FQ+AroHMfu8bm+R7lGVr99tBqAYEJkHdhHW71b18s0+jYW6LrcclpYLg05FsJrvSe5ggfhhS5reX7FEDD97VgiKg33tdpJrlzFvvEKmfqfJkq1s5WC60SDdW55pCVWAXbgkeUa+JRstAhoWSWUDFQ0g9LdU50QSM2zxp4GYTM+SFWSuvPJKXH311Th06BDOOussHH/88XqBzL/85S9Yv349hgwZgn//93/vS367TU4QajDItMS/ZfyphoF6G+t2KZs/9ElA5kvGcW5fwTjPgpHnavAMfRakWZ4v45uptUGDKYClcGG+K8cmKgVljgVUrAstyLQwJquH3Vp6fxbzvPz4OUaiLZG8qUVnySrQwF2g5WsYmAWgW6lcNtr3Spx1wRq3GuuGHRmjPXaBMfGYugdaMWi7a5YpsxAnXphHz7RItDJSIF7y5rF+H7QbTrjP6LwNlMICvx/UnkgvdoSbT4NTSVh9nFnFFlTEjVZRntpHZKmuiE/R89GuV2E98XnbXDDp6tUxnYzJS2SDOJ1UEx+31P2LOWa2JXWYpMVWTRpshNtTK1wWK6yrFGIgJhNL559/Ps4//3w899xzeOqpp7BhwwYcOHAAQ4cOxUknnYQHH3wQJ598cl/y2mOkXQT5zlcvCMXKxEHWNHm5PgtE8ItOabq5PSoQ0jFSaeURASvccfrDY2FVNIUGkyf2ZOf6HCsqE2A07CxGyrKrTbr2/Lp4IVC3nwQojxl/3Hn1RUrgq8SRSgavfouSEm5BvXIsoCNEK0o4ZXa60z0KgGCLRo8BXy8UzeulUuX5lLkNAg1hkVbGhONCDJyqHKdAu208GYjjAeSOK5hqt3y/tFVG/cr5OxV3mwAPYblKy1uOpCcAl8faKQX6eWsgJQuxPEiBj47htbFSoMZGz9VpNWM3DC4MwHJukdxZU0+E1W4w872Sqc969XCxPpwGL/0amKBlS4oAKu+2XHQ1wotudYC6Q4nwOmvWrNT7xhwJ5ARVwoW07dDj7KOyeSySiVlwcb3I8IkPVx8XzXZYeOm4A5NF69eTM4WbRVtUHgkRFpKoaNZS665kVJmAVr+HNVEzgC6BS8ehyiavlXujLzSvQEULewHsEsA1EJTIkhGCksEjUl4SgxTXL5U1IDK4VIDMTDLwhGWpsw4LJeO8BECv3bSUMi1eLI/SKvN9s55bEJaRzk6kdiz7DPF98Hsgz1eDnWeJeTEPcsVqbfGUTaVEt5c3LSIuZ4u1cH2eFKqtLuHKiq4M0Hl2oVYQ8qZFFWfpyEQbSc4AyPQoHYU2XKg/Pv1hRVwtrDnKWXWeKF+KLR/CBC0tmEX7yArBzb590vpZ89X1+C/zT0LM8YTmGlSElxYw5G7I6D01hEAlMCjXK5WR/f0ce3EFLxJEWMBJ7V271fIc5yLeeA6KHOs8XRCgArFmHo9tBIwIpNw2BvpypS1ug/qwPX9JGjxaBYCJe2SesjsLxj1x+SCnxpbHIijxsWo3W7a8JyywWVCyNZAzwUy/B5HlbUjRyPpaKcgeIMty/yFqS22TUcmEI2uv6Bvnq5eoUedFXyKTTrrLOAlCJ4xUTRStJltmniTtBSiKY5HI4JZDq4tNAmU19UQuQBiix9xlixcvxpNPPomRI0fq1Vb27duHSy65BFu3bsXEiRPx8MMPx257MnHiRDQ2NsLzPPi+32crPh99IBNGXS820q89l+PZ6m3KDebk6AQLPF4vhJdOaaMPuUG5IrTFoTVoU9PkLCep9duEjNSotcVTZSVIa40BjN0jWosmocwCy29hMCILqNUUnNri0LEZoWaTIHdbeAIMA2/8mDs2UCnxPZpWgZMXSweURTkNLOVoW8x7QQAXg4K0kiTPwu0WcfyxEiDLiXa8FrkxDH2O4vnaQDAU1yWoRakE/4B02ZrPkZMOKtYVldeby7FLSQAiC+6scP2JWIzOhNOJASY7LOg5kURn3unjeLDhTFBuTydvoDKXLCNWgbDtgClX6e5PFLfL8PLly3Huuedi6dKlWL58OZYvX47bb789tv66deswfPjwvmIXwFEIMk4QVoR2XkzFF6ARFWyiMXGd25NhQ5vF4QpLSH/YUuu3aMJWkCxXYkccG+G+NWjosmFsOd1XwQQPvf2xBtayUb/ikqK/HWLQ/M5TOUMeQ1muFD/WERL9hqUSnLx5DyG7ywTPEiy0sGarjd2g3LfkicHM9+PPi2OdYMKJIm0CqJOUIAFiTtkytlXXHQ4EsmuNxpnfKS2kCQC9Y9Q3UUm7pwy6jG1eErv4JO+cWGKCDZOMFbENofnJm9flOnTcPieeuHR/2QOqgY5j/Eifkip9V9pOuRN6pxTAQaGHUpjjdhl+/PHHsX79egDAwoULcfbZZ1tB5t2gow5kEIYVIS2FhC8EIws6LiePmeQxTAGo3RXCjcbDLzVqXU9mQ0lwYWFHQo0tIUOTlUCp/femcJHAKjXVCKBye21C2Nu2grDUt56PjKkiDRBJ13PZSvuWshKonLxcWMti+UjrSlpKkvT744tjBmhRXo6JbUxzFmtO1uP+6nLaotTvkL4XkR2oLRlyFXK2XgQ8QOXJPeVK95jF8hBJFgxafKyteqLAE65lIj33zDfb40xLPs4eDiLxKBtvabeO7i/EW9UDwOjRo7Fr167Yco7j4Pzzz4fjOPjiF7+IJUuW9Al/qUHmmWeewYMPPohdu3bhl7/8JZ577jkcOnQIf//3f9+b/PU8BUHE3RERDvJjrfVYgBELYifLU/05piKEB2uX7OrRAsEMpkeIhYksn81UCRqzL/0Jc1mbxcGC0Qa8lvOh0NYrvArAtlCYtG9RRKBKS6eig0bailigCfpqkrUmZL21PR6rCDgl3KsNvGCxqGzUkY+OO/PSqtyamVY1v0hn6YnMNm3Nsf+MiEGJkyckGMhkFpnEolPOOcmhwTfOVxIRhNIkXIO2zD2e+1bdt2xLt9nTIBOmm4y5e/duI8lqyZIlPQoEf/jDHzBmzBjs2rUL5513HqZMmdIn60+mApnvfe97uOOOO3DFFVfgkUceAQDU19fjuuuuwx//+MdeZbBXKEmrTvpokzRWm5Et4w7W/oXwsYEga+tCMzb6swl1CS5JFoW4HrEYZDn+K11Hst20lAQqolysmEgCF9s483mbm8zWTqLlK+p5lmdko6TrKSik5+8MajAv0POViR1szfn0N6B4I7uEyw3m5FnNKqdIy4xIkRknE0dk8o1t2oGMb3qUll4NGJGkFEuW5rtFI0aM6FIwftSoUdixYwdGjx6NHTt2YOTIkbHlxowZAwAYOXIk5s6di40bN/YfkPnOd76DtWvXYuLEidrXN2XKFLz66qu9ylyvUBBWBGuS28tyLLV0fRxxh5DQ4P7qSOW1aa4R952wTCRFhFtMu1LoexYXILdlnePBbQAAIABJREFU69MmgBPKJVokNkoQoGnbDYuV5S7DIj2njHhOkiz34Ijnz+RYwCQU1mHkfeELKcc88p6ldedW92N7zvTX388bELH1Rn8hrDmiyBydNjNZhV3DUo+XmXMcC+S4FIOStJwi9SzviZ5uUJUUoWOfAlwiWYbV2Xk9EEoJgB6LycTRRRddhJUrV2Lp0qVYuXIl5syZEynT2tqKIAjQ2NiI1tZWPP3007jpppt6jadqSgUyLS0tGD9+PADl1wOAYrGIbDbbWbV+SmFF240ICz/2vLxubVkIgYiWKFJoI5orkxTgScJGU0y7UgBZXH1W95YkGxBT+zWDirSQJBCI80yORevX9TvpUrfFGW9CObDeg81NmlSP+02pXETeI1EvyRVpfX8765Pf1ZLpSk6MAzKOcvmsH1+PeWCQElYDJ5poN90h4keAlJ6zJK0SjjGSazqU6f9V+pjcS0cCleGCEwbeu01xuwwvXboUn/3sZ3H33XdjwoQJ+NnPfgYAePvtt3HFFVdg9erV2LlzJ+bOnQsAKJVKuPzyy/Gxj32sT3hOBTKzZ8/G8uXLsWzZMn3uu9/9Ls4555xeY6xXKSFobCN9vTOXTFw7PRz01vW0ZVSO/+vHgE0XyQZsEYGXVtjbAJbbLSaAlS0RIRN9pZPaSh3/SfveJLmxvHSA3N3rkp+491U/J34eBZEUE0ktt9wbgZTbZoJFZAUHC7kigUSClFzRQWbyyQQWDX7VcU5WKkSWpwZCGRMF+h3I2HYZXrt2beTcmDFjsHr1agDAcccdhxdffLFXebNR6pjMpz71KfzoRz9CS0sLjj/+eDQ1NeGXv/xlqk7iJhBV0/79+7F48WK89tprqKurwz333IPp06cDANasWYPrr78e5XIZV1xxBZYuXQog/QSkCIUxwppJBs5txzay1ZPCP4nFtMJDuu8iqbPlRKvMpiUn8SaFU8QqjBH2Bgkwelco6fkLsr43tcZGkt6vrsZaanlfbfdQlfoNAE6rOc/JamXr84HRToRsMUKr61KkhVvmPCVmNVYnPXBWnrDKrIk13aSwB1OYj0RKFekaPXo0nn32WTz88MO4//77sXLlSmzYsAHve9/7UnWyaNEirFmzxnr91ltvxcyZM/HSSy9h1apVuP766wEA5XIZ11xzDZ566ils2rQJDzzwADZt2gSgMgFpy5YtOPfcc7F8+fJUvFDD8R+yPJ/2OKFcWCrFCm8+b7ue1E9ivU6oO3VTtV8sxf56u33ZT1iKJluEpaL6SZ4s74UuJ8c/4Z4S7z3p/aqVLO1F+O+sj6RvoyR++YL66eO8+nF5vs4/eZ7rRc6X6Md9iWNbe7J+R179jDLEo2ybr7e2V34D1G1KBTJz5syB4zg47bTT8I//+I84/fTT4bou5s2bl6qT2bNnY9iwYdbrmzZtwrnnngtAJRRs3boVO3fuxMaNGzF58mQcd9xxyGazuPTSS/H4448DUBOQFi5cCEBNQPrFL36RiheE3U9P7KrATAIVfd4GXl3oJ0JJQiTtz9Je2rGxlWMA6C5x+44f3d/Z8TOx52VdK48pwSXpfK1jlRawuwXsQuiHHXkVr6Hz8h2OvNMShGztS3AR7WshL8GN+bK93zYQirsmf71EYQiUAjfx916lVO6ydevWxZ7nWabdpRkzZuDRRx/FGWecgY0bN+KNN97A9u3b8dZbb+mEAwAYN24cNmzYACD9BCQAuPPOO3HnnXdarycFmxNdP0nlu+kOsQkKGfy2gkocdUdj7kZ7XbVmGHg6A4e4cp0Bli7TTQur1vqyvHxv0rYXSYZIeE/DYsnah0yGkDE1rZoluRhJWEfeRWvSQ/z5SKzPFg/jhAXh/pWZfNVUa8LEAKnstLq6OnhJIYMY6vSt5BS3QqEQSXf729/+hmOPPbbmDuNo6dKluP766zFz5kyceOKJOPnkk+H7PsIYq4Oz22qh6klNzV5l3R7rhyYobcaT7XxakEpq10ppY0Yp+pRCyHbc2yTBQYJGEtj0Ck+9HD/qC7DrakJF2vOJ8c6kftMoTnH9isuxyRgpEy56WgEL4aBoW/Knn1IQBHjwwQfx05/+FM8++yxyuRzy+TxGjBiBT3ziE1iyZAne//73p2qrU4mxbds23SH/DyhBP378eNx8881dv4sqampqwr333gsACMMQkyZNwqRJk9DW1mb0u337dj2hKO0EpAjV4C5LCyqpqcaXt1bNtuYPO0XfSbx0WzCmdI3ZyknQqQV8umodHU1Uq4JlVQHTvvtdFfBp6qXN+ns3k1H6CZ1zzjn4h3/4B9x2222YPn06XFe58/bt24d169Zh6dKlmDt3Lv7pn/4psa1OQYYF/0c+8hF84Qtf6AHW4+nAgQNoaGhANpvFXXfdhdmzZ6OpqQkf/OAHsWXLFrz++usYO3YsHnzwQdx///0A0k1AslFX3RHdpaT2agY120fTiVsurUXS15ZLrVSLWyxtW5JsoGKzspLarxWkegoEu9K/rU5ffztpFa1aXIVW6mkX8hFMv/71r5HJRN+XYcOG4eKLL8bFF1+MYjHdN5dKgjDAtLS0YM+ePYYb67jjjkusHzeBiBm88sorsXnzZixYsACe52Hq1Km4++67FXO+jxUrVuCCCy5AuVzG4sWLMW3aNACwTkDqj5TW595joJbiY0nLQ09bKj1tDfREkgCTBKwk8Enquyd5q26vJ0DN6o7s5rvZ14pZLeW6C1RdpTAEikdYCvMLL7yA8ePH6wziVatW4ec//zmOPfZY3HzzzRg2bFgsCMWRE8YFPgRt3rwZl19+OV588UU4joMwDHVspHyEoX+zewxOz33i3WajRyjNR5EEcDW75GqkpNhKfyJb3KfWY6buWjBJfHWnnyTw76511FcuxrTPoqu0d9rmbm/uNfgD78OM7y9MLJe/YW2fbSSWRKeccgp+/etfY9iwYfjd736HSy+9FN/73vfwwgsvYPPmzXoNyzSUCrqvuuoqnHPOOVi3bh0mTZqErVu34oYbbsBHPvKRLt9Ef6L+7nPvTf4G/M8VkoI36bjWdtI+vyQgTgKbztqpFRRqtdaSwKpWpaO7gBrXblrQ7ik6EgP/5XJZTzt56KGHsGTJEu0mmzlzZk1tpQKZF198Ec888wwymQzCMERzczP+4z/+A9OnT08V+Onv1FXh3VvCv6c14wHqHeqqwKtV4NrqdcVd110XYBKlBca095C2n1oUgv5oRfc3KpfLKJVK8H0fa9euNaaAlGpM9U4FMnV1dSgWi8hkMhg+fDjefPNNDB06FHv37q2N8/cYvduuglqoryyW/njvvU21Cq0kQfxuUF/13VNj1ZPU632EQDlMnnpR++SM3qPLLrsMZ511FoYPH476+nqceeaZAIC//vWvaG5urqmtVCBz5pln4uGHH8aiRYvwmc98Bh//+MeRy+WOvA3LBPVW1k93LaPU/aeIyfRUzCXtWKUNSr8XqbvWQFo32QANUG/TsmXLcO6552LHjh16N01ATWf53ve+V1NbqUDm4Ycf1v/feuutmDZtGg4fPowFCxbU1Fl/o66CwZGkpfd14P9otGSYesvVNEBHNoVwUConLxvT376Y008/PXLuAx/4QM3t1Lxgjuu6+NznPoerrroKgwYNqrnDo4Hk+ltpj5PW1Eq63iVee3jhShsx7/J3NNJ78d7DchlhP8g07S989BbdcccdmD59OqZNm4bvfOc7kethGOK6667D5MmTcdJJJ+H555/vVn8nnngi5s+fj9tvvx1PPfUUtm/fjltuuaWmNlJZMp/73Odil3PJ5XIYN24cPv3pT2PGjBk1dfxeJilA0h739byLWiht/CltuaNZa38v3ntkE7l+QtWA0195TEsvv/wyfvSjH2Hjxo3IZrP42Mc+hk9+8pPG8i5PPfUUtmzZgi1btmDDhg246qqr9HqPXaHf/va3eOmll/DSSy/hwQcfxGWXXYapU6cae4slUSpLprm5GY8//jjCMMS4ceMQhiGeeOIJeJ6HzZs348Mf/jBWrVrV5Rt5r1NPrSzcFXIy/rs6a19q7Ulj0V0tvz9ZCTZeaj3fFzz1FiVZFrVaHlxe1uNjx/MMMJHH7waFIVAqe4m/JNq8eTNOP/10NDQ0wPd9nHXWWXjssceMMo8//jgWLFgAx3Fw+umn48CBA9ixY0eXeR82bBjOPvtsXHfddVi5ciWeffbZ1GuWMaWSPn/5y1+wevVqfPSjH9Xn/vSnP+Gmm27CM888gzVr1uBLX/rSEROj6a9xg5q1/O5ucoXkBTGT6iVRrXM6jiQ6Eq2ynuKVBbzetC7h2FYvqV0byX5qrd+dvnuLdu/ejVmzZunj6oV9AWD69OlYtmwZ9u7di/r6eqxevdooDyB25fq33npLr1hfK23ZssUAlfe///146aWXamojlaTYsGEDPvShDxnnZs2ahY0bNwIALrjgAmzfvr2mjt9N6muB1msZV7YtBDoBn96e4R/pLyEDT86XSFs+7Qxvx8/0GQjUCjq9PQmwFh5q7dsm5CVJwS0FeK1gkxYAJF/V9dICXU9SECQnKI8YMaLTGf8nnHAC/vVf/xXnnXceBg8ejBkzZsCX26H30Mr1TEuWLMFrr72GsWPH4qSTTkJHRwemT5+OtrY2NDSk25s6lbts5syZWLZsGTo6OgAAHR0duPHGG3Uc5vXXX+90U7IB6iPyPHPl5U4+yLRutK6623rKTWdz77ybLkhJkkfbcX+4lyR3mc0NJY/leXZL2dxWtnq2fpLqJ7nZOqtva7M/uNaS6POf/zyef/55/O53v8OwYcMirqtx48ZZV67vCq1btw5vvvkmHnroIXzyk5/E5MmT0dbWhhkzZmDKlCmp2kglBVauXInLL78cTU1NGDZsGPbt24dZs2bhpz/9KQC1/PN//dd/dflG+iv1ldbfZcuqlg8iwbVmW9o/LXV3rBLn39TKTy9aq12d4Z+2vd5c7y2pjSTLIcmCsV3vrtWQ1nKqtd3u1knVbuig3EM7X+7atQsjR47Em2++iUcffRR/+tOfjOsXXXQRVqxYgUsvvRQbNmxAc3Nzl1xl1etTAsCECRMwYcIEXHTRRfrcoUOHUrWV6sudOHEi/vjHP2Lbtm14++23MXr0aEyYMEFfl37BI416a6+UvgMpsStg9XEPa2Za2HO73R2jtAI7ZT+djXlfu6ferThTj4JSjbGWtO0xJcVWZLmkemkoyVrpzynQF198Mfbu3YtMJoPvf//7GDp0KH7wgx8AUCvaf+ITn8Dq1asxefJkNDQ06O1aaqVzzjkHF198MebMmWPI+kKhgN///vdYuXIlzjnnHCxatCixrZrUw/HjxxtBpfcq1brdsqzX06DSqwFmWzyHiYWKZUysFlA3QSiS5p12bEW/TsbvN261tFTr2mZpF5nkuVi19BkplwA2tVKSRZRUrytg059BJIn+93//N3Luyiuv1P87joPvf//73e5nzZo1uOeee3DZZZfh9ddfx5AhQ9De3o4gCHD++efjy1/+cuqFMvvnjlR9RD3lIuptsge7qX+fgqqdtKGtG1sB20dtcbPp9hI+2Fqz16zXuwFavWVR9LalWivfSfOxgJh5TT18D2mzvtImDCTRkQIYQbk/rUyWTHV1dbj66qtx9dVXo1gsYs+ePaivr8eQIUNqbuuoBhkr2eIXFi1fUk+DT81CMgXoJPdpuuBqTZeWIJR2O+fEdhNAqwKm+Zra7QoPXS3fbTdsN+cRxVHqdfNqjMWkrf9uUF9mlx3JlMlkupwCDaQAmSAIsH79epxxxhnIZrNd7uiIpFpdAT0wb6UmIjBBjp9LIblsXNym6liSFWx0e5Yxktct6dUR8Mnl7PdQXS5B0Mdd7zKwJbmjLLzUbK1xvR6yNtKuxlB9LXX6teXb6E6spK+pOy63mvoJgSDF2mXvVUoEGdd1MWfOHLS0tPQFP71PjhONG3SVUtZP0mRt2rm1vBQWJUs8JYZXpy5n1ImAC4MDt5U3gUuXl4FYAUZhh7AkJG9JVqEEI+nuk+47HjPmn7v3vIhFFxnflEve1Oy+ku+Zjedeop5wE6adx9LbExmPJPAaIJNSwevs2bPxf//3f13uZPHixRg5ciSmT58ee/3gwYP41Kc+hRkzZmDatGk6I+LVV1/FzJkz9a+pqUkvCnfzzTdj7Nix+trq1au7zJ/j+4aw5eNaz2vi+Spy3gqXpzkkci5JzXNLuP26nPr5nvrxcTUPfI3J9+J/kmc6r++Ryw1qUD9LuciYJIyh5FNf5/O5bJXFFjMGlp/NQjN56nyei61PJ5eLt7xszz/hvYjwxe8D9yfeG9v70tl7FKmbkhddn+aSpF2+JWnuSW/NTaml3d5fVNNBGCT/+iOFYYif/OQn+OY3vwkAePPNN/Uk/LSUSqIde+yx+PjHP445c+Zg/PjxRv40d94ZLVq0CNdee6112Znvf//7mDp1Kn75y19i9+7dOP744zF//nwcf/zxeOGFFwCondrGjh2LuXPn6npf/vKX8dWvfjXNLZjEWr0QQDat3hHHEStAlIukEsv+E7T2CJ+iurZs2CqxfUyDGoA8qfTy3tj6EfdkAFEccV+e0k+sllCSpUQkx0wDSak9tn5lzKU1Isakta1y3vK8E5fOEe6qCAmXYKT9krRAxXVLRl+t4iZt5l+aNhIXaa1xtnxSynJXU5qTaMDi6Rm6+uqr4boufvOb3+Cmm25CY2MjLr74Yjz77LOp20j1Fra3t+PTn/40AHRp+ZjZs2dj69at1uuO46ClpQVhGOLw4cMYNmxYZLmEtWvX4u/+7u9w7LHH1ty/6Kzyv3QN2dJ4JbEgZFeSTUiIOIimpPYTrmvhkSX3jk8CP02smzVv3/IR8rhLoc3uL7on3SePhQQrmztMl6d+CAwiglWCHfMh3He2JIdq951UBjSPXLbWmEoK6yi2nLwnWzzL1o6MjzElpJ9rqr7OYEHjGtJzSOQl6d1MORmzp7LQauWjszK95pILgfAIyy5j2rBhA55//nmcfPLJAIChQ4eiUOgk9htDqb6Wrk7oSUvXXnstLrroIowZMwYtLS146KGH4LqmJ4+Xma6mFStWYNWqVZg1axa+/e1vY+jQobHt33nnnZU9qp2YuIIv/qYlPwGcupk4wK4YmyUU5AhkciRos3Rf5UoNPYpkeWhwKNGVcqDON+TofGD2RUCmQYd50taBZ5yHLatLj7ElHibbkQAun5WtfeaXwMxpbtRAJstGwCUhKSHSl7SQbLxJ4BUCXoJexMKxgGOEb9v56uVabNZ1L8dSmHp60qatn1r66O9LybyblMlkUC6Xtfdq9+7dEdmcRKnt6c2bN+ORRx7Bzp07sWLFCrz66qvI5/M46aSTauM6hn71q19h5syZ+M1vfoPXXnsN5513Hs4880w0NTUBULNMn3jiCdx22226zlVXXYUbb7wRjuPgxhtvxFe+8hXcc889se1Xr2banBlRuSAFHwvSiAYqrmtBmI+/zkRCxOEPg4REUkaXFgA2S4goaDAtGa/Egpm2Ss35+n9dJ6f69FrUOnQhARWXCz3qXZx3CYwYrEpD6gAA2bY8taPadbzOX8AKyHF7piANCOxcBgYaw8h5SVyf+HbZ4mrIweE62hVncVNZkgs02EuXniZxbFM6pDLT2m4eS/eotLRtLkhJApT4fnRMrbqPtG3WSDYrIa310FXB39nCmgMutNrpuuuuw9y5c7Fr1y4sW7YMjzzyCL71rW/V1EaqN+tnP/sZrr76alx88cW4//77sWLFCrS0tGDp0qX49a9/3SXmq+nee+/F0qVL4TgOJk+ejEmTJuGVV17BaaedBkBtxHPKKadg1KhRuk71/1/4whdw4YUXpuzNiWjNWkCy/Ep0Z5EgtWnlSRxIDVbGKSLHwpdPf4OsKlfOsWBXws7NU4aX7yKk1EkGlyDLZesiZRUv1CeBQHkQWQQFS7ott9tA5fL0kUs3iPzoGWREXImB0+WkAh5rBss6EWgXwF9uIjDK1+t+Hemik6661EKbxuqgyrR0Ro9U5w8dNsvp55sQO7PFxZhsICWvCyWmU1CSlqF0P/YwpV3qv1ZXVVoQkskJ7xr108B+Es2fPx+nnnoq1q5dizAM8Ytf/AInnHBCTW2kAhneN2bmzJl46KGHAAAzZszAiy++WDvXMTRhwgSsXbsWZ555Jnbu3IlXX30Vxx13nL7+wAMPRFxlO3bs0BOEHnvsMWvmWoRcx8yKQpXrJxufUaS14zbhCpIxEXZBJbnNktwbEbeLEAQkvBhcyvX0gbrqRXboOMi6yB5UVfLDlKANqOkMCW2+42Kj+s/LB0bb3KabN7V1r10FiBlcyvVUn64Hnph9zm45Yek4vnms+WgxwYvb98kVyCDmlNR5fkZeK40V9Rc0ZOC2mDEsFMSKCQxC3CbxIl1KEozKTQqoPbbyhAVjdUFyeWlJ818W/DZLW5K2eARolQWgAFEAhHnvNurq0kZJS/33NNWyf013txM4GmjhwoW44447cM011wAA9u/fj8WLF1u9RnGUCmR27dqll/Vn35zjOKn3Kbjsssuwfv167NmzB+PGjcM3vvENFIvqZb3yyitx4403YtGiRTjxxBMRhiFuv/12DB8+HADQ1taGZ555Bj/84Q+NNr/+9a/jhRdegOM4mDhxYuS6lZyKUGMtnIkFVYTY/dSQM46l64ddTSwAGbxc/oCFCwhyLgmTLROMb4HqF5pUueJgxU/dfnXdJaDIN3twSoqncsYxyuYOKiFTaM7SvQi3Glk85Sw970D1mWkhcMl6Rr1SvXkc0BgxaJXqVT9e0RS4DglCHsPiYHWcJXBhC6wwRD2bzN5Wk0/h1msbPxgA0LBNnS43+PDZSsrxpER6btL1ZkvgsEx21a5HbW2ZgCmtN3nsSrcaHw9SVljEUrZlIdZiMWkrx5LYIShpq/DEuUW1WvkpEwt6or0+A5MQ/TZFOYleeuklYymZoUOH4s9//nNNbaQCmVNPPRX33XefkYL84IMPandWEj3wwAOdXh8zZgyefvrp2GsNDQ3Yu3dv5Px9992Xqu8IOdAaLWvJoQiKaxeSOM9aPZNb4AA8udtIULp5E4TQRi8zW1DSYuJjoREHjaq8Fl1Ck+0YRvERarZMgj93iAR9BgjIIsk3q7/FRuryEAnvJnXe71BgFNCH57cHxnUmHgMGEwahCnnGeQlWPPOZQYjbY/DpGKrq1+823Xulegb6+GfG7eSJ33qf79uHP1QNkLaGDqh4lBYyUjhzrI1BJRfv3mRgdcmiYZ7cNiVw2XXH1lUglBo3L94DGc8SlrJWWvJCoLPlJNqXLkv4PoJGcpNCEMcPU07gPBJ3Mh2g2ikIAuzfv18nVe3btw8lm0VtoVQg893vfhfnn38+7r77brS2tuKCCy7AX/7yFysw9GtyHS2oZJyCBR9YeLBrhqwBFipMHgvaDAnqdvVRlxt8o56T5zgBWQHsfiubWn1FSLAGS/yw8GMwalMB45AkRUlsUFeuI029XAENBhcu2z7cvJfiIHKftSqeC3RPpTq2TAh86kmQlhmUHKNctpXcbRkGH7ZkGAzU2Qx1HxD4ZA+o445hzI9P/KoKbSPV38FvEHgcw64o06nV+j7VXsNOdb1jqKcBi4GxOFxZCrn9Yj8MFvIN9cZpnXTA4EPX2ZLU1dnVSM9fv0/kkuL3J3tAtcPuNiatpLCrTyZlENgI51vEcpbJHuxSDH23AlisGJFCFVF8aqTe2kahL7Zn6ItttJ0jNIX5K1/5Cj7ykY/gM5/5DBzHwcMPP4xly5bV1EYqkJkyZQpeeeUVPPnkk7jwwgsxfvx4XHjhhRg8eHCXGH83KXQd/aHxR88xDXYzMRXFebYKWICWAha4qjzjuxOQAKb67Gpy9pMwoJTjAJ2737SFVBAaKmnWBQIO/uvQN8L8FI4B6nep//Nk8RaG0j0S74VmdZilVYOCDFsYNAaDzOvcdvsI4pWaK+W4Pmvd6pitqxK143UQP2Sx8LFbCE3eh6jrbJkw+LB7L99M9fOqnldUfztGqL/sdis2Aq1jFXN+OysL5DJ800z8iLizKHbDz4vBRaeOcwhlmPont69k9M33wkpMSM8571Ish6w3Bkq2jFHmjDrVD4OW10YWdgMrEfSeUPxLxr3YWgnJ2xfkfN1WhhI0wga2gkTWGVHSkkdMaSe26vIptiWohdIsCXSkbfkg6dVXX8Ull1yij//2t7/hm9/8Jr70pS/pc+vXr8ecOXMwadIkAMC8efNw0003dbnPBQsWYNasWfjNb36DMAzx6KOPYurUqTW1kTpvsaGhAZ/97GdrZrLfkeNotwkLA9ayMZgtEooPDKLU4KL56RXofO4gaa5UPaCPm7Vz1mTZwokEsQlMSo0EQgROIQlBDr7LDDAWHkUCCHeyym4q/T8F+o4W1AG8dgLUwdR2HfFM1k6YIcHbwH2aw1UaREK7kc+ocgxsDCYscDW4kJJet4/aYRDiqTwk+BjM2C1XUFnryB9mdxcdH0Nj1WBaROwy5HsuDVOCpFTv63IOyb/WUQRMBGhl4Ubj8ff3U6yGtPvCEMV8TgTwO4aovrMtql77CHLDkjxlnhgAWTnh98mnZ+PR+yHjYgwI+WYCBi9eG2YLKqQYDlvWnPRRnYXIgOeJ9Hd2N2a6uHpAV3cuTbt7aFJ92/VarvWFRdMdSloBhenMM8/Ek08+2WP9Tp06tWZgqaZUb8aZZ54ZG+TP5XIYN24c5s2bh0996lNdZqIvKfQcbcEwiLBgZFBgbZzjCKz5smBjahtlCjiOazCxCyl3kIPbGWqPg+R1Rr/SBcUaskfuNhZCGRJ2hWGq43qXjglIyg0kdLIBSgScfM4drD6gPK/cnSMXX560b4of8T1xPZ/uoXUM9TFSxRnc/ex6JGBu5EQB+ktuAnbTBXWqfobiRiVtDJvvV8VyUX9KCYaEAAAgAElEQVT9EcpF2DF0kHHeFQq047OCoNprHwFkCLBY+LO1xuDCz0O7OxvN9G52i/FzYDBqozFkC8Ul2cT3ylZauViJkQFAgZMi6Hq2leoT+Hn8fvD7SO8h88H9M1i2jlEN1+03XZUOdciWeuBVxRWPiV/tOpMUeE9adYDLpVz01bY5ne04yk98YkJaCyyurFtfby3bJQodoIfdZT22AkoC5fN5/PznP8fWrVuNWEwt1lEqkDn77LOxcuVKLFy4EOPHj8e2bduwatUqXH755QjDEIsXL8bXvvY1fP3rX6/9LvqYQgdoH8FBb5FRxS7wDv5I1XHZdJ1rbZzTgUOO27eZwoa1/boDjE4UZ2ArokO8eAUzw0pnhDWaMR6X5q7Uj1KZVuOGqoDGG+QCK+9WH8moMQewq/0YAMCg0cramTBUpaBt3qok5MiRKi6xey8xSyBUaifBWk8uIFpNwGkngVynzpfI3eI3qzgDB/Y5m6ajQQgXysALyHJikHNJgOdHqmOPgKE0TPUzvJFAZpgCGQYnr91oHtlBBKLNOSoXVJIeGJgotMLgwm7QDrKSGJR0ejdl5GUOmwKYrbwCAatPoMEgw8+fXY3ssmQ8bdhB5et4DpD6W79HjQG7ClnJ4XgZK0e5Q4FRv224GUtky4aVluIgRwMTKwHS6q7/u3GqjTfeQSzZtoyQ5ZJWTSDqrX2FIuR5kQ3vurtpYU/T7t27ja3sqyeRS4pbAYXpT3/6E2bMmIExY8bgP//zPzFt2rQu8zRnzhw0Nzfj1FNPRS7lNhySUo3q008/jV/96lfGJJz58+dj4cKF2LBhA+bNm4dLL730yAAZt6LlFhrjy5QIVDLkNSmyFk5SR8dgZMCd5/xxli27dIZwrIXK5RyjAB9nD7PGaiYiMChxOdZkZ47eCgA4d9hmAMDGwWpu0XpMBgAc09CKXY3K//TRsa8DAMbUKUAa7CtLpEBI2VynpHWRUoqbc0piTmhQoPROh2rnbweViTGsXg3Oa2W1gsKgBiW5xzQp0DqUV4O4Y4+S7I0EEiVqPyAhN6pJSeA3949RYzdM9VukvYuGjFTXRw5SILllmEptZwvLaWKLSY3oMYNUPwcpXugMKaCjnWIcOQJpEsoc96lYsDBIZ7bVsTVmukNLQ9QD9TrIYqD3pthMQJpjNxa7Zfk8i2Ryzx5mS1ad9TvU+fYRDADEDysd+r3jciA+6C9bTi3C/VYHlOsYcFSjDFxstbccpz6K5nfIz2lbxFNMinUsqwzYyBb7iRxbFjdNXa+TsppqXbuwVgqRypIZMWIEnnvuucRycSugMJ1yyil44403MHjwYKxevRqf/vSnsWXLlq5wDUCtVblmzZou1wdSgswrr7xiTI4E1MrMr776KgDgtNNOw65du7rFSF9R6FXFDcgqLjaRL57cFhoM2IKRBocAl9JgckWVTBcRCxuHPnqS78gPYc2U+smyO841rlfcc2ZGF1s676tTAj1DEvbcIZsAAK8fVkBw7ohX0F5UAvC0pr8BAP5f21gAwDgCj2kNbwEAXjw8QbWZU478N8gCYuK+mBoIpPYNUYMxrvGgcX14Pd2cwgSMGaTq+/9/e9caHlV1rt89M5ncr0AgIVyNRe4IURSFVj2Aclrw0osUQaUWUTnVVp9K66FFTmvRHk9L1Yq0FJF6ROupIhTQVkArVZAqWBUwcpNAgISQkOskM7PPj/V9K9lrz87syY0krPd5eMK+rbX2nr2/d33XRZK0tC6Z2qGIu3TxNydTkMpJCGGXEi/6+eKMCKFkzYbNfuGAVSDEUUJiXV9x3HcyXgp16Y9Kp3My2Pwlrm0g7cggbYyDHqrzqO1qq72UtbxAH7qOtDwzkTPtyYzJvyf5v0w/7ad2AmQajD9NGlWNQh6keUkSS6V2iHQorkSSVB1pbIbVhYS6rEYyZl+ZOuHy1dLLriYE22rLBazbSs5RNJFqq8/mUMLHRi7RCMBh/SEjId6+xhEfi7Y0eSdDpAooDC7FBQDTpk3D3XffjdLSUpl3GCsmTJiAf/3rXxg5cmSLx+uKZCZNmoTbb78dS5YsQV5eHoqKirB48WJceeWVAIB//etfrVqesyNheho/KJ5Zmh4yexApMFkw+MMMx1mFFepJ6CSLDyJcR76edKsfJEizRtZoeMbMH7ipzFQDDstoewNWDeiylAMAgLEJgigKG4S0GpEh7DD94sowMlP8f1i8OGewX0wGMjxixh9HkqiXTwj3Xl4ynyWKl7UkmErniYdQFC/6yI8/CQDISRDkkucvs7TzYY2wFRf7hcQblFRquZcRqaK9E+TZL+2bbDnem8iGySmNNKv9NULD6Z8t+mugaX5ZlSC7pDghulkDqvAlSxNaHFWeZi0qkEWlaEgDbVB+f/7dG1IpuTXTSjKZGYJI68iJ3kBVlXk9d9buqmnWHxcnGmxoIM2GBSgn6p0WA2FyCfYW9xKk94rJicmtlgUyvY8BTgb2cFIwR1c0jpnvkWmAtXEmqKq+Yn8PtQqBssSDLWHYKanTMYFU0VDUZTMcio3ayEs5T1aTVmu0eZtZW4iLqTq02RZQCb81iFQBhXHixAn07t0bhmFg586dCIfD6NGjR8Rz3eCdd97Bs88+i0GDBiE+Ph6macIwDHz00Ueu23BFMqtXr8bdd9+NYcOGIRQKwefz4cYbb8Szzz4LAPD7/VETLjsLTC8QyCITQQoXabTOYWSiIH3UPCNlGOxX4OS4ODKL0PEgXechf0OAhI7/rDWCyutQNiqYRC3R98wOfx+VyGIy6hcnklQTDJP+CmH6tQyRkZvhqcXn8dbZzli/+AgrTfJ1UDhtgymE9lBKYCkNCxIpjxPkUBkm85XXOmNlchmbeBgAUEcOqouTjoj247Is1zFZMRqIYfunCs2qvF6ol2zOY83HT39zegpSS4wT95qIyJFAAzPI9xTwS3LxkZYTpITRmt4ktElzCPsoSmyiII+4nUK1MUnLquovnkF8mXj+A0l7q6GADtbK2ATJ93A8XvzgcR7rvdc0iPaYGL8gAjeKxW+SnCkmAtUVYjslXRBtbrro97NaMbFL6VFjub+KMgqOyKD3krnRaza+06ThNvQiAi6hSDrSgmwlcWSZHqqPx+HSMt+G+nDSgJRtw2n9okgL0zWFVyErRSOSi8hFqvumKjJqX9H67gSIVAFl+fLlAET1lJdffhlPP/00fD4fEhMTsXbtWteVWSJh06ZNrR6zK5LJysrC2rVrEQ6HUVJSgl69elnKPQ8ZMqTVA+komD6zkVwS2DlJHxCZXrxkimHnNa8FwWQSbiDzFZGIl2ao/PrzTxpHzvEG0kxqewlhwRoOw0PmtFCq+gFxFJIYV22OuM5/RvTfz0fOcNP6ErGWkusN4qoUYULrRQb7SpOiu2iUASIbJoeA2WBpM4MEYwOdx5pOAtkU4+gvb5eEhEBNoOgHJj4mFyYb1pCYpECmqu2lwizrUwQym+fy08W9xVNYWSXFRjMJsYDvnSA0mdK0ZCnEy2qtds60QcJ+ebaCSybQ86ZovZo88TeZhHt1pXhGNTniGWb4ay19ZxKBn6xLtYyFtTF1bGzWzPCL9kuSxEOozqLriEwaUsTsgrW23CTRXlGmeLGYXNgfxibG494My30lpgbgj6PnRhFUHnrHQ3n0LXg4MINm91wySakxJ5eO8FtzjBrPclgsjxNduT6bKtidNKd6h7Bitb6bre5bk+NcrocJzrHSQ9vDaKOyMpEqoMyfP1/+f8GCBViwYEGb9AUIt8iZM2dQWFiIuro6y363cB1OUVFRgf3796Oqqsqy/+qrr3bdWWeAxxeGkSpeWCYHjoiKSxEvaIjMGQlJYru2kjK+vRTO6+frKEQ5Xny4NXQdf6g8g6aCxwixuS2VnD4etq0T6XAYMZEXk1492exZ46ojgdDXK4TZ7nrx4/cjU1UJGe9LwmGUh4UAZRLp5RWz9H6krX1KM1omiQ/I4cQaT0mYzFpEHhkesX9LtQgC6RcnSOJC+sukc7xB+FDYfHaUTHlFdDPxREJOGk4wbJ2J+hQSYdQEm599JsXVSw2jxifGVhWyXpOWLsYQT79XZa3VqZ1MQrs6NbKg47El+4SQSvLFW+6B/Vlf1IhnwgTJZJHGYWlkJjsSL84blCKeKRMpa3nSRElRhT4ixfwUoXV+To6wtH4iQoyDMOqCPqT6rYK0vsFnaet4hVBlQonWZ8CJolxpIZHIJ8DVE07SSqQOSz6wZsSk5KlRKmMr58mEZCI7XnpCltThahlMDGpxWSYzTqhNim+sss5QqxzwNaE2tG11cfz+97/HsmXLUFRUhDFjxuC9997D5Zdfji1btrhuwxXJPPvss7jnnnuQkpKCpKTG2aBhGDh48GDsIz+HCIc8NnJhYe7h/JIG6wfC5jG2qYc4VJhIhcmFr/MmiRe7lj4kjqw621s87kQiL26HySjgFcfZll+fILZrPURycdaX/0BQEH4qDbeSYqtZaylpEnvN2s0HdcLBf9QnBNyrp8cBAL6ULAQSC/0Eg/w89f1oW9xTZciaQ1AZFn28XnURAKAiJN6PdGqnjhxQxwLWBeXSfdbYYz6fo9uqiDxYS2BNRiUV3s/wk2AP0LNI8jVIYuK2MxPJH+VVtSXSurzC3FSSa30PLux/0tIOkwW3X0Qk4lM0GyYXBpMR7/9Ssmi3h986geNIwDoZ9iYIOpV+34vSTlnulfvtlySuO6NEqKTFN5rwcki7YuJirYxNeFV5YlLBwSaJJVSPjYJUGjLF717Tm6t3U/02Nu1WRrYFcxULT43ol0vreGrom+AcJa7/RuH6sro2QZZgUqo1cNHRICXacmKt6ffZar9x37w8RaC3uCbheGXEsZ+PWLZsGd5//31cdtll2Lp1K/bt24ef/vSnMbXhimR4sZrrrruuRQPtTPDFhaQQryhOsxxj0mAzWc0Z8SGwZlJHpMHbKhk5VVrlGTLPmOVYSDPysk/F32DZ5uuYjNiMw45jJpWjQSF86pQY3KlJJ3A0JAQOk8veWhEqnEBEyAKqighpxxmKIqRgFI46G0JJHayJ8HUJCaKdA3VibRWevR8JC2cjC0pGddA6y+dK80fqRYdsEkr3CEFaQcJLJRMmG97PwvLwaQp+6N2Y58Hlfxgquahg89rQ3kL4F1eRFkdmLe7zaI0wR/kV0x4LeydT3nslAwEAF/coEuepiVgK+FkPSBKaTSmFwTEpHaoRzy6ZTFRMYkyCpfWNQRWpdIzHxoTEYN/YQQhfHteM81BpI87R8YTEdl0P8c4nnbRWDjCURFdZasnPVSwoEVmShPU3qrpAaOlcLdwToHByIg9eEoIJQZZq8nKyrnVtpUDPRJlsi2qOyhN9Vw8W18RVhS19iINoPczGIJKuhoSEBCQkiN8qEAjgoosuklHFbuGKZILBIKZMmRL7CDshDJhSeBt11tIq7HsxOGqMAwLqOXmSSCjJmtRlqtntNZHLVrCtvIrWZqmpo9k62cklqZA/hMmGyYXPY9JhkxVrGYx+5Oc4GDRwIiTMH6yhFFN8ayB8AQDgSKXVhFNeL16onWcF2bB/gQUn58uwsPqoSmg6LLRY+PPMmImPZ/k8u1d9LgzOq4mjpEyVEKoUTYY1l9M1QlDUlgoBUZImtjlAAGh8ruybGZxeZmmTHfinqoQQ5+ABFTWKlsXXMZiEmEjrlb+cg8SEG++3vk/8jBj827Cfi69jE2OWv9pyHkM11wXDXpylJDAeu8ybIu3oSK0grD39yBRMHHTmS17LNntfWEGtGEykf4rCw3tYRYu/ylqNgAW8rH7hoclOX/EsudBqXSaVeullfcZch66WNC4O6089KEiHE67jqrmUk1eSDGthHOAjx5RurbQAoG1IpgsjLy8P5eXluP766zF58mRkZmYiNzc3pjZckcyDDz6In/3sZ1i0aFHM6zt3NpgwUE1CXoYic6KUqok4JVDV0OyLI3VIs+HzVdJRwRoM+zJ5O6Q48HmcTCp8Xlhpl7WLnnHk/6Dto9KZ0+iTYUG376yYqVbWC4H1WUWTZanROHsuqhRCX9UY1CgwVfir/gN1ds/tM2lJM9gpMsNkclyx+MPEwEmZnP/DwjLAIbE0cWiqEfG5dfXiL/tYnFAbiOznUcmC21WJUH02KgkxVHMWk4RKFkwqAY/VLMboGSeeCYeD83HWdJhAShsL0Elth48xClJF0u76/heLe8yhyEiqWsErfHOtu0AWaeNUhy2xtLG6ANAYrh9MoLBtUqpM8ltxHcDkkxQkw+kFrDFRfxzmz8MNUnmitEPiBTk7UHSU8gWTn+i/lkimtqcXRoi0K664wbECdC4nUZvtIeO6qJvnlVdeAQAsXrwYV111FSoqKmK2aLkimV/96lc4ceIEHnvsMVvM9RdffBFTh+cawaBX+kpsJFLNkS0OaVleK5mwxiPJhn0mTFa0zQKQSaSyRgjSYD3tV3wzYYXsmFSCIevLH6AvuIzMISyMWMik+2qlJsHHDpSLmSqbhFjwstbE2FvW27KfkyelzZ4EMUc0naoWs392LJ8lX01ZAl1HJMKkxcmbbIrKSRHtZH4s7rU0W7TH/qtqMl3WpFsJoFLJPGdhyOM7eSYV6anWUODqGtF2zgjRJ5MFo77aSsgMJgt2tDOR8TNRwcKMNaNsihI7flbcM2tKTDYXpJQAAI7UiMkBEwGbu1h7ZM2Fw79P16dYzmOzGms6rJ34PCEMSLTmK/E7xCY7DuTgd53LANX15eUEONSZ3vkMqhxRJa4vzyd/Jbvu6LXi5E+uSacK8lryc3G1DQ5T44KtHL7fWO2AqyGQKYfarc0hcxpFK9Y3qeLt5e+NF+LjiuK0ijZvJxU3fn9tnzHTtfDggw/i0UcfBQB8+ctftu1zA1ck88c//rEFw+ukiLRKnUtSkU0wqdQrM54Gq5mN++EQWRnq3GB9dWXIbBVF4Cj9ceBBdQ1HuYltFgyVitmFSSfeE5Qaw+dVQtCUnRVjqabQUU4gLAskWdpOTRJTRiY2dnbXBX2We2InOpMVmwDZf1XyvkiHD+cLwRiss75yp08KgVsaL6RC/6NCaJ2mZ1nzBZnrOAuerkvvKaTO6RJxnBMu0w+J8ZcMoClzjQ+lVWSfrybHL4WMy4AA+st5LFz0M9hf9MnRZlx6h1FyVoyZJwvx5J9KTRRkoIZMF50RPpwAlaGpJ4Jm8mJykX4t2mbNiPczKTlpVkxGULivZ1wVPqsWvwcTWFm9NQk2wSNMIcnZ4vdiYuY3kouyetLF7yQnAemkJaRw6SNxflxlo5AHGkmDE45l9W7y5ahVONgSHKT93nprqR2uGxjIEOeXkVmPt3nCF0xprKTBydiyPBTVoOM8Ka4VBwCZO9FqGKazVaOz469//auNUDZt2tT2JMMM1m2hCvUGa36MhFxe2bBcJ7eJdAx/ZN1YFo9U2m1QQp9lYIFCho3kRDNUEkKsZbAwyk4QAri4Ll2Gx8qyLOQvkn4j6stbSoI1R5xf47GShUpwKCPNJC7DMjYOhkjeK47zDLY8gUlMbJ+JE2P2nSSyo6TA+FLhj/AXkZmOikiy2aU6jmbeFeJ+2FJVT88q6yPSrK6kSKFTXlmJmk0W8eXiXPbjqCHLXCGaNRZ+BhWUW8JaIGs8ZpAIkO6dSYSjFqX51GOdzPBvkpEkyKuYiJzNb9w/j/M0xF/VrKpqoZ+cEUQyPFMEP3A+TiDFJ49N7C2qRRyvESTPkXUVfnGPHITCNc5Ym/YQmfPESIL9lAF2wPPid+Kvv4wInX5ns4xCnaldTgLl6HIPFY8N5ggy5ImWWUp16DJptdEEK5PyekKhnhRBRr9doE+DXImUqx5wzTguacQIh12JxW6Np59+Gr/97W9x4MABjBo1Su6vrKzEhAkTYmrL1dNsrqzzkiVLol4/d+5cbNiwAdnZ2fj4449txysqKnDLLbfgiy++QDAYxAMPPIDbb78dADBw4ECkpqbC6/XC5/PJAnJlZWX41re+hcOHD2PgwIF46aWX5BKhzcJsFIQcscJlZdhHY9Mk6HsyFXIBk4mq0SjnmbyQl8OQVM3GVHxEPooEU89jE1RFnRAMbJbjaCqfJyxzdNjc5C1VFo+iTf7gAmW0omTYKnhNnv1TwihrFpJcKFGRqycnn6APmRy0GXup2gEJk0oqxcLCI/EI5UGUCjNayhfixJTjQnhVU/h3yhcKQZNZxFdE2soJEXodf0Jcn3y8yUJsnEJxSvxuxV8SApaTLdmMmnHM0gX8B8gkQ9GB6ZTE6yu2PqMg1USLO0Wz6YFCQCZ8QWG45F/gmXRDKpksSTssITNeBhX55N+TM/hlMnAVPStKGmYNiicrnLf1z6AousbaqK8JMaw7IGpRJSWIMTSQmfPtShEQwsTVK01MWNj8yCY/1mxZC+SE0MpKZVVRSuKs9/IyBrQ2EhWr5PV/QpQbZhCJeHLEs06mewkEqKJ0dh31x0tLWHPcgmXWagl19L7HpdSjnpbOYFIJUQVx1or5OYeTu2goWBvi29/+Nq677jr86Ec/wtKlS+X+1NRUZGVlNXOlHa5I5ujRo5btEydO4K233oq4YE4k3HbbbViwYAHmzJkT8fhTTz2FYcOGYf369SgpKcGQIUMwa9Ys+KkS79atW20F3pYuXYprrrkGCxcuxNKlS7F06VLXKpycWfIEJs6quai1q7hmmU3jqbOSiydgLVgo+1P75XbirS8zkx/7dkyaFapaR5js2ezPqNgpnPZcJr+eBLI/Lihny6wxpBTRrdAYa/rQTPMs7xdtc3l6HwU68fIFngbrK1NXyZE6dEtUJzP982rqV+wouzyHjvMCX6KdVFF9BgnlJACrhXDIOEBhuMfEwBKPkvM+hwRBPFeqFpexucU8KwaesZ9MjH0MZBygygz1XGCUQsJJe6siTcRXLsaUdlgILA6HluRA985msPTPxX52VtfTWjzJx8V2oAeF2bKbg5zW/N5VV4r+T5Ng5PfplIcXpKFaajQZCieJ+4g/QQKatIyaDB/tF/3Vkvmnmmb7HKhS39snSaWuSBCap794XqcPkuCghNNL8o/QsxFjZFMih3GrpjoGR1CWUx4M+xdryN7VM1MI9FMV1irbrCkHiQB6pokXj4NfLuwj/FX8PjM4d40jL882WEmPq3v0SK1FGR3zcyUOIjqO6vQ7aWmthdlomusqSE9PR3p6Ovx+P9LT05GRISwWZ86cwdy5c/GHP/zBdVuuSGbVqlW2fZs3b3Zdr2zSpEk4fPiw43HDMFBZWQnTNFFVVYWsrCz4nIrZEdatW4dt27YBAG699VZ85StfcU0yhmLmYiES4hkfxdFzAU0u48KrS7I5ja/j8xJK6IPKo1lbDVfzbd4ea8u3cci/kSU/aCZ7+pgg3qzDJFTIN1BNJo9AYhDGMap7RWanjEIy9dACWEknRdvJJyh3aCCZI3h1R67AU0YRcLTcQEoR5VuQqYlXf2TNRa7mefoMtS8CRnhNnPTPxbiy3xa5KIH+4iU2KYM7/guKlS0Tfz1UEiSJEunUpao5sY7XE0n9IkDj8iP1M9GGUUIhyWmCFapyKReEzCPJx6n8yiFxXm2lGFP2UTHmU18S91p7kipIU0BeKh1n7Y0TF6v6i/Mz94lnzkTo7UM5J0oQQwL55NlfEcgR98LBEHU0E+cJAC8FkP4Zr/Qq9nNtNRylsHKaSNQiGbVeSlKkdzP4kdD4vERMcadozMOEkJf5SaQRq+V82Oukltg54hFkwKa/U0QCA9KoRl0v8XuyT48FfU6u1U/FASEMNi1yPs/uYlFVnMmtntYv4m3fAHFeqj+AuhQyY9L3FJci3pEeSWJCxGbQhibE2X6FZroGPvroI0kwAJCZmYkPP/wwpjZabHycMmWKZb3p1mDBggWYPn06cnNzUVlZiRdffFGGShuGgSlTpsAwDNx5551yEZ+TJ0/Kys85OTnNLjWwYsUKrFixQmyYhjRv8fK0HMkil0umSBaOl+fcAM5mZmHAM1P+2PnjD5VaScJWjEQxh6m+F9V2L6PYeAfNcHvvJMFex6tBkjmATE+Bnl4kkMDp9SFluZeIm4ujhDNeF957VtxMciJpPpRTEFcqruP15jkTm5FIeQ4Jp0jloQxxTw0tYkZVeeMPWestJadSSI9CKqFa0Z+XyIVJRz4hqjtlcGFECmAI9RbE4aWlc/0nxY/hP9ogF9himMWC2JJOijH4aLE5XtmUCY9/n8yPxItydqDYz5pqz48p5Pi0VRQxwfb7GwWIEBHyszN9KdQf+XJ6UPjvaTqPJhmJJeL3zPic6s4RaTGB1pRTvk65eBZnLiLN6TRNcoj4Mw6Iv6eHe+W7m3ySQr8p+orPDdD6PDKhMyzuhSMWOUqRc284cIA1GvYBfildaB4Bxb/BS0wk9au3nM+RcT0pcq5UCUhgcO06Do0/kCgmWux/+swjmJ8rGnCwRKa/RhIel+vhZNqL0k5a7kWW+QHwbsRRxI6umowZDodx5swZ6YooKyuzrJDpBq5IRi0dU1NTg//93/9Fv379YurMCa+//jrGjBmDLVu24MCBA5g8eTImTpyItLQ0bN++Hbm5uTh16hQmT56Miy66CJMmTYqp/aYrzMX37wcvrZnRYy8ljlEJ9wQKbeSFnExKGufZPOcGxJdbSSBrL5uc+OGT05tMQHXZHORv1XCCSoCAGlDAZMjrjAQou5pL/icfE4KdhZpBddtTi8T5JaO8cpbN5IKz4q+vhiKlWGOsEEI5MZ6XByXTIZEFC3WpDZBw9zP5VNKHSaRgUntyvfQKa6mO5I/oWZF5zFSOM7nYVjpUixgSifk/Fu3Ib7mEbFRNqvxyGXhukzWOlCLO9aD15okU0miW7zkjXgRPiDL8WVB/QGZkJYyax+RR12Ch/pOZgKmEiq+fIB2eQKcfoNVJaZE0JkzOcuFxphwh3xCVTvE2WLwxkBsAACAASURBVCtYsNbI52fEJSPpJGl4VKbFn0raTg6ttlpqJROGKvQ5ifMgRS0OTRPPiBNGOf+mSqlmwDk9DDVhVC03pILJj/u5IEP8GAMST1uOczscwp/aJB+Iz2VtTB3TBQmNE9a2Ipmuivvvvx8TJkzA17/+dRiGgZdeegkPPfRQTG24Ipn8/HwYhgGTKvgmJSXh4osvxurVq2MfdQSsWrUKCxcuhGEYyM/Px6BBg7Bv3z5ceumlMrs0OzsbN9xwA3bu3IlJkyahd+/eKC4uRk5ODoqLi5Gdne2qLyPYaE5IOiperniKlGJNIL6MPpD+4sNK//g0HRezpPQD4rj3LAlCKmnB9ZfCtIYKz3A944Xw54gbNseF46z2bK7UysfZH8J/2V8i95NwYeJIrCeyOStmg/7ybPiPCmHLZit1cSgGLxLlqaQ2JUkoy+zyLIYEqY8r2nL1Wwb1w4tTqaRhcDt8nPbz+eFaq7BhsuI13G3bZNiQ/XH7TUiJ75nb9peTwC0lgqNrwj0p6IDIhwkw4zMqO0IhrkxaTMCmsnCXvFcmIda+6DzPWbE/hQmaj1PhRi4OaRYLoefn7F11JknPPp6P029jZgnS4fchIdUvJyQcYOEn30ncaWtVZZ7lc3FNaUrifBYih9Ja8Y0EUshfRWTEJFRBvhjWDji3h81u3A4LerVkDl/PyE8QWgcnIHNOEIfzM7kwyTUlOyYgTlodkXo84rVMYG2KrrIimoI5c+agoKAAW7ZsgWma+POf/4xhw4bF1IYrkgmH2zddtX///njzzTcxceJEnDx5Evv378fgwYNRXV2NcDiM1NRUVFdX44033pCRbtOnT8fq1auxcOFCrF69GjNmzHDVl7eh0fzlKeelKWm2f4Lsv1RHKW0fO2vE/ffcLYSNl4vunRKzKE8OERxpB0mHxSYX5IurIKFEM9sEshyFqI6T6tuJp0l4Ygn5gOjxMwnFn6E39owQFLzin6EsDOU/WWlfRIpgKhqBFIgkAMNVSj2NOCsZSKiLUSntMVTSAMlVlSxs7TAp0rOUmhEfD0YWCE1XQeRz2IjJfRn7KZFY8f95SGin1VuJkLUAGWTAz50JWFlvXkIhTvVe5b1R0AKTIWtCpkJOktx40TL+LdXVKRXyiz+WKCckclKgmh/pno6fFaZoDnYo95Cfj6K8SiivifOsDpLZin04x+sESXHiKGtG+6uEH4wF/IEqMXHjcjdsBuMlH3omiOs5PJ8rRLDvh9tncuPr1STks8EEeYy1L14Fls8pC1OoOCW3CsRWp6u9UV5ejjvuuAMff/wxDMPAH/7wB1x++eXyuGmauPfee7Fx40YkJSXh2WefxdixY1vV57Bhw2ImlqbokIDwmTNnYtu2bSgtLUVeXh4efvhhNDSID3/+/PlYtGgRbrvtNowcORKmaeLRRx9Fz549cfDgQRnBFgwG8e1vfxvXXnstAGDhwoX45je/iZUrV6J///7405/+5GosnnoTPfeIF5Nn9wbP8lnY8Ep5bO4gk46XP0Q27fB2jdXkw0Kn9kviA0pjx3yuEE5pZOYwPZwcyKMzLNvsRE8+Rv0HyPnNwo4FKQsThVCMkjI5o3daepbBglialFRNgTUNJ6HuoGlE689p2y1UEmquPZXoDCryaIYiE6iH/T10nZyEcHv0N1RuLTLp+t4UEpD9q+ubMAnxBIDGw6Sp/jYeyudR2zXOVkkik/sc1lDhZFsOQmG/ISe0VlO4v4/yXfbSdRzy3LhAm7VcEftFTpC2X1LLZjjx9/MKQQAcMq2G58NqEbSBSet4NeX/kAY2KKUMfz95gaVtJsTPzohruFqFtYJDG5BMGxbIvPfee3Httdfi5ZdfRn19PWpqrBOLTZs2obCwEIWFhdixYwfuuusu7Nixo8X9OaWoNJfWosKRZPr16+dqRTU3ZWWiRaHl5ubijTfesO0fPHgw9uzZE/GaHj164M0334zatwpPICjNTGFF8LLJxenDw2nrzFZex05q/nDZ1OQTGk7mp+LDC9P6L2ymC3spjJSaM0KKw59s6jzeVPa91FuJQxXwPJM2Q6FGAeVSiKuCtqVkYarPSNmWs3cnTSjK9W4R6Tru20mzkPeg+okoYKBxHXqXz9RBG3M0AYasmpHpNE4H4rdpjXz+2UrbNU5j8B8UmoWXPoUaWjAvqYgDBSjXjLqurxTv8oksQRaDxwp/FZvXuEYeV4ZQ96uVIjiRlVel9VHY8b5Doiq40VMM7IBfkBKHHfdOE78ZL8d9nMx+ZVlJsiDqrn35AIByqrjAY+J8Io5062w4e/Ys3n77bcuKxJzmwVi3bh3mzJkDwzBw2WWXoby8XLoVWoLk5EZfXF1dHTZs2IChQ4fG1IYjyXSrUjJNEQo1LmQU46zcSRip57GpKflTciCScMn4nJzkx0TkTaKyVgZXpvUdI3sa+zuSkyzXMcJuZsyqecsBTkJd1RCcjsdKAi0lDbftNdd+NBOcPK9O8fOoBNzKe3bq35EkHAhcbd/pN3NqN9IYsvZSEddkjsS0kgov6ZxSTMEz1SSgyd/5eVyetf046wSqOoGSg8vomyK1MJXCyDmMm5ciTzxBi5nReZUg/xqnCdBaUEcpaYlz2zj9oDTgRWmx0J4SKfpz/zFhugtXWGsZxpc1Roc2lhRtf5SUlKCgoEBuNw1YAkQAVq9evXD77bdjz549GDduHJYtW2YhgmPHjlkCsvLy8nDs2LEWk8z9999v2X7ggQcwffr0mNpwJJluW0omFG50gkeB+lE7mYIct3kmTGY3PwsHIo+4AxS+RvZxTxbliigzaJCJw7ZueZRxG764qILJdm2MGkRbk0VHImaSCDY/OWlp/y0larUdp21GU/KJplmyqTa+jBYTo1B1T4DCsml9mHgKcU84ReHzfjYBU5IucQhXOeCqC4GeVBmiiHLSKOEm/ZA14pPNTHHVlGhMIdfBYiI1slRW54ltKiJtLdcPAEac7JstB54vKFeHkmq5QnRbhxsbLpMxe/XqJSuaREIwGMQHH3yAJ554AuPHj8e9996LpUuX4r/+67/kORycZenfhUXKLWpqamJeqNKVT6a+vh4/+9nP8MILL+D48ePIzc3FzTffjIceekguaNOVoPonnD44FeFAneW4k5CQ5hjSaGR0UZ3Vl2Izy1EggS3iSrW1O8yo3fglNNzDrSmvvfppj+vc3lPSYTGx4RB2uRIlQYayEzyU4Bqm5ZMzSHDX9uJwfmt/AdIW4s8K0ko+RpGYHP1GUW0c6clIoVUsU2nZZ16PJukUJdKWCFJk60ANhYfHVXvkAmvsE60YRBUaaJkBTz1pb2mN99r8ohAdi7y8POTl5WH8+PEAgK9//euWki98TtMKLUVFRTGv/9IUI0eOlCQVCoVQUlKCRYsWxdSGK5K56667sH//fvzmN7/BgAEDcOTIEfziF7/AsWPHYiov0BlgmmarzQ7RZo627SqrWY3JykNp1NHMcXJbtae3cPwaLUNX1tqA2MbvKVFC3olEuAKDDG3nCRRp2x7666cwYW8tLWuRKsiGl2VOopUzOSxf5nERks5ayUVF/DGq2xZSIl+Ve0wm/2WS34cAEVNcJfu+qHq5kkzLFR8AoKSt7GVtEKDbp08f9OvXD/v378eQIUPw5ptv2qK+pk+fjieffBI333wzduzYgfT09BabygBgw4YN8v8+nw+9e/eOWo1FhauzX331VRw4cECWFxg2bBjGjx+P/Pz8LkcysaDNZ6xuzWxK/9F8B+r5TtsaGm7BUWgSihYuz2OtXAnb5nfWSyHTMjKT95OfkTUfzgUylAhPW/6V034Gh33zuCqo2nO8H/EhkbXOBOqhRWiMA6Kgn0FjsrTdkU4ZF3jiiScwa9Ys1NfXY/DgwVi1ahWWL18OQETqTps2DRs3bkR+fj6SkpIilgRzg//5n/9p9vgPfvAD1225Ipk+ffqgpqbGUsOmtra2VQx5PsCtRtGd/R4aXROq1hwtNN2mjXPOjkIuLPw5F8k4ZY3Y5IhPQ004ZROykr8lIymVxFdJhmTNN3xeSS5MoB6lT6ecr1ajDUOYx4wZY/PbzJ8/X/7fMAw89dRTre6nslI8o/379+P999+Xzv7169fHXHHFFcnMnj0b1157Lf7jP/5D2vyeeuopzJkzB1u2bJHnXX311TF1fq7Q0UK7o2z7GhptBbeh6Y5+QNXapZCWmuxrIy8Ha1nUHCTlOrOJBsaEZMszaqOcre6En/70pwBEjcoPPvgAqalCpVu8eDG+8Y1vxNSWK5J55plnAACPPPKIZf/y5culqmYYRsxRBxoaGp0TLY1GdG3adTANx4qoFSGaHHfycTqNSUPkQTbNxfH7/c1W1I8EVyRz6NChmBrV0NA4P9FeYdmtPd9N3lR7oqutJ8OYPXs2Lr30Ull55dVXX3VcF8wJep1RDQ2NNkdXMAV3hTGeazz00EO47rrr8Pe//x2GYWDVqlW4+OKLY2rDE/0UDQ0NDY2WwjBFpYJo/zojAoEA9u3bh+rqapSXl2P9+vWO9cycoDUZDQ0NDY2ImDFjBtLT0zFu3DjEK8uDuIUmGQ0NDY12RmfVVKKhqKgImzdvblUbrs1lp0+fxpo1a/DYY48BAI4fP46ioqJWda6hoaGh0XkxYcIE/Otf/2pVG65I5q233sKQIUPw/PPPy2JshYWFuOuuu1rVuYaGhka3ByVjRvvXGfHOO+9g3LhxGDJkCEaNGoWRI0di1KhRMbXhylx233334cUXX8Q111yDzExRmmH8+PHYuXNn7KPW0NDQ0OgS2LRpU6vbcEUyhw8fxjXXXAOgsWy03+9HUC39oKGhoaHRbTBgwIBWt+GKZIYNG4bXX38dU6dOlfv+9re/YeTIka0egIaGhkZ3R2c1h7nBnj178Pe//x0AMHHiRIwePTqm6135ZB5//HHMmjULt956K2pra3HnnXfitttuwy9/+cvYR6yhoaGh0SWwbNkyzJo1C6dOncKpU6dwyy234IknnoipDVckc9lll2HPnj0YPnw45s6di0GDBmHnzp245JJLXHUyd+5cZGdnY8SIERGPV1RU4Gtf+xpGjx6N4cOHy/LUR48exVVXXYWhQ4di+PDhWLZsmbxm8eLF6Nu3L8aMGYMxY8Zg48aNrsaioaGh0aHowsmYK1euxI4dO7BkyRIsWbIE7733Hn73u9/F1IbrPJm+ffvihz/8YcyDBIDbbrsNCxYscKx589RTT2HYsGFYv349SkpKMGTIEMyaNQs+nw+PP/44xo4di8rKSowbNw6TJ0+WC/V8//vfxwMPPNCiMWloaGh0RYRCIRQUFKBv376WRcUAYNu2bZgxYwYGDRoEALjxxhvxk5/8pMV9maYJb5NK216vN+ISz83Bdan/SOtEx8fHIy8vD9dff32zdrpJkyY1W7nTMAxUVlbCNE1UVVUhKysLPp8POTk5cs2a1NRUDB06FMeOHbOtBqehoaHRWWGgbX0yy5Ytw9ChQ3H27NmIxydOnGgjn5bi9ttvx/jx4y0FMr/zne/E1IYrc1l6ejrWrVsH0zSRl5cH0zTx2muvwev1Yu/evbj88svx3HPPxX4HhAULFmDv3r3Izc3FyJEjsWzZMng81qEdPnwYH374oVzfGgCefPJJjBo1CnPnzsWZM2fUZiVWrFiBgoICFBQUtHiMGhoaGucaRUVF+Mtf/oI77rijXfv5/PPPsX37dvzgBz/AqlWrkJWVhczMTPzmN7/B1772tZjackUyn332GTZu3Ig1a9bgkUcewZo1a7Bp0yYcOHAAa9euxZ///GfbWjOx4PXXX8eYMWNw/Phx7N69GwsWLLCwdFVVFW666Sb8+te/RlpaGgDgrrvuwoEDB7B7927k5OTg/vvvd2x/3rx52LVrl21FOQ0NDY3OgpKSEjkZLigowIoVK2zn3HfffXjsscdsk/CmePfddzF69Ghcd911+OSTT1o0lvvuu08uVDZ27Fh873vfw7333oukpCTcd999MbXlyly2Y8cOiwYBAAUFBTIZc+rUqa0qMbNq1SosXLgQhmEgPz8fgwYNwr59+3DppZeioaEBN910E2bNmoUbb7xRXtO7d2/5/+9+97v46le/2uL+NTQ0NNoNJuAJRfdj9OrVq9mJ8IYNG5CdnY1x48Zh27ZtEc8ZO3Ysjhw5gpSUFGzcuBHXX389CgsLYx7y4cOHI2b2FxQUxLxomStNZsyYMXjooYdQVyfWNq2rq8OiRYukH+bQoUPIysqKqeOm6N+/P958800AwMmTJ7F//34MHjwYpmniO9/5DoYOHYof/OAHlmuKi4vl/1955RXHyDUNDQ2N7oDt27fjtddew8CBA3HzzTdjy5YtuOWWWyznpKWlISUlBQAwbdo0NDQ0oLS0NOa+WNZHQi0tX+0Wrkhm9erV+Pvf/460tDT06dMHaWlpePvtt7F69WoAQFlZGX772986Xj9z5kxcfvnl2L9/P/Ly8rBy5UrL0s2LFi3CP/7xD4wcORLXXHMNHn30UfTs2RPbt2/HmjVrsGXLFluo8g9/+ENZR2fr1q341a9+FdONa2hoaHQU2qJ22S9+8QsUFRXh8OHDWLt2La6++mr88Y9/tJxz4sQJGf21c+dOhMNh9OjRI+bxXnLJJRFDlVeuXIlx48bF1JYrc9nAgQPxj3/8A1988QWKi4uRk5OD/v37y+PRHOovvPBCs8dzc3Pxxhtv2PZfeeWVjuFya9ascTFyDQ0Nje4NnqzPnz8fL7/8Mp5++mn4fD4kJiZi7dq1ESODo+HXv/41brjhBjz//POSVHbt2oX6+nq88sorMbVlmDEGPZumaRH8zTmgOiPSjCyMN64518PQ0NDoAjgz9lCrA4aSe/TDiGnfj3peaO//drrgpK1bt+Ljjz8GAAwfPhxXX311zG240mSOHz+Oe+65B2+//TbKy8stx0J6nWwNDQ2NbomrrroKV111VavacKWG3HnnnfD7/XjzzTeRkpKCDz74ANOnT5dqmoaGhoZGZBgQ0WXR/nVXuNJk2B+TnJwMwzAwevRorFy5EhMmTMB3v/vd9h6jhoaGhkYXhStNxuv1wucTfJSRkYGSkhIkJyfj2LFj7To4DQ0NDY2uDVeazPjx47Fx40bccMMNmDp1Kr71rW8hMTFRl2nR0NDQiAYTMM7j9R1dkcyaNWsQDota1L/+9a/x+OOPo7KyEt//fvSICQ0NDQ2N8xeuzGV//etfZUZ/YmIi/vM//xOPPvoo3nnnnXYdnIaGhkaXhwkYYTPqv+4KVyTjVNp53rx5bToYDQ0NDY3uhWbNZQcPHgQAhMNhHDp0yJKEefDgQSQkJLTv6DQ0NDS6OEQI87kexblDsySTn58PwzBgmiYuuOACy7E+ffpg8eLF7Tk2DQ0NDY0ujmZJhp39X/7yl/HWW291yIA0NDQ0NLoPXEWXaYLR0NDQaCFME0Y3zuiPBkeSmThxoqvqnW+//XabDkhDQ0NDo/vAkWTaew1pDQ0NjfMCJmAEtSZjw6233tqR49DQ0NDQaAZ1dXWYNGkSAoEAgsEgvv71r+Phhx+2nGOaJu69915s3LgRSUlJePbZZzF27NhzNGIB14vBrFq1CldffTWGDBmCq6++GqtWrWrPcWm4gOH1wvB6mz2uoaFx7tEWyZjx8fHYsmUL9uzZg927d2Pz5s147733LOds2rQJhYWFKCwsxIoVK3DXXXe11y25hivH/89//nM899xzuP/++zFgwAAcOXIEjz32GI4fP46HHnqovceo0YXBRGcq6w457dfQ0IgMwzCQkpICAGhoaEBDQ4PNb75u3TrMmTMHhmHgsssuQ3l5uVzN+FzBlSbz+9//Hm+88QbmzZuHqVOnYt68edi8eTNWrFjhqpO5c+ciOzsbI0aMiHi8oqICX/va1zB69GgMHz7coiVt3rwZQ4YMQX5+PpYuXSr3l5WVYfLkybjwwgsxefJknDlzxtVYuhM8iYnwJCae62G0CGYopAlGQ6MJSkpKUFBQIP9Fkq+hUAhjxoxBdnY2Jk+ejPHjx1uOHzt2DP369ZPbeXl557xaviuSqa6uRq9evSz7evTogdraWled3Hbbbdi8ebPj8aeeegrDhg3Dnj17sG3bNtx///2or69HKBTCPffcg02bNuHTTz/FCy+8gE8//RQAsHTpUlxzzTUoLCzENddcYyGgliKa+anTwesV/1ygs92bJz4Bnnh7xQg3JsDmjju1q6FxrmCY7hYt69WrF3bt2iX/RSrb5fV6sXv3bhQVFWHnzp1yaWRG06ossn8XUcLtCVckc+2112LWrFnYv38/amtrsW/fPtx6662YOnWqq04mTZokC2xGgmEYqKyshGmaqKqqQlZWFnw+H3bu3In8/HwMHjwYfr8fN998M9atWwdAqIUcnHDrrbfi1VdfdTWW7gSzLgCzLiAFr/qvOS1HPbe9YPjiYPji2q19DY3zERkZGfjKV75im7zn5eXh6NGjcruoqAi5ubkdPTwLXJHMk08+idTUVIwePRopKSkYM2YMkpOT8cQTT7TJIBYsWIC9e/ciNzcXI0eOxLJly+DxeJpV/U6ePCntjDk5OTh16pRj+ytWrJAqaEugCmInod7R2oIR54MR5+xWMxsaF7GIJuxjHXu0e5bHHMbI+23Plsbp1L56H51BQ2ut9qXRzUEhzNH+RUNJSQnKy8sBALW1tfjb3/6Giy66yHLO9OnT8dxzz8E0Tbz33ntIT08/p/4YwEVZGY/Hg7S0NDz33HN49tlnUVpaip49e8LjcR2YFhWvv/46xowZgy1btuDAgQOYPHkyJk6c2Gaq37x586TqmWbYNSoWACy8nHwFtvOCDTGPpS1hJCeJ/yhmSx6fkRAPQxljtHuI5qh3HIvT8Rj3R3um6nEep7wvJrRA47g6yvfj9Oy070mjLVBcXIxbb70VoVAI4XAY3/zmN/HVr34Vy5cvBwDMnz8f06ZNw8aNG5Gfn4+kpKROEQXcLMn07dsXs2fPxuzZszFy5Eh4PB5kZ2e3+SBWrVqFhQsXwjAM5OfnY9CgQdi3b1+zql/v3r1l1ERxcXGLxqUKXFVAqbZ9m0BWryOEqqpiHkuLwCRTetqym8dj+BrH5UlJBgCEq6ot50QT6uozYjgJe9mfg1+E95t1AUu7NlJT+6PjbALkZxzN/xJJwPM14UBds9e2FVQC9lCEUKiiokP6jzQWlZw1EbYn2ma9mFGjRuHDDz+07Z8/f778v2EYeOqpp1rdV1uiWXVk+fLlOHToEC699FKMHTsWy5YtQ0lJSZsPon///njzzTcBCDPY/v37MXjwYFxyySUoLCzEoUOHUF9fj7Vr12L69OkAhFq4evVqAMDq1asxY8aMmPu1mZDIkR7N1COvp+NmQ9BqmnIwrzlttxbSxMT3wwEB8X4ZgWYGgzCD9jVg1Wtt5ireVp6Fk9mK/5nBBgsRqc9UPe7YroNZzfWz8XplMECbP3flGanRfo6mQJ9P/ItmanRphm0Lc6026Wm0F5rVZGbMmIEZM2agvLwcL774ItasWYMHH3wQU6ZMwa233orp06cjLi66U3fmzJnYtm0bSktLkZeXh4cffhgNDULAzJ8/H4sWLcJtt92GkSNHwjRNPProo+jZsycA4Q+aOnUqQqEQ5s6di+HDhwMAFi5ciG9+85tYuXIl+vfvjz/96U+ubjiSuU2d+bOgMOLjI7fBwpZn+XygpSalKOc7zjLpOGspTCLSjNbk/6w5qNdGMz6qJKtuM1Go5rdozn5VCzSCLp8Nj1s1jzkdjzAOIyGe+hRjbems3qbJ8u8RTbtSyL6tNCsn7a/pfTndm9Zk2hEmYATD53oU5wyGGcnx0QwOHTqENWvW4Pe//z1qampQWlraXmNrF6R7emC8dzIAq++i6V+zukZss7AOig/QDJCgZrLgj5jJyCf2hxTzlQrul4VKSxMWvSOGiPPKzoodgXrxN5lm0z4fwAKNjvG92QgxCpHJ48p10uzF5jfS6CR50DMMl5+17FfbD7P5iwhebSdMfidvRoY4rv4WBPU3tIyV26RzuE9VGMvzowheJgduT0L1yajPJC0VABA8XixugcxnYQffmmwnmmnTyc/WjA/RqQ9NOgJnxh7Crl27WtVGWkpfjB8dPfP+TODVVvfVGeEq458RCATw/vvvY8eOHTh58iQmTJjQXuNqV6gflhQSPPtl0oj30xn1dF2S5TqpHfB59GGyIFT9H/I6FjrNzLYjjlsVqDw7YjJkkiGEU5PgqSRhG7SShLxnJlDlnlTB6aTVmeTAsh3nsVL7No2Izpfal/qbqOfzcSJys0p9hu5fZfXcFpuYFA2Yic9GKvwsWXD7rNoWlPdAaoMKwdrvI/J7EwupOF6rSUajjeDqy3znnXfw3HPP4aWXXkJ2djZmz56N3/72txgwYEB7j69d4DSbVoUAWBgFlQ+OZ77JkUlHFdBN/TUR+yeoTm1DMf1ERbKSF+M1ACZC1tYUImKCNHyR+3AU3r4o5iq+jtsNWI/L6/m6OKtWyALbibyk9qn2w4TP9x0KNfbJv4MvslBnuDE7We5FHZu6zSTE1zHxcj+038nUGM0U6TiJiWQqdDpX0UQ12hZG6Pw1lzVLMosXL8aaNWtQVlaGb3zjG/jLX/6CK664oqPG1j7weOSHxL4MCRYabFpKIkHm1JaqWbCwIAHHQkFNinTSClR/AmtEIYqNtwk/n4jbMOpJSEYiBNWU47NqGI3amoKQVcOxkY0yC7eRhqLd2cjHNh4S4GzeU9rl4/J+2BzmU8dh1R7M6hq7OUvx56jC27Zf/Z0diJTvXdqflWcox8gEqfr2nDQTB78Yv8eqGRAOkxoz2GA39Tr53BQXnoZGS9Esybz33nv4+c9/juuvvx4JCd2kVIfR5GNkQahqLnyq6qxzzPnwWI5z+x4HjUc1XUkNiPtVTEM24UdCjcnyLgAAGkVJREFUJJwkxs8hgkZAmYWGTMDPs2XlXlSysd2Tg0Yi2w5Zj3sd2nNqx4HkbISgaib8rPiZqmYdlRDi45toDr7I1/C5itC3HVc1H5Xg+J5UYlVMkypBy3HFRbkXNRRa1fqc2mkyfqlV8U7VD8gToI4Kwz8PYJjmee34b5Zkmqs31mVhNInaVslFmWlKSA2HfTD0ccerfoPI5hObOU6eT9cnKNsMNmWxbV/RgKQfxc8RWuJFZg3HjG9MRLRpY46ClGe9CmFFCQCQ8CnnMUmo5jKHfp0gBTX/rai09qeC+0lOksEPZhlphMlCQ2RtSJK6KtQd8qBsZKT6r5zGIkkmtkRmlaAbNWXSYFQfolNQhNfb+LtG+x3PY+hQ7rZFTI7/7gIjXUT32MhF+filOYp30PlhNqOxAOdZivzYqR/2fzgJwqCi6fD5qtOcopHU40YgZBmH1GxqyNzn9cC0zez9lrZtUM1eKmmoZiy3DmLVLKd+yKpWEA02M5nDeLzeRtOaalLj38stgTqNIWj19TiampT3QNVwbMEQ6mSHr3PSCtX3Qw3uCAYbQ9rVCErVV8d9RYl8ZOhAgWZgQlgVoqGbctv5RzIeo/GjSxM+GTYzManAF3mmaSrkIverZOTk5HMiGwZrLk7XhRShxv1LISle5HB80wRT0ZoJhTyiwa3QdyItpxBpR5Ojsl8VsA6mJsdn2nS/03N1GEM0s5O9Lw4QUchGHQv/ZR8aPzuv1cwmx8kE0DSIoWk7qoak3ie3n0ykWlFpDwBRNU6Ckx+KycQp7Ls7QBd0bVucfyQDNM7W2bwUH/kxqFqACtXOaiMb6fNRNKZApXXbKc/CwX8hP3g+3+ssPhvH5OCTUbUnB9Neq2Fz5DevSUmoglsdl2pmY62lqR+Mz1Hv1Ulrk31bScdmQnQy8UXTFlU4aroOkV42gvVH3la1k/RU+/N0CvxQ4DaXqDuUqTnXNQm7G85DkjEazVrRznTKjo5CPqxJsD4kNSBpVnMwHbG5LkjHZZKnMg45qyctRdG8VN9MxGudNJVo2pZTO+pfJwGrXqfuZ/Ds3Wk8DqakZoWmQ8Sb03mGMqaouTiO4d4OkXk20lJ/C4dIPMfjDufz/rpA43OTv4PDBEstPBptwuXka2uhWe1ckFX7aWWmoyyxoPsphQDOR5IxIIV5RCHc9FQHYR3thZHH1XwZ1ipsQofaDym+HXlcmcWzA9jJrMf9RIpoUcfuJHB57CzseVbscuYrEW0270Q60p/VpHpB0/EkOPhT5HXNRJJFM7WpY1K3nZ6B7Xdy+LxY23IiShVqO9E0KlVzjvQ+RplMuK04bjOrKcmcanUL9bpoJX2iCf621KRkEVa96F2b4vwjmWbQrAbgAqzhGNFmyhRWbCMDJhu22avhx4pJy/Sq5Bd23LYRjjpG3o72carXOZGIknhoE8xRNB1pmqIoMqNHpthmElGz6J3ara6xmy05+iqa5uFQ7y2aFmA7X4XTs1f7j3bcqT/ZPkcZkk8mELSF2zdea514Rasm4AQZvq/ud6kluCUVVcOKhZyiLuXRTFHcFsFt7bIY529dBZpkmkImNTY/wzRqSPj4ozgIvVYSkaHFvshRbLJ9KO2qIa9EHh4lLyas+JY8gaBtX8xQ/UMMJ5+OgsYwW8VUFe/gN3DyvTj5J6L5LYIh6fhuvMaBJNw68Pl6pzBvp6AHJ0Tzg6nmVKdJCEOZxDS242kkkZDVH6kKQSdBq4Zvq7XrGGoisls/R0ud7rGs9RSV8DpxMMPcuXOxYcMGZGdn25ZeBoBt27ZhxowZGDRoEADgxhtvxE9+8pOOHqYF5x/JGBE0CFUDYBJhAZnksIyxLcGxefOVW0T1sfBfJSxSJZ1WQXWWM7wKuahRXwRTjYhSNRtEuZ6z2UlYeEGFMfk3UdtnMHmRScoMBmEwGcQr2o/qG5Hk4pJsbIEEDhqs4l+SgplD06MklNq0jFDk4xL0XqrhIOH4uCZaNrXJwpneMfmuKWOxCWa1YgCfRwEX/Ptw3bWopXEcEo6dENWMF4Gs3BYYjaUOniuYcI44jRG33XYbFixYgDlz5jieM3HiRGzYsKFN+msLnH8k0xQ8I3RyxLIArKECharwUZI0bb4amlHKEOkoUWzq9Sq52MiGHP9GPbXPnkPa76msQzheVPj1nnUoI88ldNRlAtQw6Tolq5z3q5oKg0NdueSJcr7afmP4t7gHW9n76lrLOOR1SuRXxAoF1dYCk/JeVDMaw5FslO1IpjnAHl2mEK3sP6RoROo4Asq9qpMd9b1Uk4YZnBfk89jeIU+Ncq5aWZyg1pJzLDekwNuzB4AmVbgdSveocGuycip261QdPNI1tj5j9Tt2ICZNmoTDhw+f62HEhPOPZCLZR1VHrZNjVRUG6nWK2UOSAwkDKWjVSgFOZhKe/UTRhGS0mxLKHE5NaNRu2DyikIVNOEvNJfKHFmnhM9G+QyQel4530jz4PPrrFIzN/cqZcEgpj6KOj8+vC8BI4d9PEfLs13EiDxa0vF8hEfns1MFy3otDgqMUrCopMdQgBv59z1KpFx63qk2q+9WkXq+3cULEhKUSHYPvkZM2leUsDNV0yPfgVJdNEf4MdbkNCYXsnJ61k8YTbR0kp30A3EdYuobpKiWgpKQEBQUFcrvpsvGx4N1338Xo0aORm5uL//7v/5ZrcJ0rnJckIzUYhpNNPFr0j9vEQgZ/OLLEimJj5yEmOfSrmEFM+q5lYU5Fk0GoSeikmkCqzHZVYW0TIqpmos4YFdKS5i51Fu8kFNjGH4XETLUdpYqwCjPYIJdcYKpmLckTpAKpakUANbiASYg1ItotBaYSjGQThEopF5vjWSULFWpkH/ermhqrlWUd1PYS4mPuy7HumhMckmXVBFfHBQGlJtp88VGngq2RqhzI8x0qOzjmQXUwevXq1er1ZMaOHYsjR44gJSUFGzduxPXXX4/CwsI2GmHLcB6STLhx1sYvuoN5wQbVph/FUWvTmGyOYk/E/UZACQt1iEzxlAvhaatE0GRYsmimgyahmrPU2a+NNFRNgjUV1bymmEFs1yuhrd4o5hGVnJzMLJFWl5QRSTbntMPsWPX7sC+FtQB1SQX1maoDcHpPooR322b9/B+flZBt41dql0mBXBew9WmbJPA9cumlOmtb0fKWZCCBQ86OwQztVIWBn61DQIktcVZJmLUVH400VpWQ1HPb2ifTgUhLS5P/nzZtGu6++26UlpbKlYbPBbru02wpDKP5HIqmUBMCo8101BBZhlMuiJoXo16nnqeChQyTUqTaazx7PitCgZ2Etc0hq5RUUVdMjKapqLN12/XKcdVBrEIljzZJ0lNK8dsEklNknfRjRX52Noe7w72pxGwrsOoQuiwLZPL7qf5Wqh+sSbkaSSJQzFcJka9t7FsNfrCaIOU98KRG9UvxNiswKsHa1kKKQmoORGFDk6hGm3auXsMmQidLQkthmtFlRxvhxIkT6N27NwzDwM6dOxEOh9GjR48O6dsJHUIy0cLufvnLX+L5558HAASDQezduxclJSUoKSnBt771LXnewYMHsWTJEtx3331YvHgxfve736FXr14AgEceeQTTpk1r2QDdJgzGWkBRvc4pgVB+UMrP4dCf9PXYFiCzVwM2T58B4Ly6oo0MZNFPJSRUSVRTNYloJOEWUSOAHPIi3JCOSrC2MbOgtQU5iOfMi8n52E/g8tnJ/lSiVPNwCNyv+ptJc5/DbynbVchPttsQbAwtVq5Rl6L2OIXnq+HUahh1QJmYOQUlqMtfqFaCqNUVHL5BmTAbZeLWTFuWJTM6WQzAzJkzsW3bNpSWliIvLw8PP/wwGhrEbzp//ny8/PLLePrpp+Hz+ZCYmIi1a9fCMFxXLGwXGKZpuigP2jq8/fbbSElJwZw5cyKSTFOsX78ev/rVr7BlyxbL/lAohL59+2LHjh0YMGAAFi9ejJSUFDzwwAMxjSU9oQ8m9JkpNlQSYKg5HKqtXoVTNAqbNTih0Kn6s1MIq1PSIAvaU6WiXXV9HNm/T5JMqKIi8hgdEGvmdFeoyhstcc+TIiLxWODKxeboOD9DL50XirLmSrRn6LT8Nv+e6m/mlCWvhvM2l5joNFlQr/FdeIH4T7TcHTVwgAMKOPLNKSJOPU9WxHYIcqlRiFUlJdUEzmj6Dam+K6dJXxOUZGxttZ8k3d8bE7K/FfW8kj7/aHVfnREdosnEEnb3wgsvYObMmbb9b775Ji644ILWL/lsmrbS6DaHn+K/kOXRVWc5mxaUCC1pK6csdTkzVmdvDKekvuYcuE3aleOMoJE5zZajIVaS6IykosJpjLxfnc1LtPDeoj0Tx4rGDtHm0a6PZRxO5CKhTnBUAa1CJtE6lEZiqPvdkostx0lNNHXIHYqU45aWErkvvkYlNI1WoVP5ZGpqarB582Y8+eSTtmNr1661kc+TTz6J5557DgUFBXj88ceRmZkZsd0VK1ZgxYoVjTv44wxYE8YYckZL+z30AjuaKVgoxEXODZHRTGo9Lqe8HErqk+GjTkUMVZ+AugxvKKQryrYCjibGKImCLUU00mhLIo/alhqFpiag2s6nv2o4uEIOMkiF8nPkNpuoVHJzKi6qVCxgGGerrdexOa++IUKZJqVmIMNlAV3XMN2FMHdXtKxIVzth/fr1uOKKK5CVlWXZX19fj9deew3f+MY35L677roLBw4cwO7du5GTk4P777/fsd158+Zh165dQhVtYhwM19ZGFiShkBDQ/K8uIP7RNoO3w4E6hAN1MBuC4l+wQQj3YNBKJD6v+BcMWbUT27a4zvD5BMHwdQrU8RhxPhFBReMP19baztFwhtPvazuPf9/uDH4n6V3ibTMYtGj+6rZ85/n66hrxj9/pYFhES6rb3A+jLkDRcNQeHw8ExD/a5uuNQFAQFffr9Yp/obD413SM3BYf4zZtx/V30xboVJpMJG0FADZt2oSxY8eid+/ecl/T/3/3u9/FV7/6VXedmOHG8FyHl0glHls4bpTEQ2ljdwoXdSju6JRzAsUcp84meTzsI+gOa3p0JrQkyKCrQ41Ck/udItqaRLBZIMv8KNUJeNtJM5L+0sj5WvJ69nOqy0qrvppAvb3wqaqduV3/RyMmdBqSqaiowFtvvYU//vGPtmOR/DTFxcXIyckBALzyyisYMWKEu47CZtSkq5YKlWi2fJsPhX09DiGpTrklTsvyxjpeDQ0nSJOgQ76J+m4yPIpvRIZRM2nV+S3bUReGUydYKpSlKByrMDRpSzVDq1Uv2j4p0zyvCaxDSCZa2B0giGLKlClITk62XFtTU4O//vWveOaZZyz7f/jDH2L37t0wDAMDBw60HW8O4Xae8cv2VE1G8aFIX49DlJJTbojR3U01GucctqRb9qlEe/eUfCnbEtaq5qL4oVR/l6w9ppwvoRKEGujC30x8PBCsjdinjNZ0E+6sETM6JIS5MyHNyMJ44xoA7W9Wihbq6tQ/h5dGyl7X0OgIOJXDj/atOC5ippT+d6rObGvPoXqzbSkBRbNS9zfV/h3zk+Ls+Ulloz9vfQizrxcuT50R9bzSC3brEObuhvY2K0XLo3D0CWly0TjHiHWFSqfrVLAAdwrfjnq98m2o7TFU/yTqomth3T6Y4xzhvCYZDQ0Nd2jthKwluTytuS7ScbdaWJtPPs/zEGZNMhoaGu2GzhKE4qrsUCcZa3eDJhkNDQ2N9oRptlsCb1dAp0rG1NDQ0NDoXtAko6GhoaHRbtDmMg0NDY12hGma53XkmtZkNDQ0NLoINm/ejCFDhiA/Px9Lly61HTdNE9/73veQn5+PUaNG4YMPPjgHo7RCk4yGhoZGO0MW223mXzSEQiHcc8892LRpEz799FO88MIL+PTTTy3nbNq0CYWFhSgsLMSKFStw1113tdctuYYmGQ0NDY0ugJ07dyI/Px+DBw+G3+/HzTffjHXr1lnOWbduHebMmQPDMHDZZZehvLwcxcXF52jEAuedTyacXI8zFx0618NASUmJXDr6fB6DHoceR2ceg9vFFpvDhKmXorQ0usypra1FQUGB3J43bx7mzZsnt48dO4Z+/frJ7by8POzYscPSRqRzjh07JosJnwucdyRz0UUXdYr6QAUFBed8HJ1hDHocehydfQytxebNm9uknUhlJg3DiPmcjoY2l2loaGh0AeTl5eHo0aNyu6ioCLm5uTGf09HQJKOhoaHRBXDJJZegsLAQhw4dQn19PdauXYvp06dbzpk+fTqee+45mKaJ9957D+np6efUVAYA3sWLFy8+pyM4Bxg3bty5HgKAzjGOzjAGQI9DhR5H5xpDZ4DH48GFF16IW265BU888QRuueUW3HTTTVi+fDl27dqFgoICXHjhhXj33Xfxve99D5s3b8bvfve7c67JnHfryWhoaGhodBy0uUxDQ0NDo92gSUZDQ0NDo93QbUimNeUWol3bluN4/vnnMWrUKIwaNQoTJkzAnj175LGBAwdi5MiRGDNmjCVevj3GsW3bNqSnp2PMmDEYM2YMlixZ4vrathzHL3/5SzmGESNGwOv1oqysDEDbPY+5c+ciOzsbI0aMiHi8o96NaOPoiHcj2hg66r2INo6OeC80OghmN0AwGDQHDx5sHjhwwAwEAuaoUaPMTz75xHLOX/7yF/Paa681w+Gw+e6775qXXnqp62vbchzbt283y8rKTNM0zY0bN8pxmKZpDhgwwCwpKWlR37GOY+vWrea///u/t+jathxHU7z22mvmVVddJbfb6nm89dZb5j//+U9z+PDhEY93xLvhZhwd8W5EG0NHvBduxtEU7fVeaHQMuoUm05pyC26ubctxTJgwAZmZmQCAyy67DEVFRS276VaOoz2ubW1bL7zwAmbOnNmivprDpEmTkJWV5Xi8I94NN+PoiHcj2hic0NHPoina673Q6Bh0C5JxKqXg5hw317blOJpi5cqVuO666+S2YRiYMmUKxo0bhxUrVrRoDLGM491338Xo0aNx3XXX4ZNPPmnRPbTFOACgpqYGmzdvxk033ST3tdXzaOk42/JZxIr2ejfcoL3fi1hwLt8LjbZBtygrY7ai3IKba9tyHIytW7di5cqVeOedd+S+7du3Izc3F6dOncLkyZNx0UUXYdKkSe0yjrFjx+LIkSNISUnBxo0bcf3116OwsPCcPY/169fjiiuusMxu2+p5tHScbfksYkF7vhvR0BHvRSw4l++FRtugW2gyrSm30JZlGNy29dFHH+GOO+7AunXr0KNHD7mfz83OzsYNN9yAnTt3tts40tLSkJKSAgCYNm0aGhoaUFpaek6eBwCsXbvWZhJpq+fR0nGeixId7f1uRENHvBex4Fy+FxpthHPlDGpLNDQ0mIMGDTIPHjwonZIff/yx5ZwNGzZYnLuXXHKJ62vbchxHjhwxL7jgAnP79u2W/VVVVebZs2fl/y+//HJz06ZN7TaO4uJiMxwOm6Zpmjt27DD79etnhsPhDn8epmma5eXlZmZmpllVVSX3teXzME3TPHTokKOTuSPeDTfj6Ih3I9oYOuK9cDMO0+yY90Kj/dEtzGU+nw9PPvkkpk6dilAohLlz52L48OFYvnw5AGD+/PmYNm0aNm7ciPz8fCQlJWHVqlXNXtte41iyZAlOnz6Nu+++W16za9cunDx5EjfccAMAIBgM4tvf/jauvfbadhvHyy+/jKeffho+nw+JiYlYu3YtDMPo8OcBAK+88gqmTJmC5ORkeW1bPo+ZM2di27Ztckb+8MMPo6GhQY6hI94NN+PoiHcj2hg64r1wMw6g/d8LjY6BLiujoaGhodFu6BY+GQ0NDQ2NzglNMhoaGhoa7QZNMhoaGhoa7QZNMhoaGhoa7QZNMhoaGhoa7QZNMhpdHo888gjuuOOODuvviiuuwIcffggAWLx4MW655RbHcy+99FJZmkVD43xEt8iT0eje4Ax0QNSyio+Ph9frBQA888wz+PGPf9xhY1m/fj1SU1Nx8cUXuzr/gQcewE9+8hP83//9XzuPTEOjc0JrMhqdHlVVVfJf//79sX79erk9a9asDh3L8uXLMXv2bNfnT58+HVu3bkVxcXE7jkpDo/NCk4xGl0dTk9Xhw4dhGAZWrVqFfv36ITMzE8uXL8f777+PUaNGISMjAwsWLLBc/4c//AFDhw5FZmYmpk6diiNHjkTsp76+Hlu2bMGXv/xl2/45c+YgNTUVw4cPx65du+SxhIQEjBs3Dm+88UYb37WGRteAJhmNbokdO3agsLAQL774Iu677z78/Oc/x9/+9jd88skneOmll/DWW28BAF599VU88sgj+POf/4ySkhJMnDjRce2SwsJCeDwe5OXlWfa/9tpruPnmm1FeXo7p06fbSGzo0KGWVS41NM4naJLR6JZYtGgREhISZO2rmTNnIjs7G3379sXEiROl4/6ZZ57Bj370IwwdOhQ+nw8//vGPsXv37ojaTHl5OVJTU237r7zySkybNg1erxezZ8+2EUpqairKy8vb50Y1NDo5NMlodEv07t1b/j8xMdG2XVVVBQA4cuQI7r33XmRkZCAjIwNZWVkwTTPiglyZmZmorKy07e/Tp4/8f1JSEurq6hAMBuW+yspKZGRktMl9aWh0NWiS0Tiv0a9fPzzzzDMoLy+X/2prazFhwgTbuRdeeKEjATWHvXv3YvTo0W01ZA2NLgVNMhrnNebPn49f/OIXMpeloqICf/rTnyKeGxcXh3/7t3+T/hw3CAQC+Oc//4nJkye3yXg1NLoaNMlonNe44YYb8OCDD+Lmm29GWloaRowYgU2bNjmef+edd2LNmjWu23/ttdfwla98pUNWkdTQ6IzQ68loaMSIK6+8Ek888YSrhMzx48dj5cqVGDFiRAeMTEOj80GTjIaGhoZGu0GbyzQ0NDQ02g2aZDQ0NDQ02g2aZDQ0NDQ02g2aZDQ0NDQ02g2aZDQ0NDQ02g2aZDQ0NDQ02g2aZDQ0NDQ02g3/D7F0D0ltfup9AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#%% Slice Data and Plot\n", + "slicer = SlicerPlungerTimetrace()\n", + "slicer.beginning, slicer.ending = 0.0, 2 # in hours\n", + "data_sliced = slicer.slice(data, [node_timestamp, gates , node_r])\n", + "\n", + "plotter = PlotterPlungerTimetrace3D()\n", + "plotter.max_cond = None\n", + "plotter.savename = \"plunger_timetrace_sliced\"\n", + "plotter.plot(settings, data_sliced, [node_timestamp, gates , node_r])" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-07T13:16:50.324780Z", + "start_time": "2022-07-07T13:16:48.776894Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Do you wish to continue to work with the sliced data? [y/n]y\n", + "You are now working with the sliced data\n" + ] + } + ], + "source": [ + "yeno = input(\"Do you wish to continue to work with the sliced data? [y/n]\")\n", + "if yeno == \"y\":\n", + " data_raw = data.copy()\n", + " data = data_sliced\n", + " print(\"You are now working with the sliced data\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Let the peak hunt begin!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The bloodmoon has risen over the city of Yharnam..." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T13:58:50.985448Z", + "start_time": "2022-07-11T13:58:49.771117Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of tracked peaks: 2\n", + "Length of chosen peak track: 250\n", + "Length of samples: 250\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "peak_hunter = Peak_hunt(data[node_r], data[node_timestamp], data[gates])\n", + "peak_hunter.pf.min_peak_height = 0.01\n", + "peak_hunter.pf.min_peak_width = 5\n", + "peak_hunter.pf.min_peak_distance = 80\n", + "peak_hunter.pf.fit_interval_peak_relheight = 0.5\n", + "peak_hunter.rel_jump_height = 1000\n", + "tracked_peaks = peak_hunter.analyze()\n", + "\n", + "print(f\"Number of tracked peaks: {len(tracked_peaks['tracked_peak_positions'])}\")\n", + "index_of_peak = 0\n", + "print(f\"Length of chosen peak track: {len(tracked_peaks['tracked_peak_positions'][index_of_peak])}\")\n", + "print(f\"Length of samples: {len(data[node_r])}\")\n", + "\n", + "saver.add_info(f\"{node_r}_tracked_peaks\", tracked_peaks)\n", + "\n", + "plt.pcolor(tracked_peaks[\"time_axis\"], data[gates], np.transpose(data[node_r]))\n", + "for tracked_peak in tracked_peaks[\"tracked_peak_positions\"][0:1]:\n", + " length = min([len(tracked_peaks[\"time_axis\"]), len(tracked_peak)])\n", + " plt.plot(tracked_peaks[\"time_axis\"][:length], tracked_peak[:length], color = \"r\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Spectral noise density Calculation" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T13:58:57.109656Z", + "start_time": "2022-07-11T13:58:57.095959Z" + } + }, + "outputs": [], + "source": [ + "def linear(x, a, b):\n", + " return a * x + b\n", + "\n", + "def bilinear2(x, a, b, c, switch_point):\n", + " x = np.array(x)\n", + " part1 = a * x[x <= switch_point] + b\n", + " part2 = c * x[x > switch_point] + (a - c) * switch_point + b\n", + " return np.concatenate((part1, part2))" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T14:04:30.754477Z", + "start_time": "2022-07-11T14:04:29.192657Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "type_of_fit = \"lin\"\n", + "if type_of_fit == \"lin\":\n", + " fit_func = linear\n", + " guess = [-1, 1]\n", + "elif type_of_fit == \"bilin\":\n", + " fit_func = bilinear2\n", + " guess = [-1, 1, -0.5, -3.5]\n", + " \n", + "sampling_f = tracked_peaks[\"time_axis\"][1]**-1\n", + "peak_no = 0\n", + "noise_calculator = AnalyzerTimetraceSpectralNoiseDensity(tracked_peaks[\"tracked_peak_positions\"][peak_no],\\\n", + " sampling_f, fit_func = fit_func)\n", + "\n", + "noise_calculator.welch_segment_length = 300\n", + "noise_calculator.guess = guess\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_welch_segment_length\", noise_calculator.welch_segment_length)\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_fit_interval\", noise_calculator.fit_interval)\n", + "\n", + "spectral_result = noise_calculator.analyze()\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_spectrum\", spectral_result)\n", + "saver_overview.add_info(f\"{node_r}_peak{peak_no}_spectrum\", spectral_result)\n", + "\n", + "fit = noise_calculator.fit()\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_SNDfit_parameters\", fit)\n", + "saver_overview.add_info(f\"{node_r}_peak{peak_no}_SNDfit_parameters\", fit)\n", + "\n", + "f, s = spectral_result[\"freq\"], spectral_result[\"spectrogram\"]\n", + "saving_path = os.path.join(settings[\"file_info\"][\"savepath\"], node_r)\n", + "\n", + "plotter_SND = PlotterTimetraceSpectralNoiseDensity(saving_path, [f,s], fit)\n", + "plotter_SND.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Jump analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T14:02:59.719794Z", + "start_time": "2022-07-11T14:02:58.958987Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "jump_analysis = jump_count(tracked_peaks[\"tracked_peak_positions\"][peak_no], tracked_peaks[\"time_axis\"])\n", + "jump_analysis.big_jump_minimum_height = 5e-3\n", + "jump_analysis.bin_count = 100\n", + "jump_analysis.range = (-0.01, 0.01)\n", + "jump_hist, big_jumps = jump_analysis.analyze()\n", + "popt = jump_analysis.fit()\n", + "\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_jumphist\", jump_hist)\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_big_jumps\", big_jumps)\n", + "saver.add_info(f\"{node_r}_peak{peak_no}_jumpfit_parameters\", popt)\n", + "\n", + "saver_overview.add_info(f\"{node_r}_peak{peak_no}_big_jumps\", big_jumps)\n", + "saver_overview.add_info(f\"{node_r}_peak{peak_no}_jumpfit_parameters\", fit)\n", + "\n", + "plt.pcolor(tracked_peaks[\"time_axis\"], data[gates], np.transpose(data[node_r]))\n", + "for tracked_peak in tracked_peaks[\"tracked_peak_positions\"]:\n", + " length = min([len(tracked_peaks[\"time_axis\"]), len(tracked_peak)])\n", + " plt.plot(tracked_peaks[\"time_axis\"][:length], tracked_peak[:length], color = \"r\")\n", + "for jump_time in big_jumps[\"time_of_big_jumps\"]:\n", + " plt.axvline(jump_time, color = \"r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T14:03:00.324622Z", + "start_time": "2022-07-11T14:03:00.191394Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FHWM of the guassian distribution: 1.2719379273383578 mV\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(f\"FHWM of the guassian distribution: {2.35482e3 * popt[-1]} mV\")\n", + "x = np.linspace(min(jump_hist[\"jump_height\"]), max(jump_hist[\"jump_height\"]), 1000)\n", + "y = gauss_function(x, *popt)\n", + "plt.plot(x, y)\n", + "plt.plot(jump_hist[\"jump_height\"], jump_hist[\"jumps_per_bin\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Save your analysis!" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T14:04:34.975039Z", + "start_time": "2022-07-11T14:04:34.914984Z" + } + }, + "outputs": [], + "source": [ + "saver.save()\n", + "\n", + "ovw = saver_overview.additional_info\n", + "\n", + "saver_saver_overview = Saver_json(overview_path) #Save your saved data to be safe\n", + "analysis_key = f\"{bcv}tg{tgv}\"\n", + "\n", + "saver_saver_overview.fname = saver_overview.fname\n", + "saver_saver_overview.append_to_file = True\n", + "\n", + "saver_saver_overview.additional_info = {analysis_key : ovw}\n", + "saver_saver_overview.save()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Look at the big picture!" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T14:04:37.053920Z", + "start_time": "2022-07-11T14:04:37.030885Z" + } + }, + "outputs": [], + "source": [ + "from qkit.analysis.semiconductor.loaders.LoaderJSON import LoaderJSON\n", + "overview_path = \"/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Bias_cooling_Project/Analysis/\"\n", + "fname = \"P35B4.json\"\n", + "\n", + "loader = LoaderJSON()\n", + "ovw_data = loader.load(os.path.join(overview_path, fname))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T14:03:03.672985Z", + "start_time": "2022-07-11T14:03:03.647021Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'1.602'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(ovw_data.keys())[0].split(\"tg\")[1].split(\"vr\")[0].split(\"_\")[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T14:03:04.379061Z", + "start_time": "2022-07-11T14:03:04.350880Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['demod0&4.r0_peak0_spectrum', 'demod0&4.r0_peak0_SNDfit_parameters', 'demod0&4.r0_peak0_big_jumps', 'demod0&4.r0_peak0_jumpfit_parameters'])" + ] + }, + "execution_count": 133, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ovw_data[\"-0.5tg0.442\"].keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T14:38:55.717396Z", + "start_time": "2022-07-11T14:38:55.459948Z" + } + }, + "outputs": [ + { + "ename": "KeyError", + "evalue": "'0tg1.419'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0movw_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'0tg1.419'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"demod0.r0_peak0_jumpfit_parameters\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m: '0tg1.419'" + ] + } + ], + "source": [ + "ovw_data['0tg1.419'][\"demod0.r0_peak0_jumpfit_parameters\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T14:03:05.361742Z", + "start_time": "2022-07-11T14:03:05.350789Z" + } + }, + "outputs": [], + "source": [ + "def extract_lowest_tgv(wanted_bcv, data_dict):\n", + " tgvs = []\n", + " matching_key = []\n", + " for key in data_dict.keys():\n", + " bcv = float(key.split(\"tg\")[0])\n", + " tgv = float(key.split(\"tg\")[1].split(\"vr\")[0].split(\"_\")[0])\n", + " if bcv == wanted_bcv:\n", + " tgvs.append(tgv)\n", + " matching_key.append(key)\n", + " \n", + " val = min(tgvs)\n", + " idx = tgvs.index(val)\n", + " return val, matching_key[idx]\n", + "\n", + "def find_nearest_idx(array, value):\n", + " array = np.asarray(array)\n", + " idx = (np.abs(array - value)).argmin()\n", + " return idx\n" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-11T15:28:14.008470Z", + "start_time": "2022-07-11T15:28:13.061491Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.0, -0.5, 0.0, 0.25, 0.75, 1.0]\n", + "[1.2616880342310397e-07, 3.946114614400236e-07, 1.5180757048997228e-07, 4.063924521393863e-05, 5.870177712620064e-08, 4.830585420584747e-05]\n" + ] + }, + { + "data": { + "text/plain": [ + "<__main__.bias_cool_plotter at 0x7f52d0e197f0>" + ] + }, + "execution_count": 151, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "class bias_cool_plotter():\n", + " def __init__(self, data_dict, y_maker, y_scale = \"log\"):\n", + " self.data_dict = data_dict\n", + " self.y_maker = y_maker\n", + " self._build_x_axis()\n", + " self._build_y_axis()\n", + " print(self.x_axis)\n", + " print(self.y_axis)\n", + " self.fig, self.ax1 = plt.subplots()\n", + " self.ax1.set_xlabel(\"Bias cooling voltage in V\")\n", + " self.ax1.set_ylabel(\"Integrated Noise Power\")\n", + " self.ax1.set_yscale(y_scale)\n", + " self.ax1.set_ylim(min(self.y_axis), max(self.y_axis))\n", + " self.ax1.plot(self.x_axis, self.y_axis)\n", + " \n", + " def _build_x_axis(self):\n", + " x_vals = set()\n", + " for key in self.data_dict.keys():\n", + " bcv = float(key.split(\"tg\")[0])\n", + " x_vals.add(bcv)\n", + " self.x_axis = sorted(list(x_vals))\n", + " \n", + " def _build_y_axis(self):\n", + " self.y_axis = []\n", + " for x_value in self.x_axis:\n", + " y_value = self.y_maker(self.data_dict, x_value)\n", + " self.y_axis.append(y_value)\n", + "\n", + " \n", + "def test_y_maker(data_dict, x_value): \n", + " return extract_lowest_tgv(x_value)\n", + "\n", + "def format_float(float_no):\n", + " if float_no.is_integer():\n", + " key = f'{float_no:.0f}'\n", + " else:\n", + " key = f'{float_no}'\n", + " return key\n", + "\n", + "def find_key(data_dict, part_key):\n", + " keys = data_dict.keys()\n", + " #print(keys)\n", + " #print(part_key)\n", + " for key in keys:\n", + " if part_key in key:\n", + " return key\n", + " return \"not_found\"\n", + "\n", + "def one_mHz_value(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value)\n", + " #key = f\"{format_float(x_value)}tg{tgv}\"\n", + " \n", + " spectrum_key = find_key(data_dict[key], \"spectrum\")\n", + " freqs = data_dict[key][spectrum_key][\"freq\"]\n", + " spec = data_dict[key][spectrum_key][\"spectrogram\"]\n", + " one_mHz_idx = find_nearest_idx(freqs, 1e-3)\n", + " return spec[one_mHz_idx]\n", + "\n", + "def func_power2(x, *params):\n", + " x = np.array(x)\n", + " if len(params) == 2:\n", + " return params[1] * x ** params[0]\n", + " else:\n", + " part1 = params[1] * x[x <= params[3]] ** params[0]\n", + " part2 = params[1]/(params[3] ** (params[2]-params[0])) * x[x > params[3]] ** params[2]\n", + " return np.concatenate((part1, part2))\n", + "\n", + "def one_mHz_value_fit(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value)\n", + " #key = f\"{format_float(x_value)}tg{tgv}\"\n", + " \n", + " fit_key = find_key(data_dict[key], \"SNDfit\")\n", + " fit_pars = data_dict[key][fit_key][\"popt\"]\n", + " \n", + " return func_power2(1e-3, *fit_pars)\n", + "\n", + "def integrated_noise_power(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value)\n", + " #key = f\"{format_float(x_value)}tg{tgv}\"\n", + " \n", + " spectrum_key = find_key(data_dict[key], \"spectrum\")\n", + " freqs = data_dict[key][spectrum_key][\"freq\"]\n", + " spec = data_dict[key][spectrum_key][\"spectrogram\"]\n", + " integral = np.sum(np.diff(freqs) * spec[:-1])\n", + " return integral\n", + "\n", + "def integrated_noise_power_fit(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value, data_dict)\n", + " fit_key = find_key(data_dict[key], sub_key + \"_SNDfit\")\n", + " #print(fit_key)\n", + " if fit_key != \"not_found\":\n", + " fit_pars = data_dict[key][fit_key][\"popt\"]\n", + "\n", + " f_min = 1e-4\n", + " f_max = 1e-2\n", + "\n", + " band = np.linspace(f_min, f_max, 100000)\n", + " spec = func_power2(band, *fit_pars)\n", + "\n", + " integral = np.sum(np.diff(band) * spec[:-1])\n", + " return integral\n", + " \n", + "def integrated_noise_power_fit2(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value, data_dict)\n", + " fit_key = find_key(data_dict[key], sub_key + \"_SNDfit\")\n", + " #print(fit_key)\n", + " if fit_key != \"not_found\":\n", + " fit_pars = data_dict[key][fit_key][\"popt\"]\n", + "\n", + " f_min = 1e-4\n", + " f_max = 1e-2\n", + "\n", + " band = np.linspace(f_min, f_max, 100000)\n", + " spec = func_power2(band, *fit_pars)\n", + "\n", + " integral = np.sum(np.diff(band) * spec[:-1])\n", + " return integral\n", + " \n", + "\n", + "def fwhm(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value)\n", + " #key = f\"{format_float(x_value)}tg{tgv}\"\n", + " \n", + " jumpfit_key = find_key(data_dict[key], \"jumpfit\")\n", + " popt = data_dict[key][jumpfit_key][\"popt\"]\n", + " if len(popt) == 4:\n", + " fwhm = data_dict[key][jumpfit_key][\"popt\"][-1]\n", + " else:\n", + " fwhm = 0\n", + " return fwhm\n", + "\n", + "def length_plot(data_dict, x_value):\n", + " tgv, key = extract_lowest_tgv(x_value)\n", + " #key = f\"{format_float(x_value)}tg{tgv}\"\n", + " spectrum_key = find_key(data_dict[key], \"r4_peak0_spectrum\")\n", + " freqs = data_dict[key][spectrum_key][\"freq\"]\n", + " print(len(freqs))\n", + " print(min(freqs))\n", + " print(max(freqs))\n", + " return len(freqs)\n", + "\n", + "\n", + "bias_cool_plotter(filtered_dict, integrated_noise_power_fit)\n", + "#bias_cool_plotter(filtered_dict, integrated_noise_power_fit2)\n", + "#bias_cool_plotter(ovw_data, fwhm)\n", + "#bias_cool_plotter(ovw_data, integrated_noise_power) #dumb, because ignores bandwidth\n", + "#bias_cool_plotter(ovw_data, length_plot, y_scale = \"linear\")\n", + "#bias_cool_plotter(ovw_data, one_mHz_value_fit)" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['0.75tg1.602vr1.104', '0tg0.703vr0.703', '0.75tg1.104vr1.104', '0tg0.838vr0.717', '0tg0.838_2ndvr0.717', '0.75tg1.380vr1.307', '0.75tg1.877vr1.307', '0.75tg1.877_2ndvr1.307', '0tg0.717vr0.717', '0.75tg1.341vr1.287', '1tg1.548vr1.390', '0.25tg1.429vr1.127', '0.25tg1.927vr1.127', '-0.5tg0.442vr0.127', '-0.5tg0.739vr0.127', '-1tg0.212vr-0.211']\n" + ] + } + ], + "source": [ + "filtered_keys = []\n", + "sub_key = \"r0_peak0\"\n", + "for key in ovw_data.keys():\n", + " if any(sub_key in key for key in ovw_data[key].keys()):\n", + " filtered_keys.append(key)\n", + "\n", + "print(filtered_keys)\n", + "\n", + "filtered_dict = {key: value for key, value in ovw_data.items() if key in filtered_keys}" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['0.75tg1.602vr1.104', '0tg0.887vr0.703', '0.75tg1.104vr1.104', '0.75tg2.051vr1.307', '0.75tg2.549vr1.307', '0tg0.567vr0.717', '0.75tg1.965vr1.287', '1tg1.626vr1.390', '0.25tg1.026vr1.127', '0.25tg1.524vr1.127'])" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "filtered_dict.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-08T10:14:06.458751Z", + "start_time": "2022-07-08T10:14:06.200572Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Delta V')" + ] + }, + "execution_count": 149, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def get_Delta_tgv_rv(data_dict):\n", + " x_data = []\n", + " y_data = []\n", + " bcv = []\n", + " for key in data_dict.keys():\n", + " tgv = float(key.split(\"tg\")[1].split(\"vr\")[0].split(\"_\")[0])\n", + " rv = float(key.split(\"vr\")[1])\n", + " bcv.append(float(key.split(\"tg\")[0]))\n", + " x_data.append(tgv-rv)\n", + "\n", + " fit_key = find_key(data_dict[key], sub_key + \"_SNDfit\")\n", + " #print(fit_key)\n", + " if fit_key != \"not_found\":\n", + " fit_pars = data_dict[key][fit_key][\"popt\"]\n", + "\n", + " f_min = 1e-4\n", + " f_max = 1e-2\n", + "\n", + " band = np.linspace(f_min, f_max, 100000)\n", + " spec = func_power2(band, *fit_pars)\n", + "\n", + " y_data.append(np.sum(np.diff(band) * spec[:-1]))\n", + " \n", + " return x_data, y_data, bcv\n", + " \n", + "deltaV, intPSD, bcv = get_Delta_tgv_rv(filtered_dict)\n", + "\n", + "%matplotlib inline\n", + "\n", + "plt.plot(deltaV, intPSD, \"o\")\n", + "plt.xlabel(\"Delta V\")\n", + "plt.ylabel(\"Integrated Noise Power\")\n", + "plt.yscale(\"log\")\n", + "\n", + "plt.figure()\n", + "plt.plot(bcv, deltaV, \"x\")\n", + "plt.xlabel(\"Bias cooling V\")\n", + "plt.ylabel(\"Delta V\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4.360275306377306e-07, 1.5180757048997228e-07, 5.870177712620064e-08, 5.778022017511103e-06, 2.1248917114320424e-07, 1.9164915142202595e-07, 2.5119548994450264e-07, 2.3027160267926146e-05, 9.03289268616415e-08, 4.839235636098777e-08, 4.830585420584747e-05, 4.063924521393863e-05, 6.45315995977795e-05, 3.946114614400236e-07, 2.021002288013972e-07, 1.2616880342310397e-07]\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Integrated PSD')" + ] + }, + "execution_count": 147, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def get_Delta_tgv_rv(data_dict):\n", + " x_data = []\n", + " y_data = []\n", + " bcv = []\n", + " for key in data_dict.keys():\n", + " tgv = float(key.split(\"tg\")[1].split(\"vr\")[0].split(\"_\")[0])\n", + " rv = float(key.split(\"vr\")[1])\n", + " bcv.append(float(key.split(\"tg\")[0]))\n", + " x_data.append(tgv-rv)\n", + "\n", + " fit_key = find_key(data_dict[key], sub_key + \"_SNDfit\")\n", + " #print(fit_key)\n", + " if fit_key != \"not_found\":\n", + " fit_pars = data_dict[key][fit_key][\"popt\"]\n", + "\n", + " f_min = 1e-4\n", + " f_max = 1e-2\n", + "\n", + " band = np.linspace(f_min, f_max, 100000)\n", + " spec = func_power2(band, *fit_pars)\n", + "\n", + " y_data.append(np.sum(np.diff(band) * spec[:-1]))\n", + " \n", + " return x_data, y_data, bcv\n", + " \n", + "deltaV, intPSD, bcv = get_Delta_tgv_rv(filtered_dict)\n", + "\n", + "print(intPSD)\n", + "\n", + "%matplotlib qt\n", + "\n", + "Z = np.log10(intPSD)\n", + "\n", + "ax = plt.axes(projection='3d')\n", + "ax.scatter3D(deltaV, bcv, Z)\n", + "plt.xlabel(\"Delta V\")\n", + "#plt.ylabel(\"Integrated Noise Power\")\n", + "plt.ylabel(\"Bias cooling V\")\n", + "ax.set_zlabel(\"Integrated PSD\")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-08T11:16:46.187047Z", + "start_time": "2022-07-08T11:16:46.158725Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['demod0&4.r0_peak0_spectrum', 'demod0&4.r0_peak0_SNDfit_parameters', 'demod0&4.r0_peak0_big_jumps', 'demod0&4.r0_peak0_jumpfit_parameters'])\n", + "demod0&4.r0_peak0_SNDfit_parameters\n", + "{'popt': array([-1.09019177e+00, 2.34818237e-05]), 'cov': array([[0.0251455 , 0.06108737],\n", + " [0.06108737, 0.15225721]]), 'fit_range': [0.00014225871897666448, 0.009673592890413184]}\n" + ] + } + ], + "source": [ + "key = \"-4tg1.332\"\n", + "print(ovw_data[key].keys())\n", + "print(find_key(ovw_data[key], \"SNDfit\"))\n", + "a = find_key(ovw_data[key], \"SNDfit\")\n", + "print(ovw_data[key][a])" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-08T12:59:36.302777Z", + "start_time": "2022-07-08T12:59:36.275487Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0001\n" + ] + } + ], + "source": [ + "print(1e-4)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-08T13:33:24.003425Z", + "start_time": "2022-07-08T13:33:23.990080Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "30\n" + ] + } + ], + "source": [ + "freqs = [0, 3, 6, 9]\n", + "spec = [3,4,3,3]\n", + "integral = np.sum(np.diff(freqs) * spec[:-1])\n", + "print(integral)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-08T13:33:08.404486Z", + "start_time": "2022-07-08T13:33:08.390867Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 3, 6, 9]\n", + "[3, 3, 3]\n" + ] + } + ], + "source": [ + "print(freqs)\n", + "print(spec[:-1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Initialization Cell", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "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": {}, + "toc_section_display": true, + "toc_window_display": true + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/qkit/analysis/semiconductor/scripts/accumulation.py b/qkit/analysis/semiconductor/scripts/accumulation.py new file mode 100644 index 00000000..ff3f8f18 --- /dev/null +++ b/qkit/analysis/semiconductor/scripts/accumulation.py @@ -0,0 +1,56 @@ +#%% +from qkit.analysis.semiconductor.loaders.Loaderh5 import Loaderh5 +from qkit.analysis.semiconductor.plotters.PlotterAccumulation import PlotterAccumulation +from qkit.analysis.semiconductor.main.loading import print_nodes + +settings = {"file_info" : { + "absolute_path" : "/home/ws/oc0612/SEMICONDUCTOR/analysis/bias-cooling/-3V/cooldown_1/", + "filetype" : ".h5", + "date_stamp" : "20220104", + "filename" : "094628_1D_Accumulate_with_All_Gates", + "savepath" : "analysis/", + "analysis" : "accumulation"}, + "meas_params" : { + "measurement_amp" : 200e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3} + } + + + +#%% Load Timetrace +loader = Loaderh5() +data = loader.load(settings) +print_nodes(data) + + +#%% Define nodes +node_0_timestamp = "demod0&4.timestamp0" +node_0_x = "demod0.x0" +node_0_y = "demod0.y0" +node_0_r = "demod0.r0" + +node_4_timestamp = "demod0&4.timestamp4" +node_4_x = "demod4.x4" +node_4_y = "demod4.y4" +node_4_r = "demod4.r4" + +gates = "gates_4_5_6_7_9_10_11_12_13_14_15_16_17_18_19_20_21_22_23" + +# Rotate Data??? + +#%% Plot many traces +plotter = PlotterAccumulation() +plotter.marker = "." +plotter.add_trace(settings, data, [gates, node_0_r], label_id="left") +plotter.add_trace(settings, data, [gates, node_4_r], label_id="right") +plotter.gatename = "All gates" +plotter.plot_all(settings) + + +#%% Plot only one trace +plotter = PlotterAccumulation() +plotter.marker = "." +plotter.plot_one_trace(settings, data, [gates, node_4_r]) +# %% diff --git a/qkit/analysis/semiconductor/scripts/accumulation_many_files.py b/qkit/analysis/semiconductor/scripts/accumulation_many_files.py new file mode 100644 index 00000000..3f3d5c27 --- /dev/null +++ b/qkit/analysis/semiconductor/scripts/accumulation_many_files.py @@ -0,0 +1,53 @@ +#%% +from qkit.analysis.semiconductor.loaders.Loaderh5 import H5filemerger +from qkit.analysis.semiconductor.plotters.PlotterAccumulation import PlotterAccumulation +from qkit.analysis.semiconductor.main.equalize_length import make_len_eq + +#%% +paths=['/home/ws/zz8772/Daten/20220427/143215_1D_AccumulationwithTopgateonly/143215_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220427/143334_1D_AccumulationwithTopgateonly/143334_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220427/151451_1D_AccumulationwithTopgateonly/151451_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220427/151615_1D_AccumulationwithTopgateonly/151615_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220427/151715_1D_AccumulationwithTopgateonly/151715_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220427/151746_1D_AccumulationwithTopgateonly/151746_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220427/151818_1D_AccumulationwithTopgateonly/151818_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220427/151853_1D_AccumulationwithTopgateonly/151853_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220427/151937_1D_AccumulationwithTopgateonly/151937_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220427/153830_1D_AccumulationwithTopgateonly/153830_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220427/153857_1D_AccumulationwithTopgateonly/153857_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220427/153935_1D_AccumulationwithTopgateonly/153935_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220428/134527_1D_AccumulationwithTopgateonly/134527_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220428/134642_1D_AccumulationwithTopgateonly/134642_1D_AccumulationwithTopgateonly.h5',\ + '/home/ws/zz8772/Daten/20220428/134733_1D_AccumulationwithTopgateonly/134733_1D_AccumulationwithTopgateonly.h5'] + +settings = {"file_info" : { + "absolute_path" : "/home/ws/zz8772/Daten/", + "filetype" : ".h5", + "date_stamp" : "20220427", + "filename" : "151451_1D_AccumulationwithTopgateonly", + "savepath" : "analysis/", + "analysis" : "accumulation"}, + "meas_params" : { + "measurement_amp" : 200e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3} + } + +###In settings, you can take the info of any of the files in paths (it should be identical). Remember that the generated +###.png file of the plot will be saved in the analysis folder within the timestamp folder of the file chosen for 'settings'. +nodes = ['gate_4', 'demod0.r0'] + +print(H5filemerger.__doc__) +merger = H5filemerger() +merger.add_paths(paths) +data_dict = merger.merge() +data = make_len_eq(data_dict, nodes) + +#%% Plot only one trace +plotter = PlotterAccumulation() +plotter.marker = "." +plotter.gatename = "Topgate (V)" +plotter.plot_one_trace(settings, data, nodes) + +# %% diff --git a/qkit/analysis/semiconductor/scripts/load_and_pickle.py b/qkit/analysis/semiconductor/scripts/load_and_pickle.py new file mode 100644 index 00000000..cb57c805 --- /dev/null +++ b/qkit/analysis/semiconductor/scripts/load_and_pickle.py @@ -0,0 +1,89 @@ +#%% +import copy +from qkit.analysis.semiconductor.loaders.Loaderh5 import Loaderh5 +from qkit.analysis.semiconductor.savers.SaverPickle import SaverPickle + +settings_list = [] + +settings_basic = {"file_info" : { + "absolute_path" : "/home/ws/oc0612/SEMICONDUCTOR/analysis/bias-cooling/P35_B3/", + "filetype" : ".h5", + "date_stamp" : "", + "filename" : "", + "savepath" : "analysis/", + "analysis" : "noise_timetrace"}, + "meas_params" : { + "measurement_amp" : 200e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3, + "sampling_rate" : 13732.91015625} + } + + + +#%% 1 +settings = copy.deepcopy(settings_basic) +settings["file_info"]["date_stamp"] = "20220516" +settings["file_info"]["filename"] = "112714_1D_measurement_time" +settings_list.append(settings) + +#%% 2 +settings = copy.deepcopy(settings_basic) +settings["file_info"]["date_stamp"] = "20220517" +settings["file_info"]["filename"] = "183049_1D_measurement_time" +settings_list.append(settings) + +#%% 3 +settings = copy.deepcopy(settings_basic) +settings["file_info"]["date_stamp"] = "20220518" +settings["file_info"]["filename"] = "211429_1D_measurement_time" +settings_list.append(settings) + +#%% 4 +settings = copy.deepcopy(settings_basic) +settings["file_info"]["date_stamp"] = "20220528" +settings["file_info"]["filename"] = "121949_1D_measurement_time" +settings_list.append(settings) + +#%% 5 +settings = copy.deepcopy(settings_basic) +settings["file_info"]["date_stamp"] = "20220528" +settings["file_info"]["filename"] = "194601_1D_measurement_time" +settings_list.append(settings) + + +#%% 6 +settings = copy.deepcopy(settings_basic) +settings["file_info"]["date_stamp"] = "20220528" +settings["file_info"]["filename"] = "210639_1D_measurement_time" +settings_list.append(settings) + + +#%% 7 +settings = copy.deepcopy(settings_basic) +settings["file_info"]["date_stamp"] = "20220529" +settings["file_info"]["filename"] = "104210_1D_measurement_time" +settings_list.append(settings) + +#%% 8 +settings = copy.deepcopy(settings_basic) +settings["file_info"]["date_stamp"] = "20220529" +settings["file_info"]["filename"] = "185805_1D_measurement_time" +settings_list.append(settings) + + +#%% Load Timetraces +loader = Loaderh5() +saver = SaverPickle() + +for setting in settings_list: + try: + data = loader.load(setting) + saver.save(setting, data) + print("File saved : ", setting["file_info"]["filename"]) + except: + print("Failure at ", setting["file_info"]["filename"]) + + +# %% diff --git a/qkit/analysis/semiconductor/scripts/plot_3D.py b/qkit/analysis/semiconductor/scripts/plot_3D.py new file mode 100644 index 00000000..1d649886 --- /dev/null +++ b/qkit/analysis/semiconductor/scripts/plot_3D.py @@ -0,0 +1,56 @@ +#%% +from qkit.analysis.semiconductor.loaders.Loaderh5 import Loaderh5 +from qkit.analysis.semiconductor.plotters.Plotter3D import Plotter3D +from qkit.analysis.semiconductor.main.loading import print_nodes + + +settings = {"file_info" : { + "absolute_path" : "/home/ws/oc0612/SEMICONDUCTOR/analysis/bias-cooling/0V/cooldown_1/", + "filetype" : ".h5", + "date_stamp" : "20220112", + "filename" : "223439_2D_2D_Sweeps_both_SETs", + "savepath" : "analysis/", + "analysis" : "3D plot"}, + "meas_params" : { + "measurement_amp" : 200e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3} + } + + +#%% Load Timetrace +loader = Loaderh5() +data = loader.load(settings) +print_nodes(data) + + +#%% Define nodes +node_0_x = "gates_5_15" +node_0_y = "gates_7_17" +node_0_r = "demod0.r0" + +node_4_x = "gates_5_15" +node_4_y = "gates_7_17" +node_4_r = "demod4.r4" + + +#%% Plot 3D data +plotter = Plotter3D() +plotter.colorcode = "seismic" # checkout viridis, seismic, PiYG, plasma, gist_rainbow +plotter.savename = "Plot3D_1" +plotter.conductance = True +plotter.min = 0 +plotter.max = None # standart is None +plotter.plot(settings, data, [node_0_x, node_0_y, node_0_r], axis_labels=["Gate 5", "Gate 15"]) + + +#%% +plotter = Plotter3D() +plotter.colorcode = "viridis" +plotter.savename = "Plot3D_2" +plotter.conductance = True +plotter.min = 0 +plotter.max = None +plotter.plot(settings, data, [node_4_x, node_4_y, node_4_r], axis_labels=["Gate 10", "Gate 11"]) +# %% diff --git a/qkit/analysis/semiconductor/scripts/plot_combined_noise.py b/qkit/analysis/semiconductor/scripts/plot_combined_noise.py new file mode 100644 index 00000000..710db0be --- /dev/null +++ b/qkit/analysis/semiconductor/scripts/plot_combined_noise.py @@ -0,0 +1,196 @@ +#%% +import copy +from qkit.analysis.semiconductor.loaders.Loaderh5 import Loaderh5 +from qkit.analysis.semiconductor.main.loading import print_nodes +from qkit.analysis.semiconductor.analyzers.AnalyzerPlungerSweep import AnalyzerPlungerSweep +from qkit.analysis.semiconductor.analyzers.AnalyzerTimetraceSpectralNoiseDensity import AnalyzerTimetraceSpectralNoiseDensity +from qkit.analysis.semiconductor.plotters.PlotterTimetraceSpectralNoiseDensity import PlotterTimetraceSpectralNoiseDensity +from qkit.analysis.semiconductor.plotters.PlotterTimetracePeakTrackingSND import PlotterTimetracePeakTrackingSND +from qkit.analysis.semiconductor.plotters.PlotterDifferenceTimetraceSpectralNoiseDensity import PlotterDifferenceTimetraceSpectralNoiseDensity +from qkit.analysis.semiconductor.plotters.PlotterPlungerSweep import PlotterPlungerSweep +from qkit.analysis.semiconductor.plotters.PlotterTimetraceConductance import PlotterTimetraceConductance +from qkit.analysis.semiconductor.plotters.PlotterTimetrace import PlotterTimetrace +from qkit.analysis.semiconductor.plotters.PlotterTimetracePhase import PlotterTimetracePhase +from qkit.analysis.semiconductor.main.rotate_phase import rotate_phase +from qkit.analysis.semiconductor.main.SlicerTimetrace import SlicerTimetrace +from qkit.analysis.semiconductor.loaders.Loader_spectrum_np import Loader_spectrum_np +from qkit.analysis.semiconductor.savers.Saver_spectrum_np import Saver_spectrum_np + +loader = Loader_spectrum_np() + +#%% +settings_timetrace = {"file_info" : { + "absolute_path" : "/home/ws/oc0612/SEMICONDUCTOR/analysis/bias-cooling/-0.5V/", + "filetype" : ".h5", + "date_stamp" : "20220128", + "filename" : "175941_1D_measurement_time", + "savepath" : "analysis/", + "analysis" : "noise_timetrace"}, + "meas_params" : { + "measurement_amp" : 200e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3, + "sampling_rate" : 13732.91015625} + } + + +#%% +settings_peak = {"file_info" : { + "absolute_path" : "/home/ws/oc0612/SEMICONDUCTOR/analysis/bias-cooling/test/", + "filetype" : ".h5", + "date_stamp" : "20220214", + "filename" : "184856_2D_Peak_tracking", + "savepath" : "analysis/", + "analysis" : "plunger_sweep_timetrace"}, + "meas_params" : { + "measurement_amp" : 100e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 40e3} + } + +#%% +settings_background = {"file_info" : { + "absolute_path" : "/home/ws/oc0612/SEMICONDUCTOR/analysis/bias-cooling/background/", + "filetype" : ".h5", + "date_stamp" : "20220427", + "filename" : "143444_1D_measurement_time", + "savepath" : "analysis/", + "analysis" : "noise_timetrace"}, + "meas_params" : { + "measurement_amp" : 200e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3, + "sampling_rate" : 13732.91015625} + } + +#%% +settings_background_long = {"file_info" : { + "absolute_path" : "/home/ws/oc0612/SEMICONDUCTOR/analysis/bias-cooling/background/", + "filetype" : ".h5", + "date_stamp" : "20220427", + "filename" : "154538_1D_measurement_time", + "savepath" : "analysis/", + "analysis" : "noise_timetrace"}, + "meas_params" : { + "measurement_amp" : 200e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3, + "sampling_rate" : 858.306884765625} + } + + + +#%% Loading timetrace spectrum +(data_timetrace_Fourier, fit_params_plunger_timetrace, power_fit_params_timetrace_Fourier) = loader.load(settings_timetrace, ending="Fourier") +(data_timetrace_Welch, fit_params_plunger_timetrace, power_fit_params_timetrace_Welch) = loader.load(settings_timetrace, ending="Welch") + +#%% Loading peak tracking spectrum +(data_peak_Fourier, _, _) = loader.load(settings_peak, ending="Fourier") +(data_peak_Welch, _, _) = loader.load(settings_peak, ending="Welch") + +#%% Loading background spectrum +(data_background_Fourier, _, power_fit_params_background_Fourier) = loader.load(settings_background, ending="Fourier") +(data_background_Welch, _, power_fit_params_background_Welch) = loader.load(settings_background, ending="Welch") + +#%% Loading long 5h background spectrum +(data_background_long_Fourier, _, power_fit_params_background_long_Fourier) = loader.load(settings_background_long, ending="Fourier") +(data_background_long_Welch, _, power_fit_params_background_long_Welch) = loader.load(settings_background_long, ending="Welch") + + + + + +#%% Plotting Timetrace +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = fit_params_plunger_timetrace +plotter_SND.fit_vals = power_fit_params_timetrace_Fourier +plotter_SND.savename = "SND_fourier" +plotter_SND.plot(settings_timetrace, data_timetrace_Fourier) + +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = fit_params_plunger_timetrace +plotter_SND.fit_vals = power_fit_params_timetrace_Welch +plotter_SND.savename = "SND_welch" +plotter_SND.plot(settings_timetrace, data_timetrace_Welch) + + + +#%% Plotting Peak Tracking +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = None +plotter_SND.fit_vals = None +plotter_SND.savename = "SND_fourier" +plotter_SND.plot(settings_peak, data_peak_Fourier) + +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = None +plotter_SND.fit_vals = None +plotter_SND.savename = "SND_welch" +plotter_SND.plot(settings_peak, data_peak_Welch) + + + +#%% Plotting Timetrace AND Peak Tracking in one Plot +plotter_SND = PlotterTimetracePeakTrackingSND() +plotter_SND.fit_params_plunger = fit_params_plunger_timetrace +plotter_SND.fit_vals = power_fit_params_timetrace_Fourier +plotter_SND.savename = "SND_combined_fourier" +plotter_SND.plot(settings_peak, data_timetrace_Fourier, data_peak_Fourier) + +plotter_SND = PlotterTimetracePeakTrackingSND() +plotter_SND.fit_params_plunger = fit_params_plunger_timetrace +plotter_SND.fit_vals = power_fit_params_timetrace_Welch +plotter_SND.savename = "SND_combined_welch" +plotter_SND.plot(settings_peak, data_timetrace_Welch, data_peak_Welch) + + + +#%% Plotting Background +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = None +plotter_SND.fit_vals = power_fit_params_background_Fourier +plotter_SND.savename = "SND_fourier" +plotter_SND.fiftyHz = True +plotter_SND.plot(settings_background, data_background_Fourier) + +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = None +plotter_SND.fit_vals = power_fit_params_background_Welch +plotter_SND.savename = "SND_welch" +plotter_SND.fiftyHz = True +plotter_SND.plot(settings_background, data_background_Welch) + + +#%% Plotting long Background +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = None +plotter_SND.fit_vals = power_fit_params_background_long_Fourier +plotter_SND.savename = "SND_fourier" +plotter_SND.plot(settings_background_long, data_background_long_Fourier) + +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = None +plotter_SND.fit_vals = power_fit_params_background_long_Welch +plotter_SND.savename = "SND_welch" +plotter_SND.plot(settings_background_long, data_background_long_Welch) + + + +#%% Plotting Background and long Background in one Plot +plotter_SND = PlotterTimetracePeakTrackingSND() +plotter_SND.fit_params_plunger = None +plotter_SND.fit_vals = power_fit_params_background_Fourier +plotter_SND.fiftyHz = True +plotter_SND.savename = "SND_combined_fourier" +plotter_SND.plot(settings_background, data_background_Fourier, data_background_long_Fourier) + +plotter_SND = PlotterTimetracePeakTrackingSND() +plotter_SND.fit_params_plunger = None +plotter_SND.fit_vals = power_fit_params_background_Welch +plotter_SND.fiftyHz = True +plotter_SND.savename = "SND_combined_welch" +plotter_SND.plot(settings_background, data_background_Welch, data_background_long_Welch) diff --git a/qkit/analysis/semiconductor/scripts/plunger_sweep.py b/qkit/analysis/semiconductor/scripts/plunger_sweep.py new file mode 100644 index 00000000..18376a77 --- /dev/null +++ b/qkit/analysis/semiconductor/scripts/plunger_sweep.py @@ -0,0 +1,120 @@ +#%% +from qkit.analysis.semiconductor.loaders.Loaderh5 import Loaderh5 +from qkit.analysis.semiconductor.main.loading import print_nodes +from qkit.analysis.semiconductor.analyzers.AnalyzerTimetraceSpectralNoiseDensity import AnalyzerTimetraceSpectralNoiseDensity +from qkit.analysis.semiconductor.plotters.PlotterTimetraceSpectralNoiseDensity import PlotterTimetraceSpectralNoiseDensity +from qkit.analysis.semiconductor.analyzers.AnalyzerPeakTracker_Daniel import AnalyzerPeakTracker +from qkit.analysis.semiconductor.analyzers.AnalyzerTimetraceJumps import AnalyzerTimetraceJumps +from qkit.analysis.semiconductor.plotters.PlotterPlungerTimetrace3D import PlotterPlungerTimetrace3D +from qkit.analysis.semiconductor.plotters.PlotterPlungerTraceFit import PlotterPlungerTraceFit +from qkit.analysis.semiconductor.plotters.PlotterPlungerTraceTimestampsDifference import PlotterPlungerTraceTimestampsDifference +from qkit.analysis.semiconductor.plotters.PlotterTimetraceJumpsHistogram import PlotterTimetraceJumpsHistogram +from qkit.analysis.semiconductor.main.SlicerPlungerTimetrace import SlicerPlungerTimetrace +from qkit.analysis.semiconductor.loaders.Loader_spectrum_np import Loader_spectrum_np +from qkit.analysis.semiconductor.savers.Saver_spectrum_np import Saver_spectrum_np + +settings = {"file_info" : { + "filepath" : "/V/GroupWernsdorfer/SEMICONDUCTOR_SYSTEMS/Presentations/2022_06_13/Data/002320_2D_Peak_tracking_lowest_TG/002320_2D_Peak_tracking.h5", + "savepath" : "analysis/", + "analysis" : "plunger_sweep_timetrace"}, + "meas_params" : { + "measurement_amp" : 100e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 40e3} + } + + +#%% Load Timetrace +loader = Loaderh5() +data = loader.load(settings) +print_nodes(data) + +#%% Define nodes +node_timestamp = "demod0&4.timestamp0" +node_x = "demod0&4.x0" +node_y = "demod0&4.y0" +node_r = "demod0&4.r0" + +gates = "gates_6_16" + + +#%% Plot Data +plotter = PlotterPlungerTimetrace3D() +plotter.max_cond = None +plotter.plot(settings, data, [node_timestamp, gates , node_r]) + +#%% Slice Data and Plot +slicer = SlicerPlungerTimetrace() +slicer.beginning, slicer.ending = 0, 10 # in hours +data_sliced = slicer.slice(data, [node_timestamp, gates , node_r]) + +plotter = PlotterPlungerTimetrace3D() +plotter.max_cond = None +plotter.savename = "plunger_timetrace_sliced" +plotter.plot(settings, data_sliced, [node_timestamp, gates , node_r]) + +#%% Analyze Data +analyzer = AnalyzerPeakTracker() + +analyzer.intervall1 = 0.01 +analyzer.intervall2 = 0.005 +analyzer.peak_voltage = -0.305 +analyzer.analyze( data_sliced, [node_timestamp, gates , node_r]) + +#%% Plot Analyzed Data +plotter = PlotterPlungerTimetrace3D() +plotter.point_size = 0.5 +plotter.marker_shape = "or" +plotter.max_cond = 10 +plotter.savename = "plunger_timetrace_sliced_fitted" +plotter.plot(settings, data_sliced, [node_timestamp, gates , node_r]) + +#%% Plot time difference between consecutive plunger sweeps +plotter = PlotterPlungerTraceTimestampsDifference() +plotter.plot(settings, data_sliced) + + +#%% Plot a single plunger trace +plotter = PlotterPlungerTraceFit() +plotter.trace_num = 10 +plotter.plot(settings, data_sliced, [gates , node_r]) + + + +#%% Analyze Jumps of Timetrace +analyzer_jumps = AnalyzerTimetraceJumps() +analyzer_jumps.bin_count = 50 +jumps_hist = analyzer_jumps.analyze_difference(data_sliced, ["peaks_value", node_timestamp]) + +plotter_hist = PlotterTimetraceJumpsHistogram() +plotter_hist.marker_size = 8 +plotter_hist.plot(settings, jumps_hist) + + + +#%% SND +sampling_f = 1/data_sliced["avg_sweep_time"] +analyzer_SND = AnalyzerTimetraceSpectralNoiseDensity() +spectral_result = analyzer_SND.analyze(sampling_f, data_sliced, ["peaks_plunger_V"]) # classic Fourier + +saver = Saver_spectrum_np() # Saving Data +saver.save(settings, spectral_result, ending="Fourier") + +analyzer_SND.segment_length = 50 # length of each segment for Welch +spectral_result_welch = analyzer_SND.analyze_welch(sampling_f, data_sliced, ["peaks_plunger_V"]) # Welch's method + +saver = Saver_spectrum_np() # Saving Data +saver.save(settings, spectral_result_welch, ending="Welch") + +#%% +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter.savename = "SND" +plotter_SND.plot(settings, spectral_result) # classic Fourier + +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter.savename = "SND_welch" +plotter_SND.plot(settings, spectral_result_welch) # Welch's method + + + diff --git a/qkit/analysis/semiconductor/scripts/timetrace.py b/qkit/analysis/semiconductor/scripts/timetrace.py new file mode 100644 index 00000000..3d921a36 --- /dev/null +++ b/qkit/analysis/semiconductor/scripts/timetrace.py @@ -0,0 +1,387 @@ +#%% +import copy +from qkit.analysis.semiconductor.loaders.Loaderh5 import Loaderh5 +from qkit.analysis.semiconductor.main.loading import print_nodes +from qkit.analysis.semiconductor.analyzers.AnalyzerPlungerSweep import AnalyzerPlungerSweep +from qkit.analysis.semiconductor.analyzers.AnalyzerTimetraceSpectralNoiseDensity import AnalyzerTimetraceSpectralNoiseDensity +from qkit.analysis.semiconductor.plotters.PlotterTimetraceSpectralNoiseDensity import PlotterTimetraceSpectralNoiseDensity +from qkit.analysis.semiconductor.plotters.PlotterDifferenceTimetraceSpectralNoiseDensity import PlotterDifferenceTimetraceSpectralNoiseDensity +from qkit.analysis.semiconductor.plotters.PlotterPlungerSweep import PlotterPlungerSweep +from qkit.analysis.semiconductor.plotters.PlotterTimetraceConductance import PlotterTimetraceConductance +from qkit.analysis.semiconductor.plotters.PlotterTimetrace import PlotterTimetrace +from qkit.analysis.semiconductor.plotters.PlotterTimetracePhase import PlotterTimetracePhase +from qkit.analysis.semiconductor.main.rotate_phase import rotate_phase +from qkit.analysis.semiconductor.main.SlicerTimetrace import SlicerTimetrace +from qkit.analysis.semiconductor.loaders.Loader_spectrum_np import Loader_spectrum_np +from qkit.analysis.semiconductor.savers.Saver_spectrum_np import Saver_spectrum_np +from qkit.analysis.semiconductor.loaders.LoaderPickle import LoaderPickle +from qkit.analysis.semiconductor.savers.SaverPickle import SaverPickle + + +settings = {"file_info" : { + "absolute_path" : "/home/ws/oc0612/SEMICONDUCTOR/analysis/bias-cooling/P35_B3/", + "filetype" : ".h5", + "date_stamp" : "20220501", + "filename" : "132507_1D_measurement_time", + "savepath" : "analysis/", + "analysis" : "noise_timetrace"}, + "meas_params" : { + "measurement_amp" : 200e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3, + "sampling_rate" : 13732.91015625} + } + + +settings_plunger = copy.deepcopy(settings) +settings_plunger["file_info"]["filename"] = "131831_1D_Plunger_sweep_both" + +#%% Load Timetrace +loader = Loaderh5() +data = loader.load(settings) +print_nodes(data) + +#%% save as Pickle +saver = SaverPickle() +saver.save(settings, data) + +#%% load from Pickle +loader = LoaderPickle() +data = loader.load(settings) + + +#%% +side = "l" + +#Define nodes +if side == "l": + node_timestamp = "demod0&4.timestamp0" + node_x = "demod0&4.x0" + node_y = "demod0&4.y0" + node_r = "demod0&4.r0" +elif side == "r": + node_timestamp = "demod0&4.timestamp4" + node_x = "demod0&4.x4" + node_y = "demod0&4.y4" + node_r = "demod0&4.r4" +else: + print("Idiot!") + +# define plunger notes +if side == "l": + node_plunger_timestamp = "demod0&4.timestamp0" + node_plunger_x = "demod0&4.x0" + node_plunger_y = "demod0&4.y0" + node_plunger_r = "demod0&4.r0" +elif side == "r": + node_plunger_timestamp = "demod0&4.timestamp4" + node_plunger_x = "demod0&4.x4" + node_plunger_y = "demod0&4.y4" + node_plunger_r = "demod0&4.r4" +else: + print("Idiot!") + +gate_plunger = "gates_6_12" + + +#%% Plot Timetrace Lock-in R + +plotter_timetrace = PlotterTimetrace() +plotter_timetrace.savename = "timetrace_R" + "_" + side +plotter_timetrace.title = "Timetrace R" +plotter_timetrace.plot(settings, data, [node_timestamp, node_x]) + +#%% Plot Timetrace Lock-in x +plotter_timetrace = PlotterTimetrace() +plotter_timetrace.savename = "timetrace_x" + "_" + side +plotter_timetrace.title = "Timetrace x" +plotter_timetrace.plot(settings, data, [node_timestamp, node_x]) + +#%% Plot Timetrace Lock-in y +plotter_timetrace = PlotterTimetrace() +plotter_timetrace.savename = "timetrace_y" + "_" + side +plotter_timetrace.title = "Timetrace y" +plotter_timetrace.plot(settings, data, [node_timestamp, node_y]) + + +#%% Plot Timetrace Cond R +plotter_timetrace = PlotterTimetraceConductance() +plotter_timetrace.savename = "timetraceCond_R" + "_" + side +plotter_timetrace.title = "Timetrace R" +plotter_timetrace.plot(settings, data, [node_timestamp, node_r]) + + +#%% Plot Timetrace Cond x +plotter_timetrace = PlotterTimetraceConductance() +plotter_timetrace.savename = "timetraceCond_x" + "_" + side +plotter_timetrace.title = "Timetrace x" +plotter_timetrace.plot(settings, data, [node_timestamp, node_x]) + +#%% Plot Timetrace Cond y +plotter_timetrace = PlotterTimetraceConductance() +plotter_timetrace.savename = "timetraceCond_y" + "_" + side +plotter_timetrace.title = "Timetrace y" +plotter_timetrace.plot(settings, data, [node_timestamp, node_y]) + +#%% Plot Phase of Timetrace +plotter_phase = PlotterTimetracePhase() +plotter_phase.savename = "phase" + "_" + side +plotter_phase.plot(settings, data, [node_timestamp, node_x, node_y]) + + +#%% Slice Timetrace +begin, end = 0, 2000 #seconds +slicer = SlicerTimetrace(begin, end) +data_sliced = slicer.make_slice_timetrace(data, [node_timestamp, node_r, node_x, node_y]) + + +plotter_timetrace = PlotterTimetrace() +plotter_timetrace.savename = "timetrace_sliced_R" + "_" + side +plotter_timetrace.title = "Timetrace R" +plotter_timetrace.plot(settings, data_sliced, [node_timestamp, node_r]) + +plotter_timetrace = PlotterTimetrace() +plotter_timetrace.savename = "timetrace_sliced_x" + "_" + side +plotter_timetrace.title = "Timetrace x" +plotter_timetrace.plot(settings, data_sliced, [node_timestamp, node_x]) + +plotter_timetrace = PlotterTimetrace() +plotter_timetrace.savename = "timetrace_sliced_y" + "_" + side +plotter_timetrace.title = "Timetrace y" +plotter_timetrace.plot(settings, data_sliced, [node_timestamp, node_y]) + +plotter_timetrace = PlotterTimetraceConductance() +plotter_timetrace.savename = "timetrace_sliced_R_Cond" + "_" + side +plotter_timetrace.plot(settings, data_sliced, [node_timestamp, node_r]) + +plotter_phase = PlotterTimetracePhase() +plotter_phase.savename="timetrace_sliced_phase" + "_" + side +plotter_phase.plot(settings, data_sliced, [node_timestamp, node_x, node_y]) + +#%% Rotate Data +phase_correction = +75 +data_sliced_rotated = rotate_phase(data_sliced, [node_x, node_y], phase_correction) + +plotter_timetrace = PlotterTimetrace() +plotter_timetrace.savename = "timetrace_sliced_rotated_x" + "_" + side +plotter_timetrace.title = "Timetrace x" +plotter_timetrace.plot(settings, data_sliced_rotated, [node_timestamp, node_x]) + +plotter_timetrace = PlotterTimetrace() +plotter_timetrace.savename = "timetrace_sliced_rotated_y" + "_" + side +plotter_timetrace.title = "Timetrace y" +plotter_timetrace.plot(settings, data_sliced_rotated, [node_timestamp, node_y]) + +plotter_phase = PlotterTimetracePhase() +plotter_phase.savename = "timetrace_sliced_rotated_phase" + "_" + side +plotter_phase.plot(settings, data_sliced_rotated, [node_timestamp, node_x, node_y]) + + + + + +#################################### +### Load Plunger Data and Fit it ### +#################################### + +#%% Load Plunger Gate Sweep +loader = Loaderh5() +data_plunger = loader.load(settings_plunger) +print_nodes(data_plunger) + + +#%% Rotate data +data_plunger_rotated = rotate_phase(data_plunger, [node_plunger_x, node_plunger_y], phase_correction) + +#%% Plot Plunger Sweep +plotter_plunger = PlotterPlungerSweep() +plotter_plunger.savename = "plunger_sweep_x" + "_" + side +plotter_plunger.plot(settings, settings_plunger, data_plunger_rotated, [gate_plunger, node_plunger_x]) + + +#%% Analyze Equvalent Gate Voltage +analyzer_plunger = AnalyzerPlungerSweep() +analyzer_plunger.voltage_fit = 0.5507 +analyzer_plunger.intervall_fit = 4e-3 +plunger_fit_params = analyzer_plunger.analyze(data_plunger_rotated, [gate_plunger, node_plunger_x]) + +plotter_plunger = PlotterPlungerSweep() +plotter_plunger.fit_params = plunger_fit_params +plotter_plunger.savename = "plunger_sweep_fit_x" + "_" + side +plotter_plunger.plot(settings, settings_plunger, data_plunger_rotated, [gate_plunger, node_plunger_x]) + + +#%% Analyze and Plot SND with classic Fourier Trafo +sampling_f = settings["meas_params"]["sampling_rate"] #data[" "] +analyzer_SND = AnalyzerTimetraceSpectralNoiseDensity() +analyzer_SND.guess = [1e-5, -1] +spectral_result = analyzer_SND.analyze(sampling_f, data_sliced_rotated, [node_x]) +power_fit_params = analyzer_SND.fit(spectral_result) + +saver = Saver_spectrum_np() # Saving Data +saver.save(settings, spectral_result, plunger_fit_params, power_fit_params, ending=f"Fourier_{side}") + +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = plunger_fit_params +plotter_SND.fit_vals = power_fit_params +plotter_SND.savename = "SND_fourier" + "_" + side +plotter_SND.plot(settings, spectral_result) + + + + +#%% Analyze and Plot SND with Welch's method +sampling_f = settings["meas_params"]["sampling_rate"] +analyzer_SND = AnalyzerTimetraceSpectralNoiseDensity() +analyzer_SND.segment_length = 5e5 # length of each segment that is used for Welch +spectral_result_welch = analyzer_SND.analyze_welch(sampling_f, data_sliced_rotated, [node_x]) +power_fit_params_welch = analyzer_SND.fit(spectral_result_welch) + +saver = Saver_spectrum_np() # Saving Data +saver.save(settings, spectral_result_welch, plunger_fit_params, power_fit_params_welch, ending=f"Welch_{side}") + +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = plunger_fit_params +plotter_SND.fit_vals = power_fit_params_welch +plotter_SND.savename = "SND_welch" + "_" + side +plotter_SND.plot(settings, spectral_result_welch) + + + + + + + + + +#%% +################################################ +################################################ +#Background noise +settings_background = {"file_info" : { + "absolute_path" : "/home/ws/oc0612/SEMICONDUCTOR/analysis/bias-cooling/background/", + "filetype" : ".h5", + "date_stamp" : "20220427", + "filename" : "154538_1D_measurement_time", + "savepath" : "analysis/", + "analysis" : "noise_timetrace"}, + "meas_params" : { + "measurement_amp" : 200e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3, + "sampling_rate" : 858.306884765625} + } + +settings_background = {"file_info" : { + "absolute_path" : "/home/ws/oc0612/SEMICONDUCTOR/analysis/bias-cooling/background/", + "filetype" : ".h5", + "date_stamp" : "20220427", + "filename" : "143444_1D_measurement_time", + "savepath" : "analysis/", + "analysis" : "noise_timetrace"}, + "meas_params" : { + "measurement_amp" : 200e-6, + "voltage_divider" : 3, + "IVgain" : 1e8, + "in_line_R": 42e3, + "sampling_rate" : 13732.91015625} + } + +#%% Load Timetrace +loader = Loaderh5() +data_background = loader.load(settings_background) +print_nodes(data_background) + +#%% Define nodes +node_background_timestamp = "demod0&4.timestamp0" +node_background_x = "demod0&4.x0" +node_background_y = "demod0&4.y0" +node_background_r = "demod0&4.r0" + +#%% Slice Timetrace +#begin, end = 0, 100 #seconds +#slicer = SlicerTimetrace(begin, end) +#data_sliced_background = slicer.make_slice_timetrace(data_background, [node_background_timestamp, node_background_r, node_background_x, node_background_y]) +data_sliced_background = data_background + +#%% Rotate Data +phase_correction_background = +75 +data_sliced_rotated_background = rotate_phase(data_sliced_background, [node_background_x, node_background_y], phase_correction_background) + +plotter_timetrace = PlotterTimetrace() +plotter_timetrace.jumbo_data = True +print(plotter_timetrace.jumbo_data) +plotter_timetrace.savename = "timetrace_background_sliced_rotated_x" +plotter_timetrace.title = "Timetrace x" +plotter_timetrace.plot(settings_background, data_sliced_rotated_background, [node_background_timestamp, node_background_x]) + +plotter_timetrace = PlotterTimetrace() +plotter_timetrace.jumbo_data = True +plotter_timetrace.savename = "timetrace_background_sliced_rotated_y" +plotter_timetrace.title = "Timetrace y" +plotter_timetrace.plot(settings_background, data_sliced_rotated_background, [node_background_timestamp, node_background_y]) + +plotter_phase = PlotterTimetracePhase() +plotter_timetrace.jumbo_data = True +plotter_timetrace.savename = "timetrace_background_sliced_rotated_phase" +plotter_phase.plot(settings_background, data_sliced_rotated_background, [node_background_timestamp, node_background_x, node_background_y]) + + + +#%% Analyze Equvalent Gate Voltage +analyzer_plunger = AnalyzerPlungerSweep() +plunger_fit_params_background = None + +#%% Analyze and Plot SND with classic Fourier Trafo +sampling_f_background = settings_background["meas_params"]["sampling_rate"] #data[" "] +analyzer_SND = AnalyzerTimetraceSpectralNoiseDensity() +spectral_result_background = analyzer_SND.analyze(sampling_f_background, data_sliced_rotated_background, [node_background_x]) +power_fit_params_background = analyzer_SND.fit(spectral_result_background) + +saver = Saver_spectrum_np() # Saving Data +saver.save(settings_background, spectral_result_background, plunger_fit_params_background, power_fit_params_background, ending="Fourier") + +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = None +plotter_SND.fit_vals = power_fit_params_background +plotter_SND.savename = "SND_fourier_background" +plotter_SND.plot(settings_background, spectral_result_background) + + +#%% Analyze and Plot SND with Welch's method +analyzer_SND = AnalyzerTimetraceSpectralNoiseDensity() +sampling_f_background = settings_background["meas_params"]["sampling_rate"] +analyzer_SND.segment_length = 1e7 # length of each segment that is used for Welch +spectral_result_welch_background = analyzer_SND.analyze_welch(sampling_f_background, data_sliced_rotated_background, [node_background_x]) +power_fit_params_welch_background = analyzer_SND.fit(spectral_result_welch_background) + +saver = Saver_spectrum_np() # Saving Data +saver.save(settings_background, spectral_result_welch_background, plunger_fit_params_background, power_fit_params_welch_background, ending="Welch") + +plotter_SND = PlotterTimetraceSpectralNoiseDensity() +plotter_SND.fit_params_plunger = None +plotter_SND.fit_vals = power_fit_params_welch_background +plotter_SND.savename = "SND_welch_background_8" +plotter_SND.xlim = [5e-5,1e0] +plotter_SND.ylim = [1e-6,1e-1] +plotter_SND.plot(settings_background, spectral_result_welch_background) + + + +#%% +plotter_SND = PlotterDifferenceTimetraceSpectralNoiseDensity() +plotter_SND.savename = "SND_Fourier_NO_background" +plotter_SND.fit_params_plunger = plunger_fit_params +plotter_SND.plot(settings, spectral_result, spectral_result_background) + + +#%% +plotter_SND = PlotterDifferenceTimetraceSpectralNoiseDensity() +plotter_SND.savename = "SND_Welch_NO_background" +plotter_SND.fit_params_plunger = plunger_fit_params +plotter_SND.plot(settings, spectral_result_welch, spectral_result_welch_background) + + +# %% \ No newline at end of file diff --git a/src/qkit/config/environment.py b/src/qkit/config/environment.py index 80efdf7a..c0557412 100644 --- a/src/qkit/config/environment.py +++ b/src/qkit/config/environment.py @@ -84,7 +84,7 @@ ## the log file is located under cfg['logdir'] ## stdout log is displayed in jupyter notebooks ## default log level is 'WARNING' -cfg['file_log_level'] = 'INFO' # one of ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] +cfg['file_log_level'] = 'WARNING' # one of ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] cfg['stdout_log_level'] = 'WARNING' ## diff --git a/src/qkit/core/lib/misc.py b/src/qkit/core/lib/misc.py index 19a4a97a..090bca69 100644 --- a/src/qkit/core/lib/misc.py +++ b/src/qkit/core/lib/misc.py @@ -56,6 +56,7 @@ def register_exit(func): import atexit atexit.register(func) + def str3(string,encoding='UTF-8'): try: return string.decode(encoding) diff --git a/src/qkit/drivers/Keysight_VNA_E5080B.py b/src/qkit/drivers/Keysight_VNA_E5080B.py index 23feed49..2ef302ee 100644 --- a/src/qkit/drivers/Keysight_VNA_E5080B.py +++ b/src/qkit/drivers/Keysight_VNA_E5080B.py @@ -1,4 +1,4 @@ -# Agilent_VNA_E5071C driver, P. Macha, modified by M. Weides July 2013, J. Braumueller 2015 ++# Agilent_VNA_E5071C driver, P. Macha, modified by M. Weides July 2013, J. Braumueller 2015 # Adapted to Keysight VNA by A. Schneider and L. Gurenhaupt 2016 # Updated from E5071B to E5080B by M. Wildermuth and M. Kristen 2019 # diff --git a/src/qkit/drivers/adwin_spin_transistor.py b/src/qkit/drivers/adwin_spin_transistor.py new file mode 100644 index 00000000..961eb2c1 --- /dev/null +++ b/src/qkit/drivers/adwin_spin_transistor.py @@ -0,0 +1,407 @@ +''' ADwin driver for the Spin-Transistor measurement. The idea is to + view the Adwin as a highly configurable measurement device (since it + is a programmable fpga with different hardware configurations it + will always be specially programmed to do certain tasks efficiently) + Here we view the Adwin as a unit together with its peripherals, like + current sources, voltage dividers, iv_converters, filters, coils, .. + We just want to tell it what physical quantities we want to measure + or apply at the sample (B-Fields, voltages, currents ...) + Therefore the driver includes two parts: + * AdwinIO which handles the translation between physical + quantities and BITS. + * The insturment driver (adwin_spin_transistor) itself only + containes the measurement functions using bit values for the + DAC/ADC. + + So far, all measurements consist of a sweep process and a lockin + process: + * The lockin process can apply a sine wave at a hard coded adwin + output and performs the measurement of the input with 500kHz + sample_rate. It contains the lockin demodulation with low pass + filter and can send subsampled data to the PC (depending on + the filter constant of the filters it does not make sense to + use a to high data rate). The same process can also be used to + measure the raw input of the ADC with full 500kHz or + subsampled to a smaller sample_rate. + * The sweep process can perform a linear sweep of the adwin + outputs in a certain time. As soon as the sweep starts, it + triggers the lockin process. + + Modes: + * LOCKIN: After initiliazing the ADwin the lockin process has to + be started setting the desired lockin-parameters. Then the + lockin will continously just without sending data to the PC. + Therfore the filter parameters are always initialized. + As soon as the "measurment_active" flag is set to "1", the + lockin will write the values to the FIFO. Since communication + between PC and Adwin does affect the measurement by + introducing jitter and maybe more, it makes sense to fetch the + data after the measurement is done, limiting (sample_rate * + measurement time) by the length of the FIFOs. + * DC: Here we just want to use the lockin prcoess for data + aquisition, therefore just set the amplitude of the lockin to + zero to not apply a lockin signal. + + + ToDO: * Sanity checky for sweep parameters e.g. + * Maybe programm the LP filter for dc measurements as well + ''' + +__all__ = ['adwin_spin_transistor', 'AdwinIO'] +__version__ = '0.1_20240514' +__author__ = 'Luca Kosche' + +import logging as log +from pathlib import Path +from time import sleep +import numpy as np +import ADwin as adw +from qkit.core.instrument_base import Instrument +from qkit.drivers.adwinlib.io_handler import AdwinIO, AdwinModeError +from qkit.drivers.adwinlib.io_handler import AdwinLimitError +from qkit.drivers.adwinlib.io_handler import AdwinArgumentError +from qkit.drivers.adwinlib.io_handler import AdwinNotImplementedError + +# These constants have to be synchronised with the definitions of Par_no +# FPar_no and Data_no and constants in the ADbasic files. + +# BOTH PROCESSES +LOCKIN_ACTIVE_PAR = 21 # Reports "1" if lockin process is active +# LOCKIN PROCESS +LOCKIN_BIAS_PAR = 8 # Lockin bias voltage (bits) +MEASURE_ACTIVE_PAR = 22 # activate data aquisition with "1" +LOCKIN_OR_DC_PAR = 23 # Measure lockin or raw dc input +AMPLITUDE_PAR = 24 # Lockin amplitude (bits) +TAO_FPAR = 23 # Time constant of lockin filter +FREQUENCY_FPAR = 22 # Target lockin frequency +REPORT_FREQUENCY_FPAR = 24 # Real lockin frequency due to lockin_array +SAMPLERATE_FPAR = 25 # Target sample rate +REPORT_SAMPLERATE_FPAR = 26 # Real samplerate due to 2us time resolution +FIFO_LEN = 1000003 # Length of Fifo for data transmittion +INS = {'inph': 1, 'quad': 2, 'raw': 3} #fifo numbers +LOCKIN_CARD = 3 # Hard coded DAC card for lockin output +LOCKIN_CHANNEL = 8 # Hard coded DAC channel for lockin output +LOCKIN_LEN = 8003 # Length of lockin output/reference arrays +# SWEEP PROCESS +SWEEP_ACTIVE_PAR = 20 # Active sweep by setting to "2" and check + # rate by looking for "1". +NB_OUTS = 8 # number of Adwin outputs +DURATION_FPAR = 20 # Target duration of sweep +REPORT_DURATION_FPAR = 21 # Duration of sweep due to 50kHz resolution +TARGET_DATA = 20 # Target values of the next sweep. + +# RESULTING FROM ADBASIC FILES +MIN_FREQUENCY = 62.48 +MAX_FREQUENCY = 40E3 # too high frequency might suffer from jitter + + +class adwin_spin_transistor(Instrument): + ''' ADwin driver to handle kHz lockin + readout while performing + sweeps on the output. So far the T11 processor, 16-bit output + card and 18-bit input card are supported. ''' + def __init__(self, + name='my_instrument', + processor='T11', + mode='lockin', #lockin or dc + devicenumber=1, + bootload=True, + hard_config=None, + soft_config=None): + + log.info('Initializing instrument in "%s" mode.', mode) + Instrument.__init__(self, name, tags=['physical','ADwin_ProII']) + + self._state = 'init' + self._params = {'sample_rate': None, + 'inputs': []} + module_dir = Path(__file__).parent + adbasic_dir = module_dir / 'adwinlib' / 'spin-transistor' + self._lockin_process = adbasic_dir / 'Pro2_T11_lockin.TB1' + self._lockin_process_no = 1 + self._sweep_process = adbasic_dir / 'Pro2_T11_sweep.TB2' + self._sweep_process_no = 2 + + # create AdwinIO Instance + self.aio = AdwinIO(hard_config, soft_config) + + # create ADwin instance + self.adw = adw.ADwin(DeviceNo=devicenumber, + raiseExceptions=1, + useNumpyArrays=True) + + # Set 'bootload' to 'False' to not reboot the Adwin. + if bootload: + # before boot try to read the current outputs, which can + # fail if the adwin was power cycled and never booted since + try: + output_buffer = self.read_outputs(out_format='bit') + self._state = 'output_buffer_loaded' + except adw.ADwinError: + self._state = 'output_buffer_unknown' + log.critical('ADwin: outputs unknown! Booting.') + #boot adwin + btl_name = f"ADwin{processor.replace('T', '')}.btl" + btl_path = Path(self.adw.ADwindir) / btl_name + self.adw.Boot(str(btl_path)) + # set output buffer if possible, otherwise set all outputs + # to zero volts + if self._state == 'output_buffer_loaded': + self.set_output_buffer(output_buffer, val_format='bit') + else: + outs_zero = [2**15] * NB_OUTS + self.set_output_buffer(outs_zero, val_format='bit') + msg = ('Adwin: setting output buffer to zero! Recover ' + + 'the current working Point by manually setting' + + ' the output buffer using set_output_buffer() ' + + 'BEFORE THE FIRST SWEEP') + log.critical(msg) + + self._state = 'booted' + + # load processes + log.info('Adwin loading: %s', self._lockin_process.name) + self.adw.Load_Process(str(self._lockin_process)) + log.info('Adwin loading: %s', self._sweep_process.name) + self.adw.Load_Process(str(self._sweep_process)) + + self._state = 'processes_loaded' + + # implement general functions + self.add_function("sweep") + self.add_function("sweep_measure") + self.add_function("measure") + self.add_function("init_measurement") + self.add_function("stop_measurement") + self.add_function("read_outputs") + self.add_function("stop_sweep") + self.add_function("set_output_buffer") + +######################################################################## +####################### MEASUREMENT ROUTINES ########################### +######################################################################## + + def sweep(self, target, duration, wait=True): + """ Ramp the outputs of the ADwin wihtout measurement. + If wait==True it waits for the sweep to be finished. """ + self._start_sweep(target, duration) + while wait is True and self.adw.Get_Par(SWEEP_ACTIVE_PAR) == 1: + pass + for i in INS.values(): + self.adw.Fifo_Clear(i) + if wait is True: + log.info('Adwin finished sweep.') + else: + log.info('Adwin sweeping with no idea, when it ends.') + + def sweep_measure(self, target, duration): + ''' Start a sweep while measuring with lockin with minimal + communication between adwin-PC (buffering the measurement + in fifo). The sample rate is determined by the lockin + process which needs to be already running. ''' + # sanity checks + self._check_measurement_active() + self._warn_if_fifo_to_small(duration) + # start sweep + self._start_sweep(target, duration) + # wait for sweep to be finished (this might not be the best + # timing, but limits communication during measurement) + sleep(duration) + # check if sweep has ended + while self.adw.Get_Par(SWEEP_ACTIVE_PAR) == 1: + pass + # fetch measurement data from adwin and return + return self._fetch_data_from_fifos() + + def measure(self, duration): + ''' Measure DC input for duration with full 500kHz sample rate + for duration seconds. If no lockin should be applied, start + lockin process with amplitude zero. Amount of collectable + data is limited by fifo buffer length. ''' + # sanity checks + self._check_measurement_active() + self._warn_if_fifo_to_small(duration) + # enable data aquisition + self.adw.Set_Par(MEASURE_ACTIVE_PAR, 1) + sleep(duration) + # disable data aquisition + self.adw.Set_Par(MEASURE_ACTIVE_PAR, 0) + # fetch measurement data from adwin and return + return self._fetch_data_from_fifos() + + def _fetch_data_from_fifos(self): + ''' Fetch all data from the fifos which has been set as inputs + during init_measurement() and clear all other fifos ''' + res = {'inph': None, 'quad': None, 'raw': None} + samples = self.adw.Fifo_Full(INS['inph']) + for key in res: + if key in self._params['inputs']: + tmp = self.adw.GetFifo_Float(INS[key], samples) + res[key] = self.aio.bit2qty(tmp, 'readout', False) + else: + self.adw.Fifo_Clear(INS[key]) + return res + +######################################################################## +########################## PREPARE MEASUREMENT ######################### +######################################################################## + + def init_measurement(self, mode, sample_rate, bias, inputs, + **kwargs): + ''' Initialize a lockin or dc measurement (mode). This start + the process needed for data aquisition. In lockin mode it + also applies the continous lockin signal. ''' + # stop old measurement process if still running + if self._state == 'measurement_ready': + self.adw.Stop_Process(self._lockin_process_no) + # set sample rate + self.adw.Set_FPar(SAMPLERATE_FPAR, sample_rate) + # set bias voltage + bias_bits = self.aio.qty2bit(bias, LOCKIN_CHANNEL) + self.adw.Set_Par(LOCKIN_BIAS_PAR, bias_bits) + # set inputs + for inp in inputs: + if inp not in INS: + raise AdwinArgumentError + self._params['inputs'] = inputs + # handle measurement modes + match mode: + case 'lockin': + try: + # get lockin frequency + freq = kwargs['frequency'] + # check if frequency is supported + if not MIN_FREQUENCY <= freq <= MAX_FREQUENCY: + raise AdwinLimitError + self.adw.Set_FPar(FREQUENCY_FPAR, freq) + # get lockin amplitude + amp = kwargs['amplitude'] + # translate to bit value + amp_bits = self.aio.qty2bit(amp, LOCKIN_CHANNEL, + absolute=False) + self.adw.Set_Par(AMPLITUDE_PAR, amp_bits) + # get filter constant tao + tao = kwargs['tao'] + self.adw.Set_FPar(TAO_FPAR, tao) + except KeyError as exc: + raise AdwinArgumentError from exc + case 'dc': + # set 'fake' frequency (no effect with amplitude zero) + self.adw.Set_FPar(FREQUENCY_FPAR, 62.5) + # set zero amplitude + self.adw.Set_Par(AMPLITUDE_PAR, 0) + # set 'fake' tao + self.adw.Set_FPar(TAO_FPAR, 1) + case _: + raise AdwinArgumentError + + # start lockin process + log.info('Adwin starting: %s', self._lockin_process.name) + self.adw.Start_Process(self._lockin_process_no) + + # get actual parameters + sample_rate = self.adw.Get_FPar(REPORT_SAMPLERATE_FPAR) + self._params['sample_rate'] = sample_rate + # set measurement ready state + self._state = 'measurement_ready' + # handle logging for each mode + match mode: + case 'lockin': + freq = self.adw.Get_FPar(REPORT_FREQUENCY_FPAR) + log.warning('ADwin: lock-in: frequency = %s Hz. ' + + 'amplitdue = %s V, tao = %s s, ' + + 'sample_rate = %s', freq, amp, tao, + sample_rate) + case 'dc': + log.warning('ADwin dc measurement initialized with ' + + 'sample_rate = %s', sample_rate) + + def stop_measurement(self): + """ Stops the lockin process. No lockin signal is applied and no + readout is triggered by a sweep anymore. """ + self._check_measurement_active() + log.info('Adwin stopping: %s', self._lockin_process.name) + self.adw.Stop_Process(self._lockin_process_no) + self._state = 'processes_loaded' + +######################################################################## +########################## OTHER FUNCTIONS ############################# +######################################################################## + + def read_outputs(self, channel:int|str=None, out_format='qty'): + """ Read the current saved output values of the ADwin. After a + restart this might not be the correct values. """ + # Read all adwin parameters holding the current output values + match channel: + case int(): + val = self.adw.Get_Par(channel) + if out_format == 'qty': + return self.aio.bit2qty(val, channel, absolute=True) + elif out_format == 'bit': + return val + else: + raise AdwinArgumentError + case str(): + raise AdwinNotImplementedError + case None: + if out_format == 'qty': + outs = np.empty(NB_OUTS) + outs.fill(np.NaN) + for i, _ in enumerate(outs): + val = self.adw.Get_Par(i+1) + outs[i] = self.aio.bit2qty(val, i+1, True) + elif out_format == 'bit': + outs = [] + for i in range(NB_OUTS): + outs.append(self.adw.Get_Par(i+1)) + else: + raise AdwinArgumentError + return outs + case _: + raise AdwinArgumentError + + def stop_sweep(self): + """ Stopping sweep process immediately """ + log.info('Adwin stopping: %s', self._sweep_process.name) + self.adw.Stop_Process(self._sweep_process_no) + + def set_output_buffer(self, outs, val_format='qty'): + ''' Set the buffer in which the Adwin saveds the current output + values of the DAC's (Par_1 - Par_8 so far). This can be + useful after a reboot of the adwin in which the adwin can + loose this information. ''' + if val_format in ['qty', 'wp']: + outs = self.aio.qty2bit(outs) + if len(outs) != NB_OUTS: + raise AdwinArgumentError + for idx, val in enumerate(outs): + self.adw.Set_Par(idx+1, int(val)) + + def _start_sweep(self, target, duration, delay=0.05): + # set sweep parameters + self.adw.Set_FPar(DURATION_FPAR, duration) + target_bits = self.aio.qty2bit(target) + self.adw.SetData_Long(target_bits, TARGET_DATA, 1, + len(target_bits)) + log.info('Adwin starting %.1f second sweep.', duration) + # initialize process + self.adw.Start_Process(self._sweep_process_no) + # start process after small delay to wait for init to calm down + sleep(delay) + self.adw.Set_Par(SWEEP_ACTIVE_PAR, 1) + + def _check_measurement_active(self): + # just check the state of the adwin driver. It could be done by + # reading the adwin's lockin_active par, but I want to limit + # communication + if self._state != 'measurement_ready': + log.critical('ADwin: measurement not initialized. Abort! ' + + 'Run init_measurement() first.') + raise AdwinModeError + + def _warn_if_fifo_to_small(self, duration): + if duration * self._params['sample_rate'] > FIFO_LEN: + log.warning('ADwin: Fifo holds values for max %s seconds.', + FIFO_LEN / self._params['sample_rate']) + +if __name__ == '__main__': + pass diff --git a/src/qkit/drivers/adwinlib/io_handler.py b/src/qkit/drivers/adwinlib/io_handler.py new file mode 100644 index 00000000..0b92d9df --- /dev/null +++ b/src/qkit/drivers/adwinlib/io_handler.py @@ -0,0 +1,292 @@ +''' The io_handler is meant to build the interface between the bit + values of the adc's and dac's and the physical quantities the user + wants to apply at the DUT. Therefore, i see the Adwin Outputs in + combination with everything between the adc/dac and the DUT: + * Magnetic fields: The current sources and the supraconducting + coils determine the translation factor between bit_values and + magnetic fields. + * Current outputs: voltage_dividers, gain_stages, and filters + determine the voltage which is applied at the sample. + * Inputs: IV_converters, gain_stages, voltage_dividers determine + what quantity is measured (can be voltage in 4-point measurement + or current in IV-converter measurements, inphase/quadrature for + lokin_measurmeent) + For all cases the outputs are defined in two seperate configs: + * Hard_config: Holds of config parameters, which need to be changed + by physically altering the setup and are not reguarly changed + like: output_channels, vector_magnet, current sources ... + * Soft_config: Holds all parameters, which can be easily changed + between measurements by flipping switches like voltage dividers. + * WARNING THIS SRIPT HANDLES ONLY 16 bit output channels! + +EXAMPLE CONFIGS: + +# 'hard wired' configuration of the adwin and accessories +hard_config = { + 'no_output_channels': 8, + 'outputs': { + 'bx': {'card': 3, 'channel': 1, 'scale': 0.995, 'unit': 'T', 'bits':16}, + 'by': {'card': 3, 'channel': 3, 'scale': 0.945, 'unit': 'T', 'bits':16}, + 'bz': {'card': 3, 'channel': 5, 'scale': 1.265, 'unit': 'T', 'bits':16}, + 'vg': {'card': 3, 'channel': 7, 'scale': 10, 'unit': 'V', 'bits':16}, + 'vd': {'card': 3, 'channel': 8, 'scale': 10, 'unit': 'V', 'bits':16} + }, + 'inputs': { + 'id': {'card': 2, 'channel': 8, 'scale': 10, 'unit': 'A', 'bits': 18} + } + } + +# between measurement 'switchable' configuration of adwin accessories +soft_config = { + 'vdivs': {'vg':0.5, 'vd':0.01}, + 'iv_gain': {'id':1e8}, + 'readout_channel': 'id' +} + +''' + +from copy import deepcopy +import math +from math import sqrt, atan2 +import logging as log +from numpy import ndarray, float32 +import numpy as np + +__version__ = '1.0_20240425' +__author__ = 'Luca Kosche' + +def bit2volt(val: int|float|ndarray|list, bits, vrange, absolute): + """ Calculate voltage from bit value for card with voltage range -10V + to 10V with 16-bits (default). + absolute=True: 0 -> -vrange + absolute=False: 0 -> 0""" + match val: + case float32() | float() | int() | np.int32(): + if absolute: + res = val * vrange / 2**(bits-1) - vrange + else: + res = val * vrange / 2**(bits-1) + return res + case list(): + return [bit2volt(v, bits, vrange, absolute) for v in val] + case ndarray(): + return np.vectorize(bit2volt)(val, bits, vrange, absolute) + case _: + raise AdwinArgumentError + +def volt2bit(val, bits=16, vrange=10, absolute=True): + """ Calculating bit value from voltage for card with voltage range -10V + to 10V with 16-bits (default). """ + bit0 = 2**(bits-1) + match val: + case float32() | float() | int(): + if not math.isnan(val): + if absolute: + res = round(val * bit0 / vrange + bit0) + if 0 <= res <= 2**bits: + return res + else: + res = round(val * bit0 / vrange) + if -bit0 <= res <= bit0: + return res + # if there is no return so far, raise error + raise AdwinInvalidOutputError + case list(): + return [volt2bit(v, bits, vrange) for v in val] + case ndarray(): + return np.vectorize(volt2bit)(val, bits, vrange) + case _: + raise AdwinArgumentError + +def calc_r(x, y): + ''' Calc R of lockin signal from X and Y. ''' + match x: + case int() | float(): + return sqrt(x**2 + y**2) + case list(): + return [calc_r(x[i], y[i]) for i in range(len(x))] + case np.ndarray(): + return np.vectorize(calc_r)(x, y) + +def calc_theta(x, y): + ''' Calc theta of lockin signal from X and Y. ''' + match x: + case int() | float(): + return atan2(y, x) + case list(): + return [calc_theta(x[i], y[i]) for i in range(len(x))] + case np.ndarray(): + return np.vectorize(calc_theta)(x, y) + +class AdwinTransmissionError(Exception): + """ Error which happens, when the adwin does send more or less than + expected samples during readout. There might be some handlers in + place accpeting some deviation """ + +class AdwinModeError(Exception): + """ Error when unsupported functions for the currently seleted mode + are used """ + +class AdwinLimitError(Exception): + """ Error when unsupported parameters are used for the Adwin + functions """ + +class AdwinInvalidOutputError(Exception): + """ Error when the Adwin is supposed to put out a value outside of + it's range """ + +class AdwinArgumentError(Exception): + """ Error raised, when function arguments are systematically of the + wrong type """ + +class AdwinNotImplementedError(Exception): + """ Error raised, when a specific case or function is not implemented""" + +class AdwinIO(): + ''' This class holds Adwin output and input configuration and + translates between physical quantities and bit_values values. + So far 16-bit output cards are assumed. ''' + def __init__(self, hard_config:dict, soft_config:dict): + # save a copy of hard_config (which should never be changed) + self.__hard_config = deepcopy(hard_config) + # save configuration outputs, in which the scaling factor will be + # updated by the soft_config and runtime changes + self._cfg = {'out': hard_config['outputs'], + 'in': hard_config['inputs']} + self._no_output_channels = hard_config['no_output_channels'] + # soft config + self._readout_ch = None + self.update_soft_config(**soft_config) + + def update_soft_config(self, + vdivs: dict = None, + iv_gain: dict = None, + readout_channel: str = None): + ''' update soft configuration parameters ''' + if readout_channel: + self._readout_ch = readout_channel + if vdivs: + self.set_voltage_diviers(vdivs) + if iv_gain: + self.set_iv_converters(iv_gain) + + def set_voltage_diviers(self, dividers: dict): + ''' set total voltage divider for output channels between + adwin and sample including dividers, gain or filters. + Sanity check might need an update. ''' + if isinstance(dividers, dict): + for name, vdiv in dividers.items(): + # sanity check + if not 0.0001 <= vdiv <= 1: + raise AdwinLimitError + base_scale = self.__hard_config['outputs'][name]['scale'] + self._cfg['out'][name]['scale'] = base_scale * vdiv + else: + raise AdwinArgumentError + + def set_iv_converters(self, iv_gain: dict): + ''' set the total gain of the iv_converters for input channels + (total gain of the IV_stage including potential voltage + or filters after the IV converter itself)''' + if isinstance(iv_gain, dict): + for name, gain in iv_gain.items(): + base_scale = self.__hard_config['inputs'][name]['scale'] + self._cfg['in'][name]['scale'] = base_scale / gain + else: + raise AdwinArgumentError + + def qty2bit(self, values:dict|ndarray|int|float, + channel:str|int=None, absolute:bool=True): + ''' Transform the physical quantities of the outputs into bit + values using the given information about the used setup + All configured output channels will be translated based on + the index in the given list. Index 0 will be treated as + output channel 1 an so for. All undefined channels will be + set to zero.''' + # check the type of values to decide what the function should do + match values: + # if values is dict, the keys should be channels, the values + # should be single values|list|array of values. + # Then for each channel the function will recursively be + # called to transform each channel seperately. + case dict(): + # create output array and initialize with DAC_ZERO + res = np.empty(self._no_output_channels) + res.fill(2**15) + for name, qty in values.items(): + if name in self._cfg['out']: + idx = self._cfg['out'][name]['channel'] - 1 + else: + msg = 'ADwinIO: neglected given input ch.' + log.warning(msg) + res[idx] = self.qty2bit(qty, name, absolute) + return res + # if channel number is given instead of name, translate + # into channel name (only works for output channels). + case list() | ndarray() | int() | float(): + if isinstance(channel, int): + channel = self._get_output_channel_name(channel) + if not self.is_channel(channel): + log.critical('ADwinIO: channel %s does not exist.', + channel) + raise AdwinArgumentError + inout = self._channel_direction(channel) + scale = self._cfg[inout][channel]['scale'] + bits = self._cfg[inout][channel]['bits'] + return volt2bit(values, bits, scale, absolute) + # in all other cases raise error + case _: + log.critical('AdwnIO: type(values) not supported.') + raise AdwinArgumentError + + + def bit2qty(self, values:ndarray|list|int|float, channel:str|int, + absolute:bool): + ''' Translate bit values of out/inputs physical quantity into bit value + using the information of the scaling factor of the out/input and + how many bits the corresponding card has. The value should be a + single value of a list of values of one channel.''' + if channel == 'readout': + channel = self._readout_ch + if isinstance(channel, int): + # Channel int should represent the output numnber of the channel + # starting from 1 + channel = self._get_output_channel_name(channel) + # Now the channel name should be known -> translate values + if self.is_channel(channel): + inout = self._channel_direction(channel) + scale = self._cfg[inout][channel]['scale'] + bits = self._cfg[inout][channel]['bits'] + return bit2volt(values, bits, scale, absolute) + elif channel is None: + return None + # if nothing could be returned, raise error + raise AdwinArgumentError + + def is_channel(self, channel:str): + ''' check if channel is configured ''' + if self._channel_direction(channel) in ['in', 'out']: + return True + return False + + def list_channels(self, inout:str): + ''' return a list of the names of all configured inout (inputs/outputs) + channels ''' + return self._cfg[inout].keys() + + def _channel_direction(self, channel): + if channel in self._cfg['out']: + return 'out' + if channel in self._cfg['in']: + return 'in' + return None + + def _get_output_channel_name(self, channel): + if isinstance(channel, int): + for key, val in self._cfg['out'].items(): + if val['channel'] == channel: + return key + return None + +if __name__ == '__main__': + pass diff --git a/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin.BAK b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin.BAK new file mode 100644 index 00000000..160883be --- /dev/null +++ b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin.BAK @@ -0,0 +1,222 @@ +' +' Process_Number = 1 +' Initial_Processdelay = 3000 +' Eventsource = Timer +' Control_long_Delays_for_Stop = No +' Priority = High +' Version = 1 +' ADbasic_Version = 6.4.0 +' Optimize = Yes +' Optimize_Level = 1 +' Stacksize = 1000 +' Info_Last_Save = DESKTOP-0M2IFQQ DESKTOP-0M2IFQQ\kaptn +'
+' ADwin lockin driver written by Luca Kosche in April 2024 +' Idea: +' * measure input at input_channel with 18-bit resolution +' * lockin signal output on lockin_channel +' * lockin demodulation by reference signal + low pass filtering +' * write (subsampled) lockin results and raw input to FIFOs (if measurement flag is set) + +' Background of implementation: +' * Delay between input and output leads to shifts and jitter +' * -> set output first, then fetch the already measured input +' * The lockin process is seperate from the sweep process to optimize for fast lockin out/input. +' * The lockin signal is calculated in the init and saved to an array to minimize calculation times +' * -> for the phase shifted references the same array is used, but the index is shifted by a quarter period. +' * length of the lockin_sig/lockin_ref arrays are limited by local memory and limit the frequency to min 62.5Hz. +' * -> This can easily be changed by increasing 'lockin_len' and removing 'at dm_local' at the expense of processing time. +' * Output and input cards and lockin channels are hard coded because this saves calculation time in event. +' * The lockin signal is always added to the bias value set by the sweep process. Only when the lockin is inctive, +' * the sweep process can write a value to the lockin output channel. + +'SPECIALITIES ABOUT T11 AND 18-BIT INPUT CARD: +'With T11 processor, it is crucial to optimize every command to archive the processdelay of 600, +'which which is the maximum sample rate of the 18-bit input card (500kHz | 2us) +'only the 18-bit card can work in timer mode enabled by "P2_ADCF_Mode(2, 1)". Thereby the card is +' automatically triggered to give a new measurement at the beginning of each event cycle. + +'WHAT COULD BE DONE WITH T12, 16-BIT INPUT CARD, FIFO OUTPUT CARD? +'Faster lockin cycle enabling higher lockin frequencies +'moving average in the 16-bit card. +'with output card with fifo, the lockin output could be handled by the fifo. + +#Include ADwinPro2.Inc + +'hard coded settings +#define input_card 2 +#define input_channel 7 +#define lockin_card 3 +#define lockin_channel 8 'this cannot simply changed here, but also needs to implemented fo2 adding lockin to channel +#define process_delay 600 'process time needs to be updated as well!!! +#define process_time 2E-6 'time of one event cycle +#define DAC_ZERO 32768 +#define DAC_ZERO_18 131072 +#define PI 3.1415927 +#define fifo_len 1000003 +#define lockin_len 8003 '8003 gives a minimum lockin frequency of 62.48Hz @ 2us cycle time. + +'communication PC ADwin +#define lockin_bias Par_8 'lock-in bias voltage (bits) +#define lockin_active Par_21 'lockin active flag +#define measure_active Par_22 +#define amplitude Par_24 'lock-in amplitude (bits) +#define frequency FPar_22 'lock_in frequency (Hz) +#define tao FPar_23 'lock_in tau: test purposes later only kappa will be given to program +#define report_frequency FPar_24 +#define sample_rate FPar_25 'sample rate +#define report_samplerate FPar_26 +#define fifo_inphase Data_1 +#define fifo_quadrature Data_2 +#define fifo_input Data_3 +'ADwin only +#define lockin_sig Data_10 +#define lockin_ref Data_11 + +'EVENT VARIABLES +dim lockin_sig[lockin_len] as long at dm_local 'lockin output signal in bit steps for output card +dim lockin_ref[lockin_len] as float at dm_local 'lockin reference normalized to 1 and shifted by one step because measurement happens one cycle after setting the output value +dim lockin_cycles, inph_cycle, quad_cycle, lockin_in, lockin_out, subs_cycle, subs_cycles as long +dim kappa, c0, c1, c2, c3, c4, s0, s1, s2, s3, s4 as float 'lockin demodulation and filter variables + +dim fifo_inphase[fifo_len], fifo_quadrature[fifo_len] as float as fifo 'output fifo for data transmittion +dim fifo_input[fifo_len] as long as fifo + +sub create_lockin_signal() + dim sig_phase, ref_phase as float + dim i as long + 'FIND HOW MANY lockin_cycles ARE NEEDED FOR ONE FULL SINE WAVE AT GIVEN FREQUENCY + lockin_cycles = Round(1 / (frequency * process_time)) + subs_cycles = Round(1 / (sample_rate * process_time)) + 'INCREASE TILL IT IS DEVIDABLY BY 4. (EASIER REFERENCE HANDLING, BUT ONLY CERTAIN FREQUENCIES POSSIBLE + if (lockin_cycles and 11b <> 0) then + do + Inc lockin_cycles + until (lockin_cycles and 11b = 0) + endif + 'REPORT ACTUAL FREQUENCY + report_frequency = 1 / (lockin_cycles * process_time) + report_samplerate = 1 / (subs_cycles * process_time) + 'CREATE LOCKIN SIN ARRAY + for i = 1 to lockin_len + if (i <= lockin_cycles) then + sig_phase = (i / lockin_cycles) * 2 * PI 'phase of lockin output signal + ref_phase = ((i-1.0) / lockin_cycles) * 2 * PI 'phase of reference has to lack one cycle behind output + lockin_sig[i] = Round(amplitude * sin(sig_phase)) ' BEFORE: sin(phase) + lockin_ref[i] = sin(ref_phase) + else + lockin_sig[i] = 0 'theoretically not necessary, just safety + lockin_ref[i] = 0 'theoretically not necessary, just safety + endif + next i +endsub + +sub init_lockin_filter() + c0 = 0 + c1 = 0 + c2 = 0 + c3 = 0 + c4 = 0 + s0 = 0 + s1 = 0 + s2 = 0 + s3 = 0 + s4 = 0 +endsub + +init: + 'DEBUG + 'lockin_bias = DAC_ZERO + 'amplitude = DAC_ZERO / 10 + 'frequency = 9100.31 + 'tao = 0.0033 + 'sample_rate = 500000 + Processdelay = process_delay + + 'CLEAR TRANSMITTION FIFOS + fifo_clear(1) + fifo_clear(2) + + 'CREATE LOCKIN SIGNAL AND REFERENCE + create_lockin_signal() + + 'INITIALITE FILTER + init_lockin_filter() + 'INIT IN-PHASE CYCLE FOR INPHASE DEMODULATION AND LOCKIN OUTPUT + inph_cycle = 1 + 'INIT IN-QUADRATURE CYCLE FOR IN_QUADRATURE DEMODULATION BY SHIFTING LOCKIN PHASE BY 90DEG AND CORRECT FOR NEGATIVE VALUE + quad_cycle = inph_cycle - Shift_Right(lockin_cycles, 2) + lockin_cycles + 'INIT subs_cycles CYCLE + subs_cycle = 1 + 'SET FILTER KONSTANT + kappa = 1 - exp(-process_time / tao) + + 'SET LOCKIN ACTIVE FLAG + lockin_active = 1 + + 'CALC FIRST LOCKIN OUTPUT + lockin_out = lockin_bias + lockin_sig[inph_cycle] + + 'ACTIVTATE TIMER MODE FOR 18-BIT INPUT CARD (MUST BE AT THE END OF INIT) + P2_ADCF_Mode(input_card, 1) + +event: + 'WRITE LOCKIN OUTPUT [3 lockin_cycles (+2 jitter, comm)] + P2_DAC(lockin_card, lockin_channel, lockin_out) + + 'READ LOCK-IN INPUT [88-93 lockin_cycles (+43 jitter, comm.)] + lockin_in = P2_Read_ADCF24(input_card, input_channel) '18-bit resolution + + '24 -> 18 BIT AND -OFFSET [5 lockin_cycles] + lockin_in = Shift_Right(lockin_in, 6) - DAC_ZERO_18 + + 'instead of idx_corr as function it could be done as sub and save some time! + s0 = lockin_in * 2 * lockin_ref[inph_cycle] + c0 = lockin_in * 2 * lockin_ref[quad_cycle] 'phase inph_cycle - 1 and shift by 90deg of the previous output + + '4 x 1st ORDER LOW PASS IN SERIES [91 lockin_cycles] + c1 = c1 + kappa * (c0-c1) + s1 = s1 + kappa * (s0-s1) + c2 = c2 + kappa * (c1-c2) + s2 = s2 + kappa * (s1-s2) + c3 = c3 + kappa * (c2-c3) + s3 = s3 + kappa * (s2-s3) + c4 = c4 + kappa * (c3-c4) ' output quadrature: c4 + s4 = s4 + kappa * (s3-s4) ' output in_phase: s4 + + 'TRANSMIT DATA TO PC [max 103 during cycles measurement, 11 cycles no measurement] + if (measure_active = 0) then + 'don't save data (faster this way, because else is processed faster than if) + else + 'SUBSAMPLE + if (subs_cycle < subs_cycles) then + Inc subs_cycle + else + subs_cycle = 1 + 'SEND DATAPOINT TO FIFO (27cycles per FIFO with no sweep) + fifo_inphase = s4 + fifo_quadrature = c4 + fifo_input = lockin_in + endif + endif + + 'HANDLE LOCKIN AND REFERENCE PHASE + if (inph_cycle = lockin_cycles) then + inph_cycle = 1 + else + Inc inph_cycle + endif + if (quad_cycle = lockin_cycles) then + quad_cycle = 1 + else + Inc quad_cycle + endif + + 'CALCULATE NEXT LOCKIN OUTPUT [13 lockin_cycles] + lockin_out = lockin_bias + lockin_sig[inph_cycle] + +finish: + ' SET OUTPUT TO LOCKIN_BIAS + P2_DAC(lockin_card, lockin_channel, lockin_bias) + ' DISABLE LOCKIN ACTIVE FLAG + lockin_active = 0 diff --git a/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin.TB1 b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin.TB1 new file mode 100644 index 00000000..9b1a9cf5 Binary files /dev/null and b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin.TB1 differ diff --git a/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin.bas b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin.bas new file mode 100644 index 00000000..3f187e43 --- /dev/null +++ b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin.bas @@ -0,0 +1,222 @@ +' +' Process_Number = 1 +' Initial_Processdelay = 3000 +' Eventsource = Timer +' Control_long_Delays_for_Stop = No +' Priority = High +' Version = 1 +' ADbasic_Version = 6.4.0 +' Optimize = Yes +' Optimize_Level = 1 +' Stacksize = 1000 +' Info_Last_Save = DESKTOP-0M2IFQQ DESKTOP-0M2IFQQ\kaptn +'
+' ADwin lockin driver written by Luca Kosche in April 2024 +' Idea: +' * measure input at input_channel with 18-bit resolution +' * lockin signal output on lockin_channel +' * lockin demodulation by reference signal + low pass filtering +' * write (subsampled) lockin results and raw input to FIFOs (if measurement flag is set) + +' Background of implementation: +' * Delay between input and output leads to shifts and jitter +' * -> set output first, then fetch the already measured input +' * The lockin process is seperate from the sweep process to optimize for fast lockin out/input. +' * The lockin signal is calculated in the init and saved to an array to minimize calculation times +' * -> for the phase shifted references the same array is used, but the index is shifted by a quarter period. +' * length of the lockin_sig/lockin_ref arrays are limited by local memory and limit the frequency to min 62.5Hz. +' * -> This can easily be changed by increasing 'lockin_len' and removing 'at dm_local' at the expense of processing time. +' * Output and input cards and lockin channels are hard coded because this saves calculation time in event. +' * The lockin signal is always added to the bias value set by the sweep process. Only when the lockin is inctive, +' * the sweep process can write a value to the lockin output channel. + +'SPECIALITIES ABOUT T11 AND 18-BIT INPUT CARD: +'With T11 processor, it is crucial to optimize every command to archive the processdelay of 600, +'which which is the maximum sample rate of the 18-bit input card (500kHz | 2us) +'only the 18-bit card can work in timer mode enabled by "P2_ADCF_Mode(2, 1)". Thereby the card is +' automatically triggered to give a new measurement at the beginning of each event cycle. + +'WHAT COULD BE DONE WITH T12, 16-BIT INPUT CARD, FIFO OUTPUT CARD? +'Faster lockin cycle enabling higher lockin frequencies +'moving average in the 16-bit card. +'with output card with fifo, the lockin output could be handled by the fifo. + +#Include ADwinPro2.Inc + +'hard coded settings +#define input_card 2 +#define input_channel 8 +#define lockin_card 3 +#define lockin_channel 8 'this cannot simply changed here, but also needs to implemented fo2 adding lockin to channel +#define process_delay 600 'process time needs to be updated as well!!! +#define process_time 2E-6 'time of one event cycle +#define DAC_ZERO 32768 +#define DAC_ZERO_18 131072 +#define PI 3.1415927 +#define fifo_len 1000003 +#define lockin_len 8003 '8003 gives a minimum lockin frequency of 62.48Hz @ 2us cycle time. + +'communication PC ADwin +#define lockin_bias Par_8 'lock-in bias voltage (bits) +#define lockin_active Par_21 'lockin active flag +#define measure_active Par_22 +#define amplitude Par_24 'lock-in amplitude (bits) +#define frequency FPar_22 'lock_in frequency (Hz) +#define tao FPar_23 'lock_in tau: test purposes later only kappa will be given to program +#define report_frequency FPar_24 +#define sample_rate FPar_25 'sample rate +#define report_samplerate FPar_26 +#define fifo_inphase Data_1 +#define fifo_quadrature Data_2 +#define fifo_input Data_3 +'ADwin only +#define lockin_sig Data_10 +#define lockin_ref Data_11 + +'EVENT VARIABLES +dim lockin_sig[lockin_len] as long at dm_local 'lockin output signal in bit steps for output card +dim lockin_ref[lockin_len] as float at dm_local 'lockin reference normalized to 1 and shifted by one step because measurement happens one cycle after setting the output value +dim lockin_cycles, inph_cycle, quad_cycle, lockin_in, lockin_out, subs_cycle, subs_cycles as long +dim kappa, c0, c1, c2, c3, c4, s0, s1, s2, s3, s4 as float 'lockin demodulation and filter variables + +dim fifo_inphase[fifo_len], fifo_quadrature[fifo_len] as float as fifo 'output fifo for data transmittion +dim fifo_input[fifo_len] as long as fifo + +sub create_lockin_signal() + dim sig_phase, ref_phase as float + dim i as long + 'FIND HOW MANY lockin_cycles ARE NEEDED FOR ONE FULL SINE WAVE AT GIVEN FREQUENCY + lockin_cycles = Round(1 / (frequency * process_time)) + subs_cycles = Round(1 / (sample_rate * process_time)) + 'INCREASE TILL IT IS DEVIDABLY BY 4. (EASIER REFERENCE HANDLING, BUT ONLY CERTAIN FREQUENCIES POSSIBLE + if (lockin_cycles and 11b <> 0) then + do + Inc lockin_cycles + until (lockin_cycles and 11b = 0) + endif + 'REPORT ACTUAL FREQUENCY + report_frequency = 1 / (lockin_cycles * process_time) + report_samplerate = 1 / (subs_cycles * process_time) + 'CREATE LOCKIN SIN ARRAY + for i = 1 to lockin_len + if (i <= lockin_cycles) then + sig_phase = (i / lockin_cycles) * 2 * PI 'phase of lockin output signal + ref_phase = ((i-1.0) / lockin_cycles) * 2 * PI 'phase of reference has to lack one cycle behind output + lockin_sig[i] = Round(amplitude * sin(sig_phase)) ' BEFORE: sin(phase) + lockin_ref[i] = sin(ref_phase) + else + lockin_sig[i] = 0 'theoretically not necessary, just safety + lockin_ref[i] = 0 'theoretically not necessary, just safety + endif + next i +endsub + +sub init_lockin_filter() + c0 = 0 + c1 = 0 + c2 = 0 + c3 = 0 + c4 = 0 + s0 = 0 + s1 = 0 + s2 = 0 + s3 = 0 + s4 = 0 +endsub + +init: + 'DEBUG + 'lockin_bias = DAC_ZERO + 'amplitude = DAC_ZERO / 10 + 'frequency = 9100.31 + 'tao = 0.0033 + 'sample_rate = 500000 + Processdelay = process_delay + + 'CLEAR TRANSMITTION FIFOS + fifo_clear(1) + fifo_clear(2) + + 'CREATE LOCKIN SIGNAL AND REFERENCE + create_lockin_signal() + + 'INITIALITE FILTER + init_lockin_filter() + 'INIT IN-PHASE CYCLE FOR INPHASE DEMODULATION AND LOCKIN OUTPUT + inph_cycle = 1 + 'INIT IN-QUADRATURE CYCLE FOR IN_QUADRATURE DEMODULATION BY SHIFTING LOCKIN PHASE BY 90DEG AND CORRECT FOR NEGATIVE VALUE + quad_cycle = inph_cycle - Shift_Right(lockin_cycles, 2) + lockin_cycles + 'INIT subs_cycles CYCLE + subs_cycle = 1 + 'SET FILTER KONSTANT + kappa = 1 - exp(-process_time / tao) + + 'SET LOCKIN ACTIVE FLAG + lockin_active = 1 + + 'CALC FIRST LOCKIN OUTPUT + lockin_out = lockin_bias + lockin_sig[inph_cycle] + + 'ACTIVTATE TIMER MODE FOR 18-BIT INPUT CARD (MUST BE AT THE END OF INIT) + P2_ADCF_Mode(input_card, 1) + +event: + 'WRITE LOCKIN OUTPUT [3 lockin_cycles (+2 jitter, comm)] + P2_DAC(lockin_card, lockin_channel, lockin_out) + + 'READ LOCK-IN INPUT [88-93 lockin_cycles (+43 jitter, comm.)] + lockin_in = P2_Read_ADCF24(input_card, input_channel) '18-bit resolution + + '24 -> 18 BIT AND -OFFSET [5 lockin_cycles] + lockin_in = Shift_Right(lockin_in, 6) - DAC_ZERO_18 + + 'instead of idx_corr as function it could be done as sub and save some time! + s0 = lockin_in * 2 * lockin_ref[inph_cycle] + c0 = lockin_in * 2 * lockin_ref[quad_cycle] 'phase inph_cycle - 1 and shift by 90deg of the previous output + + '4 x 1st ORDER LOW PASS IN SERIES [91 lockin_cycles] + c1 = c1 + kappa * (c0-c1) + s1 = s1 + kappa * (s0-s1) + c2 = c2 + kappa * (c1-c2) + s2 = s2 + kappa * (s1-s2) + c3 = c3 + kappa * (c2-c3) + s3 = s3 + kappa * (s2-s3) + c4 = c4 + kappa * (c3-c4) ' output quadrature: c4 + s4 = s4 + kappa * (s3-s4) ' output in_phase: s4 + + 'TRANSMIT DATA TO PC [max 103 during cycles measurement, 11 cycles no measurement] + if (measure_active = 0) then + 'don't save data (faster this way, because else is processed faster than if) + else + 'SUBSAMPLE + if (subs_cycle < subs_cycles) then + Inc subs_cycle + else + subs_cycle = 1 + 'SEND DATAPOINT TO FIFO (27cycles per FIFO with no sweep) + fifo_inphase = s4 + fifo_quadrature = c4 + fifo_input = lockin_in + endif + endif + + 'HANDLE LOCKIN AND REFERENCE PHASE + if (inph_cycle = lockin_cycles) then + inph_cycle = 1 + else + Inc inph_cycle + endif + if (quad_cycle = lockin_cycles) then + quad_cycle = 1 + else + Inc quad_cycle + endif + + 'CALCULATE NEXT LOCKIN OUTPUT [13 lockin_cycles] + lockin_out = lockin_bias + lockin_sig[inph_cycle] + +finish: + ' SET OUTPUT TO LOCKIN_BIAS + P2_DAC(lockin_card, lockin_channel, lockin_bias) + ' DISABLE LOCKIN ACTIVE FLAG + lockin_active = 0 diff --git a/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin_and_sweep.abp b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin_and_sweep.abp new file mode 100644 index 00000000..af159abe --- /dev/null +++ b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin_and_sweep.abp @@ -0,0 +1,5 @@ +ADbasic Project File 1002000 +2 +44 2 3 -1 -1 -1 -1 -9 -9 1929 1039 +".\Pro2_T11_lockin.bas" 0 44 0 1 -1 -1 -1 -1 0 0 1054 512 +".\Pro2_T11_sweep.bas" 0 44 2 3 -1 -1 -1 -1 -9 -38 1486 643 diff --git a/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin_and_sweep.abpx b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin_and_sweep.abpx new file mode 100644 index 00000000..b95d74bc --- /dev/null +++ b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_lockin_and_sweep.abpx @@ -0,0 +1,19 @@ + + + false + true + 1.0.0.1 + false + 11 + 6000 + 1 + false + + + + false + false + false + false + false + \ No newline at end of file diff --git a/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_sweep.BAK b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_sweep.BAK new file mode 100644 index 00000000..bbf77bd0 --- /dev/null +++ b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_sweep.BAK @@ -0,0 +1,124 @@ +' +' Process_Number = 2 +' Initial_Processdelay = 50000 +' Eventsource = Timer +' Control_long_Delays_for_Stop = No +' Priority = Low +' Priority_Low_Level = 1 +' Version = 1 +' ADbasic_Version = 6.4.0 +' Optimize = Yes +' Optimize_Level = 1 +' Stacksize = 1000 +' Info_Last_Save = DESKTOP-0M2IFQQ DESKTOP-0M2IFQQ\kaptn +'
+'Sweeps for spin transistor measurements written by Luca Kosche in April 2024 +'This script is written sweep up to all outputs in the most efficient way on T11 and 16-bit output card. +'If the lockin process is active, the lockin channel is not set by this script, but the bias value is set, +'which is handled by the locking. +'At the end of each sweep the current outputs are saved to the sweep_start array which serve as new starting point +'for the next sweep, if nothing else is given by the PC. Problems can arise after repowering or rebooting the adwin, +'because the sweep_start array might not be filled with the ecpected values. + +#Include ADwinPro2.Inc + +#define refresh_rate 5000 'sampling frequency of sweep process. (MCU_frequency / sweep_processdelay) +#define MCU_frequency 300E6 'Processor frequency +#define sweep_processdelay 60000 'must be high enough to don't overload ADwin. +#define DAC_ZERO 32768 +#define output_card 3 +#define nb_outs 8 'number of outputs + +#define out1 Par_1 +#define out2 Par_2 +#define out3 Par_3 +#define out4 Par_4 +#define out5 Par_5 +#define out6 Par_6 +#define out7 Par_7 +#define out8 Par_8 +#define sweep_active Par_20 +#define lockin_active Par_21 +#define measure_active Par_22 +#define duration FPar_20 'duration of the sweep (s) +#define report_duration FPar_21 +#define target Data_20 'sweep all outputs to these values (array of 8) + +dim start1, start2, start3, start4, start5, start6, start7, start8, cycle, steps as long +dim inc1, inc2, inc3, inc4, inc5, inc6, inc7, inc8 as float +dim target[nb_outs] as long at dm_local + + +init: + processdelay = sweep_processdelay + steps = Round(duration * refresh_rate) + report_duration = steps / refresh_rate + + ' SET START VALUES OF THE SWEEP + start1 = out1 + start2 = out2 + start3 = out3 + start4 = out4 + start5 = out5 + start6 = out6 + start7 = out7 + start8 = out8 + + ' SET INCREMENT VALUES OF THE SWEEP + inc1 = (target[1] - start1) / steps + inc2 = (target[2] - start2) / steps + inc3 = (target[3] - start3) / steps + inc4 = (target[4] - start4) / steps + inc5 = (target[5] - start5) / steps + inc6 = (target[6] - start6) / steps + inc7 = (target[7] - start7) / steps + inc8 = (target[8] - start8) / steps + + cycle = 0 + sweep_active = 0 + +event: + if (sweep_active = 0) then + 'Do nothing + else + ' SET MEASUREMENT FLAG TO START MEASUREMENT + measure_active = 1 + + ' GO TO THE NEXT CYCLE OR END PROCESS + if (cycle = steps) then + measure_active = 0 'set measurement active flag as early as possible to prevent sending extra data to PC + sweep_active = 0 + end + else + Inc cycle + endif + + ' CALCULATE NEW OUTPUTS AND WRITE TO PAR_1 - Par_8 + out1 = start1 + inc1 * cycle + out2 = start2 + inc2 * cycle + out3 = start3 + inc3 * cycle + out4 = start4 + inc4 * cycle + out5 = start5 + inc5 * cycle + out6 = start6 + inc6 * cycle + out7 = start7 + inc7 * cycle + out8 = start8 + inc8 * cycle + + ' SET ALL OUTPUTS EXCEPT LOCKIN CHANNEL (123 cycles) + ' this is the fastest way i found for T11 and F8/18 + P2_DAC(output_card, 1, out1) + P2_DAC(output_card, 2, out2) + P2_DAC(output_card, 3, out3) + P2_DAC(output_card, 4, out4) + P2_DAC(output_card, 5, out5) + P2_DAC(output_card, 6, out6) + P2_DAC(output_card, 7, out7) + + 'ONLY SET DAC OUTPUT IF LOCKIN IS INACTIVE + if (lockin_active = 0) then + P2_DAC(output_card, 8, out8) + endif + + endif + +finish: + diff --git a/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_sweep.TB2 b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_sweep.TB2 new file mode 100644 index 00000000..16787982 Binary files /dev/null and b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_sweep.TB2 differ diff --git a/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_sweep.bas b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_sweep.bas new file mode 100644 index 00000000..bbf77bd0 --- /dev/null +++ b/src/qkit/drivers/adwinlib/spin-transistor/Pro2_T11_sweep.bas @@ -0,0 +1,124 @@ +' +' Process_Number = 2 +' Initial_Processdelay = 50000 +' Eventsource = Timer +' Control_long_Delays_for_Stop = No +' Priority = Low +' Priority_Low_Level = 1 +' Version = 1 +' ADbasic_Version = 6.4.0 +' Optimize = Yes +' Optimize_Level = 1 +' Stacksize = 1000 +' Info_Last_Save = DESKTOP-0M2IFQQ DESKTOP-0M2IFQQ\kaptn +'
+'Sweeps for spin transistor measurements written by Luca Kosche in April 2024 +'This script is written sweep up to all outputs in the most efficient way on T11 and 16-bit output card. +'If the lockin process is active, the lockin channel is not set by this script, but the bias value is set, +'which is handled by the locking. +'At the end of each sweep the current outputs are saved to the sweep_start array which serve as new starting point +'for the next sweep, if nothing else is given by the PC. Problems can arise after repowering or rebooting the adwin, +'because the sweep_start array might not be filled with the ecpected values. + +#Include ADwinPro2.Inc + +#define refresh_rate 5000 'sampling frequency of sweep process. (MCU_frequency / sweep_processdelay) +#define MCU_frequency 300E6 'Processor frequency +#define sweep_processdelay 60000 'must be high enough to don't overload ADwin. +#define DAC_ZERO 32768 +#define output_card 3 +#define nb_outs 8 'number of outputs + +#define out1 Par_1 +#define out2 Par_2 +#define out3 Par_3 +#define out4 Par_4 +#define out5 Par_5 +#define out6 Par_6 +#define out7 Par_7 +#define out8 Par_8 +#define sweep_active Par_20 +#define lockin_active Par_21 +#define measure_active Par_22 +#define duration FPar_20 'duration of the sweep (s) +#define report_duration FPar_21 +#define target Data_20 'sweep all outputs to these values (array of 8) + +dim start1, start2, start3, start4, start5, start6, start7, start8, cycle, steps as long +dim inc1, inc2, inc3, inc4, inc5, inc6, inc7, inc8 as float +dim target[nb_outs] as long at dm_local + + +init: + processdelay = sweep_processdelay + steps = Round(duration * refresh_rate) + report_duration = steps / refresh_rate + + ' SET START VALUES OF THE SWEEP + start1 = out1 + start2 = out2 + start3 = out3 + start4 = out4 + start5 = out5 + start6 = out6 + start7 = out7 + start8 = out8 + + ' SET INCREMENT VALUES OF THE SWEEP + inc1 = (target[1] - start1) / steps + inc2 = (target[2] - start2) / steps + inc3 = (target[3] - start3) / steps + inc4 = (target[4] - start4) / steps + inc5 = (target[5] - start5) / steps + inc6 = (target[6] - start6) / steps + inc7 = (target[7] - start7) / steps + inc8 = (target[8] - start8) / steps + + cycle = 0 + sweep_active = 0 + +event: + if (sweep_active = 0) then + 'Do nothing + else + ' SET MEASUREMENT FLAG TO START MEASUREMENT + measure_active = 1 + + ' GO TO THE NEXT CYCLE OR END PROCESS + if (cycle = steps) then + measure_active = 0 'set measurement active flag as early as possible to prevent sending extra data to PC + sweep_active = 0 + end + else + Inc cycle + endif + + ' CALCULATE NEW OUTPUTS AND WRITE TO PAR_1 - Par_8 + out1 = start1 + inc1 * cycle + out2 = start2 + inc2 * cycle + out3 = start3 + inc3 * cycle + out4 = start4 + inc4 * cycle + out5 = start5 + inc5 * cycle + out6 = start6 + inc6 * cycle + out7 = start7 + inc7 * cycle + out8 = start8 + inc8 * cycle + + ' SET ALL OUTPUTS EXCEPT LOCKIN CHANNEL (123 cycles) + ' this is the fastest way i found for T11 and F8/18 + P2_DAC(output_card, 1, out1) + P2_DAC(output_card, 2, out2) + P2_DAC(output_card, 3, out3) + P2_DAC(output_card, 4, out4) + P2_DAC(output_card, 5, out5) + P2_DAC(output_card, 6, out6) + P2_DAC(output_card, 7, out7) + + 'ONLY SET DAC OUTPUT IF LOCKIN IS INACTIVE + if (lockin_active = 0) then + P2_DAC(output_card, 8, out8) + endif + + endif + +finish: + diff --git a/src/qkit/drivers/virtual_step_attenuator.py b/src/qkit/drivers/virtual_step_attenuator.py index 29a8f42c..0e310e31 100644 --- a/src/qkit/drivers/virtual_step_attenuator.py +++ b/src/qkit/drivers/virtual_step_attenuator.py @@ -10,7 +10,8 @@ def __init__(self, name): Instrument.__init__(self, name, tags=['virtual']) self.add_parameter('attenuation', type=float, - flags=Instrument.FLAG_SET, units='dB') + flags=self.FLAG_GETSET, units='dB') + self._attn = None def do_set_attenuation(self, attn): self._attn = attn diff --git a/src/qkit/gui/plot/plot.py b/src/qkit/gui/plot/plot.py index a13fc752..3790ea43 100644 --- a/src/qkit/gui/plot/plot.py +++ b/src/qkit/gui/plot/plot.py @@ -11,7 +11,7 @@ import qkit from qkit.storage import store -from qkit.storage.hdf_constants import ds_types +from qkit.storage.hdf_constants import ds_types, view_types from qkit.core.lib.misc import str3,concat import sys @@ -118,9 +118,9 @@ def __init__(self,h5_filepath, comment='', save_pdf=False): """Inits h5plot with a h5_filepath (string, absolute path), optional comment string, and optional save_pdf boolean. """ - if not plot_enable or not qkit.module_available("matplotlib"): - logging.warning("matplotlib not installed. I can not save your measurement files as png. I will disable this function.") - qkit.cfg['save_png'] = False + # if not plot_enable or not qkit.module_available("matplotlib"): + # logging.warning("matplotlib not installed. I can not save your measurement files as png. I will disable this function.") + # qkit.cfg['save_png'] = False if not qkit.cfg.get('save_png',True): return self.comment = comment @@ -173,16 +173,15 @@ def plt(self): self.x_ds_url = self.ds.attrs.get('x_ds_url','') self.y_ds_url = self.ds.attrs.get('y_ds_url','') self.z_ds_url = self.ds.attrs.get('z_ds_url','') - + self.view_type = self.ds.attrs.get('view_type','') self.fig = Figure(figsize=(20,10),tight_layout=True) - self.ax = self.fig.gca() self.canvas = FigureCanvas(self.fig) self._unit_prefixes = {24: 'Y', 21: 'Z', 18: 'E', 15: 'P', 12: 'T', 9: 'G', 6: 'M', 3: 'k', 0: '', -3: 'm', -6: u'µ', -9: 'n', -12: 'p', -15: 'f', -18: 'a', -21: 'z', -24: 'y'} self.plot_styles = {0:'-', 1:'.-', 2:'.'} if self.ds_type == ds_types['coordinate']: - #self.plt_coord() + self.plt_coord() return elif self.ds_type == ds_types['vector']: self.plt_vector() @@ -191,24 +190,29 @@ def plt(self): elif self.ds_type == ds_types['box']: self.plt_box() elif self.ds_type == ds_types['txt']: - #self.plt_txt() + self.plt_txt() return elif self.ds_type == ds_types['view']: - self.plt_view() + if self.view_type == view_types['1D-V']: + # self.plt_view() + return + elif self.view_type == view_types['polarplot']: + self.plt_polar() else: return ## Some labeling depending on the ds_type. The label variables are set ## in the respective plt_xxx() fcts. - self.ax.set_xlabel(self.x_label) - self.ax.set_ylabel(self.y_label) - self.ax.xaxis.label.set_fontsize(20) - self.ax.yaxis.label.set_fontsize(20) - self.ax.ticklabel_format(useOffset=False) - for i in self.ax.get_xticklabels(): - i.set_fontsize(16) - for i in self.ax.get_yticklabels(): - i.set_fontsize(16) + if not self.view_type: + self.ax.set_xlabel(self.x_label) + self.ax.set_ylabel(self.y_label) + self.ax.xaxis.label.set_fontsize(20) + self.ax.yaxis.label.set_fontsize(20) + self.ax.ticklabel_format(useOffset=False) + for i in self.ax.get_xticklabels(): + i.set_fontsize(16) + for i in self.ax.get_yticklabels(): + i.set_fontsize(16) save_name = str(os.path.basename(self.filedir))[0:6] + '_' + self.key.replace('/entry/','').replace('/','_') if self.comment: @@ -235,6 +239,7 @@ def plt_vector(self): No return variable. The function operates on the self- matplotlib objects. """ + self.ax = self.fig.gca() self.ax.set_title(self.hf._filename[:-3]+" "+str3(self.ds.attrs.get('name','_name_'))) self.y_data = np.array(self.ds) self.y_exp = self._get_exp(self.y_data) @@ -252,7 +257,7 @@ def plt_vector(self): #else: # plot_style = '-' try: - self.ax.plot(np.array(self.x_data)*10**int(-self.x_exp), self.y_data[0:len(self.x_data)]*10**int(-self.y_exp), plot_style) #JB: avoid crash after pressing the stop button when arrays are of different lengths + self.ax.plot(np.array(self.x_data)[0:len(self.y_data)]*10**int(-self.x_exp), self.y_data[0:len(self.x_data)]*10**int(-self.y_exp), plot_style) #JF: If measurement is stopped by watchdog, plots are still saved due to cropping of x-axis. except TypeError: self.ax.plot(0,self.y_data, plot_style) @@ -294,6 +299,7 @@ def plt_matrix(self): self.ds_data = np.flipud(self.ds_data) # plot + self.ax = self.fig.gca() self.ax.set_title(self.hf._filename[:-3]+" "+str3(self.ds.attrs.get('name','_name_'))) self.cax = self.ax.imshow(self.ds_data, extent=(x_min, x_max, y_min, y_max), @@ -350,6 +356,8 @@ def plt_box(self): self.ds_data = np.flipud(self.ds_data) # plot + + self.ax = self.fig.gca() self.ax.set_title(concat(self.hf._filename[:-3]," ",self.ds.attrs.get('name','_name_'))) self.cax = self.ax.imshow(self.ds_data, extent=(x_min, x_max, y_min, y_max), @@ -394,6 +402,8 @@ def plt_view(self): overlay_num = self.ds.attrs.get("overlays",0) overlay_urls = [] err_urls = [] + + self.ax = self.fig.gca() self.ax.set_title(self.hf._filename[:-3]+" "+str3(self.ds.attrs.get('name','_name_'))) # the overlay_urls (urls of the x and y datasets that ar plotted) are extracted from the metadata @@ -487,6 +497,65 @@ def plt_view(self): self.y_label += ' (' + self._unit_prefixes[y_exp] + self.y_unit + ')' self.ax.legend() + def plt_polar(self): + """ + Plot two-dimensional z dataset color-coded in y-coordinate + vs. x-coordinate polarplot. + x is the angle + y is a radius + z data with neagative radius y will be shifted by 180 degree in x, + so there are no negative radii in polarplot. + + Args: + self: Object of the h5plot class. + Returns: + No return variable. The function operates on the self- matplotlib + objects. + """ + urls = self.ds.attrs.get('xyz','') + print(urls) + self.x_ds_url, self.y_ds_url, self.z_ds_url = urls.split(":") + self.x_ds = self.hf[self.x_ds_url] + self.x_ds = np.array(self.x_ds) + self.x_exp = self._get_exp(self.x_ds) + self.x_name = concat(self.hf[self.x_ds_url].attrs.get('name', '_xname_')) + self.y_ds = self.hf[self.y_ds_url] + self.y_ds = np.array(self.y_ds) + self.y_exp = self._get_exp(self.y_ds) + self.y_unit = concat(self._unit_prefixes[self.y_exp] ,self.hf[self.y_ds_url].attrs.get('unit','_yunit_')) + self.z_ds = np.array(self.hf[self.z_ds_url]) #transpose matrix to get x/y axis correct + self.z_exp = self._get_exp(self.z_ds) + self.z_ds *= 10.**-self.z_exp + self.z_label = concat(self.hf[self.z_ds_url].attrs.get('name', '_name_'),' (',self._unit_prefixes[self.z_exp],self.hf[self.z_ds_url].attrs.get('unit', '_unit_'),')') + + + self.x_ds *= 10.**-self.x_exp + self.y_ds *= 10.**-self.y_exp + + sweeprange = [0, max(self.y_ds)] + polarsplit = int(len(self.y_ds[:]) / 2) + swp_neg = abs(self.y_ds[:polarsplit]) + swp_pos = self.y_ds[polarsplit:] + angle_pos = self.x_ds / 180 * np.pi + angle_neg = angle_pos + np.pi + stepvar = self.x_ds_url.split("/")[-1] + if self.z_ds.shape[0]*self.z_ds.shape[1] < len(self.x_ds) * len(self.y_ds): + # Handle incomplete data by filling with NaNs or zeros + data = np.full((len(self.x_ds), len(self.y_ds)), np.nan) + data.flat[:self.z_ds.shape[0]*self.z_ds.shape[1]] = self.z_ds + else: + data = self.z_ds + val = np.reshape(data.T, (len(self.y_ds), len(self.x_ds))) + val_neg = val[:polarsplit] + val_pos = val[polarsplit:] + # create polar colormap plot + self.ax = self.fig.add_subplot(polar=True) + self.ax.grid(False) + self.ax.set_yticks([]) + self.ax.pcolormesh(angle_pos, swp_pos, val_pos, shading='nearest') + self.ax.pcolormesh(angle_neg, swp_neg, val_neg, shading='nearest') + self.ax.set_title(f"Polarplot: angle: {self.x_name}, amplitude: {round(sweeprange[1])} {self.y_unit}") + def _get_exp(self, data): """ This function calculates the order of magnitude (exponent in steps of 3) to use for unit-prefix. diff --git a/src/qkit/gui/qviewkit/PlotWindow.py b/src/qkit/gui/qviewkit/PlotWindow.py index 302c7f32..f7cff170 100644 --- a/src/qkit/gui/qviewkit/PlotWindow.py +++ b/src/qkit/gui/qviewkit/PlotWindow.py @@ -27,14 +27,22 @@ import pyqtgraph as pg import numpy as np - +from matplotlib.figure import Figure +from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas import qkit from qkit.gui.qviewkit.plot_view import Ui_Form from qkit.storage.hdf_constants import ds_types, view_types -from qkit.gui.qviewkit.PlotWindow_lib import _display_1D_view, _display_1D_data, _display_2D_data, _display_table, _display_text +from qkit.gui.qviewkit.PlotWindow_lib import _init_polarplot,_display_polarplot, _display_1D_view, _display_1D_data, _display_2D_data, _display_table, _display_text from qkit.gui.qviewkit.PlotWindow_lib import _get_ds, _get_ds_url, _get_name, _get_unit from qkit.core.lib.misc import str3 + +class MplCanvas(FigureCanvas): + def __init__(self, parent=None, width=5.5, height=5, dpi=100): + fig = Figure(figsize=(width, height), dpi=dpi, tight_layout=True) + self.axes = fig.add_subplot(polar=True) + super(MplCanvas, self).__init__(fig) + class PlotWindow(QWidget,Ui_Form): """PlotWindow class organizes the correct display of data in a h5 file. @@ -135,13 +143,21 @@ def update_plots(self): self.VTraceYValueChanged = False # the following calls rely on ds_type and setup the layout of the plot window. - self.setupUi(self,self.ds_type, selector_label) + + if self.ds_type == ds_types['view']: + self.view_type = self.ds.attrs.get('view_type', None) + self.setupUi(self,self.ds_type, selector_label, self.view_type) + else: + self.setupUi(self,self.ds_type, selector_label) + + window_title = str(self.dataset_url.split('/')[-1]) +" "+ str(self.DATA.filename) self.setWindowTitle(window_title) self._setDefaultView() - self._setup_signal_slots() + if self.view_type != view_types['polarplot']: + self._setup_signal_slots() ## We check here for the view type given by either default setting or ## user input. Creates the canvas and calls the associated plot @@ -180,6 +196,18 @@ def update_plots(self): self.linestyle_selector.setDisabled(True) _display_2D_data(self,self.graphicsView) + elif self.view_type == view_types['polarplot']: + if not self.graphicsView or self._onPlotTypeChanged: + self._onPlotTypeChanged = False + self.graphicsView = MplCanvas(self, width=5, height=5, dpi=100) + self.gridLayout.addWidget(self.graphicsView) + self.coord_label = QLabel(self) + self.coord_label.setMaximumHeight(40) + self.coord_label.setStyleSheet(f"font-size: {16}px;") + self.gridLayout.addWidget(self.coord_label) + _init_polarplot(self, self.graphicsView) + _display_polarplot(self, self.graphicsView) + elif self.view_type == view_types['table']: if not self.graphicsView or self._onPlotTypeChanged: self._onPlotTypeChanged = False @@ -296,8 +324,13 @@ def _setDefaultView(self): self.view_type = view_types['txt'] elif self.ds_type == ds_types["view"]: - self.view_type = view_types['1D-V'] - self._defaultView() + if self.view_type == view_types['1D-V']: + self._defaultView() + elif self.view_type == view_types['polarplot']: + self._defaultPolarplot() + else: + self.view_type = view_types['1D-V'] + self._defaultView() else: self._defaultOld() @@ -344,6 +377,9 @@ def _defaultView(self): self.VTraceXNum = -1 self.VTraceYNum = -1 + def _defaultPolarplot(self): + pass + def _defaultOld(self): if not self.view_type: if len(self.ds.shape) == 1: @@ -531,7 +567,13 @@ def _init_XY_add(self): self.addYPlotSelector.setItemText(i, str(key)) #print i,key - + def on_mouse_move(self, event): + if event.inaxes: + theta = event.xdata + r = event.ydata + self.coord_label.setText(f"Theta: {np.degrees(theta):.2f}°, R: {r:.4f} T") + else: + self.coord_label.setText("") def _getXValueFromTraceNum(self,ds,num): x_ds = _get_ds(ds, ds.attrs.get('x_ds_url')) @@ -743,7 +785,6 @@ def setHistogram(self): if not self._windowJustCreated: self.obj_parent.pw_refresh_signal.emit() - from collections import OrderedDict class ImageViewMplColorMaps(pg.ImageView): diff --git a/src/qkit/gui/qviewkit/PlotWindow_lib.py b/src/qkit/gui/qviewkit/PlotWindow_lib.py index 3ae7eccc..4ed28e63 100644 --- a/src/qkit/gui/qviewkit/PlotWindow_lib.py +++ b/src/qkit/gui/qviewkit/PlotWindow_lib.py @@ -31,6 +31,7 @@ import numpy as np import json +from matplotlib.widgets import Cursor import pyqtgraph as pg import qkit from qkit.storage.hdf_constants import ds_types @@ -38,6 +39,88 @@ from qkit.core.lib.misc import str3 +def _init_polarplot(self, graphicsView): + graphicsView.mpl_connect('motion_notify_event', self.on_mouse_move) + # Cursor hinzufügen + self.cursor = Cursor(graphicsView.axes, useblit=True, color='red', linewidth=1) + # Initiale Daten plotten + xyzurls = str3(self.ds.attrs.get("xyz", "")) + ds_urls = [xyzurls.split(":")[0], xyzurls.split(":")[1], xyzurls.split(":")[2]] + if xyzurls: + dss, names, units, scales = _get_all_ds_names_units_scales(self.ds, ds_urls) + if dss[0] is None or dss[1] is None or dss[2] is None: + print("Could not load view xyz: " + str(xyzurls)+" : Datasets not found.") + ## retrieve the data type and store it in x_ds_type, y_ds_type + x_data = dss[0][()] + y_data = dss[1][()] + stepvar = names[0] + sweepunit = units[1] + sweeprange = [0, max(y_data)] + self.polarsplit = int(len(y_data[:]) / 2) + self.swp_neg = abs(y_data[:self.polarsplit]) + self.swp_pos = y_data[self.polarsplit:] + self.angle_pos = x_data / 180 * np.pi + self.angle_neg = self.angle_pos + np.pi + nans = np.full((len(x_data), len(y_data)), np.nan) + new_val = np.reshape(nans.T, (len(y_data), len(x_data))) + val_neg = new_val[:self.polarsplit] + val_pos = new_val[self.polarsplit:] + graphicsView.axes.grid(False) + graphicsView.axes.set_yticks([]) + self.pos_mesh = graphicsView.axes.pcolormesh(self.angle_pos, self.swp_pos, val_pos, shading='nearest') + self.neg_mesh = graphicsView.axes.pcolormesh(self.angle_neg, self.swp_neg, val_neg, shading='nearest') + graphicsView.axes.set_title(f'angle: {stepvar}, amplitude: {round(sweeprange[1], 2)} {sweepunit}') + graphicsView.draw() + +def _display_polarplot(self, graphicsView): + """displays a 2d matrix of data color coded in a polarplot. + + Args: + self: Object of the PlotWindow class. + graphicsView: Modified object of matplotlib's FigureCanvasQTAgg class. + + Returns: + No return variable. The function operates on an object of the + PlotWindow class. + """ + xyzurls = str3(self.ds.attrs.get("xyz", "")) + ds_urls = [xyzurls.split(":")[0], xyzurls.split(":")[1], xyzurls.split(":")[2]] + if xyzurls: + dss, names, units, scales = _get_all_ds_names_units_scales(self.ds, ds_urls) + if dss[0] is None or dss[1] is None or dss[2] is None: + print("Could not load view xyz: " + str(xyzurls)+" : Datasets not found.") + ## retrieve the data type and store it in x_ds_type, y_ds_type + x_ds_type = dss[0].attrs.get('ds_type', "ds_types['coordinate']") + y_ds_type = dss[1].attrs.get('ds_type', "ds_types['coordinate']") + z_ds_type = dss[2].attrs.get('ds_type', "ds_types['matrix']") + x_data = dss[0][()] + y_data = dss[1][()] + z_data = dss[2][()] + if z_data.shape[0]*z_data.shape[1] < len(x_data) * len(y_data): + # Handle incomplete data by filling with NaNs or zeros + data = np.full((len(x_data), len(y_data)), np.nan) + data.flat[:z_data.shape[0]*z_data.shape[1]] = z_data + else: + data = z_data + self.complete = True + new_val = np.reshape(data.T, (len(y_data), len(x_data))) + + # Daten für die Polar Heatmap vorbereiten + val_neg = new_val[:self.polarsplit] + val_pos = new_val[self.polarsplit:] + + # Alte pcolormesh-Objekte entfernen + self.pos_mesh.remove() + self.neg_mesh.remove() + + # Neue pcolormesh-Objekte erstellen + self.pos_mesh = graphicsView.axes.pcolormesh(self.angle_pos, self.swp_pos, val_pos, shading='nearest') + self.neg_mesh = graphicsView.axes.pcolormesh(self.angle_neg, self.swp_neg, val_neg, shading='nearest') + + # Canvas neu zeichnen + graphicsView.draw() + + def _display_1D_view(self, graphicsView): """displays the 1d plot(s) views from the respective datasets. @@ -401,7 +484,6 @@ def _display_1D_data(self, graphicsView): dss, names, units, scales = _get_all_ds_names_units_scales(self.ds, ['x_ds_url']) x_data = dss[0][()][:dss[1].shape[0]] y_data = dss[1][()][:, self.TraceYNum, self.TraceZNum] - ## Any data manipulation (dB <-> lin scale, etc) is done here x_data, y_data, names[0], names[1], units[0], units[1] = _do_data_manipulation(x_data, diff --git a/src/qkit/gui/qviewkit/plot_view.py b/src/qkit/gui/qviewkit/plot_view.py index baf83934..cc720a35 100644 --- a/src/qkit/gui/qviewkit/plot_view.py +++ b/src/qkit/gui/qviewkit/plot_view.py @@ -23,7 +23,7 @@ sys.exit(-1) import qkit -from qkit.storage.hdf_constants import ds_types +from qkit.storage.hdf_constants import ds_types, view_types try: _fromUtf8 = QtCore.QString.fromUtf8 @@ -48,7 +48,7 @@ class Ui_Form(object): setupUi() creates the overall window and ds_type sensitive signal slots are added by the respective functions. """ - def setupUi(self, Form,ds_type, selector_labels): + def setupUi(self, Form, ds_type, selector_labels, view_type=None): """Sets up the general window This function coordinates the changing input from the signal slots and @@ -105,8 +105,10 @@ def setupUi(self, Form,ds_type, selector_labels): if ds_type == ds_types['txt']: self.setupTxt(Form) if ds_type == ds_types['view']: - self.setupView(Form) - + if view_type == view_types['1D-V']: + self.setupView(Form) + elif view_type == view_types['polarplot']: + pass def setupCoordinate(self,Form): # see setupVector() self.setupVector(Form) diff --git a/src/qkit/measure/magnetoconductance/default_adwin_config.py b/src/qkit/measure/magnetoconductance/default_adwin_config.py new file mode 100644 index 00000000..bdfd3d7c --- /dev/null +++ b/src/qkit/measure/magnetoconductance/default_adwin_config.py @@ -0,0 +1,21 @@ +# default config for adwin +# 'hard wired' configuration of the adwin and accessories +default_hard_config = { + 'no_output_channels': 8, + 'outputs': { + 'bx': {'card': 3, 'channel': 1, 'scale': 0.995, 'unit': 'T', 'bits':16}, + 'by': {'card': 3, 'channel': 3, 'scale': 0.945, 'unit': 'T', 'bits':16}, + 'bz': {'card': 3, 'channel': 5, 'scale': 1.265, 'unit': 'T', 'bits':16}, + 'vg': {'card': 3, 'channel': 7, 'scale': 10, 'unit': 'V', 'bits':16}, + 'vd': {'card': 3, 'channel': 8, 'scale': 10, 'unit': 'V', 'bits':16} + }, + 'inputs': { + 'id': {'card': 2, 'channel': 7, 'scale': 10, 'unit': 'A', 'bits': 18} + } + } + # between measurement 'switchable' configuration of adwin accessories +default_soft_config = { + 'vdivs': {'vg':0.5, 'vd':0.01}, + 'iv_gain': {'id':1e8}, + 'readout_channel': 'id' + } \ No newline at end of file diff --git a/src/qkit/measure/magnetoconductance/measurement_script.py b/src/qkit/measure/magnetoconductance/measurement_script.py new file mode 100644 index 00000000..c273e547 --- /dev/null +++ b/src/qkit/measure/magnetoconductance/measurement_script.py @@ -0,0 +1,727 @@ +''' The measurement script is a class to describe and run + a 1D or 2D measurement, therefore several vars must be set. + These variables describe the working points (wp) to sweep between + during the measurement. Additional needed parameter is the mode + (normal/sweep) of the wp, more about this in the wp class. + The measurement can run with and without lockin signal, + if there should no lockin signal be applied, set no amplitude + or set amplitude to zero. + + *Required keywords: + -anna: *adwin instrument + + (all below listed variables are saved as dictionaries, + some vars vaulues are restricted to certain values, + these are defined in the init of the class as valid values) + + -sph: *spherical coordinates and values for wp + *phi, theta, psi, bp, bt + *if a sph coordinate is used as step or sweep var + it is not needed, because the value will be overwritten + + -modes: *mode of wp and measure mode + *wp: normal, sweep; measure: sweep, static + *the "static" measure mode is not yet implemented! + + -volts: *source-drain and gate voltage + *vd, vg + + -sweep: *vars to generate virtual sweep values array + *name, start, stop, unit + *optional: rate, duration + *if no rate or duration is set, max_rate_config of sweep var will be used + + -step: *vars to generate step values array (only needed for 2D measurement) + *name, start, stop, stepsize, unit + *stop value is incuded in step values array + + -inputs: *inputs to measure and return from adwin instrument + *raw, inph, quad (for "inph" and "quad" is a lockin signal required) + *optional: retrace (default=False, describes if retrace is measured) + *if "save" is set in data, needed outputs will be generated automatically + + -data: *vars that should be saved and plotted from the measurement + *save: (traces, inputs); plot: (traces, inputs) + *traces and inputs in "plot" will automatically be added to save, + cause its required to save the data to plot it with qviewkit. + *additional inputs: amp, phase (inph, quad needed for calculation) + + *Optional keywords: + -h5_path: *path of .h/hdf5 file to extract and load measurement config + from previous measurement + + + *ToDo: -static measurement: *measurement without sweep or step + -interactive measurement: *measurement with adwin communication while sweep + !!! B to zero, all to zero !!! + +''' +#imports +import logging as log +import numpy as np +import json +import time +import h5py +import qkit +from qkit.measure.magnetoconductance.spin_tune_ST import Tuning_ST +from qkit.measure.magnetoconductance.working_point import WorkingPoint +from qkit.drivers.adwin_spin_transistor import adwin_spin_transistor + + +def calc_r(x, y): + ''' calc func for amplitude from lockin''' + return np.sqrt(np.square(x) + np.square(y)) + +def calc_theta(x, y): + ''' calc func for phase shift from lockin''' + return np.arctan2(y, x) + +class MeasurementScript(): + ''' The Measurement Script generates a + measurement routine with given params''' + + def __init__(self, adwin:adwin_spin_transistor, + h5_path=None, **kwargs): + self.def_valids() # define valid inputs for params + self.setup_params() # setup needed measurement params + self.def_setter() # define params setter funcs + + # load measurement params from h5file + if h5_path is not None: + self.load_config(h5_path) + + self.set_(**kwargs) # set imported param values + + self.anna = adwin # connect ADwin instrument + + self.update_script() # generate measurement routine + + def def_valids(self): + ''' define validations''' + self.valid_step_vars = ['vg','vd','N','bt','bp','phi','psi','theta'] + self.valid_sweep_vars = ['vg','vd','bt','bp','phi','psi','theta'] + self.valid_wp_mode = ['normal','sweep'] + self.valid_measure_mode = ['static','sweep'] # static mode not availible yet + self.valid_inputs = ['raw','inph','quad'] + self.valid_traces = ['trace','retrace','difference'] + self.valid_calc = ['amp','phase'] + self.max_rate_config = {'bx':0.1,'by':0.1,'bz':0.1,'bp':0.1,'bt':0.1,'vg':0.1,'vd':0.1} # rate in T(/V) per sec + self.unit = {'inph':'S','quad':'S','raw':'V','amp':'S','phase':'rad'} + self.valids = {'step':self.valid_step_vars,'sweep':self.valid_sweep_vars, + 'wp':self.valid_wp_mode,'measure':self.valid_measure_mode, + 'traces':self.valid_traces,'inputs':self.valid_inputs, + 'calc':self.valid_calc,'maxrate':self.max_rate_config} + + def setup_params(self): + ''' setup params for the measurement''' + self._sph = {'theta': 0, 'phi': 0, 'psi': 0, 'bp': 0, 'bt': 0} + self._sweep = {'name':None,'start':None,'stop':None,'unit':None, + 'rate':None,'duration':None,'values':None} + self._step = {'name':None,'start':None,'stop':None,'unit':None, + 'step_size':None,'values':None} + self._modes = {'wp':None,'measure':None} + self._volts = {'vd':None,'vg':None} + self._lockin = {'freq':None,'amp':None,'tao':None,'init_time':None,'sample_rate':500e3} + self._inputs = {'retrace':False,'inputs':[]} + self._data = {'temp_save':{'inph':[],'quad':[],'raw':[], + 'amp':[],'phase':[]}, + 'save':{'inph':[],'quad':[],'raw':[], + 'amp':[],'phase':[]}, + 'plot':{'inph':[],'quad':[],'raw':[], + 'amp':[],'phase':[]}} + + def def_setter(self): + ''' define setter functions of params''' + self.set_functions = {'sph':self.set_sph,'sweep':self.set_sweep,'step':self.set_step, + 'modes':self.set_modes,'volts':self.set_volts,'lockin':self.set_lockin, + 'data':self.set_data,'hard_config':self.set_hard_config, + 'soft_config':self.set_soft_config,'adwin_bootload':self.set_adwin_bootload} + + def update_script(self): + ''' genererate measurement setup''' + self.create_output_channel()# create output channel for adwin + self.add_saves() # generate data save and temp_save dicts + self.add_inputs() # generate ADwin inputs + self.start_lockin() # start lockin signal + self.update_lockin() # get real lockin data from adwin + + self.generate_sweep() # generate sweep values + self.generate_steps() # generate step values + + self.init_wps() # init start and stop wp of first sweep + self.start_sweep() # start sweep to the first wp + + self.create_tuning() # create Tuning_ST instance + self.create_inputs() # create a dict of the input nodes + self.register_measurement() # register measure function + self.set_node_bounds() # create bounds for input variables + self.activate_measurement() # activate measurement + self.set_parameter() # set x/y coordinate parameter + self.prepare_measurement_datasets() + self.prepare_measurement_datafile() + + self.show_plots() # determine names from datasets to plot + self.add_view() # add view datasets + + def end_measurement(self): + ''' end measurement''' + self.anna.stop_measurement() + self.tune._qvk_process.terminate() + + def prepare_measurement_datasets(self): + ''' prepare datasets for measurement''' + if self.dim == 2: + self.ds = self.tune.multiplexer.prepare_measurement_datasets([self._x_parameter, self._y_parameter]) + elif self.dim == 1: + self.ds = self.tune.multiplexer.prepare_measurement_datasets([self._x_parameter]) + + def prepare_measurement_datafile(self): + ''' prepare .hdf/h5 file for measurement''' + self.tune._prepare_measurement_file(self.ds) + self.coordinates = self.tune._coordinates + self.datasets = self.tune._datasets + self.datafile = self.tune._data_file + + def create_tuning(self): + ''' creates instance of class Tuning_ST(Tuning)''' + self.tune = Tuning_ST() + self.tune.qviewkit_singleInstance = True + + def create_output_channel(self): + ''' create output channel dictionary''' + self.outs = {key: val['channel'] for key, val in self.hard_config['outputs'].items()} + + def show_plots(self): + ''' create list of datasets to plot''' + plotted_data = [] + if self._modes['measure'] == 'sweep': + for key, val in self._data['plot'].items(): + for key1 in val: + plotted_data.append(f'sweep_measure.{key}_{key1}') + if plotted_data: + self.plots = plotted_data + else: + self.plots = None + + def start_measurement(self): + ''' start activated measurement''' + self.save_config() + if self.dim == 1: + self.tune.measure1D(self.plots) + elif self.dim == 2: + self.tune.measure2D(self.plots) + else: + assert ModuleNotFoundError + + def add_view(self): + ''' adds 1D views''' + for key in self.inputs_dict.keys(): + if 'retrace' in key: + if self.dim == 2: + view = self.datafile.add_view(name=key.replace("_retrace",""),x=self.coordinates[self._y_parameter.name],y=self.datasets['sweep_measure.'+key]) + view.add(x=self.coordinates[self._y_parameter.name], y=self.datasets['sweep_measure.'+key.replace("retrace","trace")]) + else: + view = self.datafile.add_view(name=key.replace("_retrace",""), x=self.coordinates[self._x_parameter.name], y=self.datasets['sweep_measure.'+key]) + view.add(x=self.coordinates[self._x_parameter.name], y=self.datasets['sweep_measure.'+key.replace("retrace","trace")]) + if 'difference' in key: + if self.dim == 2: + view = self.datafile.add_view(name=key, x=self.coordinates[self._y_parameter.name], y=self.datasets['sweep_measure.'+key]) + else: + view = self.datafile.add_view(name=key, x=self.coordinates[self._x_parameter.name], y=self.datasets['sweep_measure.'+key]) + if 'amp_difference' in self.inputs_dict.keys(): + if 'deg' in self._step.get('unit') or '°' in self._step.get('unit'): + view = self.datafile.add_polarview(name='polar_colormap', x=self.coordinates[self._x_parameter.name], y=self.coordinates[self._y_parameter.name], z=self.datasets['sweep_measure.amp_difference']) + + def set_parameter(self): + ''' setter for x/y parameter of measurement''' + if self.dim == 1: + self.tune.set_x_parameters(self._sweep['values'], self._sweep['name'], None, self._sweep['unit']) + self._x_parameter = self.tune._x_parameter + elif self.dim == 2: + self.tune.set_x_parameters(self._step['values'], self._step['name'], self.wp_setter, self._step['unit']) + self.tune.set_y_parameters(self._sweep['values'], self._sweep['name'], None, self._sweep['unit']) + self._x_parameter = self.tune._x_parameter + self._y_parameter = self.tune._y_parameter + + def update_lockin(self): + ''' updates the sample rate and lockin frequency data in the script + with real data readout from adwin -> no new lockin signal''' + self.set_lockin(**{'freq':self.anna.adw.Get_FPar(24),'sample_rate':self.anna.adw.Get_FPar(26)}) + + def get_wp(self): + ''' getter function for last working point of adwin''' + return self.anna.read_outputs() + + def start_sweep(self): + ''' start sweep from adwin outputs to the first wp of the measurement''' + outs_start = self.get_wp() + start_time=0 + for key,val in self.wp_start.outs.items(): + duration = abs(val - outs_start[self.hard_config['outputs'][key]['channel']-1])/self.valids['maxrate'][key] + if start_time < duration: + start_time = duration + log.info(f"Sweeping to start working point! Sweep durtion is {round(start_time,2)}s") + self.ramp_to_wp(dt=start_time) + time.sleep(5) + + def get_hard_config(self): + ''' getter function for hard config of adwin''' + return self.hard_config + + def get_soft_config(self): + ''' getter function for soft config of adwin''' + return self.soft_config + + def start_lockin(self): + ''' start lockin signal''' + if self._lockin['amp']: + self.anna.init_measurement('lockin', self._lockin['sample_rate'], bias=self._volts['vd'], inputs=self._inputs['inputs'], + amplitude=self._lockin['amp'], frequency=self._lockin['freq'], tao=self._lockin['tao']) + else: + log.warning("No lockin signal applied!") + self.stop_lockin() + time.sleep(1) + + def stop_lockin(self): + ''' stop lockin signal''' + self.anna.init_measurement('lockin', sample_rate=100, bias=self._volts['vd'], inputs=['raw'], + amplitude=0, frequency=100, tao=1/100) + + def sweep_measure(self): + ''' measure sweep and generate data dict''' + trace,retrace=None,None + trace = self.anna.sweep_measure(self.wp_stop.outs, duration=self._sweep['duration']) + if self._inputs['retrace']: + retrace = self.anna.sweep_measure(self.wp_start.outs, duration=self._sweep['duration']) + sample_rate = int(self.anna.adw.Get_FPar(26)*self.anna.adw.Get_FPar(21)) + values_dict = {} # dictionary contains all the data required to calculate the data to be saved + for key,val in self._data['temp_save'].items(): + if val: + if key in self.valid_inputs: # inph, quad and raw data + tr, rt, diff = [], [], [] + for key1 in val: + if key1 == 'trace': + tr = trace[key].astype(np.float32)[:sample_rate] + elif key1 == 'retrace': + rt = np.flip(retrace[key].astype(np.float32)[:sample_rate]) + if 'difference' in val: + if isinstance(tr, np.ndarray) and isinstance(rt, np.ndarray): + diff = rt - tr + else: + assert ValueError + if isinstance(tr, np.ndarray): + values_dict[f'{key}_trace']=tr + if isinstance(rt, np.ndarray): + values_dict[f'{key}_retrace']=rt + if isinstance(diff, np.ndarray): + values_dict[f'{key}_difference']=diff + for key,val in self._data['temp_save'].items(): # amp and phase data calculation + if val: + if key in self.valid_calc: + amp, phase = {'trace':[],'retrace':[],'difference':[]}, {'trace':[],'retrace':[],'difference':[]} + for key1 in val: + if (values_dict.get(f'inph_{key1}') is not None) and (values_dict.get(f'quad_{key1}') is not None): + if key == 'amp': + amp[key1] = calc_r(values_dict.get(f'inph_{key1}'), values_dict.get(f'quad_{key1}')) + elif key == 'phase': + phase[key1] = calc_theta(values_dict.get(f'inph_{key1}'), values_dict.get(f'quad_{key1}')) + else: + assert KeyError + else: + assert ValueError + if 'difference' in val: + if key == 'amp': + if isinstance(amp['trace'],np.ndarray) and isinstance(amp['retrace'],np.ndarray): + amp[key1] = amp.get('retrace') - amp.get('trace') + else: + assert ValueError + elif key == 'phase': + if isinstance(phase['trace'],np.ndarray) and isinstance(phase['retrace'],np.ndarray): + phase[key1] = phase.get('retrace') - phase.get('trace') + else: + assert ValueError + else: + assert KeyError + for key1,val1 in amp.items(): + if isinstance(val1, np.ndarray): + values_dict[f'{key}_{key1}']=val1 + for key1,val1 in phase.items(): + if isinstance(val1, np.ndarray): + values_dict[f'{key}_{key1}']=val1 + save_dict = {} # dictionary with the data to be saved + for key, val in self._data['save'].items(): + for key1 in val: + save_dict[f'{key}_{key1}'] = values_dict[f'{key}_{key1}'] + return save_dict + + def create_inputs(self): + ''' create dictionary for measurement inputs with unit''' + self.inputs_dict = {} + for key, val in self._data['save'].items(): + for key1 in val: + self.inputs_dict[f'{key}_{key1}'] = self.unit[key] + + def register_measurement(self): + ''' register measurement with needed data input dict''' + if self._modes['measure'] == 'sweep': + self.tune.register_measurement('sweep_measure', self.inputs_dict, self.sweep_measure) + + def set_node_bounds(self): + ''' set bounds for data input dict''' + if self._modes['measure'] == 'sweep': + for key,val in self.inputs_dict.items(): + self.tune.set_node_bounds('sweep_measure', key, -10e9, 10e9) + def activate_measurement(self): + ''' activate measurement''' + if self._modes['measure'] == 'sweep': + self.tune.activate_measurement('sweep_measure') + + def init_wps(self): + self.wp_start = WorkingPoint(self.outs.keys(), magnet='vector3d') + self.wp_start.set_sph(**self._sph) + self.wp_start.set_wp(**self._volts) + self.wp_start.set_mode(self._modes['wp']) + self.wp_stop = WorkingPoint(self.outs.keys(), magnet='vector3d') + self.wp_stop.set_sph(**self._sph) + self.wp_stop.set_wp(**self._volts) + self.wp_stop.set_mode(self._modes['wp']) + if (self._sweep['name'] in self.wp_start.get_sph().keys()): + self.wp_start.set_sph(**{self._sweep['name']:self._sweep['start']}) + self.wp_stop.set_sph(**{self._sweep['name']:self._sweep['stop']}) + elif (self._sweep['name'] in self.wp_start._outputs.keys()): + self.wp_start.set_wp(**{self._sweep['name']:self._sweep['start']}) + self.wp_stop.set_wp(**{self._sweep['name']:self._sweep['stop']}) + if self.dim == 2: + self.set_start_wp() + self.set_stop_wp() + + def set_start_wp(self,**kwargs): + ''' setter function for start working point of sweep''' + if self._step['name'] in self.wp_start.get_sph().keys(): + self.wp_start.set_sph(**kwargs) + elif self._step['name'] in self.wp_start._outputs.keys(): + self.wp_start.set_wp(**kwargs) + + def set_stop_wp(self,**kwargs): + ''' setter function for stop working point of sweep''' + if self._step['name'] in self.wp_stop.get_sph().keys(): + self.wp_stop.set_sph(**kwargs) + elif self._step['name'] in self.wp_stop._outputs.keys(): + self.wp_stop.set_wp(**kwargs) + + def ramp_to_wp(self,dt): + ''' sweep to wp without measurement''' + self.anna.sweep(self.wp_start.outs,duration=dt) + + def wp_setter(self, x=None, dt=None): + ''' set new step val of step var for wp''' + if self._inputs['retrace']: + temp_wp_outs=self.wp_start.outs + else: + temp_wp_outs=self.wp_stop.outs + self.set_start_wp(**{self._step['name']:x}) + self.set_stop_wp(**{self._step['name']:x}) + min_duration=0 + for key,val in self.wp_start.outs.items(): + duration = abs(val - temp_wp_outs[key])/self.max_rate_config[key] + if min_duration < duration: + min_duration = duration + if dt is None: + dt = min_duration + elif dt this module handles the translation from the abstract spherical + representation to the cartesian 3D vector magnets used in the + experiment + * voltages applied to the transistor + + ToDO: * No init values for magnetic field and error handling if no valid + values are set by the user. (this makes sure that after a restart + of the software the magnetic fields are not accidently turned off + but the user has to set explisit values in the measurement script + ). + ''' + +__all__ = ['VectorMagnet3D', 'WorkingPoint'] +__version__ = '0.1_20240515' +__author__ = 'Luca Kosche' + +from numpy import cos, sin, pi, NaN + +class MagnetUnderdefinedError(Exception): + """ Error which is thrown when the VectorMagnet has not enough + parameters to calculate """ + +def grad2rad(grad): + """ Transform angle in grad to rad """ + return grad * 2 * pi / 360 + +class VectorMagnet3D(): + ''' The vectormagnet class is designed to translate 3D B-field + vectors in spherical coordinates to experimentally applicable + cartesian coordinates of the 3D Vector magnet. + There are two supported modes: "sweep" and "normal" mode. + "sweep": THETA and PHI and Bp define the direction and length of + the magnetic field to be swept. The transverse field + direction is a linear combination of the unit vectors + in spherical cordinates e_theta and e_phi and defined + by the angle PSI. The length is defined by Bt. + "normal": THETA and PHI define the direction of the transverse + Field whereas psi defines the direction of Bp. + This allows to sweep Bp in the normal plane defines by + Bt leaving the transverse field direction constant + (not possible in sweep mode). + + z | / Bp + |theta/. + | / . + | / . + | / . + | / . + |/_____.____ y + / . . + / . . + / phi . + x / + + ''' + def __init__(self, mode=None, **kwargs): + self._mode = mode + self._sph = {'theta': 0, + 'phi': 0, + 'psi': 0, + 'bp': 0, + 'bt': 0} + self.set_sph(**kwargs) + + #dynamically create properties + for n in self._sph: + setattr( + VectorMagnet3D, + n, + property( + fget=lambda self, var=n: self.get_vec(var), + fset=lambda self, val, var=n: self.set_vec(var, val) + ) + ) + + def set_vec(self, var, val): + ''' setter function for var of vector3d vector ''' + self._sph[var] = val + + def get_vec(self, var): + ''' getter function for var of vector3d vector ''' + return self._sph[var] + + def get_mode(self): + ''' getter function for mode of vector3d vector ''' + return self._mode + + def get_sph(self): + ''' getter function for sph vars of vector3d vector ''' + return self._sph + + def set_sph(self, **kwargs): + ''' update all given spherical b parameters ''' + for key, val in kwargs.items(): + self._sph[key] = val + + def calc_cartesian(self, **kwargs): + ''' Use the current magnet field setpoint to calculate the + cartesian magnetic field values, if all needed variables + are there available ''' + # Update if new values are given + self.set_sph(**kwargs) + # All necessary parameters given to calculate cartesian vector? + if self._mode is None: + raise MagnetUnderdefinedError + if None in self._sph.values(): + raise MagnetUnderdefinedError + + theta = grad2rad(self._sph['theta']) + phi = grad2rad(self._sph['phi']) + psi = grad2rad(self._sph['psi']) + bp = self._sph['bp'] + bt = self._sph['bt'] + + if self._mode == 'sweep': + # caclulate + bp_vec = ( + bp * sin(theta) * cos(phi), + bp * sin(theta) * sin(phi), + bp * cos(theta) + ) + # calculate Bt as linear comb. of E_theta and E_phi + # Bt_vec = Bt * ( cos(psi) * E_theta + sin(psi) * E_phi ) + bt_vec = ( + bt * (cos(psi) * cos(theta) * cos(phi) - sin(psi) * sin(phi)), + bt * (cos(psi) * cos(theta) * sin(phi) + sin(psi) * cos(phi)), + bt * -cos(psi) * sin(theta) + ) + + elif self._mode == 'normal': + # caclulate Bt + bt_vec = ( + bt * sin(theta) * cos(phi), + bt * sin(theta) * sin(phi), + bt * cos(theta) + ) + # calculate Bp as linear comb. of E_theta and E_phi + # Bp_vec = Bp * ( cos(psi) * E_theta + sin(psi) * E_phi ) + bp_vec = ( + bp * (cos(psi) * cos(theta) * cos(phi) - sin(psi) * sin(phi)), + bp * (cos(psi) * cos(theta) * sin(phi) + sin(psi) * cos(phi)), + bp * -cos(psi) * sin(theta) + ) + # cartesian = superpostion of parallel and transverse field + b_vec = (bp_vec[0] + bt_vec[0], + bp_vec[1] + bt_vec[1], + bp_vec[2] + bt_vec[2]) + # return as tuple for safety reasons (harder to mess up later) + return b_vec + +class WorkingPoint(VectorMagnet3D): + ''' The working point describes a set of output values using dict + If magnet="cartesian" magnetic field are just set as target + values for the outputs of the coils. + If magnet="vector3d" the channels "bx", "by", "bz" must be + configured as output channels. When asking for the outputs with + property "outs", the cartesian fields will be calculated ''' + def __init__(self, output_names, wp=None, magnet='cartesian'): + if magnet in ['cartesian', 'vector3d']: + self._magnet = magnet + else: + raise TypeError + if magnet == 'vector3d': + super().__init__(mode='sweep') + self._outputs = {key: NaN for key in output_names} + if wp is not None: + self.set_wp(**wp) + self._create_properties(output_names) + + @property + def outs(self): + ''' the outputs property ''' + if self._magnet == 'vector3d': + self.set_b(self.calc_cartesian()) + return self._outputs + + def set_out(self, name: str, value: float): + ''' setter function for output "name" ''' + if self._magnet == 'vector3d' and name in ['bx', 'by', 'bz']: + print(f'WARNING: vector3D will overwrite {name}!' ) + self._outputs[name] = value + + def get_out(self, name: str): + ''' getter function for output "name" ''' + return self._outputs[name] + + def set_wp(self, **kwargs): + ''' set multiple outputs with a single function call ''' + for key, val in kwargs.items(): + if key in self._outputs.keys(): + self.set_out(key, val) + else: + print(f'working point: output {key} not configured. IGNORED!') + + def set_b(self, b_fields: tuple): + ''' Set magnetic field setpoints from tuple (to not mess up). + Preferably from VectorMagnet3D.calc_cartesian() ''' + bdict = {'0': 'bx', '1': 'by', '2': 'bz'} + for idx, val in enumerate(b_fields): + name = bdict[str(idx)] + self._outputs[name] = val + + def set_mode(self, mode): + ''' set mode of working point (normal/sweep)''' + self._mode = mode + + + def _create_properties(self, names): + ''' dynamically create properties for all output names ''' + for n in names: + setattr( + WorkingPoint, + n, + property( + fget=lambda self, var=n: self.get_out(var), + fset=lambda self, val, var=n: self.set_out(var, val) + ) + ) + +if __name__ == '__main__': + pass diff --git a/src/qkit/measure/measurement_base.py b/src/qkit/measure/measurement_base.py index 7cfa7e90..e57adcac 100644 --- a/src/qkit/measure/measurement_base.py +++ b/src/qkit/measure/measurement_base.py @@ -110,7 +110,7 @@ def remove_log_function(self, index=None): self.log_functions.pop(index) class Coordinate: - def __init__(self, name, unit="", values=None, set_function=None, wait_time=0): + def __init__(self, name, unit="", values=np.array([]), set_function=lambda x: True, wait_time=0): if type(name) is not str: raise TypeError('{:s}: Cannot set {!s} as name for coordinate: string needed'.format(__name__, self.name)) self.name = name @@ -282,12 +282,13 @@ def _create_file_name(self, data): self.measurement_name = ", ".join(coordinates) self._file_name = '{}D_'.format(self._dim) + self.measurement_name.replace(' ', '').replace(',', '_') - def _prepare_measurement_file(self, data, coords=()): + def _prepare_measurement_file(self, data, coords=(), **kwargs): """ creates the output .h5-file with distinct dataset structures for each measurement type. at this point all measurement parameters are known and put in the output file All nacessary coordinates are alread included in the data instances, but you can supply a list of additional coords, which will be created. """ + for c in coords: if not isinstance(c, self.Coordinate): raise TypeError('{:s}: {!s} is no valid coordinate object'.format(__name__, c)) @@ -354,7 +355,9 @@ def _end_measurement(self): the data file is closed and filepath is printed """ print(self._data_file.get_filepath()) - threading.Thread(target=qviewkit.save_plots, args=[self._data_file.get_filepath()]).start() + + #threading.Thread(target=qviewkit.save_plots, args=[self._data_file.get_filepath()]).start() + qviewkit.save_plots(self._data_file.get_filepath()) self._data_file.close_file() waf.close_log_file(self._log) self.measurement_name = None diff --git a/src/qkit/measure/spin_suite/__init__.py b/src/qkit/measure/spin_suite/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/qkit/measure/spin_suite/spin_tune.py b/src/qkit/measure/spin_suite/spin_tune.py new file mode 100644 index 00000000..52de1d24 --- /dev/null +++ b/src/qkit/measure/spin_suite/spin_tune.py @@ -0,0 +1,433 @@ +# spin_watch.py intented for use with arbitrary measurement hardware. +# JF@KIT 04/2021 + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +from warnings import warn +import numpy as np +import qkit +import qkit.measure.measurement_base as mb +from qkit.measure.spin_suite.utils.multiplexer import Sequential_multiplexer +from qkit.measure.spin_suite.utils.watchdog import Watchdog +from qkit.gui.notebook.Progress_Bar import Progress_Bar +from qkit.measure.write_additional_files import get_instrument_settings + + + + +class Tuning(mb.MeasureBase): + """ + A class containing measurement routines for non-realtime synchronous data acquisition. + + Parents + ------- + Measurement_base + + Attributes + ---------- + meander_sweep : bool + Zig-zag sweeping during 2D Measurements + + report_static_voltages: bool + Create an extra entry in the .h5 file which reports the active (non-zero) gate voltages + + Methods + ------- + register_measurement(name, unit, nodes, get_tracedata_func, *args, **kwargs): + Registers a measurement. + + activate_measurement(measurement): + Activates the given measurement. + + deactivate_measurement(measurement): + Deactivates the given measurement. + + set_node_bounds(measurement, node, bound_lower, bound_upper): + Sets the upper and the lower bounds for a registered measurement node. + + set_z_parameters(ec, coordname, set_obj, unit, dt=None): + sets the z-axis for 3D Measurements. + + measure1D() : + Starts a 1D measurement + + measure2D() : + Starts a 2D measurement + + measure3D() : + Starts a 3D measurement + """ + def __init__(self, exp_name = "", sample = None): + """ + Parameters + ---------- + exp_name : str, optional + Name of the current experiment + sample : qkit.measure.samples_class.Sample, optional + Sample used in the current experiment + + """ + mb.MeasureBase.__init__(self, sample) + + + self._z_parameter = None + + self.meander_sweep = False + self.report_static_voltages = True + + self.multiplexer = Sequential_multiplexer() + self.watchdog = Watchdog() + + @property + def meander_sweep(self): + return self._meander_sweep + + @meander_sweep.setter + def meander_sweep(self, yesno): + if not isinstance(yesno, bool): + raise TypeError(f"{__name__}: Cannot use {yesno} as meander_sweep. Must be a boolean value.") + self._meander_sweep = yesno + + @property + def report_static_voltages(self): + return self._report_static_voltages + + @report_static_voltages.setter + def report_static_voltages(self, yesno): + if not isinstance(yesno, bool): + raise TypeError(f"{__name__}: Cannot use {yesno} as report_static_voltages. Must be a boolean value.") + self._report_static_voltages = yesno + + def register_measurement(self, name, nodes, get_tracedata_func, *args, **kwargs): + """ + Registers a measurement. + + Parameters + ---------- + name : string + Name of the measurement the measurement which is to be registered. + nodes : dict(string:string) + The data nodes (keys) of the measurement and units (values) of the respective data node. + get_tracedata_func : callable + Callable object which produces the data for the measurement which is to be registered. + *args, **kwargs: + Additional arguments which are passed to the get_tracedata_func during registration. + + Returns + ------- + None + """ + self.multiplexer.register_measurement(name, nodes, get_tracedata_func, *args, **kwargs) + for node in nodes.keys(): + self.watchdog.register_node(f"{name}.{node}", -10, 10) + + def activate_measurement(self, measurement): + """ + Activates the given measurement. + + Parameters + ---------- + measurement : string + Name of the measurement the measurement which is to be activated. + + Returns + ------- + None + + Raises + ------ + KeyError + If the given measurement doesn't exist. + """ + self.multiplexer.activate_measurement(measurement) + + def deactivate_measurement(self, measurement): + """ + Deactivates the given measurement. + + Parameters + ---------- + measurement : string + Name of the measurement the measurement which is to be deactivated. + + Returns + ------- + None + + Raises + ------ + KeyError + If the given measurement doesn't exist. + """ + self.multiplexer.deactivate_measurement(measurement) + + def set_node_bounds(self, measurement, node, bound_lower, bound_upper): + """ + Sets the upper and the lower bounds for a registered measurement node. + + Parameters + ---------- + measurement : string + Name of the measurement the measurement node belongs to. + node : string + Name of the node whose limits are to be set. + bound_lower : float + Lower bound for the allowed measurement node values. + bound_upper : float + Upper bound for the allowed measurement node values. + + Returns + ------- + None + + Raises + ------ + KeyError + If the given measurement doesn't exist. + KeyError + If the given node does not exist within the given measurement. + """ + register = self.multiplexer.registered_measurements + if measurement not in register.keys(): + raise KeyError(f"{__name__}: {measurement} is not a registered measurement.") + if node not in register[measurement]["nodes"]: + raise KeyError(f"{__name__}: Measurement {measurement} does not contain node {node}.") + self.watchdog.register_node(f"{measurement}.{node}", bound_lower, bound_upper) + + def set_z_parameters(self, vec, coordname, set_obj, unit, dt=None): + """ + Sets z-parameters for 2D and 3D scan. + In a 3D measurement, the x-parameters will be the "outer" sweep meaning for every x value all y values + are swept and for each (x,y) value the bias is swept according to the set sweep parameters. + + Parameters + ---------- + vec : array_like + An N-dimensional array that contains the sweep values. + coordname : string + The coordinate name to be created as data series in the .h5 file. + set_obj : obj + An callable object to execute with vec-values. + unit : string + The unit name to be used in data series in the .h5 file. + dt : float, optional + The sleep time between z-iterations. + + Returns + ------- + None + + Raises + ------ + Exception + If the creation of the coordinate fails. + """ + try: + self._z_parameter = self.Coordinate(coordname, unit, np.array(vec, dtype=float), set_obj, dt) + self._z_parameter.validate_parameters() + except Exception as e: + self._z_parameter = None + raise e + + def _prepare_measurement_file(self, data, coords=()): + mb.MeasureBase._prepare_measurement_file(self, data, coords=()) + + if self.report_static_voltages: + self._static_voltages = self._data_file.add_textlist("static_voltages") + _instr_settings_dict = get_instrument_settings(self._data_file.get_filepath()) + + string1 = "gate" + string2 = "_out" + active_gates = {} + + for parameters in _instr_settings_dict.values(): + for (key, value) in parameters.items(): + if string1 in key and key.endswith(string2) and abs(value) > 0.0004: + active_gates.update({key:value}) + self._static_voltages.append(active_gates) + + def _prepare_empty_container(self): + sweepy = {} + for name, measurement in self.multiplexer.registered_measurements.items(): + if measurement["active"]: + for node in measurement["nodes"]: + sweepy[f"{name}.{node}"] = [] + return sweepy + + def _append_value(self, latest_data, container): + for name, values in latest_data.items(): + self.watchdog.limits_check(name, values) + container[f"{name}"].append(float(values)) + + def _append_vector(self, latest_data, container, direction): + for name, values in latest_data.items(): + container[f"{name}"].append(values[::direction]) + + def measure_hyst1D(self): + """Starts a 1D - hysteresis measurement, along the x coordinate.""" + assert self._x_parameter, f"{__name__}: Cannot start measure1D. x_parameters required." + self._measurement_object.measurement_func = "%s: measure1D" % __name__ + pb = Progress_Bar(len(self._x_parameter.values) * self.multiplexer.no_active_nodes) + + dsets = self.multiplexer.prepare_measurement_datasets([self._x_parameter]) + self._prepare_measurement_file(dsets) + self._open_qviewkit() + + a = self._data_file.add_view("Hysteresis", x = self._datasets["Chain.a"], y = self._datasets["Block.1"]) + print(a) + + #circ_view_amp = self._hf.add_view('circ_amp', x=self._y_co, y=self._ds_amp) # dein erstes x und y datenset + #circ_view_amp.add(x=self._frequency_co, y=self._circ_amp_gen) # hier kannst du weitere datensets adden (auch später noch) + pass + + def measure1D(self, data_to_show = None): + """ + Starts a 1D - measurement, along the x coordinate. + + Parameters + ---------- + data_to_show : List of strings, optional + Name of Datasets, which qviewkit opens at measurement start. + """ + assert self._x_parameter, f"{__name__}: Cannot start measure1D. x_parameters required." + self._measurement_object.measurement_func = "%s: measure1D" % __name__ + pb = Progress_Bar(len(self._x_parameter.values) * self.multiplexer.no_active_nodes) + + dsets = self.multiplexer.prepare_measurement_datasets([self._x_parameter]) + self._prepare_measurement_file(dsets) + self._open_qviewkit(datasets = data_to_show) + + try: + for x_val in self._x_parameter.values: + self._x_parameter.set_function(x_val) + qkit.flow.sleep(self._x_parameter.wait_time) + latest_data = self.multiplexer.measure() + + self._append_value(latest_data, self._datasets) + + pb.iterate(addend = len(latest_data)) + + if self.watchdog.stop: + warn(f"{__name__}: {self.watchdog.message}") + break + finally: + self.watchdog.reset() + self._end_measurement() + + def measure2D(self, data_to_show = None): + """ + Starts a 2D - measurement, with y being the inner and x the outer loop coordinate. + + Parameters + ---------- + data_to_show : List of strings, optional + Name of Datasets, which qviewkit opens at measurement start. + """ + assert self._x_parameter, f"{__name__}: Cannot start measure2D. x_parameters required." + assert self._y_parameter, f"{__name__}: Cannot start measure2D. y_parameters required." + self._measurement_object.measurement_func = "%s: measure2D" % __name__ + pb = Progress_Bar(len(self._x_parameter.values) * len(self._y_parameter.values) * self.multiplexer.no_active_nodes) + + dsets = self.multiplexer.prepare_measurement_datasets([self._x_parameter, self._y_parameter]) + self._prepare_measurement_file(dsets) + self._open_qviewkit(datasets = data_to_show) + + try: + y_direction = 1 + for x_val in self._x_parameter.values: + self._x_parameter.set_function(x_val) + self._acquire_log_functions() + qkit.flow.sleep(self._x_parameter.wait_time) + sweepy = self._prepare_empty_container() + + for y_val in self._y_parameter.values[::y_direction]: + self._y_parameter.set_function(y_val) + qkit.flow.sleep(self._y_parameter.wait_time) + latest_data = self.multiplexer.measure() + self._append_value(latest_data, sweepy) + + pb.iterate(addend = len(latest_data)) + + if self.watchdog.stop: + warn(f"{__name__}: {self.watchdog.message}") + break + + if self.watchdog.stop: break + + self._append_vector(sweepy, self._datasets, direction = y_direction) + + if self.meander_sweep: y_direction *= -1 + + finally: + self.watchdog.reset() + self._end_measurement() + + def measure3D(self, data_to_show = None): + """ + Starts a 3D - measurement, with z being the innermost, y the inner and x the outer loop coordinate. + + Parameters + ---------- + data_to_show : List of strings, optional + Name of Datasets, which qviewkit opens at measurement start. + """ + assert self._x_parameter, f"{__name__}: Cannot start measure3D. x_parameters required." + assert self._y_parameter, f"{__name__}: Cannot start measure3D. y_parameters required." + assert self._z_parameter, f"{__name__}: Cannot start measure3D. z_parameters required." + self._measurement_object.measurement_func = "%s: measure3D" % __name__ + pb = Progress_Bar(len(self._x_parameter.values) * len(self._y_parameter.values) * len(self._z_parameter.values) * self.multiplexer.no_active_nodes) + + dsets = self.multiplexer.prepare_measurement_datasets([self._x_parameter, self._y_parameter, self._z_parameter]) + self._prepare_measurement_file(dsets) + self._open_qviewkit(datasets = data_to_show) + + try: + for x_val in self._x_parameter.values: + self._x_parameter.set_function(x_val) + self._acquire_log_functions() + qkit.flow.sleep(self._x_parameter.wait_time) + + z_direction = 1 + for y_val in self._y_parameter.values: + sweepy = self._prepare_empty_container() + self._y_parameter.set_function(y_val) + qkit.flow.sleep(self._y_parameter.wait_time) + + for z_val in self._z_parameter.values[::z_direction]: + self._z_parameter.set_function(z_val) + qkit.flow.sleep(self._z_parameter.wait_time) + latest_data = self.multiplexer.measure() + self._append_value(latest_data, sweepy) + pb.iterate(addend = len(latest_data)) + if self.watchdog.stop: + warn(f"{__name__}: {self.watchdog.message}") + break + + if self.watchdog.stop: break + + self._append_vector(sweepy, self._datasets, direction = z_direction) + + if self.meander_sweep: z_direction *= -1 + + for dset in self._datasets.values(): + dset.next_matrix() + if self.watchdog.stop: break + finally: + self.watchdog.reset() + self._end_measurement() + +if __name__ == "__main__": + tuning = Tuning() + print(tuning.measurement_limit) + print(tuning.report_static_voltages) \ No newline at end of file diff --git a/src/qkit/measure/spin_suite/utils/multiplexer.py b/src/qkit/measure/spin_suite/utils/multiplexer.py new file mode 100644 index 00000000..e50b6103 --- /dev/null +++ b/src/qkit/measure/spin_suite/utils/multiplexer.py @@ -0,0 +1,162 @@ +import qkit.measure.measurement_base as mb + +class Sequential_multiplexer: + """ + A sequential multiplexer. + + Attributes + ---------- + no_active_nodes: int + The total number of data_nodes which belong to currently active measurements + + Methods + ------- + register_measurement(name, unit, nodes, get_tracedata_func, *args, **kwargs): + Registers a measurement. + + activate_measurement(measurement): + Activates the given measurement. + + deactivate_measurement(measurement): + Deactivates the given measurement. + + prepare_measurement_datasets(coords): + Creates qkit.measure.measurement_base.MeasureBase.Data objects along the coords for each active measurement. + + measure(): + Calls all active measurements sequentially. + """ + def __init__(self): + self.registered_measurements = {} + self.no_measurements = 0 + + @property + def no_active_nodes(self): + no_nodes = 0 + for measurement in self.registered_measurements.values(): + if measurement["active"]: + no_nodes += len(measurement["nodes"]) + return no_nodes + + def register_measurement(self, name, nodes, get_tracedata_func, *args, **kwargs): + """ + Registers a measurement. + + Parameters + ---------- + name : string + Name of the measurement which is to be registered. + nodes : dict(string:string) + The data nodes (keys) of the measurement and units (values) of the respective data node. + get_tracedata_func : callable + Callable object which produces the data for the measurement which is to be registered. + *args, **kwargs: + Additional arguments which are passed to the get_tracedata_func during registration. + + Returns + ------- + None + """ + if type(name) != str: + raise TypeError(f"{__name__}: {name} is not a valid experiment name. The experiment name must be a string.") + if type(nodes) != dict: + raise TypeError(f"{__name__}: {nodes} are not valid data nodes. The data nodes must be a dictionary.") + else: + for node, unit in nodes.items(): + if type(node) != str: + raise TypeError(f"{__name__}: {node} is not a valid data node. A data node must be a string.") + if type(unit) != str: + raise TypeError(f"{__name__}: {unit} is not a valid unit. The unit must be a string.") + if not callable(get_tracedata_func): + raise TypeError("%s: Cannot set %s as get_value_func. Callable object needed." % (__name__, get_tracedata_func)) + + self.registered_measurements[name] = {"nodes" : nodes, "get_tracedata_func" : lambda: get_tracedata_func(*args, **kwargs), "active" : False} + self.no_measurements = len(self.registered_measurements) + + def activate_measurement(self, name): + """ + Activates the given measurement. + + Parameters + ---------- + measurement : string + Name of the measurement the measurement which is to be activated. + + Returns + ------- + None + + Raises + ------ + KeyError + If the given measurement doesn't exist. + """ + if name not in self.registered_measurements.keys(): + raise KeyError(f"{__name__}: {name} is not a registered measurement. Cannot activate.") + self.registered_measurements[name]["active"] = True + + def deactivate_measurement(self, name): + """ + Deactivates the given measurement. + + Parameters + ---------- + measurement : string + Name of the measurement the measurement which is to be deactivated. + + Returns + ------- + None + + Raises + ------ + KeyError + If the given measurement doesn't exist. + """ + if name not in self.registered_measurements.keys(): + raise KeyError(f"{__name__}: {name} is not a registered measurement. Cannot deactivate.") + self.registered_measurements[name]["active"] = False + + def prepare_measurement_datasets(self, coords): + """ + Creates qkit.measure.measurement_base.MeasureBase.Data objects along the coords for each active measurement. + + Parameters + ---------- + coords : list(qkit.measure.measurement_base.MeasureBase.Coordinate) + The measurement coordinates along which Data objects will be created. + + Returns + ------- + datasets : list(qkit.measure.measurement_base.MeasureBase.Data) + """ + datasets = [] + # print(coords) + for name, measurement in self.registered_measurements.items(): + # print(name, measurement) + if measurement["active"]: + for node, unit in measurement["nodes"].items(): + # print(node,unit) + datasets.append(mb.MeasureBase.Data(name = f"{name}.{node}", + coords = coords, + unit = unit, + save_timestamp = False)) + # print(datasets) + assert datasets, f"{__name__}: Tried to initialize an empty measurement dataset. Register and/or activate measurements." + return datasets + + def measure(self): + """ + Sequentially calls the measurement functions of each active measurement. + + Returns + ------- + latest_data : dict() + """ + latest_data = {} + for name, measurement in self.registered_measurements.items(): + if measurement["active"]: + temp = measurement["get_tracedata_func"]() + for node, value in temp.items(): + latest_data[f"{name}.{node}"] = value + return latest_data \ No newline at end of file diff --git a/src/qkit/measure/spin_suite/utils/watchdog.py b/src/qkit/measure/spin_suite/utils/watchdog.py new file mode 100644 index 00000000..7df57ac9 --- /dev/null +++ b/src/qkit/measure/spin_suite/utils/watchdog.py @@ -0,0 +1,106 @@ +import numpy as np + +class Watchdog: + """ + An object containing restrictions and functions to check whether given values lie wihtin the boundaries given + by the restrictions. + + Attributes + ---------- + stop: bool + Is True once a check finds a value which does not lie within the given restrictions + + message: string + Is set once a check finds a value which does not lie within the given restrictions. + Describes which restriction was violated. + + Methods + ------- + register_node(data_node, bound_lower, bound_upper): + Registers upper and lower bounds for a measurement node. + + reset(): + Sets the stop attribute to False, and the message attribute to an empty string. + + limits_check(self, data_node, values): + Checks whether the values lie within the boundaries for the given data_node. + """ + def __init__(self): + self.stop = False + self.message = "" + self.measurement_bounds = {} + + def register_node(self, data_node, bound_lower, bound_upper): + """ + Registers a measurement node. + + Parameters + ---------- + data_node : string + Name of the measurement node which is to be registered. + bound_lower : float + Lower bound of the allowed values for data_node. + bound_upper : float + Upper bound of the allowed values for data_node. + + Returns + ------- + None + + Raises + ------ + ValueError + If the given bound_lower is larger or equals the bound_upper + """ + if type(data_node) != str: + raise TypeError(f"{__name__}: {data_node} is not a valid measurement node. The measurement node must be a string.") + try: + bound_lower = float(bound_lower) + except Exception as e: + raise type(e)(f"{__name__}: Cannot set {bound_lower} as lower measurement bound for node {data_node}. Conversion to float failed.") + try: + bound_upper = float(bound_upper) + except Exception as e: + raise type(e)(f"{__name__}: Cannot set {bound_lower} as lower measurement bound for node {data_node}. Conversion to float failed.") + + if bound_lower >= bound_upper: + raise ValueError(f"{__name__}: Invalid bounds. {bound_lower} is larger or equal to {bound_upper}.") + + self.measurement_bounds[f"{data_node}"] = [bound_lower, bound_upper] + + def reset(self): + """ + Resets the watchdog. + """ + self.stop = False + self.global_message = "" + + def limits_check(self, data_node, values): + """ + Checks wether the values lie within the bounds for data_node. + + Parameters + ---------- + data_node : string + Name of the data_node the values belong to. + values : int, float, list(int), list(float), np.array + Values to be checked. + + Returns + ------- + None + + Raises + ------ + KeyError + No bounds are defined for data_node. + """ + if data_node not in self.measurement_bounds.keys(): + raise KeyError(f"{__name__}: No bounds are defined for {data_node}.") + for value in np.atleast_1d(values): + if value < self.measurement_bounds[data_node][0]: + self.stop = True + self.message = f"{__name__}: Lower measurement bound for {data_node} reached. Stopping measurement." + elif value > self.measurement_bounds[data_node][1]: + self.stop = True + self.message = f"{__name__}: Upper measurement bound for {data_node} reached. Stopping measurement." \ No newline at end of file diff --git a/src/qkit/storage/hdf_config.py b/src/qkit/storage/hdf_config.py new file mode 100644 index 00000000..b52591cf --- /dev/null +++ b/src/qkit/storage/hdf_config.py @@ -0,0 +1,30 @@ +# -*- coding: utf-8 -*- + +import qkit +import json + +class dataset_config(object): + """This class describes a specific data analysis plots, + like polar plot and hystogramms. + + Analysis do not contain any data but only ds_url information about the datasets + that should be displayed. The attributes 'ds_type' and 'xyz' hold the + information about what type of plots are created and which + datasets are plotted against each other. + """ + + def __init__(self, hdf_file, name, folder = 'data', **cfg): + ''' init config dataset''' + self.hf = hdf_file + self.name = name + self.folder = folder + self.ds_url = "/entry/" + folder + "/" + name + + self.ds = self.hf.create_dataset(self.name,0,folder=self.folder,dim=1) + # self._setup_metadata(**cfg) + self.hf.flush() + + def add(self,name,value): + ''' add attribute to config dataset''' + self.ds.attrs.create(name,json.dumps(value)) + self.hf.flush() \ No newline at end of file diff --git a/src/qkit/storage/hdf_constants.py b/src/qkit/storage/hdf_constants.py index 16b1c962..deaf3de6 100644 --- a/src/qkit/storage/hdf_constants.py +++ b/src/qkit/storage/hdf_constants.py @@ -10,12 +10,14 @@ 'matrix':2, 'box':3, 'txt':10, - 'view':20, - } + 'view':20, + } view_types = {'1D':0, - '1D-V':1, - '2D':2, - '3D':3, - 'table':4, - 'txt':5} \ No newline at end of file + '1D-V':1, + '2D':2, + '3D':3, + 'table':4, + 'txt':5, + 'polarplot':6 + } diff --git a/src/qkit/storage/hdf_polarview.py b/src/qkit/storage/hdf_polarview.py new file mode 100644 index 00000000..28337669 --- /dev/null +++ b/src/qkit/storage/hdf_polarview.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- + +import qkit +from qkit.storage.hdf_constants import ds_types, view_types +from qkit.core.lib.misc import str3 +class dataset_polarview(object): + """This class describes a polar colormap of a 2D dataset. + + The dataset do not contain any data but only ds_url information about the dataset + that should be displayed. + """ + + def __init__(self, hdf_file, name, x=None, y=None, z=None, + ds_type = ds_types['view'], folder = 'views'): + + self.hf = hdf_file + self.name = name + self.folder = folder + self.ds_url = "/entry/" + folder + "/" + name + self.ds_type = ds_type + self.view_type = view_types['polarplot'] + self.filter = filter + + if ds_type != ds_types['view']: + raise TypeError(__name__ + ": Dataset contains wrong ds_type") + + if not x or not y or not z: + raise ValueError(__name__ + ": Error creating view '{!s}' in file {!s}: x or y axis not given.".format(name, hdf_file.hf.attrs['_filepath'])) + self.x_object = str3(x.ds_url) + self.y_object = str3(y.ds_url) + self.z_object = str3(z.ds_url) + + self.ds = self.hf.create_dataset(self.name,0,folder=self.folder,dim=1) + self._setup_metadata() + self.hf.flush() + + def _setup_metadata(self,init=True): + ds = self.ds + if init: + ds.attrs.create('ds_type',self.ds_type) + ds.attrs.create('view_type',self.view_type) + ds.attrs.create("xyz",(str(self.x_object)+":"+str(self.y_object)+":"+str(self.z_object)).encode()) + ds.attrs.create("step_var",str(self.x_object)) + ds.attrs.create("sweep_var",str(self.y_object)) \ No newline at end of file diff --git a/src/qkit/storage/store.py b/src/qkit/storage/store.py index 7464beeb..47b53945 100644 --- a/src/qkit/storage/store.py +++ b/src/qkit/storage/store.py @@ -6,6 +6,7 @@ @author: hannes.rotzinger@kit.edu 2018 @author: marco.pfirrmann@kit.edu 2018 @version: 0.1 +*modified* """ import logging import os @@ -16,6 +17,8 @@ from qkit.storage.hdf_dataset import hdf_dataset from qkit.storage.hdf_constants import ds_types from qkit.storage.hdf_view import dataset_view +from qkit.storage.hdf_config import dataset_config +from qkit.storage.hdf_polarview import dataset_polarview from qkit.storage.hdf_DateTimeGenerator import DateTimeGenerator @@ -94,7 +97,7 @@ def _mapH5PathToObject(self): """ class group(object): pass - + a = group() for n, o in self.hf.hf['/entry/analysis0'].items(): n = n.replace(" ","_") @@ -156,7 +159,7 @@ def add_comment(self,comment, folder = "data" ): self.hf.dgrp.attrs.create('comment',comment.encode()) elif folder == "analysis": self.hf.agrp.attrs.create("comment",comment.encode()) - else: + else: logging.warning("Foler muset be either 'data' (default) or 'analysis': '%s' provided" % (folder)) raise ValueError @@ -177,7 +180,7 @@ def add_textlist(self,name,comment = "" ,folder="data", **meta): """ ds = hdf_dataset(self.hf, name, comment = comment, folder=folder, ds_type = ds_types['txt'], dim=1, **meta) return ds - + def add_coordinate(self, name, unit = "", comment = "",folder="data",**meta): """Adds a coordinate dataset to the h5 file. @@ -217,7 +220,7 @@ def add_value_vector(self, name, x, unit = "", comment = "",folder="data",**meta hdf_dataset object. """ ds = hdf_dataset(self.hf, name, x=x, unit=unit, ds_type = ds_types['vector'], - comment=comment, folder=folder, dim = 1, **meta) + comment=comment, folder=folder, dtype='float64', dim = 1, **meta) return ds def add_value_matrix(self, name, x , y, unit = "", comment = "",folder="data",**meta): @@ -240,7 +243,7 @@ def add_value_matrix(self, name, x , y, unit = "", comment = "",folder="data",** hdf_dataset object. """ ds = hdf_dataset(self.hf, name, x=x, y=y, unit=unit, ds_type = ds_types['matrix'], - comment=comment, folder=folder, dim = 2, **meta) + comment=comment, folder=folder, dtype='float64', dim = 2, **meta) return ds def add_value_box(self, name, x , y, z, unit = "", comment = "",folder="data",**meta): @@ -262,9 +265,9 @@ def add_value_box(self, name, x , y, z, unit = "", comment = "",folder="data",** Returns: hdf_dataset object. - """ + """ ds = hdf_dataset(self.hf,name, x=x, y=y, z=z, unit=unit, ds_type = ds_types['box'], - comment=comment, folder=folder, dim = 3, **meta) + comment=comment, folder=folder, dtype='float64', dim = 3, **meta) return ds def add_view(self,name,x = None, y = None, error = None, filter = None, view_params = {}): @@ -280,7 +283,18 @@ def add_view(self,name,x = None, y = None, error = None, filter = None, view_pa (Fixme: not jet implemented) """ ds = dataset_view(self.hf,name, x=x, y=y, error=error, filter = filter, - ds_type = ds_types['view'],view_params = view_params) + ds_type = ds_types['view'],view_params = view_params) + return ds + + def add_polarview(self,name,x = None, y = None, z = None): + """Adds a view to plot x-y-z data as polar colormap. + """ + ds = dataset_polarview(self.hf,name, x=x, y=y, z=z, ds_type = ds_types['view']) + return ds + + def add_config(self,name='measurement.config',**cfg): + """Adds a config dataset to save the config of the measurement""" + ds = dataset_config(self.hf,name,**cfg) return ds def add_fid_param(self, param, value):