From 0d643e4c78560904b3d45d0777e65ad52ac5bbb5 Mon Sep 17 00:00:00 2001 From: Hector Date: Thu, 30 Apr 2020 17:23:50 +0200 Subject: [PATCH 01/17] Adapted so a component has a list of labels and a list of values. Doesn't work with the GUI, only Network. The J class is modified to be an arbitrary component. --- core.py | 2866 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2866 insertions(+) create mode 100644 core.py diff --git a/core.py b/core.py new file mode 100644 index 00000000..2c4dd7eb --- /dev/null +++ b/core.py @@ -0,0 +1,2866 @@ +import sympy as sp +import scipy +J(from sympy import Function +import numpy as np +from numpy.polynomial.polynomial import Polynomial as npPoly +from sympy.core.mul import Mul, Pow, Add +from copy import deepcopy +from numbers import Number +from math import floor, factorial +import os +from subprocess import run +import inspect +import matplotlib.pyplot as plt +import time +from warnings import warn +try: + from ._constants import * + from ._utility import * + from .plotting_settings import plotting_parameters_show,plotting_parameters_normal_modes +except ImportError: + # When running from source without pip installation + from _constants import * + from _utility import * + from plotting_settings import plotting_parameters_show,plotting_parameters_normal_modes + +from scipy.optimize import minimize as mini +from numpy import cos, sin + +PROFILING = False + +def timeit(method): + ''' + Decorator which prints the time + a function took to execute. + Only works the global variable PROFILING is set to True. + ''' + def timed(*args, **kw): + ts = time.time() + result = method(*args, **kw) + te = time.time() + if PROFILING: + print('calling %r took %2.2f ms' % \ + (method.__name__, (te - ts) * 1000)) + return result + return timed + +def string_to_component(s, *arg, **kwarg): + ''' + Allows the creation of a Component object using a string. + + Parameters + ---------- + s : string + One of 'W', 'R', 'L', 'J', 'C', 'G', dicatates the type + of component to create + args, kwargs : + Arguments needed for the component creation + + Returns + ------- + A component of type ``s`` + ''' + if s == 'W': + return W(*arg, **kwarg) + elif s == 'R': + return R(*arg, **kwarg) + elif s == 'L': + return L(*arg, **kwarg) + elif s == 'J': + return J(*arg, **kwarg) + elif s == 'D': + return D(*arg, **kwarg) + elif s == 'C': + return C(*arg, **kwarg) + elif s == 'G': + return G(*arg, **kwarg) + + + +class Qcircuit(object): + """A class representing a quantum circuit. + + Attributes: + components (dict): Dictionary of components having a label, such that a component + with label 'L_1' can be obtained by ``Qcircuit.components['L_1']`` + Q_min (float): Modes with have a quality factor below Q_min will not ignored + inductors (list): List of inductor objects present in the circuit + resistors (list): List of inductor objects present in the circuit + junctions (list): List of junction objects present in the circuit + capacitors (list): List of capacitor objects present in the circuit + netlist (list): List of all components present in the circuit + ref_elt (J or L): list of junction or inductor component used as a reference for the calculation + of zero-point fluctations, each index of the list corresponds to a different mode + """ + + def __init__(self, netlist): + self.Q_min = 1 # Modes with have a quality factor below Q_min will not ignored + + self.warn_discarded_mode = True # If this is set to True, the user will be notified when a mode is discarded. + + # After an initial estimation of the complex eigenfrequenceis using a diaglinalization + # of the companion matrix, the frequencies are polishd to a tolerence + # self.root_relative_tolerance using a gradient based root finder, with a maximum number of iterations self.root_max_iterations + self.root_max_iterations = 1e4 + self.root_relative_tolerance = 1e-12 + + self._plotting_normal_mode = False # Used to keep track of which imported plotting_settings to use + # only set to true when show_normal_mode is called + self.plotting_parameters_normal_modes = plotting_parameters_normal_modes + self.plotting_parameters_show = plotting_parameters_show + + self.netlist = netlist # List of all components present in the circuit + + self._network = _Network(netlist) # Converts the list of components into a network object + # The Network object has methods to compute of the admittance between two nodes + # or the tranfer function between two nodes and two others + + # We construct (enpty) lists of all the different type of + # components that could be present in the circuit + self.inductors = [] + self.capacitors = [] + self.junctions = [] + self.resistors = [] + self._wire = [] + self._grounds = [] + + # Initialize a dictionary of components having a label, such that a component + # with label 'L_1' can be obtained by ``Qcircuit.components['L_1']`` + self.components = {} + + # Initialize a list which will contain the labels of the componentns which have + # no value (these will have to be specified in most methods as a kwarg) + self._no_value_components = [] + + # For each component of the circuit.... + for elt in netlist: + # ...tell the component what circuit it belongs to + elt._circuit = self + # ...and populate the empty lists/dictionaries initialized above with the element if appropriate + elt._set_component_lists() + + + # Check that there is at least one inductive element in the circuit + if len(self.junctions) == 0 and len(self.inductors) == 0: + raise ValueError( + "There should be at least one junction or inductor in the circuit") + + # Check that there is at least one capacitive element in the circuit + if len(self.capacitors) == 0: + raise ValueError( + "There should be at least one capacitor in the circuit") + + + # define the function which returns the inverse of dY + # where Y is the admittance at the nodes of an inductive element + for inductive_element in self.inductors+self.junctions: + inductive_element._compute_flux_zpf_r() + + # Initialize the flux transformation dictionary, + # where _flux_transformation_dict[ref_node_minus,ref_node_plus,node_minus,node_plus] + # will be populated with a function which gives + # the voltage transfer function between the nodes surrounding + # the reference element and (node_plus,node_minus) + # this function takes as an argument an angular frequency + # and keyword arguments if component values need to be specified + self._flux_transformation_dict = {} + + # define the functions which returns the components of the characteristic polynomial + # (the roots of which are the eigen-frequencies) + self._char_poly_coeffs = [lambdify(self._no_value_components, c, ['numpy']) + for c in self._network.compute_char_poly_coeffs(is_lossy = (len(self.resistors)>0))] + +#self.no_value_components : array de tous les labels non spécifiés +#c = expression sympy + + + @property + def _pp(self): + ''' + Returns the plotting parameters used + * in the Qcircuit.show method (if self._plotting_normal_mode is False) + * in the Qcircuit.show_normal_modes() method (if self._plotting_normal_mode is True) + ''' + if self._plotting_normal_mode: + return self.plotting_parameters_normal_modes + else: + return self.plotting_parameters_show + + def _parse_kwargs(self, **kwargs): + ''' + Raises a ValueError + * if one of the kwargs is not the label of a circuit element + * if a component without a value has not had its value specified in the kwargs + + Called in all functions accepting keyword arguments (for un-specified circuit components). + + Parameters + ---------- + kwargs: + Values for un-specified circuit components, + ex: ``L=1e-9``. + ''' + for key in kwargs: + if key in self._no_value_components: + kwargs[key] = kwargs[key] + else: + raise ValueError( + '%s is not the label of a circuit element' % key) + + for label in self._no_value_components: + try: + kwargs[label] + except Exception: + raise ValueError( + 'The value of %s should be specified with the keyword argument %s=... ' % (label, label)) + + @timeit + def _set_zeta(self, **kwargs): + ''' + Sets the Qcircuit.zeta to the circuit eigenfrequencies + (including the imaginary part due to losses). + + Parameters + ---------- + kwargs: + Values for un-specified circuit components, + ex: ``L=1e-9``. + ''' + try: + if kwargs == self._kwargs_previous: + # Avoid doing the same thing two + # times in a row + return + except AttributeError: + pass + self._kwargs_previous = kwargs + + # Check if the kwargs provided are correct + self._parse_kwargs(**kwargs) + + if len(self.resistors) == 0: + + # Compute the coefficients of the characteristic polynomial. + # The roots of this polynomial will provide the complex eigenfrequencies + char_poly = npPoly([np.real(coeff(**kwargs)) for coeff in self._char_poly_coeffs]) + + # char_poly = remove_multiplicity(char_poly) + + # In this case, the variable of the characteristic polynomial is \omega^2 + # And we can safely take the real part of the solution as there are no + # resistors in the circuit. + w2 = np.real(char_poly.roots()) + w2 = polish_roots(char_poly,w2, self.root_max_iterations,np.sqrt(self.root_relative_tolerance)) + + # Sometimes, when the circuits has vastly different + # values for its circuit components or modes are too + # decoupled, the symbolic + # calculations can yield an incorrect char_poly + # We can easily discard some of these casese by throwing away + # negative solutions + for w2_single in w2: + if np.real(w2_single) < 0 and self.warn_discarded_mode: + error_message = "Imaginary frequency mode f = 1j %f Hz mode found (and discarded).\n"%(np.sqrt(-w2_single)/2/np.pi) + warn(error_message) + w2 = w2[np.nonzero(w2 >= 0.)] + + # Take the square root to get to the eigenfrequencies + zeta = np.sqrt(w2) + + # Sort solutions with increasing frequency + order = np.argsort(np.real(zeta)) + zeta = zeta[order] + + else: + + # Compute the coefficients of the characteristic polynomial. + # The roots of this polynomial will provide the complex eigenfrequencies + char_poly = npPoly([complex(coeff(**kwargs)) for coeff in self._char_poly_coeffs]) + # char_poly = remove_multiplicity(char_poly) + + zeta = char_poly.roots() + zeta = polish_roots(char_poly,zeta, self.root_max_iterations,self.root_relative_tolerance) + + # Sort solutions with increasing frequency + order = np.argsort(np.real(zeta)) + zeta = zeta[order] + + # Negative modes are discarded + zeta = zeta[np.nonzero(np.real(zeta) >= 0.)] + + # For each solution, its complex conjugate + # is also a solution, we want to discard the negative + # imaginary part solutions which correspond to unphysical + # negative dissipation modes + zeta = zeta[np.nonzero(np.imag(zeta) >= 0.)] + + # zero frequency modes are discarded + zeta = zeta[np.nonzero(np.logical_not(np.isclose(np.real(zeta),0*zeta, rtol = self.root_relative_tolerance)))] + + # Only consider modes with Q>self.Q_min (=1 by default) + # The reason for this measure is that + # 0-frequency solutions (with real parts close to 0) + # tend to have frequencies which oscillate between positive and + # negative values. + # The negative values are discarded which changes the number of modes + # and makes parameter sweeps difficult + for w in zeta: + if np.real(w) < self.Q_min*2*np.imag(w) and self.warn_discarded_mode: + error_message = "Discarding f = %f Hz mode "%(np.real(w/2/np.pi)) + error_message += "since it has a too low quality factor Q = %f < %f"%(np.real(w)/2/np.imag(w),self.Q_min) + warn(error_message) + zeta = zeta[np.nonzero(np.real(zeta) >= self.Q_min*2*np.imag(zeta))] + + # Choose reference elements for each mode which + # maximize the inverse of dY: we want the reference + # element to the element where zero-point fluctuations + # in flux are most localized. + inductive_elements = self.junctions+self.inductors + ref_elt = [] + zeta_copy = deepcopy(zeta) + zeta = [] + + for w in zeta_copy: + largest_dYm1 = 0 + ref_elt_index = None + for ind_index,ind in enumerate(inductive_elements): + try: + dYm1 = ind._flux_zpf_r(w,**kwargs) + except Exception: + # Computation of dYm1 failed for some reason + dYm1 = -1 + + if dYm1>largest_dYm1: + ref_elt_index = ind_index + largest_dYm1 = dYm1 + + if ref_elt_index is None and self.warn_discarded_mode: + # Sometimes, when the circuits has vastly different + # values for its circuit components or modes are too + # decoupled, the symbolic + # calculations can yield an incorrect char_poly + # We can easily discard some of these cases by throwing away + # any solutions with a complex impedance (ImY'<0) + error_message = "Discarding f = %f Hz mode.\n"%(np.real(w/2/np.pi)) + error_message += "since the calculation of zero-point-fluctuations was unsuccesful.\n" + warn(error_message) + else: + zeta.append(w) + ref_elt.append(inductive_elements[ref_elt_index]) + zeta = np.array(zeta) + + self.zeta = zeta + self.ref_elt = ref_elt + + def _anharmonicities_per_junction(self, **kwargs): + ''' + Returns the contribution of each junction to the anharmonicity of each mode. + For more details, see the documentation of J.anharmonicity. + + Anharmonicities are given in units of Hz (not angular frequency). + + Parameters + ---------- + kwargs: + Values for un-specified circuit components, + ex: ``L=1e-9``. + + Returns + ------- + anh_per_jun: ndarray + where ``anh_per_jun[j,m]`` corresponds to the contribution of junction ``j`` + to the anharmonicity of mode ``m`` + ''' + self._set_zeta(**kwargs) + return [[j.anharmonicity(mode, **kwargs) for mode in range(len(self.zeta))] for j in self.junctions] + + @vectorize_kwargs + def eigenfrequencies(self, **kwargs): + '''Returns the normal mode frequencies of the circuit. + + Frequencies are provided in units of Hertz, + not in angular frequency. + + Parameters + ---------- + kwargs: + Values for un-specified circuit components, + ex: ``L=1e-9``. + + Returns + ------- + numpy.array + Normal mode frequencies of the circuit, ordered from lowest + to highest frequency, given in Hertz. + + Notes + ----- + + These eigen-frequencies :math:`f_m` correspond to the real parts + of the complex frequencies which make the conductance matrix + singular, or equivalently the real parts of the poles of the impedance + calculated between the nodes of an inductor or josephson junction. + + The Hamiltonian of the circuit is + + :math:`\hat{H} = \sum_m hf_m\hat{a}_m^\dagger\hat{a}_m + \hat{U}`, + + where :math:`h` is Plancks constant, + :math:`\hat{a}_m` is the annihilation operator of the m-th + normal mode of the circuit and :math:`f_m` is the frequency of + the m-th normal mode. The frequencies :math:`f_m` would + be the resonance frequencies of the circuit if all junctions + were replaced with linear inductors. In that case the + non-linear part of the Hamiltonian :math:`\hat{U}`, + originating in the junction non-linearity, would be 0. + + For more information on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf. + ''' + self._set_zeta(**kwargs) + return np.real(self.zeta)/2./pi + + @vectorize_kwargs + def loss_rates(self, **kwargs): + '''Returns the loss rates of the circuit normal modes. + + The array is ordered ordered with increasing normal mode frequencies + such that the first element of the array corresponds to the loss + rate of the lowest frequency mode. Losses are provided in units of Hertz, + **not in angular frequency**. + + Parameters + ---------- + kwargs: + Values for un-specified circuit components, + ex: ``L=1e-9``. + + Returns + ------- + numpy.array + Normal mode losses of the circuit + + Notes + ----- + + These loss rates :math:`\kappa_m` correspond to twice the imaginary parts + of the complex frequencies which make the conductance matrix + singular, or equivalently twice the imaginary parts of the poles of the impedance + calculated between the nodes of an inductor or josephon junction. + + For further details on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf. + + The dynamics of the circuit can be studied in QuTiP + by considering collapse operators for the m-th mode + :math:`\sqrt{2\pi\kappa_m(n_{th,m}+1)}\hat{a}_m` and + :math:`\sqrt{2\pi\kappa_m(n_{th,m})}\hat{a}_m^\dagger` + where :math:`n_{th,m}` is the average thermal occupation + of mode :math:`m` and :math:`\hat{a}_m` is the annihilation operator of the m-th + normal mode of the circuit. + Note that dissipation rates that are obtained from this function + have to be converted to angular frequencies through the factor :math:`2\pi`. + If you are also using a hamiltonian generated from qucat, + then it too should be converted to angular frequencies by multiplying + the entire Hamiltonian by :math:`2\pi` when performing time-dependant + simulations. + ''' + self._set_zeta(**kwargs) + return 2*np.imag(self.zeta)/2./pi + + @vectorize_kwargs + def anharmonicities(self, **kwargs): + r'''Returns the anharmonicity of the circuit normal modes. + + The array is ordered ordered with increasing normal mode frequencies + such that the first element of the array corresponds to the + anharmonicity of the lowest frequency mode. + Anharmonicities are provided in units of Hertz, + not in angular frequency. + + + Parameters + ---------- + kwargs: + Values for un-specified circuit components, + ex: ``L=1e-9``. + + Returns + ------- + numpy.array + Normal mode anharmonicities + + Notes + ----- + The Hamiltonian of a circuit in first order perturbation theory is given by + + :math:`\hat{H} = \sum_m\sum_{n\ne m} (\hbar\omega_m-A_m-\frac{\chi_{mn}}{2})\hat{a}_m^\dagger\hat{a}_m -\frac{A_m}{2}\hat{a}_m^\dagger\hat{a}_m^\dagger\hat{a}_m\hat{a}_m -\chi_{mn}\hat{a}_m^\dagger\hat{a}_m\hat{a}_n^\dagger\hat{a}_n`, + + valid for weak anharmonicity :math:`\chi_{mn},A_m\ll \omega_m`. + + Here + + * :math:`\omega_m` are the frequencies of the normal modes of the circuit where all junctions have been replaced with inductors characterized by their Josephson inductance + + * :math:`A_m` is the anharmonicity of mode :math:`m` , the difference in frequency of the first two transitions of the mode + + * :math:`\chi_{mn}` is the shift in mode :math:`m` that incurs if an excitation is created in mode :math:`n` + + This function returns the values of :math:`A_m`. + + For more information on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf. + ''' + Ks = self.kerr(**kwargs) + return np.array([Ks[i, i] for i in range(Ks.shape[0])]) + + @vectorize_kwargs + def kerr(self, **kwargs): + r'''Returns the Kerr parameters for the circuit normal modes. + + The diagonal component ``K[m,m]`` of the returned matrix correspond to the + anharmonicity (or self-Kerr) of mode ``m``. + An off-diagonal component ``K[m,n]`` corresponds to the cross-Kerr coupling + between modes ``m`` and ``n``. + The modes are indexed with increasing normal mode frequencies, + for example ``K[0,1]`` corresponds to the cross-Kerr interaction + between the lowest frequency mode and next highest frequency mode. + Kerr parameters are provided in units of Hertz, + not in angular frequency. + + Parameters + ---------- + kwargs: + Values for un-specified circuit components, + ex: ``L=1e-9``. + + Returns + ------- + numpy.array of dimension 2 + Kerr parameters + + Notes + ----- + The Hamiltonian of a circuit in first order perturbation theory is given by + + :math:`\hat{H} = \sum_m\sum_{n\ne m} (\hbar\omega_m-A_m-\frac{\chi_{mn}}{2})\hat{a}_m^\dagger\hat{a}_m -\frac{A_m}{2}\hat{a}_m^\dagger\hat{a}_m^\dagger\hat{a}_m\hat{a}_m -\chi_{mn}\hat{a}_m^\dagger\hat{a}_m\hat{a}_n^\dagger\hat{a}_n`, + + valid for weak anharmonicity :math:`\chi_{mn},A_m\ll \omega_m`. + + Here + + * :math:`\omega_m` are the frequencies of the normal modes of the circuit where all junctions have been replaced with inductors characterized by their Josephson inductance + + * :math:`A_m` is the anharmonicity of mode :math:`m` , the difference in frequency of the first two transitions of the mode + + * :math:`\chi_{mn}` is the shift in mode :math:`m` that incurs if an excitation is created in mode :math:`n` + + This function returns the values of :math:`A_m` and :math:`\chi_{mn}` . + + For more information on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf. + ''' + + # Compute anharmonicity per junction ``As`` + # where ``As[j,m]`` corresponds to the contribution of junction ``j`` + # to the anharmonicity of mode ``m`` + As = self._anharmonicities_per_junction(**kwargs) + + # Number of modes in the circuit + N_modes = len(self.zeta) + + # Number of junctions in the circuit + N_junctions = len(self.junctions) + + # initialize the vector of Kerr coefficients + Ks = np.zeros((N_modes, N_modes)) + + for i in range(N_modes): + for j in range(N_modes): + for k in range(N_junctions): + if i == j: + # Add contribution to self-Kerr + Ks[i, i] += np.real(As[k][i]) + else: + # Add contribution to cross-Kerr + # Note that taking the square root here is fine + # since Ks[i, j]~phi_ki^2*phi_kj^2 is necessarily a positive real + # since phi_ki,phi_kj are real numbers + Ks[i, j] += 2. * np.sqrt(As[k][i]*As[k][j]) + return Ks + + def f_k_A_chi(self, pretty_print=False, **kwargs): + r'''Returns the eigenfrequency, loss-rates, anharmonicity, and Kerr parameters of the circuit. + + Returns these quantities in the form ``[[f_0,f_1,..],[k_0,k_1,..],[A_0,A_1,..],[[A_0,chi_01,..],[chi_10,A_1,..]..]]`` + + Each quantity is returned as a numpy arrays, + where each index corresponds to a normal mode, ordered with + increasing normal mode frequency. + All quantities are provided in units of Hertz, + not in angular frequency. + + This method is equivalent to calling + + ``[_.eigenfrequencies(**kwargs),_.loss_rates(**kwargs), _.anharmonicities(**kwargs),_.kerr(**kwargs)]`` + + For more details, refer to the functions + + :meth:`qucat.Qcircuit.eigenfrequencies` + + :meth:`qucat.Qcircuit.loss_rates` + + :meth:`qucat.Qcircuit.anharmonicities` + + :meth:`qucat.Qcircuit.kerr` + + Parameters + ---------- + pretty_print: Boolean, optional + If set to True, this method will print a summary + of the system parameters as a table. + kwargs: + Values for un-specified circuit components, + ex: ``L=1e-9``. + + Returns + ------- + List of numpy arrays + ``[[f_0,f_1,..],[k_0,k_1,..],[A_0,A_1,..],[[A_0,chi_01,..],[chi_10,A_1,..]..]]`` + ''' + + # Quantity to be returned: + # eigenfrequency, loss-rates, anharmonicity, and Kerr parameters of the circuit + to_return = self.eigenfrequencies(**kwargs),\ + self.loss_rates(**kwargs),\ + self.anharmonicities(**kwargs),\ + self.kerr(**kwargs) + + + if pretty_print: + + # Number of modes in the circuit + N_modes = len(to_return[0]) + + # Setup a template for the mode/frequency/dissipation/anharmonicity + # table row in the form `` 7 spaces | 7 spaces | 7 spaces | 7 spaces |`` + table_line = "" + for i in range(4): + table_line += " %12s |" + table_line += "\n" + + # Top row for content of columns + to_print = table_line % ( + "mode", " freq. ", " diss. ", " anha. ") + + # add all the other rows (each row is a mode) + for i, w in enumerate(to_return[0]): + to_print += table_line % tuple([str(i)]+[pretty_value( + to_return[j][i], use_unicode=False)+'Hz' for j in range(3)]) + + to_print += "\nKerr coefficients (diagonal = Kerr, off-diagonal = cross-Kerr)\n" + + # Setup template for the rows of the Kerr coefficients table row + # in the form `` 7 spaces | 7 spaces | ...`` + table_line = "" + for i in range(N_modes+1): + table_line += " %12s |" + table_line += "\n" + + # Top row indexing each column as a mode + to_print += table_line % tuple(['mode'] + + [str(i)+' ' for i in range(N_modes)]) + + # Add other rows + for i in range(N_modes): + line_elements = [str(i)] + for j in range(N_modes): + if i >= j: + line_elements.append(pretty_value( + to_return[3][i][j], use_unicode=False)+'Hz') + else: + line_elements.append("") + to_print += table_line % tuple(line_elements) + + # Print the two tables + print(to_print) + + return to_return + + @refuse_vectorize_kwargs(exclude = ['modes','taylor','excitations','return_ops']) + def hamiltonian(self, modes='all', taylor=4, excitations=6, return_ops = False, **kwargs): + r'''Returns the circuits Hamiltonian for further analysis with QuTiP. + The Hamiltonian is provided in units of frequency (not angular frequency), + such that :math:`h=1`. + + Parameters + ---------- + modes: array of integers, optional + List of modes to consider, where the modes are + ordered with increasing frequency, such that + ``modes = [0,1]`` would lead to considering only + the two lowest frequency modes of the circuit. + By default all modes are considered. + taylor: integer, optional + Order to which the potential of all josephson + junctions should be taylor-expanded. Default + is `4`. + excitations:integer or array of integers, optional + Number of energy levels considered for each + junction. If one number is given, all modes + have the same number of levels, if an array + is given, its length should match the number + of modes considered. For example if ``modes = [0,1]`` and + ``excitations = [5,10]``, then we will consider + 5 excitation levels for mode 0 and 10 for mode 1. + return_ops: Boolean, optional + If set to True, a list of the annihilation operators + will be returned along with the hamiltonian in the form + ``, ``. + The form of the return is then ``H,[a_0,a_1,..]`` + where ``a_i`` is the annihilation operator of the + i-th considered mode, a QuTiP Qobj + kwargs: + Values for un-specified circuit components, + ex: ``L=1e-9``. + + Returns + ------- + qutip.qobj + Hamiltonian of the circuit + + Notes + ----- + + The Hamiltonian of the circuit, with the non-linearity of the Josephson junctions + Taylor-expanded, is given in the limit of low dissipation by + + :math:`\hat{H} = \sum_{m\in\text{modes}} \hbar \omega_m\hat{a}_m^\dagger\hat{a}_m + \sum_j\sum_{2n\le\text{taylor}}E_j\frac{(-1)^{n+1}}{(2n)!}\left[\frac{\phi_{zpf,m,j}}{\phi_0}(\hat{a}_m^\dagger+\hat{a}_m)\right]^{2n}`, + + where :math:`\hat{a}_m` is the annihilation operator of the m-th + normal mode of the circuit, :math:`\omega_m` is the frequency of + the m-th normal mode, :math:`E_j` is the Josephson energy of + the j-th junction and :math:`\phi_0 = \hbar/2e` and :math:`\phi_{zpf,m,j}` + is the zero point fluctuation of mode + :math:`m` through junction :math:`j`. + + In the expression above, ``modes`` and ``taylor`` are arguments of the ``hamiltonian`` function. + + For more details on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf + ''' + from qutip import destroy, qeye, tensor + + self.hamiltonian_modes = modes + self.hamiltonian_taylor = taylor + self.hamiltonian_excitations = excitations + + fs = self.eigenfrequencies(**kwargs) + + if modes == 'all': + modes = range(len(fs)) + for m in modes: + try: + fs[m] + except IndexError: + error_message ="There are only %d modes in the circuit, and you specified mode index %d "%(len(fs),m) + error_message +="corresponding to the %d-th mode."%(m+1) + # error_message +="\nNote that the numer of modes may change as one sweeps a parameter" + # error_message +=" for example if a 0 frequency, spurious mode becomes negative due to " + # error_message +="numerical imprecision. Adding a resistance to the circuit may help with this." + raise ValueError(error_message) + + if not isinstance(excitations,list): + excitations = [int(excitations) for i in modes] + else: + if len(excitations)!=len(modes): + raise ValueError("excitations and modes should have the same length") + + + H = 0 + operators = [] + phi = [0 for junction in self.junctions] + qeye_list = [qeye(n) for n in excitations] + + for index,mode in enumerate(modes): + a_to_tensor = deepcopy(qeye_list) + a_to_tensor[index] = destroy(excitations[index]) + a = tensor(a_to_tensor) + operators.append(a) + H += fs[mode]*a.dag()*a + + for j, junction in enumerate(self.junctions): + # Note that zpf returns the flux in units of phi_0 = hbar/2./e + phi[j] += np.real(junction.zpf(quantity='flux',mode=mode, **kwargs))*(a+a.dag()) + # a = x+iy => -i*(a-a^) = -i(iy+iy) = --1 + phi[j] += -1j*np.imag(junction.zpf(quantity='flux',mode=mode, **kwargs))*(a-a.dag()) + + for j, junction in enumerate(self.junctions): + n = 2 + EJ = (hbar/2./e)**2/(junction._get_value(0, **kwargs)*h) + while 2*n <= taylor: + H += (-1)**(n+1)*EJ/factorial(2*n)*phi[j]**(2*n) + n += 1 + + if return_ops: + return H, operators + return H + + @refuse_vectorize_kwargs(exclude = ['plot','return_fig_ax']) + def show(self, + plot=True, + return_fig_ax=False, + **kwargs): + '''Plots the circuit. + + Only works if the circuit was created using the GUI. + + + Parameters + ---------- + plot: Boolean, optional + If set to True (default), the function will call + plt.show() to display the circuit + return_fig_ax: Boolean, optional + If set to True (default is False), the function will + return figure and axis for further processing using + matplotlib. + ''' + pp = self._pp + + if isinstance(self,Network): + #TODO recognize if the network is of series/parallel type + # in which case the circuit can be constructed anyway + raise TypeError(''' + Plotting functions not available if the circuit was not constructed + using the GUI. + ''') + + + xs = [] + ys = [] + line_type = [] + for elt in self.netlist: + x, y, lt = elt._draw() + xs += x + ys += y + line_type += lt + + x_min = min([np.amin(x) for x in xs]) + x_max = max([np.amax(x) for x in xs]) + y_min = min([np.amin(x) for x in ys]) + y_max = max([np.amax(x) for x in ys]) + + x_margin = pp['x_fig_margin'] + # ensures that any text labels are not cutoff + y_margin = pp['y_fig_margin'] + fig = plt.figure(figsize=( + ((x_max-x_min)+2.*x_margin)*pp["figsize_scaling"], + ((y_max-y_min)+2.*y_margin)*pp["figsize_scaling"])) + ax = fig.add_subplot(111) + plt.subplots_adjust(left=0., right=1., top=1., bottom=0.) + + for i, _ in enumerate(xs): + if line_type[i] == "node": + ax.scatter(xs[i], ys[i], color=pp["color"], s=pp['node']['diameter']) + else: + ax.plot(xs[i], ys[i], color=pp["color"], lw=pp[line_type[i]]['lw']) + + for elt in self.netlist: + elt._draw_label(ax) + + ax.set_axis_off() + ax.set_xlim(x_min-x_margin, x_max+x_margin) + ax.set_ylim(y_min-y_margin, y_max+y_margin) + plt.margins(x=0., y=0.) + + if return_fig_ax: + return fig, ax + + if plot: + plt.show() + + plt.close() + + @refuse_vectorize_kwargs(exclude = ['quantity']) + def show_normal_mode(self, + mode, + quantity='current', + plot=True, + return_fig_ax=False, + add_title = True, + add_legend = True, + **kwargs): + r'''Plots a visual representation of a normal mode. + + Only works if the circuit was created using the GUI. + Plots a schematic of the circuit overlayed with + arrows representing the complex amplitude of a certain quantity + :math:`X` which can be flux, current, charge or voltage. + + More specifically, the complex amplitude of :math:`X` if a + single-photon amplitude coherent state were populating a given mode ``mode``. + + Current is shown in units of Ampere, voltage in Volts, + charge in electron charge, and flux in units of the + reduced flux quantum + (defined as :math:`\hbar/2e`) + + The direction of the arrows show what we are defining + as positive current for that component. + + Parameters + ---------- + mode: integer + Determine what mode to plot, where 0 designates + the lowest frequency mode, and the others + are arranged in order of increasing frequency + quantity: string + One of 'current' (default), 'flux','charge','voltage' + Determines what quantity the arrows should represent. + plot: Boolean, optional + If set to True (default), the function will call + plt.show() to display the circuit + return_fig_ax: Boolean, optional + If set to True (default is False), the function will + return figure and axis for further processing using + matplotlib. + add_title: Boolean, optional + If set to True (default), the function will + add a title detailing the modes frequency, anharmonicity + and dissipation rate + add_legend: Boolean, optional + If set to True (default), the function will + add a legend detailing the definition of + arrow size and arrow direction + + Notes + ----- + + This annotated quantity, called a phasor, is calculated by multiplying the + voltage transfer function :math:`T_{rc}` (between a reference component :math:`r` + and the annotated component :math:`c` ), with + :math:`X_{zpf,m,r}`, the zero-point fluctuations of :math:`\hat{X}` at the reference component. + + Note that resistors make the transfer function :math:`T_{rc}`, and hence the phasors complex. + + Since this is plotted for a single-photon amplitude coherent state, the absolute value + of the annotation is equal to the + contribution of a mode to the zero-point fluctuations accross this component. + + For more detail on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf. + ''' + + # This changes the default plotting settings + # to those defined in plotting_settings.py + # under plotting_parameters_normal_modes + self._plotting_normal_mode = True + + # This will set pp to plotting_parameters_normal_modes + # (see the definition of the Qcircuit._pp propoerty function) + pp = self._pp + + # Make sure this has been called on a + # Qcircuit defined with the GUI + if isinstance(self,Network): + raise TypeError(''' + Plotting functions not available if the circuit was not constructed + using the GUI. + ''') + + def pretty(v, quantity): + # Utility function to print a pretty + # value for the phasor + if quantity == 'flux': + return pretty_value(v, is_complex = True)+u"\u03A6_0" + elif quantity == 'charge': + return pretty_value(v, is_complex = True, use_power_10=True)+'e' + elif quantity == 'voltage': + return pretty_value(v, is_complex = True)+'V' + elif quantity == 'current': + return pretty_value(v, is_complex = True)+'A' + + # Plot the circuit and return the + # figure and axis for further + # editing below + fig, ax = self.show( + plot=False, + return_fig_ax=True) + + # Determine smallest and largest arrow size + # Based on the absolute value of the + # phasor through all components + all_values = [] + for el in self.netlist: + if not isinstance(el,W): + all_values.append(el.zpf(mode = mode, quantity = quantity, **kwargs)) + all_values = np.absolute(all_values) + max_value = np.amax(all_values) + min_value = np.amin(all_values) + + def value_to_01_range(value): + # Returns a number between 0 and 1 + # where 0 corresponds to the smallest + # phasor and 1 to the largest + + if pretty(np.absolute(max_value), quantity) == pretty(np.absolute(min_value), quantity): + # Case where all the components have + # the same phasor magnitude + return 1. + else: + return (np.absolute(value)-min_value)/(max_value-min_value) + + def arrow_width(value=None,value_01 = None): + # Converts value between 0 and 1 + # to an arrow width where 0 will + # get the ``min_width`` and + # 1 will get the ``max_width``` + + if value_01 is None: + value_01 = value_to_01_range(value) + + # part of the plotting parameters + # which concern the arrow + ppnm = pp['normal_mode_arrow'] + + return np.absolute(ppnm['min_width']+value_01*(ppnm['max_width']-ppnm['min_width'])) + + def arrow_kwargs(value=None,value_01 = None): + # Constructs the keyword arguments to be passed + # in the construction of an arrow based on the + # zpf value + + if value_01 is None: + value_01 = value_to_01_range(value) + + # part of the plotting parameters + # which concern the arrow + ppnm = pp['normal_mode_arrow'] + + # linewidth + lw = ppnm['min_lw']+value_01*(ppnm['max_lw']-ppnm['min_lw']) + + # head size + head = ppnm['min_head']+value_01 * \ + (ppnm['max_head']-ppnm['min_head']) + + return {'lw': lw, + 'head_width': head, + 'head_length': head, + 'clip_on': False} + + # For each element in the circuit, if it + # isn't a ground, add an arrow and a label + for el in self.netlist: + if not isinstance(el,W): + + # phasor for the quantity and for the current + value = el.zpf(mode = mode, quantity = quantity, **kwargs) + + # location of the element center + x = el.x_plot_center + y = el.y_plot_center + + if el.angle==EAST or el.angle==WEST: + # Case of horizontal element + + # Text position + x_text = x+pp["normal_mode_label"]["text_position_horizontal"][0] + y_text = y+pp["normal_mode_label"]["text_position_horizontal"][1] + + # text alignment + ha = 'center' + va = 'top' + + # Arrow position in y + y_arrow = y+pp["normal_mode_label"]["y_arrow"] + dy_arrow = 0. + + # Arrow position in x + if el.angle == EAST: + # Define the direction for positive values + # and the positive node on the east + x_arrow = x-arrow_width(value)/2. + dx_arrow = arrow_width(value) + elif el.angle == WEST: + # Define the direction for positive values + # and the positive node on the west + x_arrow = x+arrow_width(value)/2. + dx_arrow = -arrow_width(value) + + if el.angle==NORTH or el.angle==SOUTH: + # Case of vertical element + + # Text position + x_text = x+pp["normal_mode_label"]["text_position_vertical"][0] + y_text = y+pp["normal_mode_label"]["text_position_vertical"][1] + + # Text alignment + ha = 'right' + va = 'center' + + # Arrow x position + x_arrow = x-pp["normal_mode_label"]["y_arrow"] + dx_arrow = 0. + + + # Arrow position in y + if el.angle==NORTH: + # Define the direction for positive values + # and the positive node on the north + y_arrow = y-arrow_width(value)/2. + dy_arrow = arrow_width(value) + elif el.angle==SOUTH: + # Define the direction for positive values + # and the positive node on the south + y_arrow = y+arrow_width(value)/2. + dy_arrow = -arrow_width(value) + + + # Add the arrow + if np.real(value)+np.imag(value)<0: + # If the dominating part of the complex number is negative + # Flip the arrow and the value + arrow_coords = [x_arrow+dx_arrow, y_arrow+dy_arrow, -dx_arrow, -dy_arrow] + value = -value + else: + arrow_coords = [x_arrow, y_arrow, dx_arrow, dy_arrow] + + ax.arrow(*arrow_coords, + fc=pp['normal_mode_arrow']['color'], + ec=pp['normal_mode_arrow']['color'], + **arrow_kwargs(value)) + + # Add the annotation + ax.text(x_text, y_text, + pretty(value, quantity), + fontsize=pp["normal_mode_label"]["fontsize"], + ha=ha, va=va, weight='normal',color =pp["normal_mode_label"]["color"] ) + + # Add the title + if add_title: + w,k,A,chi = self.f_k_A_chi(**kwargs) + ax.annotate(r'Mode %d, f=%sHz, k=%sHz, A=%sHz,'% + (mode, + pretty_value(w[mode]), + pretty_value(k[mode]), + pretty_value(A[mode])), + xy=(0.05, 0.97), + horizontalalignment='left', + verticalalignment='top', + xycoords='axes fraction', + fontsize=12, + weight='bold') + + ax.annotate('populated by single-photon amplitude coherent state', + xy=(0.05, 0.97-0.045), + horizontalalignment='left', + verticalalignment='top', + xycoords='axes fraction', + fontsize=12) + + if add_legend: + if quantity == 'current': + value_text= "|I|" + elif quantity == 'voltage': + value_text= u"|V|" + if quantity == 'flux': + value_text= u"|\u03A6|" + elif quantity == 'charge': + value_text= "|Q|" + value_text += u"exp(i\u03B8)" + + x_legend = ax.get_xlim()[0]+0.4 + y_legend = ax.get_ylim()[0]+0.25 + + legend_text_kwargs = { + 'ha':'center', + 'va':'center', + 'fontsize':12, + 'weight':'normal' + } + + ax.text(x_legend, y_legend, + value_text, + **legend_text_kwargs) + + v01 = 0.7 + ax.arrow(x_legend-arrow_width(value_01 = v01)/2, + y_legend-0.15, + arrow_width(value_01 = v01), 0, + fc=pp['normal_mode_arrow']['color'], + ec=pp['normal_mode_arrow']['color'], + **arrow_kwargs(value_01 =v01)) + + + if plot == True: + plt.show() + plt.close() + self._plotting_normal_mode = False + + if return_fig_ax: + return fig, ax + +class Network(Qcircuit): + r'''Constructs a Qcircuit object from a list of components without resorting to a graphical user interface. + + The list can be composed of instances of the :class:`qucat.L`, :class:`qucat.C`, + :class:`qucat.R` or :class:`qucat.J` classes + for inductors, capacitors, resistors or junctions respectively. + + This Qcircuit construction method offers the advantage of programmatically constructing + the circuit of the GUI class. + On could, for example, construct an array of LC-resonators using a python ``for`` loop, which + would be tedious using a graphical user interface. + The disadvantage is that one cannot use the plotting tools :meth:`show` or + :meth:`show_normal_modes` to visualize the circuit or its innerworkings. + + Parameters + ---------- + netlist: list of :class:`qucat.Component` + See examples + + Returns + ------- + qucat.Qcircuit + A Qcircuit object, see qucat.Qcircuit + + Examples + -------- + Here we construct a parallel combination of a capacitor, inductor and junction, grounded + on one end and connected at the other end through a capacitor to a 50 Ohm resistor to ground. + + .. image:: Network_example_circuit.png + + Import the Network class, and the components we will need + + >>> from qucat import Network, R,L,C,J + + Note that the components (R,L,C,J) accept node indexes as their two first arguments, + here we will use the node ``0`` to designate ground. The last arguments should be + a label (``str``) or a value (``float``) or both, the order in which these + arguments are provided are unimportant. + + >>> circuit = Network([ + ... L(0,1,'L',1e-9), # Add the inductor between ground and node 1 + ... C(0,1,100e-15,'C'), # Add the capacitor + ... J(0,1,'L_J'), # Add the junction + ... C(1,2,1e-15), # Add a capacitor which will connect to a resistor + ... R(2,0,50) # Add a 50 Ohm resistance to ground + ... ]) + + The junction was parametrized only by a string ``L_J`` , + this is the best way to proceed if one wants to sweep the value of a + component. Indeed, the most computationally expensive part of the + analysis is performed upon initializing the Network, subsequently + changing the value of a component and re-calculating a quantity + such as the frequency or anharmonicity can be performed much faster. + + For example, we can compute the eigenfrequency, loss-rates, anharmonicity, and Kerr parameters of the circuit + for a specific junction inductance. + + >>> circuit.f_k_A_chi(L_J = 1e-9) + + ''' + + def __init__(self, netlist): + super(Network, self).__init__(netlist) + +class GUI(Qcircuit): + r'''Opens a graphical user interface to constructs a circuit. + + Parameters + ---------- + filename: string + Path to a file which will store all the information + about the graphically constructed circuit. + edit: Boolean + If True (default), the graphical user interface will be opened. + One can set this argument to False to import the circuit without opening + the graphical user interface + plot: Boolean + If True (default), the circuit will be plotted using matplotlib. + print_network: Boolean + If True (default), a text description of the constructed + network will be printed. + + Returns + ------- + qucat.Qcircuit + A Qcircuit object, see qucat.Qcircuit + + Notes + ----- + + All the necessary information about the circuit generated by the graphical user interface application + is stored in a human-readable format at the specified path. + + Each line of this text file is in the format: + + ``type`` ; ``x_minus`` , ``y_minus`` ; ``x_plus`` , ``y_plus`` ; ``value`` ; ``label`` + + and represents a circuit component, wire or ground element. + + ``type`` can take the values ``L``, ``C``, ``R``, ``J``, ``W`` or ``G`` for + inductor, capacitor, resistor, junction, wire or ground respectively. + + ``value`` will be a float representing the value of the component or will be empty + + ``label`` will be a string corresponding to the label of the component or will be empty + + ``x/y_minus`` (``x/y_plus``) represents the horizontal/vertical location of the minus (plus) node of the component. + Negative value are allowed and components have a length of 1 unit. + + For example, the circuit below, is described by the following text file + + :: + + L;3,-10;3,-11;1.000000e-09;L + C;4,-10;4,-11;1.000000e-13;C + J;5,-10;5,-11;;L_J + C;5,-12;6,-12;1.000000e-15; + R;7,-11;7,-12;5.000000e+01; + G;7,-10;7,-11;; + + + .. image:: Network_example_circuit.png + + + ''' + + def __init__(self, filename, edit=True, plot=True, print_network=False,_unittesting=False): + + # Note: this will also give a valid path if filename was specified using + # an absolute path + filename = os.path.join(os.getcwd(),filename) + + try: + with open(filename, 'r') as f: + pass + except FileNotFoundError: + # if file does not exist force the gui to open + edit = True + # and create the folder + os.makedirs(os.path.dirname(filename), exist_ok=True) + # ... and file + with open(filename, "w") as f: + pass + + if edit: + run([sys.executable, + os.path.join(os.path.dirname(__file__),"_gui.py"), + filename]) + + netlist = [] + with open(filename, 'r') as f: + for el in f: + el = el.replace('\n', '') + el = el.split(";") + if el[3] == '': + v = None + else: + v = float(el[3]) + if el[4] == '': + l = None + else: + l = el[4] + netlist.append( + string_to_component(el[0], el[1], el[2], v, l)) + + super(GUI, self).__init__(netlist) + for el in self.netlist: + el._set_plot_coordinates() + + if plot: + self.show() + + if print_network: + for el in [el for el in self.netlist if not isinstance(el,W)]: + print("%s %d %d %s"%( + el.__class__.__name__, + min(el.node_minus,el.node_plus), + max(el.node_minus,el.node_plus), + el._to_string(use_unicode = False))) + print('\n') + +class _Network(object): + """ + The _Network class parses network arrays generated by the GUI + or written manually by the user. + It allows the computation of the R, L and C matrices, the + admittance Y of the network between + two nodes as well as the voltage transfer function of the network + between two ports (4 nodes). + + Parameters + ---------- + netlist : list + list of Component objects + """ + + @timeit + def __init__(self, netlist): + + self.netlist = netlist + self.parse_netlist() + if len(self.net_dict) == 0: + raise ValueError("There are no components in the circuit") + if not self.is_connected(): + raise ValueError("There are two sub-circuits which are not connected") + if self.has_shorts(): + raise ValueError("Your circuit appears to be open or shorted making the analysis impossible") + if self.has_opens(): + raise ValueError("Your circuit appears to be open or shorted making the analysis impossible") + + @timeit + def is_connected(self, + nodes_encountered = None, + start_node = None): + ''' + Determines if a nework is connected (graph theory term). + + Starting at "start_node", + the algorithm will go from neighbouring node + to neighbouring node, adding all encountered + nodes to the encountered_nodes list. + + At then end we check if + all the nodes of the network were encountered + by checking the length of this list with respect + to the total number of nodes + ''' + + encountered_nodes = [] + start_node = list(self.net_dict)[0] # Starting point of the algo + + + def add_neighboors_to_encountered_nodes(node): + if node not in encountered_nodes: + encountered_nodes.append(node) + for neighboor in self.net_dict[node]: + add_neighboors_to_encountered_nodes(neighboor) + + add_neighboors_to_encountered_nodes(start_node) + + if len(encountered_nodes) != len(self.net_dict): + return False + else: + return True + + def has_shorts(self): + ''' + Determines if there is an short circuit. + + For each node, we construct the network where + that node has been removed. + + If the removal of that node leads to two distinct, + non-connected circuits, then that node was a point + at which the circuit was being shorted. + ''' + for node_to_remove in range(len(self.net_dict)): + # create a copy of the network + partial_network = deepcopy(self) + + # remove the node_to_remove from the network + for other_node in partial_network.net_dict[node_to_remove]: + del partial_network.net_dict[other_node][node_to_remove] + del partial_network.net_dict[node_to_remove] + + # check if that network is connected + if not partial_network.is_connected(): + return True + + # No shorts were found + return False + + def has_opens(self): + ''' + Determines if there is an open connection in the + circuit. + + If there are only two nodes in the circuit, it cannot be open. + This is because through another check we are imposing that the circuit has at least + two types of components, one inductive, one capacitive. + So a two node circuit will at minimum be an LC or JC circuit. + + If there are more than two nodes, and one of the nodes is connected + to only one other, the circuit is open. + ''' + for _, connections in self.net_dict.items(): + if len(connections) == 1 and len(self.net_dict)>2: + return True + return False + + def parse_netlist(self): + + def merge_chains(chains, i, j): + '''Merges two chains (two arrays)''' + to_add = chains[j] + del chains[j] + chains[i] = chains[i]+to_add + return chains + + # ``chains``` is a list of node-lists (node-list = a chain) + # each chain lists nodes which are connected one to another + # either through wires or through ground + chains = [] + + # We start by grouping all nodes which are connected by wires + # into chains of nodes indexed by a integer which is to become + # the new node names for future calculations + for el in self.netlist: + + # Go through all the wires (note: grounds are instances of wires) + if isinstance(el,W): + + # If this element is a ground, call it's negative node '__ground' + np = el.node_plus + if type(el) is G: + nm = '__ground' + else: + nm = el.node_minus + + # added tells us if both nodes have already + # been added to a same chain + added = False + + # go through all chains to see if it + # contains the nodes of this wire + for i, ch in enumerate(chains): + + # If both node of the wire have already been + # added to a same chain, don't do anyting + if (nm in ch) and (np in ch): + added = True + + # If minus node was added to chain 'ch'... + elif (nm in ch): + for j, ch2 in enumerate(chains): + # ...and plus node to chain 'ch2' + if np in ch2: + # merge the two chains + chains = merge_chains(chains, i, j) + added = True + if added == False: + # otherwise add plus node to chain 'ch' + ch.append(np) + added = True + + # same check for the plus node + elif (np in ch): + for j, ch2 in enumerate(chains): + if nm in ch2: + chains = merge_chains(chains, i, j) + added = True + if added == False: + ch.append(nm) + added = True + + # if none of the nodes were present in chains, + # create a new chain linking the two nodes of the wire + if added == False: + chains.append([nm, np]) + + def plot_node_to_new_node(plot_node): + ''' + Transforms the node ``plot_node``` to a new node. + + Parameters + ---------- + plot_node: typically a string or an integer, but could be any + hashable object + For GUI generated networks, + this is a string 'x,y' that determines the position + of the node when plotting it. + + Returns + ------- + i: integer, a unique number corresponding to all nodes + connected via a wire or ground. + ``i`` is one of [0,..,N-1] where N is the number of + nodes in the circuit stripped of all wires. + + ''' + i = 0 + # if plot_node is already in a chain, + # return the index of that chain in ``chains`` + for ch in chains: + if plot_node in ch: + return i + i+=1 + + # other wise append ``chains`` and + # return the the last index of ``chains`` + chains.append([plot_node]) + return i + + # replace plotting nodes with new nodes + # for all non-wire elements + # and make a list of all nodes + self.nodes = [] + for el in self.netlist: + el._node_minus_plot = el.node_minus + el._node_plus_plot = el.node_plus + if not isinstance(el,W): + el.node_minus = plot_node_to_new_node(el.node_minus) + el.node_plus = plot_node_to_new_node(el.node_plus) + if el.node_minus == el.node_plus: + raise ValueError("Your circuit appears to be shorted, making the analysis impossible") + for n in [el.node_minus, el.node_plus]: + if n not in self.nodes: + self.nodes.append(n) + + + # build ``net_dict``, a dictionary such that + # ``net_dict[node_A][node_B]`` gives the non-wire circuit + # component connecting ``node_A`` and ``node_B``. + # If ``node_A`` and ``node_B`` are not connected, + # calling ``net_dict[node_A][node_B]`` will raise a KeyError + self.net_dict = {} + for n in self.nodes: + self.net_dict[n] = {} + for el in self.netlist: + if not isinstance(el,W): + self.connect(el, el.node_minus, el.node_plus) + + @timeit + def compute_char_poly_coeffs(self, is_lossy = True): + + @timeit + def determinant(matrix): + return matrix.berkowitz_det() + + self.is_lossy = is_lossy + ntr = deepcopy(self) # ntr stands for Network To Reduce + + # compute conductance matrix + ntr.compute_RLC_matrices() + + if self.is_lossy: + w = sp.Symbol('w') + char_poly = determinant((ntr.RLC_matrices['L']+1j*w*ntr.RLC_matrices['R']-w**2*ntr.RLC_matrices['C'])) + char_poly = sp.collect(sp.expand(char_poly), w) + self.char_poly_order = sp.polys.polytools.degree( + char_poly, gen=w) # Order of the polynomial + # Get polynomial coefficients, index 0 = lowest order term + self.char_poly_coeffs_analytical =\ + [char_poly.coeff(w, n) for n in range(self.char_poly_order+1)] + else: + w2 = sp.Symbol('w2') + char_poly = determinant((-ntr.RLC_matrices['L']+w2*ntr.RLC_matrices['C'])) + char_poly = sp.collect(sp.expand(char_poly), w2) + self.char_poly_order = sp.polys.polytools.degree(char_poly, gen=w2) # Order of the polynomial + # Get polynomial coefficients, index 0 = lowest order term + self.char_poly_coeffs_analytical =\ + [char_poly.coeff(w2, n) for n in range(self.char_poly_order+1)] + + + # Divide by w if possible + n=0 + while self.char_poly_coeffs_analytical[n]==0: + n+=1 + self.char_poly_coeffs_analytical = self.char_poly_coeffs_analytical[n:] + + return self.char_poly_coeffs_analytical + + def compute_RLC_matrices(self): + N_nodes = len(self.net_dict) + self.RLC_matrices = { + 'R':sp.zeros(N_nodes), + 'L':sp.zeros(N_nodes), + 'C':sp.zeros(N_nodes) + } + + for i in range(N_nodes): + for j, el in self.net_dict[i].items(): + if j>i: + RLC_matrix_components = el._get_RLC_matrix_components() + for k in self.RLC_matrices: + self.RLC_matrices[k][i,j] = -RLC_matrix_components[k] + self.RLC_matrices[k][j,i] = -RLC_matrix_components[k] + self.RLC_matrices[k][i,i] += RLC_matrix_components[k] + self.RLC_matrices[k][j,j] += RLC_matrix_components[k] + + # count the number of coefficients in each row + number_coefficients = np.zeros((N_nodes)) + for k in self.RLC_matrices: + for i in range(N_nodes): + for j in range(N_nodes): + if self.RLC_matrices[k][i,j] != 0: + number_coefficients[i]+=1 + + + # set a ground + ground_node = np.argmax(number_coefficients) + for k in self.RLC_matrices: + self.RLC_matrices[k].row_del(ground_node) + self.RLC_matrices[k].col_del(ground_node) + + def connect(self, element, node_minus, node_plus): + ''' + Modifies the ``net_dict`` variable such that ``node_minus`` + and ``node_plus`` are marked as connected in future calculations. + ``net_dict`` is a dictionary such that + ``net_dict[node_A][node_B]`` gives the non-wire circuit + component connecting ``node_A`` and ``node_B``. + If ``node_A`` and ``node_B`` are not connected, + calling ``net_dict[node_A][node_B]`` will raise a KeyError + + Parameters + ---------- + element: a ``Circuit`` object which is not a Wire or a Ground + node_minus: integer + negative node of the element + node_plus: integer + positive node of the element + ''' + + # Connect node minus to node plus + try: + # If the nodes are already connected, add this element in parallel + self.net_dict[node_minus][node_plus] = self.net_dict[node_minus][node_plus] | element + except KeyError: + # Case where the nodes are not connected + self.net_dict[node_minus][node_plus] = element + + # Connect node plus to node minus + try: + self.net_dict[node_plus][node_minus] = self.net_dict[node_plus][node_minus] | element + except KeyError: + self.net_dict[node_plus][node_minus] = element + + def remove_node(self, node_to_remove): + ''' + Makes use of the star-mesh transform to remove the ``node_to_remove`` from the network. + A node N=``node_to_remove`` connected to nodes A,B,C,.. through impedances + Z_A,Z_B,... (the star) can be eliminated + if we interconnect nodes A,B,C,.. with impedances Z_{AB},Z_{AC},Z_{BC},... + given by Z_{XY} = Z_XZ_Y\sum_M1/Z_M. + The resulting network is called the mesh. + + Parameters + ---------- + node: integer, node to be removed of the network stored in ``net_dict`` + ''' + + # List of (connecting_nodes, connecting_components) connecting the + # node_to_remove to (nearest neighbour) connecting_nodes + connections = [x for x in self.net_dict[node_to_remove].items()] + + # Sum of admittances of connecting_components + sum_Y = sum([elt._admittance() for _, elt in connections]) + + # Go through all pairs of connecting nodes + # and calculate the admittance Y_XY that will connect them + # in the mesh + mesh_to_add = [] + for i, (node_A, elt_A) in enumerate(connections): + for node_B, elt_B in connections[i+1:]: + Y = elt_A._admittance()*elt_B._admittance()/sum_Y + mesh_to_add.append([Admittance(node_A, node_B, Y), node_A, node_B]) + + # Remove the node_to_remove from the net_dict, along with all + # the connecting components + for other_node in self.net_dict[node_to_remove]: + del self.net_dict[other_node][node_to_remove] + del self.net_dict[node_to_remove] + + # Add admittances Y_XY connecting nodes X,Y directly adjascent to + # the removed node + for mesh_branch in mesh_to_add: + self.connect(*mesh_branch) + + @timeit + def admittance(self, node_minus, node_plus): + ''' + Compute the admittance of the network between two nodes + ``node_plus`` and ``node_minus`` + by removing all other nodes through star-mesh transformations. + + Parameters + ---------- + node_minus: integer + node_plus: integer + ''' + if node_minus == node_plus: + raise ValueError('node_minus == node_plus') + + # Create a temporary copy of the network which will be reduced + ntr = deepcopy(self) # ntr stands for Network To Reduce + + # # order nodes from the node with the least amount of connections + # # to the one with the most + nodes = [key for key in ntr.net_dict] + nodes_order = np.argsort([len(ntr.net_dict[key]) for key in nodes]) + nodes_sorted = [nodes[i] for i in nodes_order] + + # Remove all nodes except from node_minus, node_plus + # through star-mesh transforms with the remove_node function + for node in nodes_sorted: + if node not in [node_minus, node_plus]: + ntr.remove_node(node) + + # Compute the admittance between the two remaining nodes: + # node_minus and node_plus + Y = ntr.net_dict[node_minus][node_plus]._admittance() + return Y + + def branch_admittance(self, node_1, node_2): + ''' + Returns the admittance in the branch connecting ``node_1`` and ``node_2``. + If they are not directly connected through a single Component, this function + returns 0 (i.e. the admittnce of an open circuit). + This function is written to avoid calling try/except clauses repetitivly + to verify if ``self.net_dict[node_1][node_2]`` is an existing key + + Parameters + ---------- + node_1: integer + node_2: integer + ''' + if node_1 == node_2: + raise ValueError('node_1 == node_2') + + try: + return self.net_dict[node_1][node_2]._admittance() + except KeyError: + return 0. + + def transfer(self, node_left_minus, node_left_plus, node_right_minus, node_right_plus): + ''' + Returns the transfer function V_right/V_left relating the voltage on + a port 'right' defined by ``node_right_minus`` and ``node_right_plus`` + and a port 'left' defined by ``node_left_minus`` and ``node_left_plus`` + We proceed by constructing an ABCD matrix and returning V_right/V_left = 1/A + + Parameters + ---------- + node_left_minus: integer + node_left_plus: integer + node_right_minus: integer + node_right_plus: integer + ''' + + if node_left_minus == node_left_plus: + raise ValueError('node_left_minus == node_left_plus') + elif node_right_minus == node_right_plus: + raise ValueError('node_right_minus == node_right_plus') + + # Case where the left an right port are identical + if (node_left_minus == node_right_minus)\ + and (node_left_plus == node_right_plus): + return 1. + + # Case where the left an right port are identical, but inverted + elif (node_left_plus == node_right_minus)\ + and (node_left_minus == node_right_plus): + return -1. + + # If the ports are not identical, reduce the network such that only + # the nodes provided as arguments remain + + # Create a temporary copy of the network which will be reduced + ntr = deepcopy(self) # ntr stands for Network To Reduce + + # # order nodes from the node with the least amount of connections + # # to the one with the most + nodes = [key for key in ntr.net_dict] + nodes_order = np.argsort([len(ntr.net_dict[key]) for key in nodes]) + nodes_sorted = [nodes[i] for i in nodes_order] + + # Remove nodes using the star-mesh relation + for node in nodes_sorted: + if node not in [node_left_minus, node_left_plus, node_right_minus, node_right_plus]: + ntr.remove_node(node) + + if (node_left_minus in [node_right_plus, node_right_minus]) or\ + (node_left_plus in [node_right_plus, node_right_minus]): + + # Case where there are two of the nodes provided as arguments + # are identical. + # The circuit has then three distinct nodes connected by + # three components. + # For this case, the ABCD matrix can be constructed following + # the before last case of Table 4.1 in Microwave Engineering (Pozar) + # Indeed, all these cases are equivelant to the network below: + # + # p1 --------- Y_3 ---------- p2 + # | | + # Y_1 Y_2 + # | | + # gr ------------------------ gr + # Note that the transfer function is independant of Y_1, this in essence + # a voltage divider (see https://en.wikipedia.org/wiki/Voltage_divider) + # where the voltage at p2 is entirely determined by Y_2,Y_3 and the voltage at p1 + + + if node_left_minus == node_right_minus: + p1 = node_left_plus + p2 = node_right_plus + gr = node_left_minus #= node_right_minus + # Y_1 = ntr.branch_admittance(p1,gr) + Y_2 = ntr.branch_admittance(p2,gr) + Y_3 = ntr.branch_admittance(p1,p2) + + # A component of the ABCD matrix + A = 1+Y_2/Y_3 # node Y_3 cannot be 0 in theory + return 1/A + + elif node_left_plus == node_right_plus: + # Ports 1 and 2 are the wrong way round, minuses cancel out + p1 = node_left_minus + p2 = node_right_minus + gr = node_left_plus #= node_right_plus + + # Y_1 = ntr.branch_admittance(p1,gr) + Y_2 = ntr.branch_admittance(p2,gr) + Y_3 = ntr.branch_admittance(p1,p2) + + # A component of the ABCD matrix + A = 1+Y_2/Y_3 # node Y_3 cannot be 0 in theory + return 1/A + + elif node_left_minus == node_right_plus: + # Port 2 is the wrong way round, transfer function gets a minus + p1 = node_left_plus + p2 = node_right_minus + gr = node_left_minus #= node_right_plus + # Y_1 = ntr.branch_admittance(p1,gr) + Y_2 = ntr.branch_admittance(p2,gr) + Y_3 = ntr.branch_admittance(p1,p2) + + # A component of the ABCD matrix + A = 1+Y_2/Y_3 # node Y_3 cannot be 0 in theory + return -1/A + + elif node_left_plus == node_right_minus: + # Port 2 is the wrong way round, transfer function gets a minus + p1 = node_left_minus + p2 = node_right_plus + gr = node_left_plus #= node_right_minus + # Y_1 = ntr.branch_admittance(p1,gr) + Y_2 = ntr.branch_admittance(p2,gr) + Y_3 = ntr.branch_admittance(p1,p2) + + # A component of the ABCD matrix + A = 1+Y_2/Y_3 # node Y_3 cannot be 0 in theory + return -1/A + + else: + # Most complex case (discussed in the paper) + # First, compute the impence matrix of the lattice network following notations in + # https://www.globalspec.com/reference/71734/203279/10-11-lattice-networks + # excerpt of Network Analysis & Circuit (By M. Arshad) section 10.11: LATTICE NETWORKS + Ya = ntr.branch_admittance(node_left_plus, node_right_plus) + Yb = ntr.branch_admittance(node_left_minus, node_right_plus) + Yc = ntr.branch_admittance(node_left_plus, node_right_minus) + Yd = ntr.branch_admittance(node_left_minus, node_right_minus) + + # The book provides formulas with impedance: + # sum_Z = Za + Zb + Zc + Zd + # Z11 is V1/I1 (with V2=0) + # Z11 = (Za+Zb)*(Zd+Zc)/sum_Z + # Z21 is V1/I2 (with V2=0) + # Z21 = (Zb*Zc-Za*Zd)/sum_Z + # Z22 is V2/I2 (with V1=0) + # Z22 = (Za+Zc)*(Zd+Zb)/sum_Z + + # From Pozar, we obtain the A and B components of the ABCD matrix of the lattice + # The C and D components play no role in determining the transfer function + # A_lattice = Z11/Z21 + # B_lattice = Z11*Z22/Z21-Z21 + + # We will work with admittances, to deal in an easier + # way with Yx = 0 (otherwise we would have to + # distinguish many more cases) + + # Using Mathematica, we compute simplify the expressions for + # A_lattice and B_lattice to: + + A_lattice = (Ya + Yb)*(Yd + Yc)/(Ya*Yd-Yb*Yc) + B_lattice = (Ya + Yb + Yc + Yd)/(Ya*Yd-Yb*Yc) + + # The admittance accross the left port plays no role + # The admittance accross the right port comes into play to yield the A component + # of the total ABCD matrix: + + A = A_lattice + B_lattice*ntr.branch_admittance(node_right_minus,node_right_plus) + + return 1/A + +class Circuit(object): + """docstring for Circuit""" + + def __init__(self, node_minus, node_plus): + self.node_minus = node_minus + self.node_plus = node_plus + self._circuit = None + + def __or__(self, other_circuit): + return Parallel(self, other_circuit) + + def _set_plot_coordinates(self): + + self.x_plot_node_minus = float(self._node_minus_plot.split(',')[0]) + self.x_plot_node_plus = float(self._node_plus_plot.split(',')[0]) + self.y_plot_node_minus = -float(self._node_minus_plot.split(',')[1]) + self.y_plot_node_plus = -float(self._node_plus_plot.split(',')[1]) + self.x_plot_center = (self.x_plot_node_minus + + self.x_plot_node_plus)/2. + self.y_plot_center = (self.y_plot_node_minus + + self.y_plot_node_plus)/2. + if self.x_plot_node_minus == self.x_plot_node_plus: + # increasing y = SOUTH in tkinter + if self.y_plot_node_minus < self.y_plot_node_plus: + self.angle = SOUTH + else: + self.angle = NORTH + else: + if self.x_plot_node_minus < self.x_plot_node_plus: + self.angle = WEST + else: + self.angle = EAST + + def _draw_label(self, ax): + pp = self._circuit._pp + if self.angle%180. == 0.: + x = self.x_plot_center+pp['label']['text_position_horizontal'][0] + y = self.y_plot_center+pp['label']['text_position_horizontal'][1] + ha = 'center' + va = 'top' + + else: + x = self.x_plot_center+pp['label']['text_position_vertical'][0] + y = self.y_plot_center+pp['label']['text_position_vertical'][1] + ha = 'left' + va = 'center' + + ax.text(x, y, + to_string(self.unit, self.label, self.value), + fontsize=pp['label']['fontsize'], + ha=ha, va=va) + +class Parallel(Circuit): + + def __init__(self, left, right): + super(Parallel, self).__init__(node_minus=None, node_plus=None) + + # sets the two children circuit elements + self.left = left + self.right = right + + def _admittance(self): + return Add( + self.left._admittance(), + self.right._admittance()) + + def _get_RLC_matrix_components(self): + RLC_matrix_components = { + 'R':0, + 'L':0, + 'C':0 + } + for el in [self.left,self.right]: + values_to_add = el._get_RLC_matrix_components() + for k in RLC_matrix_components: + RLC_matrix_components[k] += values_to_add[k] + return RLC_matrix_components + +class Component(Circuit): + + def __init__(self, node_minus, node_plus, *args): + super(Component, self).__init__(node_minus, node_plus) + self.label = None + self.value = None + self.__flux = None + self.labels = [None for c in range(3)] + self.values = [None for c in range(3)] + + if len(args)==0: + raise ValueError("Specify either a value or a label") + + for a in args: + + if a in ["", '', ' ', 'None', None]: + break + for i, c in enumerate(a): + if c is None: + pass + elif type(c) is str: + self.labels[i] = c + else: + self.values[i] = c + + + # Check its not too big, too small, or negative + # Note that values above max(min)_float would then + # be interpreted as infinity (or zero) + # if self.value>max_float: + # raise ValueError("Maximum allowed value is %.2e"%max_float) + # elif self.value<0: + # raise ValueError("Value should be a positive float") + # elif 0<=self.value or or , + Other arguments should be a float corresponding to the + inductance, a string corresponding to the + name of that value (ex: `"L"`), or both. + If only a label is provided, + a value for should be passed + as a keyword argument in subsequent function calls + (ex: `L = 1e-9`) + This is the best way to proceed if one wants to sweep the value of this + inductor. Indeed, the most computationally expensive part of the + analysis is performed upon initializing the circuit, subsequently + changing the value of a component and re-calculating a quantity + such as the frequency or anharmonicity can be performed much faster. + """ + def __init__(self, node_minus, node_plus, *args): + super(L, self).__init__(node_minus, node_plus, *args) + self.unit = 'H' + + def _admittance(self): + return -sp.I*Mul(1/sp.Symbol('w'), 1/self._get_value(0)) + + def _set_component_lists(self): + super(L, self)._set_component_lists() + self._circuit.inductors.append(self) + + def _draw(self): + pp = self._circuit._pp + + x = np.linspace(0.5, float( + pp['L']['N_turns']) + 1., pp['L']['N_points']) + y = -np.sin(2.*np.pi*x) + x = np.cos(2.*np.pi*x)+2.*x + + line_type = [] + line_type.append('L') + + # reset leftmost point to 0 + x_min = x[0] + x -= x_min + + # set width inductor width + x_max = x[-1] + x *= pp['L']['width']/x_max + + # set leftmost point to the length of + # the side connection wires + x += (1.-pp['L']['width'])/2. + + # add side wire connections + x_min = x[0] + x_max = x[-1] + x_list = [x] + x_list += [np.array([0., x_min])] + x_list += [np.array([x_max, 1.])] + line_type.append('W') + line_type.append('W') + + # center in x + x_list = shift(x_list, -1./2.) + + # set height of inductor + y *= pp['L']['height']/2. + + # add side wire connections + y_list = [y] + y_list += [np.array([0., 0.])] + y_list += [np.array([0., 0.])] + + if self.angle%180. == 0.: + return shift(x_list, self.x_plot_center), shift(y_list, self.y_plot_center), line_type + if self.angle%180. == 90.: + return shift(y_list, self.x_plot_center), shift(x_list, self.y_plot_center), line_type + + def _get_RLC_matrix_components(self): + return { + 'R':0, + 'L':1/self._get_value(0), + 'C':0 + } + + @timeit + def _compute_flux_zpf_r(self): + ''' + Generate the L._flux_zpf_r function which + takes as an argument an angular frequency (and keyword arguments + if component values need to be specified) and returns the + derivative of the admittance evaluated at the nodes of the inductor, + which is effective capacitance at that frequency. + ''' + # Compute a sympy expression for the admittance + # at the nodes of the reference element + Y = self._circuit._network.admittance(self.node_minus, self.node_plus) + + # Write the expression as a single fraction + # with the numerator and denomenator as polynomials + # (it combines but also "de-nests") + Y_together = sp.together(Y) + + # Extract numerator and denominator + u = sp.numer(Y_together) + v = sp.denom(Y_together) + + # Symbol representing angular frequency + w = sp.Symbol('w') + + # Calculate derivatives + derivatives = [] + for P in [u]:#[u,v]: + # Write as polynomial in 'w' + P = sp.collect(sp.expand(P), w) + + # Obtain the order of the polynomial + P_order = sp.polys.polytools.degree(P, gen=w) + + # Compute list of coefficients + P_coeffs_analytical = [P.coeff(w, n) for n in range(P_order+1)[::-1]] + + # Express the derivative of the polynomial + dP = sum([(P_order-n)*a*w**(P_order-n-1) + for n, a in enumerate(P_coeffs_analytical)]) + + derivatives.append(dP) + + du = derivatives[0] + # dv = derivatives[1] + + # Convert the sympy expression for v/du to a function + # Note the function arguments are the angular frequency + # and component values that need to be specified + dY = lambdify(['w']+self._circuit._no_value_components,du/v, "numpy") + + def _flux_zpf_r(z,**kwargs): + return np.sqrt(hbar/np.real(z)/np.imag(dY(z,**kwargs))) + + self._flux_zpf_r = _flux_zpf_r + + +class J(L): + """A class representing a junction + + Parameters + ---------- + node_minus: integer + Index corresponding to one node of junction + node_minus: integer + Index corresponding to the other node of the junction + args: or or , + Other arguments should be a float which by default + corresponds to the Josephson inductance of the + junction, a string corresponding to the + name of that value (ex: `"L_J"`), or both. + If only a label is provided, + a value for this junction should be passed + as a keyword argument in subsequent function calls + (ex: `L_J = 10e-9`). + This is the best way to proceed if one wants to sweep the value of this + junction. Indeed, the most computationally expensive part of the + analysis is performed upon initializing the circuit, subsequently + changing the value of a component and re-calculating a quantity + such as the frequency or anharmonicity can be performed much faster. + use_E: Boolean + If set to True, the junction will be parametrized by + its Josephson energy, given in units of Hertz, rather + than its Josephson inductance + use_I: Boolean + If set to True, the junction will be parametrized by + its critical current, given in units of Ampere, rather + than its Josephson inductance + """ + def __init__(self, node_minus, node_plus, *args, use_E=False, use_I=False): + super(J, self).__init__(node_minus, node_plus, *args) + + self.use_E = use_E + self.use_I = use_I + if self.use_E: + self.unit = 'Hz' + elif self.use_I: + self.unit = 'A' + else: + self.unit = 'H' + + def _get_value(self, i, **kwargs): + # Returns the Josephson inductance + value = super(J, self)._get_value(i, **kwargs) + if (self.use_E == False) and (self.use_I == False): + print(value) + return value + elif (self.use_E == True) and (self.use_I == False): + L = (hbar/2./e)**2/(value*h) # E is assumed to be provided in Hz + print(L) + return L + elif (use_E == False) and (use_I == True): + L = (hbar/2./e)/value + return L + else: + raise ValueError("Cannot set both use_E and use_I to True") + + def _get_Ej(self, **kwargs): + return (hbar/2./e)**2/(self._get_value(0, **kwargs)*h) + + def _set_component_lists(self): + super(L, self)._set_component_lists() + self._circuit.junctions.append(self) + + @vectorize_kwargs(exclude = ['mode']) + def anharmonicity(self, mode, **kwargs): + r'''Returns the contribution of this junction to the anharmonicity of a given normal mode. + + Returned in units of Hertz, not angular frequency. + + Parameters + ---------- + kwargs: + Values for un-specified circuit components, + ex: ``L=1e-9``. + + mode: integer + where 0 designates + the lowest frequency mode, and the others + are arranged in order of increasing frequency + Returns + ------- + float + contribution of this junction to the anharmonicity of a given normal mode + + Notes + ----- + The quantity returned is the anharmonicity + of the mode ``m`` if this junction were the only junction + present in the circuit (i.e. if all the + others were replaced by linear inductors). + + The total anharmonicity of a mode (in first order perturbation theory) is obtained + by summing these contribution over all modes. + + For more details, see https://arxiv.org/pdf/1908.10342.pdf + ''' + return self._get_Ej(**kwargs)/2*np.absolute(self.zpf(mode,quantity='flux',**kwargs))**4 + + + def _draw(self): + pp = self._circuit._pp + + line_type = [] + x = [ + np.array([0., 1.]), + np.array([(1.-pp['J']['width'])/2., + (1.+pp['J']['width'])/2.]), + np.array([(1.-pp['J']['width'])/2., + (1.+pp['J']['width'])/2.]) + ] + y = [ + np.array([0., 0.]), + np.array([-1., 1.])*pp['J']['width']/2., + np.array([1., -1.])*pp['J']['width']/2. + ] + line_type.append('W') + line_type.append('J') + line_type.append('J') + + # center in x and y + x = shift(x, -1./2.) + + if self.angle%180. == 0.: + return shift(x, self.x_plot_center), shift(y, self.y_plot_center), line_type + if self.angle%180. == 90.: + return shift(y, self.x_plot_center), shift(x, self.y_plot_center), line_type + +class J(L): + + + + def __init__(self, node_minus, node_plus, *args): + super(J, self).__init__(node_minus, node_plus, *args) + self.unit = 'Hz' + + + + + + def _get_value(self, i, **kwargs): + value = super(J, self)._get_value(i, **kwargs) + + L = (hbar/2./e)**2/(value*h) # E is assumed to be provided in Hz + return L + + + def _get_Ej(self, i, **kwargs): + if i == 0: + print((hbar/2./e)**2/(self._get_value(i, **kwargs)*h)) + return (hbar/2./e)**2/(self._get_value(i, **kwargs)*h) + else: + return super(J, self)._get_value(i, **kwargs) + + def _set_component_lists(self): + super(J, self)._set_component_lists() + self._circuit.junctions.append(self) + + @vectorize_kwargs(exclude = ['mode']) + def anharmonicity(self, mode, **kwargs): + r'''Returns the contribution of this junction to the anharmonicity of a given normal mode. + + Returned in units of Hertz, not angular frequency. + + Parameters + ---------- + kwargs: + Values for un-specified circuit components, + ex: ``L=1e-9``. + + mode: integer + where 0 designates + the lowest frequency mode, and the others + are arranged in order of increasing frequency + Returns + ------- + float + contribution of this junction to the anharmonicity of a given normal mode + + Notes + ----- + The quantity returned is the anharmonicity + of the mode ``m`` if this junction were the only junction + present in the circuit (i.e. if all the + others were replaced by linear inductors). + + The total anharmonicity of a mode (in first order perturbation theory) is obtained + by summing these contribution over all modes. + + For more details, see https://arxiv.org/pdf/1908.10342.pdf + ''' + return self._get_Ej(2, **kwargs)/2*np.absolute(self.zpf(mode,quantity='flux',**kwargs))**4 + + + def _draw(self): + pp = self._circuit._pp + + line_type = [] + x = [ + np.array([0., 1.]), + np.array([(1.-pp['J']['width'])/2., + (1.+pp['J']['width'])/2.]), + np.array([(1.-pp['J']['width'])/2., + (1.+pp['J']['width'])/2.]) + ] + y = [ + np.array([0., 0.]), + np.array([-1., 1.])*pp['D']['width']/2., + np.array([1., -1.])*pp['D']['width']/2. + ] + line_type.append('W') + line_type.append('J') + line_type.append('J') + + # center in x and y + x = shift(x, -1./2.) + + if self.angle%180. == 0.: + return shift(x, self.x_plot_center), shift(y, self.y_plot_center), line_type + if self.angle%180. == 90.: + return shift(y, self.x_plot_center), shift(x, self.y_plot_center), line_type + + +class R(Component): + """A class representing a resistor + + Parameters + ---------- + node_minus: integer + Index corresponding to one node of resistor + node_minus: integer + Index corresponding to the other node of the resistor + args: or or , + Other arguments should be a float corresponding to the + resistance, a string corresponding to the + name of that value (ex: `"R"`), or both. + If only a label is provided, + a value for should be passed + as a keyword argument in subsequent function calls + (ex: `R = 1e-9`) + This is the best way to proceed if one wants to sweep the value of this + resistor. Indeed, the most computationally expensive part of the + analysis is performed upon initializing the circuit, subsequently + changing the value of a component and re-calculating a quantity + such as the dissipation rate can be performed much faster. + """ + def __init__(self, node_minus, node_plus, *args): + super(R, self).__init__(node_minus, node_plus, *args) + self.unit = u"\u03A9" + + def _admittance(self): + return 1/self._get_value(0) + + def _set_component_lists(self): + super(R, self)._set_component_lists() + self._circuit.resistors.append(self) + + def _get_RLC_matrix_components(self): + return { + 'R':1/self._get_value(0), + 'L':0, + 'C':0 + } + + def _draw(self): + pp = self._circuit._pp + + x = np.linspace(-0.25, 0.25 +float(pp['R']['N_ridges']), pp['R']['N_points']) + height = 1. + period = 1. + a = height*2.*(-1.+2.*np.mod(np.floor(2.*x/period), 2.)) + b = -height*2.*np.mod(np.floor(2.*x/period), 2.) + y = (2.*x/period - np.floor(2.*x/period))*a+b+height + + line_type = [] + line_type.append('R') + + # reset leftmost point to 0 + x_min = x[0] + x -= x_min + + # set width inductor width + x_max = x[-1] + x *= pp['R']['width']/x_max + + # set leftmost point to the length of + # the side connection wires + x += (1.-pp['R']['width'])/2. + + # add side wire connections + x_min = x[0] + x_max = x[-1] + x_list = [x] + x_list += [np.array([0., x_min])] + x_list += [np.array([x_max, 1.])] + line_type.append('W') + line_type.append('W') + + # center in x + x_list = shift(x_list, -1./2.) + + # set height of inductor + y *= pp['R']['height']/2. + + # add side wire connections + y_list = [y] + y_list += [np.array([0., 0.])] + y_list += [np.array([0., 0.])] + + if self.angle%180. == 0.: + return shift(x_list, self.x_plot_center), shift(y_list, self.y_plot_center), line_type + if self.angle%180. == 90.: + return shift(y_list, self.x_plot_center), shift(x_list, self.y_plot_center), line_type + +class C(Component): + """A class representing a capacitor + + Parameters + ---------- + node_minus: integer + Index corresponding to one node of capacitor + node_minus: integer + Index corresponding to the other node of the capacitor + args: or or , + Other arguments should be a float corresponding to the + capacitance, a string corresponding to the + name of that value (ex: `"C"`), or both. + If only a label is provided, + a value for should be passed + as a keyword argument in subsequent function calls + (ex: `C = 1e-9`) + This is the best way to proceed if one wants to sweep the value of this + capacitor. Indeed, the most computationally expensive part of the + analysis is performed upon initializing the circuit, subsequently + changing the value of a component and re-calculating a quantity + such as the anharmonicity can be performed much faster. + """ + def __init__(self, node_minus, node_plus, *args): + super(C, self).__init__(node_minus, node_plus, *args) + self.unit = 'F' + + def _admittance(self): + return sp.I*Mul(sp.Symbol('w'), self._get_value(0)) + + def _set_component_lists(self): + super(C, self)._set_component_lists() + self._circuit.capacitors.append(self) + + def _draw(self): + pp = self._circuit._pp + line_type = [] + x = [ + np.array([0., (1.-pp['C']['gap'])/2.]), + np.array([(1.+pp['C']['gap']) / + 2., 1.]), + np.array([(1.-pp['C']['gap'])/2., + (1.-pp['C']['gap'])/2.]), + np.array([(1.+pp['C']['gap'])/2., + (1.+pp['C']['gap'])/2.]), + ] + y = [ + np.array([0., 0.]), + np.array([0., 0.]), + np.array([-pp['C']['height']/2., pp['C']['height']/2.]), + np.array([-pp['C']['height']/2., pp['C']['height']/2.]), + ] + line_type.append('W') + line_type.append('W') + line_type.append('C') + line_type.append('C') + + # center in x and y + x = shift(x, -1./2.) + + if self.angle%180. == 0.: + return shift(x, self.x_plot_center), shift(y, self.y_plot_center), line_type + if self.angle%180. == 90.: + return shift(y, self.x_plot_center), shift(x, self.y_plot_center), line_type + + def _get_RLC_matrix_components(self): + return { + 'R':0, + 'L':0, + 'C':self._get_value(0) + } + +class Admittance(Component): + def __init__(self, node_minus, node_plus, Y): + self.node_minus = node_minus + self.node_plus = node_plus + self.Y = Y + + def _admittance(self): + return self.Y \ No newline at end of file From dfe216ac01f29a4a5203b6a2e0d87e3d73132348 Mon Sep 17 00:00:00 2001 From: Hector Date: Mon, 4 May 2020 17:52:57 +0200 Subject: [PATCH 02/17] Changed class J so it can be an arbitrary component. Gui works with it but in a special way : labels must be lists, and values float. --- src/_generate_graphics.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/_generate_graphics.py b/src/_generate_graphics.py index ba32bca6..dae3975f 100644 --- a/src/_generate_graphics.py +++ b/src/_generate_graphics.py @@ -83,4 +83,4 @@ def generate_icon(comp, hover=False, selected=False): generate_icon(string_to_component(el, None, None, ''), hover=True) generate_icon(string_to_component(el, None, None, ''), selected=True) generate_icon( - string_to_component(el, None, None, ''), hover=True, selected=True) + string_to_component(el, None, None, ''), hover=True, selected=True) \ No newline at end of file From 912657007d26752510b6d8b7c3905b601690b399 Mon Sep 17 00:00:00 2001 From: Hector Date: Mon, 4 May 2020 18:01:26 +0200 Subject: [PATCH 03/17] Same as before with all the changes --- src/core.py | 292 +++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 243 insertions(+), 49 deletions(-) diff --git a/src/core.py b/src/core.py index f588f5ba..fd43ee79 100644 --- a/src/core.py +++ b/src/core.py @@ -1,5 +1,7 @@ import sympy as sp +import scipy from sympy.utilities.lambdify import lambdify +from sympy import Function import numpy as np from numpy.polynomial.polynomial import Polynomial as npPoly from sympy.core.mul import Mul, Pow, Add @@ -21,6 +23,9 @@ from _constants import * from _utility import * from plotting_settings import plotting_parameters_show,plotting_parameters_normal_modes + +from scipy.optimize import minimize as mini +from numpy import cos, sin PROFILING = False @@ -56,6 +61,14 @@ def string_to_component(s, *arg, **kwarg): ------- A component of type ``s`` ''' + + print(arg) + l = [c for c in arg] + for i,c in enumerate(arg): + if type(c) in [float, int]: + l[i] = [c] + arg = l + if s == 'W': return W(*arg, **kwarg) elif s == 'R': @@ -65,10 +78,12 @@ def string_to_component(s, *arg, **kwarg): elif s == 'J': return J(*arg, **kwarg) elif s == 'C': - return C(*arg, **kwarg) + return C(*arg, **kwarg) elif s == 'G': return G(*arg, **kwarg) + + class Qcircuit(object): """A class representing a quantum circuit. @@ -159,8 +174,12 @@ def __init__(self, netlist): # define the functions which returns the components of the characteristic polynomial # (the roots of which are the eigen-frequencies) - self._char_poly_coeffs = [lambdify(self._no_value_components, c, 'numpy') + self._char_poly_coeffs = [lambdify(self._no_value_components, c, ['numpy']) for c in self._network.compute_char_poly_coeffs(is_lossy = (len(self.resistors)>0))] + +#self.no_value_components : array de tous les labels non spécifiés +#c = expression sympy + @property def _pp(self): @@ -362,6 +381,7 @@ def _anharmonicities_per_junction(self, **kwargs): self._set_zeta(**kwargs) return [[j.anharmonicity(mode, **kwargs) for mode in range(len(self.zeta))] for j in self.junctions] + @vectorize_kwargs def eigenfrequencies(self, **kwargs): '''Returns the normal mode frequencies of the circuit. @@ -573,6 +593,26 @@ def kerr(self, **kwargs): Ks[i, j] += 2. * np.sqrt(As[k][i]*As[k][j]) return Ks + @vectorize_kwargs + def three_waves(self, mode1, mode2, mode3, **kwargs): + # Compute three terms per junction ``As`` + # where ``As[j,m1, m2, m3]`` corresponds to the contribution of junction ``j`` + # to the three_wave mixing term of modes m1, m2, m3 + self._set_zeta(**kwargs) + + # Number of junctions in the circuit + N_junctions = len(self.junctions) + + # initialize the vector of Kerr coefficients + Tw = 0 + for j in self.junctions: + Tw += j.three_term(mode1, mode2, mode3, **kwargs) + return Tw + + + + + def f_k_A_chi(self, pretty_print=False, **kwargs): r'''Returns the eigenfrequency, loss-rates, anharmonicity, and Kerr parameters of the circuit. @@ -780,7 +820,7 @@ def hamiltonian(self, modes='all', taylor=4, excitations=6, return_ops = False, for j, junction in enumerate(self.junctions): n = 2 - EJ = (hbar/2./e)**2/(junction._get_value(**kwargs)*h) + EJ = (hbar/2./e)**2/(junction._get_value(0, **kwargs)*h) while 2*n <= taylor: H += (-1)**(n+1)*EJ/factorial(2*n)*phi[j]**(2*n) n += 1 @@ -1345,8 +1385,12 @@ def __init__(self, filename, edit=True, plot=True, print_network=False,_unittest v = float(el[3]) if el[4] == '': l = None - else: - l = el[4] + else: + l = el[4][1:-1].split(",") + + + + netlist.append( string_to_component(el[0], el[1], el[2], v, l)) @@ -2057,56 +2101,72 @@ def __init__(self, node_minus, node_plus, *args): self.label = None self.value = None self.__flux = None - + self.labels = [None for c in range(3)] + self.values = [None for c in range(3)] + if len(args)==0: raise ValueError("Specify either a value or a label") - for a in args: - if a is None: + + for a in args: + + if a in ["", '', ' ', 'None', None]: pass - elif type(a) is str: - self.label = a else: - self.value = a + for i, c in enumerate(a): + if c is None: + pass + elif type(c) is str: + self.labels[i] = c + else: + self.values[i] = c # Check its not too big, too small, or negative # Note that values above max(min)_float would then # be interpreted as infinity (or zero) - if self.value>max_float: - raise ValueError("Maximum allowed value is %.2e"%max_float) - elif self.value<0: - raise ValueError("Value should be a positive float") - elif 0<=self.valuemax_float: + # raise ValueError("Maximum allowed value is %.2e"%max_float) + # elif self.value<0: + # raise ValueError("Value should be a positive float") + # elif 0<=self.value Date: Mon, 4 May 2020 20:42:04 +0200 Subject: [PATCH 04/17] print elements for checking removed --- src/_utility.py | 3 ++- src/core.py | 1 - 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/_utility.py b/src/_utility.py index 49be0031..2687730a 100644 --- a/src/_utility.py +++ b/src/_utility.py @@ -113,6 +113,7 @@ def wrapper_vectorize(self, *args,**kwargs): non_iterables[kw] = arg else: if np.any(np.array([arg]) == 0): + pass raise ValueError("Cannot set value of element %s to zero"%kw) try: iter(arg) @@ -276,4 +277,4 @@ def to_string(unit,label,value, use_unicode=True, maximum_info = False): if unit is not None: s+=unit - return s + return s \ No newline at end of file diff --git a/src/core.py b/src/core.py index fd43ee79..53af777e 100644 --- a/src/core.py +++ b/src/core.py @@ -2650,7 +2650,6 @@ def _get_value(self, i, **kwargs): def _get_Ej(self, i, **kwargs): if i == 0: - print((hbar/2./e)**2/(self._get_value(i, **kwargs)*h)) return (hbar/2./e)**2/(self._get_value(i, **kwargs)*h) else: return super(J, self)._get_value(i, **kwargs) From 370b0006c0b7a70b389d94b3a04deced7f1d6ecd Mon Sep 17 00:00:00 2001 From: Hector Date: Mon, 4 May 2020 20:48:19 +0200 Subject: [PATCH 05/17] removed the print Please enter the commit message for your changes. Lines starting --- src/core.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/core.py b/src/core.py index 53af777e..8548c01b 100644 --- a/src/core.py +++ b/src/core.py @@ -62,7 +62,6 @@ def string_to_component(s, *arg, **kwarg): A component of type ``s`` ''' - print(arg) l = [c for c in arg] for i,c in enumerate(arg): if type(c) in [float, int]: From 2265ca8d9eb8323997259a4476b3d01cfc98db80 Mon Sep 17 00:00:00 2001 From: Hector Date: Tue, 5 May 2020 15:30:28 +0200 Subject: [PATCH 06/17] Arbitrary Dipole D added everywhere. Only classical dipoles can have a specified value. The arbitrary Dipole can't have any specified value, and each needs a list of three labels that are used only by it. Other labels of other dipoles need to be put between [] even if single. The values are specified as usual (only the value, no []) --- src/.graphics/D.jpg | Bin 0 -> 18080 bytes src/.graphics/D.png | Bin 0 -> 12369 bytes src/.graphics/D_hover.jpg | Bin 0 -> 17856 bytes src/.graphics/D_hover.png | Bin 0 -> 12467 bytes src/.graphics/D_hover_selected.jpg | Bin 0 -> 25060 bytes src/.graphics/D_hover_selected.png | Bin 0 -> 13267 bytes src/.graphics/D_selected.jpg | Bin 0 -> 25526 bytes src/.graphics/D_selected.png | Bin 0 -> 13251 bytes src/_generate_graphics.py | 3 +++ src/_gui.py | 27 ++++++++++++++++++++++ src/core.py | 36 +++++++++++++++-------------- src/plotting_settings.py | 9 ++++++++ 12 files changed, 58 insertions(+), 17 deletions(-) create mode 100644 src/.graphics/D.jpg create mode 100644 src/.graphics/D.png create mode 100644 src/.graphics/D_hover.jpg create mode 100644 src/.graphics/D_hover.png create mode 100644 src/.graphics/D_hover_selected.jpg create mode 100644 src/.graphics/D_hover_selected.png create mode 100644 src/.graphics/D_selected.jpg create mode 100644 src/.graphics/D_selected.png diff --git a/src/.graphics/D.jpg b/src/.graphics/D.jpg new file mode 100644 index 0000000000000000000000000000000000000000..04e43147e37a957cd210800e82a8e83b1aff89d8 GIT binary patch literal 18080 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 ScAt^L%A-xk$K0QYSN<24+g=C& literal 0 HcmV?d00001 diff --git a/src/.graphics/D.png b/src/.graphics/D.png new file mode 100644 index 0000000000000000000000000000000000000000..f5fed7e680041e3a6733f61927b9efe601988806 GIT binary patch literal 12369 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 literal 0 HcmV?d00001 diff --git a/src/.graphics/D_hover.jpg b/src/.graphics/D_hover.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f027cd87a9deeeb0095212033b57dda96adec876 GIT binary patch literal 17856 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 literal 0 HcmV?d00001 diff --git a/src/.graphics/D_hover.png b/src/.graphics/D_hover.png new file mode 100644 index 0000000000000000000000000000000000000000..55f1a236a4b398a5296c47c92708cae83edafd9d GIT binary patch literal 12467 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 literal 0 HcmV?d00001 diff --git a/src/.graphics/D_hover_selected.jpg b/src/.graphics/D_hover_selected.jpg new file mode 100644 index 0000000000000000000000000000000000000000..84001981e4951b4920ed7a6ab7c5d4f57e8392cd GIT binary patch literal 25060 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 HV=etZy0(mg literal 0 HcmV?d00001 diff --git a/src/.graphics/D_hover_selected.png b/src/.graphics/D_hover_selected.png new file mode 100644 index 0000000000000000000000000000000000000000..cdbabd98b4c254cc268ad09df9b292af698cb40a GIT binary patch literal 13267 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 literal 0 HcmV?d00001 diff --git a/src/.graphics/D_selected.jpg b/src/.graphics/D_selected.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f8bc31741de52b74ea33a21b48dcfcf37345ef9 GIT binary patch literal 25526 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 K*3-yD&Hn*x$v-Cm literal 0 HcmV?d00001 diff --git a/src/.graphics/D_selected.png b/src/.graphics/D_selected.png new file mode 100644 index 0000000000000000000000000000000000000000..f3c014642b299b390946ac454f8247b60c6fcea7 GIT binary patch literal 13251 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 literal 0 HcmV?d00001 diff --git a/src/_generate_graphics.py b/src/_generate_graphics.py index dae3975f..82404a21 100644 --- a/src/_generate_graphics.py +++ b/src/_generate_graphics.py @@ -45,6 +45,8 @@ def generate_icon(comp, hover=False, selected=False): pp['L']['lw'] += pp['hover_increment'] pp['R']['lw'] += pp['hover_increment'] pp['J']['lw'] += pp['hover_increment'] + pp['D']['lw'] += pp['hover_increment'] + state_string = '_hover_selected' ax.add_patch(Rectangle(*rect_args, edgecolor=blue, **rect_kwargs)) elif hover: @@ -53,6 +55,7 @@ def generate_icon(comp, hover=False, selected=False): pp['L']['lw'] += pp['hover_increment'] pp['R']['lw'] += pp['hover_increment'] pp['J']['lw'] += pp['hover_increment'] + pp['D']['lw'] += pp['hover_increment'] state_string = '_hover' # ax.add_patch(Rectangle(*rect_args,edgecolor=lighter_blue,**rect_kwargs)) elif selected: diff --git a/src/_gui.py b/src/_gui.py index 0f92a1e6..2d5b299f 100644 --- a/src/_gui.py +++ b/src/_gui.py @@ -568,6 +568,10 @@ def generate_delete_all_key_sequence(): label=label_template.format("Junction", ""), command=(lambda: self.event_generate('j')), font=menu_font) + menu.add_command( + label=label_template.format("Dipole", ""), + command=(lambda: self.event_generate('d')), + font=menu_font) menu.add_command( label=label_template.format("Inductor", ""), command=(lambda: self.event_generate('l')), @@ -1093,6 +1097,8 @@ def load_netlist(self, lines): L(self, auto_place_info=el) elif el[0] == 'J': J(self, auto_place_info=el) + elif el[0] == 'D': + D(self, auto_place_info=el) elif el[0] == 'C': C(self, auto_place_info=el) elif el[0] == 'G': @@ -1289,6 +1295,7 @@ def define_permenant_bindings(self): ['l', lambda event: L(self, event)], ['c', lambda event: C(self, event)], ['j', lambda event: J(self, event)], + ['d', lambda event: D(self, event)], ['w', lambda event: W(self, event)], ['g', lambda event: G(self, event)] ] @@ -2856,6 +2863,7 @@ def manual_place(self, event): self.canvas.bind('l', self.abort_creation) self.canvas.bind('c', self.abort_creation) self.canvas.bind('j', self.abort_creation) + self.canvas.bind('d', self.abort_creation) self.canvas.bind('w', self.abort_creation) self.canvas.bind('g', self.abort_creation) @@ -3220,6 +3228,7 @@ def init_create_component(self, event, angle=0.): self.canvas.bind('l', self.abort_creation) self.canvas.bind('c', self.abort_creation) self.canvas.bind('j', self.abort_creation) + self.canvas.bind('d', self.abort_creation) self.canvas.bind('w', self.abort_creation) self.canvas.bind('g', self.abort_creation) self.canvas.bind('', lambda event: self.init_create_component(event, angle=WEST)) @@ -3435,6 +3444,13 @@ def __init__(self, canvas, event=None, auto_place_info=None): self.unit = 'H' super(J, self).__init__(canvas, event, auto_place_info) +class D(Component): + """docstring for J""" + + def __init__(self, canvas, event=None, auto_place_info=None): + self.unit = 'H' + super(D, self).__init__(canvas, event, auto_place_info) + class G(Component): """docstring for J""" @@ -3513,16 +3529,27 @@ def __init__(self, master, component): if isinstance(self.component,C): info_text = 'Specify label and/or capacitance (in units of Farad)' self.value_string = 'Capacitance' + info_text += '\nPut the label between []: [label]' + elif isinstance(self.component,J): self.value_string = 'Inductance' info_text = 'Specify label and/or Josephson inductance (in units of Henry)' info_text += '\nNote that L = (hbar/2/e)**2/[Josephson Energy in Joules]' + info_text += '\nPut the label between []: [label]' + + elif isinstance(self.component,D): + self.value_string = 'Energy' + info_text = 'Specify a list of three labels for the dipole (the 2nd, 3rd and 4th derivatives of the inductance energy)' + info_text += '\nDo not specify any value, they have to be passed as kwargs in further computations' elif isinstance(self.component,L): self.value_string = 'Inductance' info_text = 'Specify label and/or inductance (in units of Henry)' + info_text += '\nPut the label between []: [label]' elif isinstance(self.component,R): self.value_string = 'Resistance' info_text = 'Specify label and/or resistance (in units of Ohm)' + info_text += '\nPut the label between []: [label]' + # Entry field strings fields = self.value_string, 'Label' diff --git a/src/core.py b/src/core.py index 8548c01b..0fc396ca 100644 --- a/src/core.py +++ b/src/core.py @@ -76,6 +76,8 @@ def string_to_component(s, *arg, **kwarg): return L(*arg, **kwarg) elif s == 'J': return J(*arg, **kwarg) + elif s == 'D': + return D(*arg, **kwarg) elif s == 'C': return C(*arg, **kwarg) elif s == 'G': @@ -95,7 +97,7 @@ class Qcircuit(object): junctions (list): List of junction objects present in the circuit capacitors (list): List of capacitor objects present in the circuit netlist (list): List of all components present in the circuit - ref_elt (J or L): list of junction or inductor component used as a reference for the calculation + ref_elt (J or L or D): list of junction or inductor component used as a reference for the calculation of zero-point fluctations, each index of the list corresponds to a different mode """ @@ -2545,7 +2547,7 @@ def __init__(self, node_minus, node_plus, *args, use_E=False, use_I=False): def _get_value(self, i, **kwargs): # Returns the Josephson inductance - value = super(J, self)._get_value(i, **kwargs) + value = super(J, self)._get_value(0, **kwargs) #Only 1 value specified if (self.use_E == False) and (self.use_I == False): return value elif (self.use_E == True) and (self.use_I == False): @@ -2557,7 +2559,7 @@ def _get_value(self, i, **kwargs): else: raise ValueError("Cannot set both use_E and use_I to True") - def _get_Ej(self, **kwargs): + def _get_Ej(self, i, **kwargs): return (hbar/2./e)**2/(self._get_value(0, **kwargs)*h) def _set_component_lists(self): @@ -2597,7 +2599,7 @@ def anharmonicity(self, mode, **kwargs): For more details, see https://arxiv.org/pdf/1908.10342.pdf ''' - return self._get_Ej(**kwargs)/2*np.absolute(self.zpf(mode,quantity='flux',**kwargs))**4 + return self._get_Ej(i, **kwargs)/2*np.absolute(self.zpf(mode,quantity='flux',**kwargs))**4 def _draw(self): @@ -2628,12 +2630,12 @@ def _draw(self): if self.angle%180. == 90.: return shift(y, self.x_plot_center), shift(x, self.y_plot_center), line_type -class J(L): +class D(L): def __init__(self, node_minus, node_plus, *args): - super(J, self).__init__(node_minus, node_plus, *args) + super(D, self).__init__(node_minus, node_plus, *args) self.unit = 'Hz' @@ -2641,7 +2643,7 @@ def __init__(self, node_minus, node_plus, *args): def _get_value(self, i, **kwargs): - value = super(J, self)._get_value(i, **kwargs) + value = super(D, self)._get_value(i, **kwargs) L = (hbar/2./e)**2/(value*h) # E is assumed to be provided in Hz return L @@ -2651,10 +2653,10 @@ def _get_Ej(self, i, **kwargs): if i == 0: return (hbar/2./e)**2/(self._get_value(i, **kwargs)*h) else: - return super(J, self)._get_value(i, **kwargs) + return super(D, self)._get_value(i, **kwargs) def _set_component_lists(self): - super(J, self)._set_component_lists() + super(D, self)._set_component_lists() self._circuit.junctions.append(self) @@ -2738,19 +2740,19 @@ def _draw(self): line_type = [] x = [ np.array([0., 1.]), - np.array([(1.-pp['J']['width'])/2., - (1.+pp['J']['width'])/2.]), - np.array([(1.-pp['J']['width'])/2., - (1.+pp['J']['width'])/2.]) + np.array([(1.-pp['D']['width'])/2., + (1.+pp['D']['width'])/2.]), + np.array([(1.-pp['D']['width'])/2., + (1.+pp['D']['width'])/2.]) ] y = [ np.array([0., 0.]), - np.array([-1., 1.])*pp['J']['width']/2., - np.array([1., -1.])*pp['J']['width']/2. + np.array([-1., 1.])*pp['D']['width']/2., + np.array([1., -1.])*pp['D']['width']/2. ] line_type.append('W') - line_type.append('J') - line_type.append('J') + line_type.append('D') + line_type.append('D') # center in x and y x = shift(x, -1./2.) diff --git a/src/plotting_settings.py b/src/plotting_settings.py index aa53f129..e702e73a 100644 --- a/src/plotting_settings.py +++ b/src/plotting_settings.py @@ -25,6 +25,10 @@ "width": 0.22, "lw": 6 }, + "D": { + "width": 0.22, + "lw": 6 + }, "L": { "width": 0.7, "height": 0.25, @@ -67,6 +71,7 @@ pp["C"]["gap"] /= scale pp["C"]["height"] /= scale pp["J"]["width"] /= scale +pp["D"]["width"] /= scale pp["L"]["width"] /= scale pp["L"]["height"] /= scale pp["R"]["width"] /= scale @@ -119,6 +124,10 @@ "width": 0.25, "lw": 6 }, + "D": { + "width": 0.25, + "lw": 6 + }, "L": { "width": 0.7, "height": 0.25, From bf025be52894d7168fcc7d1adfc0934da1f5eacc Mon Sep 17 00:00:00 2001 From: Hector Date: Tue, 5 May 2020 18:03:31 +0200 Subject: [PATCH 07/17] D _get_value modified so that given the derivatives of the inductance energy, the returned value correspond to the form of the hamiltonian given in original qucat. several Dipoles can share the same label, allows faster computation --- src/core.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/core.py b/src/core.py index 0fc396ca..bb419b36 100644 --- a/src/core.py +++ b/src/core.py @@ -2652,6 +2652,8 @@ def _get_value(self, i, **kwargs): def _get_Ej(self, i, **kwargs): if i == 0: return (hbar/2./e)**2/(self._get_value(i, **kwargs)*h) + elif i == 2: + return -super(D, self)._get_value(i, **kwargs) else: return super(D, self)._get_value(i, **kwargs) From 7155477bef81046f564cbef9af9e10b888ecea30 Mon Sep 17 00:00:00 2001 From: Hector Date: Tue, 5 May 2020 23:13:39 +0200 Subject: [PATCH 08/17] Error in D _set_component_list corrected r Please enter the commit message for your changes. Lines starting --- src/core.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/core.py b/src/core.py index bb419b36..7b4f18c7 100644 --- a/src/core.py +++ b/src/core.py @@ -594,7 +594,7 @@ def kerr(self, **kwargs): Ks[i, j] += 2. * np.sqrt(As[k][i]*As[k][j]) return Ks - @vectorize_kwargs + @vectorize_kwargs(exclude = ['mode1', 'mode2', 'mode3'] ) def three_waves(self, mode1, mode2, mode3, **kwargs): # Compute three terms per junction ``As`` # where ``As[j,m1, m2, m3]`` corresponds to the contribution of junction ``j`` @@ -2658,7 +2658,7 @@ def _get_Ej(self, i, **kwargs): return super(D, self)._get_value(i, **kwargs) def _set_component_lists(self): - super(D, self)._set_component_lists() + super(L, self)._set_component_lists() self._circuit.junctions.append(self) From 995e66aa1e093e9fbf23964d4799bbeb0f886924 Mon Sep 17 00:00:00 2001 From: Hector Date: Tue, 5 May 2020 23:52:49 +0200 Subject: [PATCH 09/17] spaces in label removed when circuit is created with GUI --- src/core.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core.py b/src/core.py index 7b4f18c7..ae533430 100644 --- a/src/core.py +++ b/src/core.py @@ -1378,7 +1378,7 @@ def __init__(self, filename, edit=True, plot=True, print_network=False,_unittest netlist = [] with open(filename, 'r') as f: for el in f: - el = el.replace('\n', '') + el = el.replace('\n', '').replace(' ', '') el = el.split(";") if el[3] == '': v = None From c365833077809703c1ba0abf04190da0a888b60b Mon Sep 17 00:00:00 2001 From: Hector Date: Wed, 6 May 2020 19:13:18 +0200 Subject: [PATCH 10/17] Hamiltonian modified to return also the odd terms (given for the dipoles D). Works only until the order 4 --- src/core.py | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/src/core.py b/src/core.py index ae533430..3f243b62 100644 --- a/src/core.py +++ b/src/core.py @@ -821,10 +821,15 @@ def hamiltonian(self, modes='all', taylor=4, excitations=6, return_ops = False, for j, junction in enumerate(self.junctions): n = 2 - EJ = (hbar/2./e)**2/(junction._get_value(0, **kwargs)*h) while 2*n <= taylor: + EJ = junction._get_Ej(2*n-2, **kwargs) H += (-1)**(n+1)*EJ/factorial(2*n)*phi[j]**(2*n) n += 1 + n = 1 + while 2*n+1 <= taylor: + EJ = junction._get_Ej(2*n-1, **kwargs) + H += EJ/factorial(2*n+1)*phi[j]**(2*n+1) + n += 1 if return_ops: return H, operators @@ -2097,13 +2102,13 @@ def _get_RLC_matrix_components(self): class Component(Circuit): - def __init__(self, node_minus, node_plus, *args): + def __init__(self, node_minus, node_plus, *args, n_taylor = 3): super(Component, self).__init__(node_minus, node_plus) self.label = None self.value = None self.__flux = None - self.labels = [None for c in range(3)] - self.values = [None for c in range(3)] + self.labels = [None for c in range(n_taylor)] + self.values = [None for c in range(n_taylor)] if len(args)==0: raise ValueError("Specify either a value or a label") @@ -2560,7 +2565,7 @@ def _get_value(self, i, **kwargs): raise ValueError("Cannot set both use_E and use_I to True") def _get_Ej(self, i, **kwargs): - return (hbar/2./e)**2/(self._get_value(0, **kwargs)*h) + return (hbar/2./e)**2/(self._get_value(0, **kwargs)*h)*((i+1)%2) def _set_component_lists(self): super(L, self)._set_component_lists() @@ -2599,7 +2604,7 @@ def anharmonicity(self, mode, **kwargs): For more details, see https://arxiv.org/pdf/1908.10342.pdf ''' - return self._get_Ej(i, **kwargs)/2*np.absolute(self.zpf(mode,quantity='flux',**kwargs))**4 + return self._get_Ej(0, **kwargs)/2*np.absolute(self.zpf(mode,quantity='flux',**kwargs))**4 def _draw(self): @@ -2643,17 +2648,15 @@ def __init__(self, node_minus, node_plus, *args): def _get_value(self, i, **kwargs): - value = super(D, self)._get_value(i, **kwargs) + value = super(D, self)._get_value(0, **kwargs) L = (hbar/2./e)**2/(value*h) # E is assumed to be provided in Hz return L def _get_Ej(self, i, **kwargs): - if i == 0: - return (hbar/2./e)**2/(self._get_value(i, **kwargs)*h) - elif i == 2: - return -super(D, self)._get_value(i, **kwargs) + if i%2 == 0: + return (-1)**(i//2) * super(D, self)._get_value(i, **kwargs) # to match the cosine developement of a Josephson junction in hamiltonian else: return super(D, self)._get_value(i, **kwargs) From d31ef00d81e88f0c652957a4145213c3f922bf8b Mon Sep 17 00:00:00 2001 From: Hector Date: Wed, 6 May 2020 19:21:14 +0200 Subject: [PATCH 11/17] Hamiltonian maximum order if there is a dipole D in the circuit set to 10 --- src/core.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/core.py b/src/core.py index 3f243b62..07a50a51 100644 --- a/src/core.py +++ b/src/core.py @@ -2102,13 +2102,13 @@ def _get_RLC_matrix_components(self): class Component(Circuit): - def __init__(self, node_minus, node_plus, *args, n_taylor = 3): + def __init__(self, node_minus, node_plus, *args): super(Component, self).__init__(node_minus, node_plus) self.label = None self.value = None self.__flux = None - self.labels = [None for c in range(n_taylor)] - self.values = [None for c in range(n_taylor)] + self.labels = [None for c in range(10)] + self.values = [None for c in range(10)] if len(args)==0: raise ValueError("Specify either a value or a label") From b6e268556e122fca5d38a5d45eb7a45f25534fe7 Mon Sep 17 00:00:00 2001 From: Hector Date: Wed, 6 May 2020 19:44:22 +0200 Subject: [PATCH 12/17] hamiltonien until 10, label have to be separated by ',' in the user interface, with no [ or (, so it fits the original version --- src/_gui.py | 2 +- src/core.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/_gui.py b/src/_gui.py index 2d5b299f..4b2f60bd 100644 --- a/src/_gui.py +++ b/src/_gui.py @@ -3539,7 +3539,7 @@ def __init__(self, master, component): elif isinstance(self.component,D): self.value_string = 'Energy' - info_text = 'Specify a list of three labels for the dipole (the 2nd, 3rd and 4th derivatives of the inductance energy)' + info_text = "Specify at least three labels separated by ',' for the dipole (the 2nd, 3rd and 4th derivatives of the inductance energy)" info_text += '\nDo not specify any value, they have to be passed as kwargs in further computations' elif isinstance(self.component,L): self.value_string = 'Inductance' diff --git a/src/core.py b/src/core.py index 07a50a51..6796e1ad 100644 --- a/src/core.py +++ b/src/core.py @@ -1392,7 +1392,7 @@ def __init__(self, filename, edit=True, plot=True, print_network=False,_unittest if el[4] == '': l = None else: - l = el[4][1:-1].split(",") + l = el[4].split(",") From d3e3d2bd7a1d87e639792414f1bd3f0e778807ec Mon Sep 17 00:00:00 2001 From: Hector Date: Fri, 21 May 2021 10:57:34 +0200 Subject: [PATCH 13/17] Clean the hamiltonian_sym function. Add a jupyter notebook tutorial to use the arbitrary dipole feature with a SNAIL in a simple circuit with three modes. --- .../arbitrary_dipole/Circuit_example.txt | 16 + .../arbitrary_dipole/Circuit_from_the_GUI.png | Bin 0 -> 52455 bytes .../arbitrary_dipole/Editor_help.png | Bin 0 -> 101450 bytes .../arbitrary_dipole/SNAIL_example.ipynb | 479 ++++++++++++++++++ .../arbitrary_dipole/SNAIL_scheme.png | Bin 0 -> 268299 bytes .../arbitrary_dipole/printed_circuit.png | Bin 0 -> 3596 bytes src/core.py | 12 +- 7 files changed, 498 insertions(+), 9 deletions(-) create mode 100644 docs_src/source/tutorials/arbitrary_dipole/Circuit_example.txt create mode 100644 docs_src/source/tutorials/arbitrary_dipole/Circuit_from_the_GUI.png create mode 100644 docs_src/source/tutorials/arbitrary_dipole/Editor_help.png create mode 100644 docs_src/source/tutorials/arbitrary_dipole/SNAIL_example.ipynb create mode 100644 docs_src/source/tutorials/arbitrary_dipole/SNAIL_scheme.png create mode 100644 docs_src/source/tutorials/arbitrary_dipole/printed_circuit.png diff --git a/docs_src/source/tutorials/arbitrary_dipole/Circuit_example.txt b/docs_src/source/tutorials/arbitrary_dipole/Circuit_example.txt new file mode 100644 index 00000000..88bdbba6 --- /dev/null +++ b/docs_src/source/tutorials/arbitrary_dipole/Circuit_example.txt @@ -0,0 +1,16 @@ +D;-1,-2;0,-2;;E2, E3, E4 +C;-2,-2;-1,-2;;C1 +W;-2,-3;-2,-2;; +W;-1,-3;-1,-2;; +L;-2,-3;-1,-3;;L +C;0,-2;1,-2;;C2 +W;0,-3;0,-2;; +W;1,-3;1,-2;; +L;0,-3;1,-3;;L +C;2,-2;3,-2;;C3 +W;2,-3;2,-2;; +W;3,-3;3,-2;; +L;2,-3;3,-3;;L +G;4,-2;3,-2;; +W;1,-2;2,-2;; +G;-3,-2;-2,-2;; diff --git a/docs_src/source/tutorials/arbitrary_dipole/Circuit_from_the_GUI.png b/docs_src/source/tutorials/arbitrary_dipole/Circuit_from_the_GUI.png new file mode 100644 index 0000000000000000000000000000000000000000..25f34579edba41d87bee40ab8db3df516601ced1 GIT binary patch literal 52455 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 ypZMRR{%0HGx2XTEk|4 zJ-RbdWtyD4jG)I5_sQLpMfXMRQr61F`Z@Hjx1ZVoDM2!U!&m76fNu>6ftMuYF)y+2 z_c1*%Z~Ws!U?_#DfOM!fk3%HWzUI=CXLefC54arJn}~hs5<25n38djSPm1pQP_AS` z1E*f!r&b{tVkC4BfV9y{7lnJv$^5?ausCpva7KkA_>cfzRPx*j+W~vlHn_Zc%gDvx z@$e1$-dt1zBhJDSTYYDR_qzAgZ-u+vS+ohLR;KyBl-t>DnxXX%-#Hxi=*rG<(S6^h zBzQ@~lch0s`keFvhgXT;_BiIeN z;}suR+KBY#J+Si1Jed}v)XN67#ucC+d;ig1$t`_`E|Gsx9L$zY9~L{xo+oXi@jx{q zAc?Z95D4H=FnRhzr|t8-iWr{T35T=Nsoe2$K?SI?ESqZGQ~rNDPVeI)e{;!8EIy9XXQlm*n11uoKT&6QcaP<|O3oDbGz`1(CPOd|(H z&g41wGKnpBOiyO#A>idmU%ST5#U)MT^7Kecps7o$n*+bSv%fg27h@<1Gc~1-G@%|{ z(ltlFnxFNV_vQ-}?-NpWNmEi^qmMBEsPN57?pld*1_PQfhPo?cEvP^tD1&SZL}59u zO&|S}iSJE+7ZI49pFohEZJt;2*8|!4H@{83)8JYqs6?c~McG7F&*76)R`3r~YP5yJ z+}9<`ov-tKrfK_VEG!ti5t_2_+l`&|W=UqL`+`pm&X5(dLk=d}4Gami4y0`P*}Zgo zT2wufkR=-QMkB1K#M*CGM%5m8i^_i|n$cqEQ8USzzt5B#+3^lVCG+dKo*$)6i&(wu z5J`#%mg$J_*pL|6Zc4;Jj>K?dh)#SZwoYnG=U4DnKO+-r0<>PZb<>ay`SW2FwS;e4 zN2HNOnRyXmX=%0&rz@dEQJZYxcA1q6g@=k}dmO2I8}6WU^juTx&7Riw#OkTKq!xFo z!S^}0RGtw=A&1EC(e1$yQjRd*#rjA?_Zs&aq73xJcL>Bj>4!a83-C-{JC0vsNkX4&kK?(TD4u%{(7j-(Q<- zW~uQI|9x|aXx`t4SVoDA!ic>il*BmfIVWo<+wE{U_A;gWv5}_t#X^bI*?&dvM?0F5 zlv7UokFkR|L!wQ(-sP~=1_7n(q9?mZ@5mN>C$tKl$>dZA#Yc2xbZ^KBlcs&4%f31E z@WVshh&_evVUrE_W2PCuCTUMWUrUo$eYc%{qXj7GqRb4ZlWwI1BpBV*d8QTe?Dx7C z$#!#H+1Ya%i-jk1B*hCKfF$e78i!)%#$GHY;H!5thG-uN7RB}RMej{d% z5P=A_m*3fKxR@WL26`669eh=KAoTfE4pKuu`nk3(xvjm8qOGxw&RF7*rYuqJK4V;} zvP_QK?I=y9#}9u#+_tUI<&z3v#r;a5iU+z6b?@rdS44i$pYZrG4xV^8 z8%xx6XiDgQ-JQq%UhQYEm^tOW{0;RT9+`O4m;7c@xv_5)#guDR+_QiFw9VZuk<`*F zk_6Yk@r0c+?vl>z7hGs^Jq{7~`;oz)xtCF;X0MJI`XDT!%gq;{rKI-P^hlXZwxQ zEy3ftlckdz$8_7fBNByYuV6X$`D~ehAxH-NEv^R3dA+05{3C-`$ER@H@VIbQqAb5g z!b$eYj5)(7nG~6*%%;plqaTaTt&dwqg7I79%E_(tXYDhC;E2UbmX;!3KV((%v`;W?8${fV=x%+|S4`8v!2#`~9 z-9yBq>B#Z)wukL;-Ddv*>oO+bQ{fpG8-y(xoCZ!TiLlSx_dwk9x$Z;m6NVW$r$x7- z*Dpjb;Zz6Y+_$FK4lFWM3=I~Fn=P_;6v-8B@11aWJr1R>c=(+&>24}xgIEn`n@}MA z8y`mI>}?6*_gE6`F9OZun}*C<+f4;0!$fh_x2t3CK7@KFp6ZWY`$dAJ171jNUCzAmC@4Dapz;IR=!OFB z0BrPDYCr5|4Vw9vJFVKS-d$y*N7BPChcTT!Y@}aJ0hW4OznqtamV~;?w|iy3?!V8h z&T?zdPB77$C^7!|Snp(VtGjSe%k8a=uI#&Pol$j0z3G|>^WE}Fw#m;E`h_P3|@$H*_Uj5gJtjaGl#eZmBAv3g1`DFvScD)8`^GDu>Fk=J~_7vLG z1Tu$i6T*pH;8WOgEc>$IJIObo?52E~v7zCl`6-_d$C(p(&3OUvI&59`bb0Mo>EdFp zBDW$PGvjkzuZn8r>ei-9JA?MoIXbv`x|4a+#>6i`{kKI=4LC%(n0!5Qb4a z_uNQD)CMD^*0%v}kmu(qXZEDCUNc*O3j>>m6=*?$x8`L`FGpgOJ~`ZR>+#tZ%GzOa zrX>G8+})%lA~MB4WzcRF;o(xh;fhOh|3v<&cW-mPu*Tj4e(|XjaprpN%?L9NXn{Rr};%-)$MmlYA zYHHw%k1u9A%I2?M6FkO`$q0xEnFvVmBSQQlMR@ODV+BHP0;0dRUn3w0u_Pe==P|1I z_0=aDzg*4v$C@ZMn1B@j>o$II%eeMmM_*^nAo{N{VJdzffsBT%vNC?HVd7|JX6N+5 z-g#mnpdY`1{G-x4CjtVxhgS=s@|y<-`14O%YU()aynZEaVsFcDWNL40#_wkP@#;JT zKsRyx(ALb^h~3TB#?DFHP4fO>{y820OY;5)XXlUN0KlhDpZGsL<+pdV00@eSi2($J07621_#^n7 z-0hr=-1zLAIR9~y|2mJHnUjg5S8yZe}*`TQ>N?1?`_}B6O$DV&*@ozJA z{ykIhnTW{Wr~Yl%e@=btWacPqZ;QXCv(&%s_0P$F-}%ppK){vge^bRj^!(RWyrQLU z00I9pn$!&kdJrAnj?9*FU`_lQ?`3~|2Jqk9_~mMiUshb7S4ZFrXK4auIT=ki!ksko z8W#D=s_p2&J`TcbWDmqR!XJNU_y4Y)N+K^^yXA6?#D_#(J(Vrwc~%zpmxa63AveEd zY0Dk_`2PKts;}?;YvjsgPD)+GjMGqfCDLWUgf#Vn$(nRb4Bp=dlEfXLWu1zTbq~a8{@!w#p7Vtg~|1xlA>ft+fmB z!JS-|AfSb(8+KCAg@^C&_F~g!V7+^wjm+UBex}2*B&xKLADoZw%)Zfj#Kt-jRb_>U zNB5n>hP5TWJ?1mwj+uzdyR}Xz*h9r81q>S?DZAv@(eUh1p=jyh*~$8)J%-4Yy8{#jVufPR zhscn!jzI_rKRiJuTKkqYBcrx1MRmqJaU_5j68o@ps5^EQmADSM8q|vQ!F!8MF65Oi z^94)v20`h+)1;uoxoIeXH%G;NHr>+uWMOyMM%q!6p){P1w+b{Q`a$tv)bXO5G(#cP zM|Oc24kbc{+*RZIc|)={HAse|^WVD+$$<5El=PFm4!PsNDMF~&?5YBSJqCouvAW5vN1$KKq3I_7Qo}-q}1}{!Y;m}KrMCC7c>>^50bSEku>LP->20w0U zt13dh;yTrK3#C8v;9Uke_U<4~cI>;XRxycE)gBn-eDj@sZ${*ti7z`7(aRaJ9?j0M zd*P!V<1`vv9>eOYzV-Hy&KW(u4sE~E|d-`;!2X+&c zzm7LyvFMT2tMCAm(`@&^b;P|vbP6hLP2k=(8n*p#yzI$O>!0%&E~%gIp|QC&F&M^> z7rdvC^SlO)OVL&0Kce5DSpg$fdOJ`^2lw6~0XvW2H8SDAnD_)kV{$sD4FbNm4^HTE z8{||N8<@I76dJ~Yb;MtO>egN-sn{4x)ReNd?#^eaDDYZMNdV949`TfLu`$NxV|fu2 zsDo1U3_ijxFGewImnC)gRo&dsmU}1-d-U1)mDS)r*okj=ITleN>DB2_H|+2CFD3)7 zoUyyOnc06ks}H}+!uB$39gz<8#A43Vpij+DkI+cQEZ0s*N1oOiu0gg!2%A3`sj$yx zIM##KK#wVuH{XN2a0X@+ktrAcA{&(p5stXyT&`I{t5iEv7%8%(!q`Kdb&av+WJSfU zC#Ze?JW_XuXDgg;5xI4Ii>ov-=a|#go5kFOU}Wr}W^V;3HKfad~7_x2JgAb|Xjq!}pbJ zPbRDGL~J`Y4sZ$sDn7+%>usv3G_5=iHsE>>{J^_Y&j;7Sxui$iqB;JpN0Hz`5F?c&?i5|0a!L<}o?`+m!Vqwg z-7~;i=#89bpHzE$b_RdW;|{Dpp_LKVO4$~Ys4oBD>|r!16Uj*BMU<>>9Y+j|FunT+ z)6(X5Vj^~~0O{ndG4-Rdd|P#$V=F32%Sw$-hgYSyi)xzq6v^)gdZU zC$WV!>0XC6Rk+6J672XE^b3>|)dIoXw;O}@+G8(7u_yZ=2z2~#@C@Qobb7vgI5`NL zL9*>pUE$yE1bXxe2~Xy;r$-RRNToxAfwcM?azs=k#9PX;FxNofY6U0XbOi^1(d;Pqo*;0$J0x-AUUwp8 zETE}E1Mvl8|9}mD%2x2v=iUo|&9_Zx;Ze$O#L*-K_eToX0YAj-Zx2qwI$RLY6Bv{g zr{{_FK%bm%qqH%o>Z?$?K-K%)h0oKTM0Pz56#jiBte!h={o5h3bC6Ba#1{7sSL-}~ z!T=76*o8#w!cuyXit8TSgP`)6M%+;1&@F7NMg<7Tth5>i$=-&EM69uO1zy+f=7}p2 zi!h!Uk1cT;tM)kAy3zN%#!{ohm{`!CJS#x!rLxS2vEb*+X`fV&+laR^0oQaNK`JWZ zybjp`tn#Q=ryo?5R(UBTE!~ugm+k|Oh_^7s^hZkwpip?;7lVDCD1>9_kTaLX$eP>&Tm>raPnEXcg?#mUZbM^u~Hsr`(C`@1ZEe^X7R)EnyVFNrh)yEkA}nXg>pvjdws zz~2ZcI953rW0i}9U5Jfc9@`d*Z)l)~=vOta@_Pl?eLNPxc;K(#-1dW0e*&j_)LzJl zTGE>^=U!0>UM=~gKz`F`v=<3rj7>Ip`r{XR{tvWe3XhTNQbvB{lTfatV zEvvA_G7|?kSbtjQhvODm+sPVi=<=d)p#OKvIh7A?f$0dJ@1qXemIp7OwjO8}VB!hV z;s9oXM*pF#|`7j!me8zvO%Aj zjMZzxvlML>Dwn8gPuwN8Ffw<1xDzih;sQxkObddd@tg(kuEm5PXfFcZEI);(DhGH` zsP;HX20=ia;j2&{DmnI@maRRWL)Oc9c}LORI5M8qXN5eAHVU669LDe#7H70f7tT!g+Iqv7rH#}0 z)21jWo_my4x)UOlCViNV7-~&CCEj=dbN-1fRCT;t%?S^MuWAp%1tw5i<0w%q(f$>e z!Hx({oFSUm?Y~5Hc(>z&8v0jI_hMuZ(7jiH3&bhG%Kl1?NegFqD1I{PDT`EXzsmmI z%wJ?rMf(e_rr|(5D5o6CPLi7_iFX`tp~7yNR(fDIFY3Nix4d5xLgbjVmF&@rr#D9spsuqN>% zqOhcN8;hl4^V4_)*~KT8;*tDUQZ8F;o5r}XqlX$8uHuJmK4ZK}Qd|MTq%uHd(by6x zm;0c0#8Cvi1U|D2ImDh}s(q#_OFy`vk>|g#sP)51JP1Rg;NQ4Bu-e}5jNTLDjbDgs zyB_8|0L#Ome_|~oJVR>bnVOaTtjUXjcqa(3_6u0JV&+U-Xgr;zzhw5aZb3$M4x$5) ze>O3LzaCI9X>;=qfTHC;9HZ4G8%&*)N8=sFzTuQYvb>JQK7;D+TmsUEa)lD;26c}L zw5j=!B~3ez3cpJe3p|wbmt!~Es@YP1W#&v^u+kn^v2|C23ryxEr=m;9(zBA!9>d=Q zCXBJ^ew%uvV4yB_!aSl5%)CoAvfHDWesLY9dnC_^+M;rQk?iFrlmFb7^UrKT)T_f% zujT!1`-AiBOVzS{_|YN6@sDv24~X z$s`zm6Y^D~c$jn{ES*iD!MJ0|^-+^j;F_k_XZe(#>{ssH)IV45nyloY$LYH#rS2@L z)SBiWX{L{Gs8kfZ-&A;)>~--3b#j3y^4b^~`hwQQgjf_F<#q=Ovz70Nmk$s3bLmUteT1Z;Vx?{8s1`6(`Q?*G z!hwtf#0G|UG{E{yT`D{?U0vx_A;AIS#@&Hbmi|2tIc=kkD(>pPD!QccHMLCX(U#~A z$zKUoAqk%Fqi zPJaR5Fx~+`P!~3LJb>d4@Zblt8-N4xFtGY=_o}k-*grv5i$|SYN#4;ReB}lBdhM;# zW2az`Q$;wgq#9>+i)RLePmmMt)N5%o5P|gSBQ(C+MQ@!zkd*E6s1@r7c;$*LAUTyN z_u2Z-AZR0Y`~5^6HijJ6G+wB!O-;s;_U4IMF0*jiZ*kudVPRrp9$t^}0*yD}KvG(9 z<4R6dF8A0Hj~Q7=e2LI755T=$N9ZBsxMH&Vp`EH>}8XwZqwmprS#7B;28{Gx8W1^t#sU23RJ+(F}@$#la6C@x++h#C;egY zE5rV)9>ovRN&0vgX@R&RaqZq6sA2me>eC5$*-(8D`(2F7*^(X6hvZ5t%uCAOH0YWH zA=~fiYb0Ch3b#4hZ7`|B!Z0C_MtuH(jOD&V6;SeEM}nkcRQGXsUjN7|{?S*vFTEGw zl$uT=a#m?#ChpJzhTGZ9f*dZY(OP0IStQak)MJ9(VK*}5TsI!E-9UA9G4rbzJ4;J( zB!CUPv)+5ZN#++i`jJoJClpzZl`SM~TA6HR^I3wlK~O?yy%@*@)Hxtz^&TGRPp+B^ z0i95M)f$Ckg_2$|(nI7Vl4=l--T&m)?sOa8iGm#7cr2eq+V|hB5m9mywuT;F{VKkf z{`7_qZpsS*szI1}KD0Z*=D+?m$QGee4t0vSy9*zq=_v-8j(@{_Nagj!{w}dW2UKxG z+-?PVnaXtr5Mb$dFo=QbdLgEOI|%J70L=8Xo5W}ru^m%8y_7LQ^6N|0>Gt#J-|-3@M)RgL00XS6!g zMHYtTUHciLW{HqcoIRF3DTg$oAkMhWipxw>L1KeEXVl{kClz4jv!Y;0)tE-2m~soA z0xkU}UuFm2idczxl#}*)RYNuXc>=gzIBK5Qh@jDJG+kQCR*|vp2hK|G5qt^}Pi0y8 z_6cfiJg%f_sL)n)byTsp#QUl)rYb6dZ!v6LmRzu#>=?ek7UkOc?>3Z!uLWPon(gD| z+GSMKI`l6_^K9V?$$(sBS8QhYj0z4#VVp8B&(aj*Cgzj{m-9M?A`UUUlzY=r&ikkM zZbt4nHb5gAMe5O-D7!DX6;K)yb->lQ`c-dDm6Vy%q$B)uBxNeuLB=a!#yUGVgKZ^j z667L}8d4_hre_fZij7g~cJnP!NpgI(2)?`#(Z!v2+wbVTlE7+CX2R0#2P9)6xj}%2 zH&XH*-ILux@YEY^QBoHlbeg=}!xtqzjyK4#T``wC6U#K^!UK1p& zGsfjY%Wy-5X)}2hU*TBvRm{(E;#*ZjRacFiapmX^^(*8%N9q0fq~b)5Cvdk?p+dn{ zb3<<5jQ>JB54?-uYwQlPs~}im8bY=p?FZq>Tpw5$uT*pXm%p$b^Jlu5xZym`7eli7 zQbB)8bjt4M4c{bf3nZs)nJP1B{jQ#!#Ui1PiXMP2w*oGW=Cb)5E?&JVfzI5$q~bFR zbe1B4#eZ#BL*$TqKW80FlA*s&rv8d$l_}aXN1R+mg41J|hBG|!H)rm{*R}X+)R7?m zE~QE$KgCUY{_y$KpVjl?uhM~xU){N@26H=F%WVZ5{LWJ{GUH;2FSX6 z8pO^7cT;vY%13*Lq9omZ`;#nYhOmBt&LFG`e`e7d&(%28{?QMHelSY}+aAU9f}eOw zt+t5e(y$%VzGl*hWOn{Kf3Vqm3q9nUL#ylzs}_wfB!4N2PIyBgfCJJNQkSy>8wS&RE90!2Ca&^luu&Ti)-4%uw3`V7hbkY0g2hqSGFZ zIWKx+{aCN6C>bC^#-~Lr0yRU6K8Pas>k?V*1GQvb%IRYKLl|b zxk}6wZ|-ndfptkwa@4;CoW|3%K`6<4rk*S}UG9acyl|Z|3Q>ykBK^NP+TZRfgPG6< zHMOx1$6=dcmkv^|QlAUXtXgthO1gSnbM>6*S_A08ZBS#qP2g`}pp1&REjV3d=nWNk z{LHKaQ`A&v@6WK3uze?H**Ew(MMfghw<0NaEt)`#KdWL#@nnk(xX{0zu-2bKuXE!X zx4|lV8}q&YYXJP$eSHWgfI;fc<~>`FR(pw{dlrMFr)rN33p=q<5$V$5w(0C#fjhYP z?g4N(hHYJ5S5@~EqZ5M( z{_K~aD(_r*-jJXpM}cTB(>8kBU%mEDq$X^D*ZpK$5F%<>P!@>`>6eiX%mJ)O0u!eB6maVi&@w@*Du zrg1z0tP)LI1=$fhsJ1bO1*)Me{Kj_9e2ew~W+G~u2hqZTUwG(=Mjmqohs?-otZ*jc%;Udt5rE0V} zi|?Mmv+p0bE*OFB|LHj@ERA0C&Ig>odWh zRc;s8zlrB%eER=%`I#5eA{P>SHJq=Kg&u~pfuv@R%eH&5B^5h3M{YGR3n9d}NlUIV zm9DL8!Iw__T$;Am0jQR_N<&R8cZ-OjFje6Vv3O;6cmO+z<|B`u%nP^ zdsj6wngEw8>c@1_?3p=YZK({uh1F6gMkA$}lOG*hsYu#>hg8|TtHEI}mxZD}({gpV zj!FD?yZ_Hoo5tzO=d;)nWQ00eb*K;EtDX~@SuY!<{my0Bnz(Cl3hjALR({E=x~Z&D zER;(1L~28?*3pc_{OF?+gBdZC+VwImDK!PjGXKD=jQH$V29(1z0E33-eJP@VovK+o zBDWl2)&GCM5V*F>!EVulzxwT|Bg5m3;o**`M#w32q{n(S;HV9+jPjFK4NGIxtqj_d z4YwgyDo5aunw;yv&u+S!%fdt^vOY20|>K z^U1h&C-kP|NdY**X+A>d&zte2L>y)xO7#ih{mJe07mVf6>u;Jbt9j_9STAaLU~JoV ze@~|Z&SZx9xHCA8#dXf1Q^2StuttsGvJp*Kj--`Ui3Ujvm*Zr!J$gn&rcgYsioQ>? zs5*(l@qx^w^nBI$g~?V%T&wg;HU71s5`#wZbuL}wRGOXr=Jl`m6rPU!%=Bq9-*NV* z(QdzJaA$dq<7C6Zlt1bHb-t=U{Kv18nX0C|2L){Q^8=fn%u{EUZ(NkR{(fe(n|1Gn zS@-T@nc{xImZ(SPkf>3$fX&EgOQ|i@4ez+qKh#@6+h6DI6dN2*e#FG4wA%KXhtzA& z(Vt9Nj!_z&In)PwbM3ICKeNP@A_BcdLVf70{w=hh9Y-_FI4L`l>Ddnsl~XPW)Joj4 z7u}L9m85XPo=b`Kl${CZ`Q9h^J)e_8hkW!Eyid`P}{tTdXG;bjv|9xJ4~NDz@qHx!zF%6%PRJY(khGSG9sQB?fV#pNaP zAbZ2fKiP@=tJH5y7b|U$y>FY<(_Ux!&d0wqRqd^}# z2G@g|Ep%Wn$Na1mE8LVUl+t<+tE}TWnQOEZNMm&Teb}h2>lJ))`&jRnc#%QvV_@CV z@WDZBpTpDDQUR}g?O?ttu?!w;+HK6{;&yBM83y?Ns2R|DaLBpb-t`HtP&8`qlE=2b zKYR=ROhr4mwc1npxm8GF2oaYZ1F3R8#>Mkr>3`ucq?t1ccpG~V0t&P)u6?v8)={lW z{+u=MRq}00;6d|8Jd+8D;Z&r&woVT}m#!EW68B7 zla`y1^A~0kk+_o*Xi#Bs-49Et1}1cuvAbaZ&<8oK=~I7=fG|EXy>OU! zM3*};$-3%mE^nQbJ{Yy18;MywFDRk1pWl2oE{2DgsyvwS#M&_HO9youmtRRey?C|McFqW6r77 z^49>R#2L7Mq4(Ic=t~-!LZ0yOjSQUcLg-v880EAUbk_fzqrqBt8>h*8npEn*uM|&L*HH?eBYqzaeUHMS*FmiX`RU(21x1{i z52Plqr~OC0mvZyk)M}zBv>CdQ8IpxbrN}G$)B6<+a$xOpV8;;%I`=w_`;8t;Qs>C%X`#EZnw?ipD@ zp{Lzhi;RUohJowJ-E7pcK61-aplPnmwf1=RUkKLxm20enrbcTcHJ0ayic8vR=S@VE$c5j!7ktTU+CUF(E^TH zWjji+1_qk^3*4^is(u#2wOL}3q`g6#jRqWb>9~_29E^Nyq3);kOf4@%SoONisZwE#{8ln{U4^$^*qdb?E{pQF_Wn*5}$?DlwK2_S! zcIvF-y_VQIP~;ej$m^-Q?}-&}wkoI7q4~ALHCu1!Q*~j~ro6v5lTNj>S-KT`7Q{1a zrdv9a*|w>ssbMAG*qy;PsZe#aSZouu!v}NKojmn21c#iVt=w*)~%bK{m1E4Ej?xbY88~Kv#X(ZC|{Q8E*`W}MbTRFbhA<- zaM&}_qAzZTVG!o2ilk;N^)K`O+wO)@A(o?g?G4!X*)O$Tl`Ck4i)geI37YEKpPrhVc$nC(S}17C-O{F#P{59cnMi`vV77M z>CweA#B_vh^`9kH`s#TPYqS#$OnFH|?uH_ZizeQn3VnOE>*?x>;|cBUcd5YMTN?LAIQVSP@2itCf0Wkm z>>~&s_z!Rsp>CEM^n#typH{bKN+<7NrVhm7wOO(<5-_l{yC3AZF5y~|(qII?3>G9<$UKjCgv6fn-&8&V3$r+euWS=KS}T@o%Y|%g5j$!d53no$ee> z1@mnAoO!Sf!HIjVOCZ!m8aCtsJrrw?SAM-&PxmY?Ut9>FVl8z?a!DP2u4$1aX2WbK zW((qM?LB7+Od7XF&+#;&g@8*zH{ZFMnd&$J`TJ6q>0^AV+tOzv^Ha;5_AvVOx0`GD zcU^SG`0P_3Jhy-U)be~40A=(!&Snd`%d3^sF4(U!t^&CjIhdKG#MPx_z!}Sp+Q`_j+APJrB+}Ft30Pq+99q`)J@a%d?^vZ1DFowHc3ZL1*ipg<)9y|(-N%xgp+P0*h^!c23QX#@ugQ7%sgL`bNgA<;D znDa~}94sW??SK4`kpBeTmTa<8Y!k8{^AvRN!WHpLf84mfCu_U)i}if8_qE5Dq`DB- z`%6|KR?w8U>OaibwX`KQC(L1ib%1d34d@F*j<>|fe%(XSph+wyuoP3l(puVNBmZ)| zTC=@udek3jlorbv*7xa9rv|zwxkw6@l-Ln9f<+!X{T=t5iTtu?(rY)9Ez-rBlVClI z_4y2!qo_l%^;FvPCmOtwq$0K^tAxC)ciwaoISNDq-q)y&=N{tAs(bTzq7ampgfw3~ zTyir^=vv3~1j2O=l2E8s*^T@9uZMU$TkU<2DIf6&`n}DD&xrhmuvXKd=+WKOw2rWmiz|pRQ%Ty*rtP*tunX!+iZ?w?Api5liHt$TumTBkQyELZ`u-7JvqJ8&R=Q zfc~!9+h6Wg+aJR`%nMmr-46UdwoH^z?WelhAc3ze|1GN@E62yhAo}25035j9^v88J zXcP>R9ITH0(0-`ap&dyYzRHHjJJO%d3rMNHl>GrLSzK^F2v6l#;=qyejm|(Xe4!Y@ z%X)>F=dA23AAL3?O0VePCRc`>%KP_ko7p0BpfB?)zPj@cu18PB1&lwoTu6K14N%@z z5?yvXN5XK-{Ix5w=hIJ^>2GXg45}Y)=4it&#>=*5tV<{?(pE$CrGM5=^I02Q{&lu zJ!fa@4-F7a6$}KpH3$@bw{N_DRP)Umt382vVi4!Oe~L}Z59R|MAFjfJA zK(1cjO(R1X)a>-j-$^-6Nh1=)SikZ^m`>j{>Ybm?LoB}qk^il)HN;CSzyxvXeg&@WK3fhiGu)=?rgisUd_Q{G0(U7|SaFUW;Ph(uK=y(ghThDZ+NB~C;NZ1e6%RP-G-5lCk z8`<}mtiM*MapxR;SCuA}Diu}&#cVI)zY2eth)psh`X9!Nv7REJxO2-#TDA){3+?tR zT`^)*T>rg6DP2vokR}^RDpe^L-N-iU^NlOw4`j8yZs`Xpz9Z@&ptyz!DsQrhYmmt^ z7o((R{VdRB5z(bVN_)+PSd6`kH^TUKo@;zr_bkh&IT}%;0PT9C)z6*92u*ROK2n$L zXA=Z{_`m3E##p$RPeB~op+yKykF@2?xA_6$zPgUU4{@970Cd2Q*)LRer*~0#Bg2P7 zk)txPlba#SGAXYh$Ua!X#J>rPA+ZRV-a69dZ*hz9R9IPxK0?n zWz4Odkkj{O2?|f=QY!_&ao*?UBN0Vl@y(o%3x1>uv02N0 zPD+rG#OH^OHvf*{tJ=&Xh`{OHeAxL|tk%<~T)E7iO*>~($g=5WV1_}J&+(gdp~@gi zkIKYRjuF$i)$@Xfp$^Q_fpIb~R@~Gi1!Y!qatX=;rL~=(sKLa|*Y!^Xsotj+@0sGvSu_e*=0yKtE+f zxW1M9`CSkFe!|3Puc+3j&*+nIfwI_i1wxYZRoXDjGErZ8``FsOGC-$fG|HP*Xi_6d z)LJ#^vH|}6KUEGv^=P+T>FT{y%K4FHit7t}GSCuXuYYo&oULb9`>@1g&~u*l^iOpy zrk<55GGwV^sDJ~KahRO5w4Q>e-!)r53R^^*4k|k_7o}MoU&~v?zFGjPux*7 zZ`k~13S?1VNW}=*m58p9-M*gI^MIJ}`D1Qv7PFjjLbrvXE|Fi6y`7cusYkB6M;8T49v>fV$fhnEsNJ&-qKwur;ParC(GY;i5K z56BM*<6lJO@i8tHiRYNQ`ZwYpy}l|o`nJQ)Q$4l{jC$gE+#7G>Ilqlgtz&MvKIHJ@ zv{_=%J`{H;22GWH{`t#dJpyAlH~C_9^KpFEGGYD=oRHIhRCKbR392sd+0}6D9X79x zOr4NBK8{x1y(~YpCXv;JT~L|g=o`_*2N98^H&*1L17r{;Su`h)xz>h$kZoy#-6mLh2J|5%hy(M zDuk1H^(Z1o8;te+YXOm8oYOBF)+GTx^>97BN(x|hHhuXKQ!77{@!;QZ5Cpi@$?VkU zn+L!Av%kbj_854+5I_X8dc$4J-Tb@>uZQpA&X*c0HWTmBns4}v9vnt~YTzvWU2*N6 z!#={e_>t=abeNerS;C=6X&)PXI5USe&5ZPd;zm)1UKn}+@Mv+U2 zO~<*56!vbiee^6;KU23;Gim?(1CI<@VmI8PxB12Kri>@>U?9N6ui2AYSiE%m>3RpF zjIWkio8ud5Sw)E+v19)6YUj<7ms_>cp~N&{4!V?_M*=h&Vk{Y4uYF6HsdRaMU$^>Y zF-U2%!&Rp=w-hCsxMxFk!=C@o5{ZT5zqqquoSfl&gS*4i1x*z0q6GIPAv0P=Y z@ZmuYmn4tZhAbP?&?#O6$_r}G-DsVFsjf4Yiyimu<1hRYD4s({1fW>7jH<7l1nZX+ zU;DdQowgfHC!#+cXhXa4tXscndmi zJ!71!U~LC_8s4~{Dqu8ggA}841!|4|e0x`&FPN{qjgI5Vy8~&Rrq)BFb33k|g&zPH zTXV>k>6-wu+1CTddi8cV@_6gJEiN_klE3aArc1}- zK0Oq@w?o43rS`Dab*Z!3kN9riYQ-n_h=7vl`FdH2B(}(J}p5s~4+XbZTji1GC z+;&a<^Ea+~YgexWv4l+jN7-2jUJuo62#mMSKl(LEv+SfI{b{>mE-fX}7ypulG$&UshR&eKE+bu% zbr1g_I}%i>S-U$?>bMrt8lUF6WTN?Yov6nMX#cRQ9GrTxSX{qP$!Xyua=hDQ!TbLD zuoj&@o7Q_|uno};i%^I{)dTr^&n@Ene{hd~3|(+0OQ@Xgm^=$oC&hp_QpV=42L{~H z)BgA;Hl@WH=ksF9XC~4}r;68k&hVRfyfs~miz?~2va;iu@NSILJ~_y3YuX4-eyO(e zH;?tBh-`i~`JQ$_e7lIy<3NAZ0=Ud*gn!B%mQq-D|14I8pPUMWJ|L+3)PziniEObG zWBuZ_;N8U$LM%1h+JL%ZuJi_O9PNUoGlUjIF8H3>enumwfa9+cg3AZ*eNd}@(5-xY z?WuP;_Qv7YN`Xdx@MOcWG|~*+ zNJxW(ba(fNfHX*VcS|UZbPwIq-QDp$to^Qi*4o!T-&ucp;l(iX-1&=pn0QI;h+nF| z%{@O4ePkGU%Es|iVEpCpt5T)uRux%e-F0FIAR1qi*iB`O!k&9&w_`Yt2(zJh547{X zaMiS~XBVU=-S_ckCEfF|?*Bhm_3)7z=VYp$cGcjkjF?3N1vOe^~n)v@oWMfyve-C&@pDp#;*%gN0oa$qs|SyG+GZdLQegM@E~d^s)d z#u8d$tIK}Wb2#b~Q{c~}AThi5$+ix$lOF{dbm{^EJ%OQSB;Nfw7NAhzH@)2Yz#-$@OcXgV{?C zTN(@!cQfe$TcKH~9@x$z%&$DJQ#qg|<{H6G{nBUILZpOa^f4lHYhdc>;z%*;`#(sY zUG`RD7t(s;UYGj;?$=LKdIgs6>-Kc5vd6(0swM6BaV70vV-`v3+zgz}ordb(tMOls zWONi0E#l=H>9HeINuWD`+VTtYCqgKDj~~0-b(+~0E`+9r3esNH&20K<{N90NkhXxD zw)EIL4CgUWsB(PvK=p8jbZSmQDoY4C9njwkZ7&H5l4BMuE z{bgbMEvB!^Ic2U-6wVn8nF?>)rjfcat?D#Xe85FLKRP5nH zc%9pz5x!{KHorS|e;c4ij8Q{pgUkpjS_88^ayai66}(t9w1BrW9Y6NIBH_lUTg!T7 zz{K^}aS&eyF0sNQ@(+5+jy^Mp7$Mi4Yz+BDziPh5BdnQ}Xa#p3Kls<=IWR1h74^+dYIDRv=0vxeM^=G@@s*oYJ1A6(Dwf~`>o$F3>YUYO3Rm!G?m z#8f1Ir_p81h4Er4&!>U4#aDqO4jQ_@!#n4AmXH{1lL_(<#xl}=$+ceh<%KyaRb;cA ziwUNp1AI|^_12f@yFt{B+eoGlF0q17hoS9~PY(es@5XIAE3uM%g3q9b#RYKg4cHt3 zs;-fDaNzuIg7gSrd5Wr=S$TKEi2g!RXF|gO+YH%i>&@11nzl@zDR_oBQGo@wOOlB|IEKAwHLJNTg>jgS{gq>n*K`?BqdZ|O$fD?zGcMsVdb3KQZp zX>qp7SS?6&B3(=s!A-f^Xf~SN6aisBp?fXD?hW@O_;?bz0`MkbcOKi#oAnTH8}7&J zHOH3MGdYLA`er|oca7fRaM6Jw$ltPrY8GqU<}y{P>CRe0^Gu^Q{m0a&Pm8HP41{Zj z*0(Y;qE=$WkzPEZ?U9ua4U^{hMpLs|HVEC=Gpvr8Fiz>GSzot%}|>5q4d{6}TeV z%$c{V5^&VS*V42>ml8=VV0F`wMLv&a}o)XGrL zwgyp-QtUoBdTXt8@k*R`M^m6;GC$Jz?$g_$b8XHyVKWyq3D&Xkqw3j)4O3t;5Rf+SZMA_u{`;6*~F%$2h%YuEAHQGcupR5HfQ3`tg=qfLvGZ-2W}5Xz<)4axeRg$abd(NP598@eC$n5KPtZrNB}fM~ z#yuM?Y8euhP-O{hXWskBdgn!x=6TKKkJfd6t^Kq;J2;t2ot&Hk&v_a0jKbqB&( zwqtEWJApFO|5b=0e#BuBRC)JPr@aN|5*?CU<2z&94ie4#w()mT=zkdbKQmQ`2vNVJ zbtRBU#MjpsU(m;^gasM?QBgisU~BcLYY6n9p}pYN!tnudY&_4r?ru>TUIfBXfC&h*Dcc{(n$ z)Rpx$scXPSi`NBkPF^0; z0}N83JYhG)k+DIX8xT{E!=Gyrc0k7#BdyB%M>?`{D!(CJPyR3>E+$v(-bH}4BNKw& zt$b1rddNtGZ4~t68sH+=nhRA}4_y<6`HEDOLyk)eZ4js|e33hu{+$wIH*-Z<_H1(~ z6sY1Il*kv6|Np`E$6Fpzg|kEa==*SyC3rW1eRqpZE4$`I4eNYLpud-ZLC)Fh^FiyR z?NWj79>$)!3)ljyzwgq-bc)HtVC7#-*ego%48!6}W8s&iy;Mr)wPtEw^10iHKpy4! z4;<=m%h;d)XaGFywVfdd@I08kh8;bELTyu#Lu7ZYW3dC!6ia^hNUN~T*TA8MOpyVq z8f0jg#D38%2UbZ;umci3FKupOf7Sp1PNm4MxhcBG#r$<({>vitw%#X+dEE{Teqp`zRk(=ibj z)|dnHy_N!jFb7@Q*o5d0hmHQ9Jsn^K(rp1!sII?`gnz!rzsH(TBxW1M@pS9sJGm52 z#xN2-&bb>bY8u$8RD_x9KEr8s0q1pbQ68sb)q0hJx3`$_Z#A*G64bznN_2r7Q#5fk z?O+YLV5(~8cIl2Fd!bifM&sGmJ`*HcHe(%Ya zpyc7L?qdfCvOG?UL&K2|08me&R7TM-5qpB$nO>1boKophlmJ1dUG_dxxgO92FbQ~G zT2;7Vy8V6q`1?ow|6ctZ5qkd~SR<`xfDQy8F2gU%)S~pD8bQwMNb4IYnW;j$KClLH zq9q>v!0T=aX-Sd3;HE-cS6h&{W%f#Q#M7b$Av|5mjJ09Kd`(*@H5Ry&;LR^dKMs{W5saB2WhC=KLXqz@ccYM8K|2+V z4$Yd>eLec;>Pj0d#-O^G;^F_6SAR`1Cp>7Y^HR4&khcduyNR65RYDBZ7TD@8whsf~ z^bKYoMwxWn$gQ)KwhaL_GLja37Qa|*bONj}nmxT4PvCZL)Jt+TZMqh(n^VB$7J<-* zqwpWp@_!95p(`M@{MJ6r)tEmITG6bRK0L^k<1uRKi2+DjL*z?PRb$sL%zA_g1)*3e zZsACMu2+6Cz@h2CpfG2}qv|&o%0!j?oLHR3Pc?zH?&ODOj!ujLR8y3@qgG!lGNgz9 z+lkSJ=tKg&e+G#8mLEabeAkX%r~(%iAof-zOPfhBrBdP;)aOnxmHt5y2QO0koh<`+&5%03{txvi zMzVQ9rJDXibE>D@JC>$aoj#S!dUAL50!`SKZdu9F^6-qHNY}z2O0e;jbxe$bcTB<{(gj9?O-Z)n)o509>`cRG(n)QJOGa1(P^l7Uq}xvn#k2ZtzCv|Fwqyz0?U| zVEsHFlkH$?+{c!PBqhnyuik2_V>X4UB1W3IDx!Krt42_h9TYj&XNt*{kWUeJs?w_| zMA}}H&LOg%O3p}#lqb&-YmfPr49IpC)8SM*z_rrF_8*$-zvlS=406q)%ijl>Pyh+# z(3RWBi!mv=G|b$p1H%DzEsod~EAm%pRl9L-fVW&YvK2i+{=rm`MVeqmMKLKAcU`&w z9dV3!&JKpqsPtn!+u?~F06%tee)|W$B0sEc5KO{H2kC9drQ5T_@ldfXpLt#o9saY` z{Wa3MQ6@28t63jIVJiPcO)xqNXF{Ont{r)#KQ!eShoa~e+k*L4R zKs;k81F0@hu_bx`aol@90b&jJmL6CaPpjMgo=oyakUT8Nn$LxHVGY`|+3LoDlw510xT9M^3kCCQ)~E=a^=n4b&Iw6ftrIAm zR3rltEivp6N3g@jqy%!Ie3hEeSJD7G{=wvT48-=GSkaOHDApG#+6v1B~a*O({ z7Xf3ygHd^*9GO9mcANWc4tos&Gcq>)v?YktqfjJIjTsZitk)ud<7<%`*Vk9ZA86p5 z#I;Vestm*v`CQAn66C?of0I7^_u3wb`G@M$WH1p6sH<^&uPToWdjN-1q9{5%Be!25 zhwyoJKu}AeSelx+SPv}Phb=HZ77k`7#pbAC^h7YI3{TJ?RtTE-6)-yh@qHYk-bCpt zFGlf?Y$gp6ermwLG_r`sjkIniMDF4%;o0T>b71Ge=H_v@dFxdWA6NT>a_x~poxi*{~|M}Hb4=zTLGIWu{tEhM?=#&;> z^w^z|Y&aew+5*(MSlfk<$ujWnZ)h2OK1ib@Bo?CIPE?WqI?nlsyb?wZA;kb_H()UC z==r}#QXrE^V1Slonj(t_j0>>P^8zkjV>8Dmu$VD4g}Od)Jg;ekIEO@Wyx~w@y)BH& z#5U<%H_zo5ETWP^bWe<$rtsh))4&BgaMRIJ{V`Ssk@>h;k)iyv>P-S|btVWvaqSaD z${m0g^sEbJ=CG)voVihu(|03y!-~ASPsoqcS-$tO!ozGW1OclL3`Jpln~MF#fxj)$ zqyH=QYiFk1i;*1i3ph~im$j9zR1sg@|6%R&8_FvHBKaAVu)fn`@jD>ZgL3g1Lw2B4 z1Q~RG_4*`SrHhVqk5EIQu>IV;KA!l+K)=B3g@y(LCxK*&d+PltJ7c2*)i!G4s)g?h zJ5HVnGIvLFsQ=4h3MBZ5A)F7;wt{qAf4_U0z+SD~DTshg#hN+AUH1aW#WWc6xjtrc zQ`n1KswE(sXaPZZYz+7Xi+`0GTW=o}TG)o4Vk$4G8G}#fdQs3cV9;CJ9INo!V4w>B zXNgSi_g;^Iv^$(A0p-_lqQ* zi!veM9Ok-Nls`1#=iROp4`84NviQpFE8l>W9}d8R>6UYh5?@m$MAzbe^Cy?+`W;*0driG zsFn5Oeoi398d-Kr6!3I$n=H{4pZZ5(js-Jw3l#avjRCOV`wUoK0~lxSH<>YdP`*$X z*Do|`gh;F>B6v>@v;lxHAdubIBi07`&^Mu%}{(3gS52Mz{C$5JTp9MHx1 z!w}9z7koS)Vbp2h;3bXVUj5ocb!`71N{fHL?q8R^hRC)qJU!w+s&xc$5+6$ClH;;Q zTVSLP84(Dq(E@c33wN5GMPd$PzJ0>{6#``8206K!r~ym_9O0Uo-zP0*+ZR<|r2XbZ z6a?-B|L9N76H3t)|17L2+CqZpl=Hu^8g`2jwGbnQRBc(p!&UVM7j-)uY~DxXzb{xaL&YeX>9vVfH4ABCXuPFM{e8;d%laj-LFzA06DOT5nRO$7#(d zGU9gDhN9IS?SFl=%mZX@n21a%as=zpG<=G$&_>vbWi7SF)dt2==U0s81qLI`EQ2pfH2F&Yz|kijyw_g^sK#7s0!+F> za6b*F@;pv_YjgY$W!B$^%|9M=W)R~2wxl3(;PRKnA)85%aI-q2GS1-;=4j^1j3@|gkRC~*Ej6^qEAOeB-1aIdU=_V&K>xP zfqkq>G`j8Yy#0TTuP~u$tTvM;VB+U?{t9Te6%qELfS9~A0 zeA}P-q3d79hb z`^E8eI=9l;yc=<@KTZII-f%yFFWP5M@B`z8@(m!DnIg#|f=+lADj!+8oS=_=bv*B+ z0kIZ9r?52$qjA{@*Fn1*pR9Jp84twQmiE<7>!w^?h1+@=4jgcGzerma_T8;jsGvB^ z>M`7&e0P=v@p{wxs(Q#Xka$k_!m^jo0E`9pxH?f3j^%M!dzbc}mws0E{kQ?wd9$Lz zC}8mcUDDn4ND6$1c0Q;9|H?m>D|bz^W`cxjP2114hMSkyRE2FkTNM~)2gIoFURiAb zVo_2%1uOLFp*VG2&A!J(WuDcqRP?~IS9Uxc^-xscuwT`q=5sf{guZ>GXbL>M-y{Bx z2@k?W4yS!I>gf;rrt04XtyI4cyU9ZVv$Z zs@1PW@MV`}RK3)G0{krmOQt8Vc1C(^#m`1((rb)k5+mP7$OBT5FWC21ya2X}7`^lA zx2v9&m?5iQRbqjN5~8@`SB?k-9uhl#+V=&I09C8bb|f=Rj1l^Zv3MU4T-Sp!)_9pw z0NI+UF`%QvMSU%9DpnUQ(ScJ%hq)}Kv@{I(0)**XS8*$P_p(yB?F}{n4do?yLwFJS z-Ai@j0mdI;9)SGnkg+7*9qkO{dtj+&S^v;Im8r~6So>_=NndmR1&?QC^_vXa+rxP% z_lnGLS1||(g2KB`?r}0XcW#9&a~^wTYi`kH5f;+xfh~9zbOZOokP*WOp8Qv{ey1*T zUxh@MH7f%2HK4|a7Ib8($Q1f^V=OC6+Vk1b)5NG zzVh#BLi%ZRpRv9GU!%O0Xi3uGr}bY1S$*e#Tqg0G)%P7{z!-P3#B{#~-!$H~NHU9^ zG-Im!$`_EcIStLm^zXRvKA0{6D#G3P+1AI43J8RqYb>9Xw<|~KP86Nzbx-K8jT3y} zVHssOht8ZrexYG`Oje+cCiFB8N&rc_+;N?0x(%3sHsi%?wmq}rztfcu@#@Z-``^D` zNlLve+rMe#;b-2}>ABccsV&dSqFov>MrG&>;+<$T;TzqE^u0GU23YH%y9Do)AK$#Ozn`8L z2nsNdCq7O6XsN|fLYu!VjzojUfEH%H?H2s)Z1dH!?0E6z;gIg~c)$7YneGRPEi1$E zAGoDK$#vuI>N$>8tdL;Nb?5I{M?2s5N=NJ8TCTBCjmW~`XPhJ4JUt#g9p)7#H{Gy5 zKFj>f3Z_F47zx|*A-^65vtg_ra;qK&5d0JXI^vk1QUh8L#=OiYQ|>Vkxb!DWPHXg` zOclM8!YsEhs+}tUe2bK_~6d;Fv76 zUQS4_IZt1T=khpHa_o0GFJ+`>nVCbgyICEf%WvoDnRJNFq?XG9Jp@g9iHMKKzTHS=w)Ft0&Y-1EZ{`tnJ4+UYXwDqq|N^-6@%xcb4* zAcKX8?aBO2&G?I!ly>&|QRh0~dCfIPq||eIh*xLzID{oH+}$&TUilf!0MCioig4PF z`O|0MF|A>sXj7BwS8j(-cK@&Y#6V#UxA%9r`3c z5gJp&x;P#_Y|L!OqCho*2!0j_pSVAgJ)Mw+16OV!{D3F@{?o^onc^_qWR<@SA?jh( zU|2pu7vIgGYZxiVUcsnxw; z7ts=8MYR&L?XQ=vKLHbq!Pa%U3fHBZlsex_y;mWoH1B+lz2`hA=D!p=bf9sm_yGQ! zu0-RRGPstYkSoL^`X((T{DF$b!vP-Xip5_#VBr99jzsas@WS*L=TH)NzwCVu^l>J9K%W-xst6^R{0qp zpnXJA@<32mC+s7C?BZMIEe)NQOj@#bmFYGRd1>!hDkaEwAE`kcl{jxCu7vp5c7OL6 z^E!PdyH6B5Zj$fGcWvI&xq0_{+dXA>BGi*&V@diJmh4(+e;jnTKhBZjGS}7=XZpRI zA|0!VoBhb*-B-!xs-L~pi_TM_TjB-N=1NZnEh*FX{f#lK5?gt*j`M>WOus$ATYwz- z;l8E9*omxvFF(cmzJu&B>I$s@mRa1GLdX6T5FxdO83_?UE}sh$?xBEgixv_v;Dz!Y z`{eNSYcHP08#oW%K%?B%}t7m&=kJXxPf>x%2h5q5Qo+Ld_W-==%>YoF~v84_3#Dtimb6 zH)&_;+#ws|4bAAb9^)yi{Goz!>^|tuQEOmkoW7k*e9soE+nI}tBNXU9yWjwNuh46M0G$@bFZUOl;sf=U47xm&@x~f7R?#= za}Usq+%GBLFp``qiZr2J$htH4Xco`|xhb!z6KlG~rGFtjBNvDx!*kRp*GD>o=6)$y2fMqRVW_9$Hb~rX;Vnhy9|H7Y*ap8gAy1TY zOWFcTvybktj1~u9P9os?&vsI3|3)Nv6LB8IHVp+e2VZ7Dgkk!V=AB7-wR{HNxA`4s zdQk1EOU0U&W3f#*Yg($d4s3Jc^hA5~DL`OuLKs26I%Ks819uyCCg0`YfsO?(CX~m^ z(WC}u5lPO};Zxa?VeKD20yeX_XP+&uF1hn?;`k{I-C~YKfJ?=!)_pRa@1bJ`k+Ybf z?%M$vUqWR;;G$A1^y{(+p5{YCKFIX@gM06XJv|5nfoOIYC(xLoDQI_**iLDp*U8~< zzWFMp88p!C{i&zOKPL)q`o*v~*QQvSzHa`HehVF%30K1f%d7NFN45r2dBF##B0lm>uh76VjaOP# zN$(t)sB_Zp;_H65y#$q=qj&`9>PV)Y9=%{XxGbAB^}GEVeP3JQec%UCV0-!$iNC*c z4;}D;c7s|V!nLTRz;{q{Uq4JX6~wC_Bgw>R_h|QZTo^E=ye$!jpSg+KeC#<1Spy4p zuMjQIsmf`|Bi^Iv4|u=lEq5C!h_BfdUPSiJ3FZ&`M0xaLP6Oh>DR#Q4c3Kr`H94Q!4J*}B3C*q>x8p+iNn^~}!oI*rM3~8up}b_{ z^^VGEWRM3W6G%tK*1-BV+DQM3_bLjSt4|D&pK5a)XL7INn>sCKTe<@c!q{7{t#Z7p zr?ZUm?5n3W3m_;)E*@$59tnAT^$`P`D!tp?_~U)`W$)s1v@1^JxC-75&j$gKu1Z$V zMe{!S<Cyxj$u0^wQOTQP_U3q({b0A{NdtEm2jQorfe7cT ze~$2ROQEANW{=TO2P;bg$(u9rTgj5=11OSNX?s<(j%xYLpZO;1aZ35pp0?WJUeCF^ z)Uh4WV-Y+ZEQY<$9_LY_Nle&Di=S+e&y?PqbGLDJP&jKE{pozOkx)RtW!{2FLCC@s zsAgp{w5Z-|w$&16lV*UNp>|7M-`U(0!Mm|U$CP#sL^+iAdUJ@N#9jkK_w!+cv#p~~ zK_n6}_zfo!9+$JGTMn8lpb79@5^l`QPVKHRzyepK!U6&lfQdfHz|Vkk#6r)r=Uo~4=Ees1elWe^h+kOJYp)k+xsyE#uFq;-dS_t&fp1@ zC=Cu92(Ket`zS-a=;LE^SIC!hn7yN;ie-KM<-1k9R(y4-Led}h)D%F;Fic$M2=EFH*^&sF1O&8LN(=8=Id+#VhEV1}7_yh2;N8jH^{#_I#`vlhrW@jBb%&;a^3vcB)Q#SbRkL@xVk8}F)8B;B+j3$VNvgkb<#@A<0*(K`JAls zKsRzIy_(H?v;ZfK?^nb4jbOtx@&Sl1CCzp6+x&k0wvqe<(q`?s{D7qn&4?4*A&@In zM0`PqM4&U>R~o9cgz0(aW|JmU`}I~=&xxXs9I19kUEkdDoF_<3Y5g{r1d0o=iGsoU zt?L4bRXWqztLG@(zuhDsfZZ-`K!1^Y0z9cSV^K8;7|}sV6I=4*MrV@Z`(Fqb}p9aF4OAN z1$VoQr%}(-QXS)qcT#Z-xdErii#H#=c*ULGW~pyWv<}=(_SMqvPZd&hgA7Vk7+Blg97=v%vVHkrfk>t3AgyFEvvO;z*BH*0^U@0;EKX_bR(-kv+*V z)08Pgqy0o1b+C4?i)|0 zM{*t3bj6K&S14coB;KP&dlIC6RwicoC8hXMIGg)*za2DgTqc`&`KVYJHtU;0eX$n> zv>{>i=$&SY+4dnyEG8V)s4(=wZ|HlEja&EBPmf&FK);(kT`xde`;OBd>CGh#o43=u z#k;i@g|}~9h}f8e?y&-`udavoe(!fUQd=SHmDCr*b)qM*q+qWQU+POhs)j7mD8Pnv{(y22@a$dzC82b*@IYnz2`pS z+WV<`Dj&mz;#zAN3eRD^jwe95{1PoL39Ge)@r2pkR+feODC^7fZ;SVK`{ zASA^|MIXa=XFeo=>MiQUm$%V;l~SUDzD|$$ONDQJl;$3{z4Rj7=QPa*4P0BMYuBJR z{N>+@th8a=fCTrC-_B6n73c}og$Jh#3GQGUWjhIVr*kJnB3S#k$&*u3RwlHAO|d5< zQTx6Q5;)x`DIT~)=`@nCC<)oAL&L_wbx`Y5_WA&odBKhOGa*(?93>07@kOVMNPxfa zgCrOOxcAnhx^j4i8-bD|{>&H9ySmVEV95|}Q~{7O@p^GddGP|b zXQ_N?yb3WWmH(I2spalUiX97 zgMuidE;1>?vMO^Dc^4kTj_JyAB|ee<{fG)x27PC*e5l>zLLtU-?I>UrnD{rRJ#gTF zuUC2}thM5rkBNCR3Efx5=HGvu$eE{9uSw5TuI)$)-YO|yx~o>VHv`LQMSJX2W0@{> zlLl`2uMgjBq;+KPj>cRL&(LExp%-)>gpho44|>SoY`*WDVFGoPM&`V?Ust~f;H+*amdE088+2Gk;ZomB>^u~=32?zsa8|lJ(#a%Fi#_4@JV&+O|{eh z>!JS_z~yzcNjPx^y3D2z^`Qz)OQmaSeSGf;1R`w~o9cD<@58JVCCMoh&eqQ|#7!g! zb*wdS7vuG1W&@`z7rj)HeUO;)+^$&_Q~8T=HP%qPiuMC_~d>7qf-02w)O zx}n})Wj+$+^3BlVzW)Yf>{k%WN%9JaTAiEAvV`f_Ys9r@OZIF|h(`5I7{7 z=XX`xLv?0nWNZJ$}JvA4&D;pKVl4$K&l`9Fs& zwf7*t_54Hvgh+u!Vs!Z~@Xf*oCq|2AFmLhwqS0_i(qS_HKON1<)zgHbA__0BA^{tLyOSX+X+`T$&ty{DkS9s z(0w7dj`ft9?kYOn8NLQa+EYo(`%Qd9nw`3##^h5ghdqnXtRo11B3ImGqw`7dRf_Qf zy?cQwX9Urd=VaY?qWY|MJFDtKu|ER1h=11v_|{$8{B^Dx-LuUc)-ke>0etr>0@x^9 zS<>4~1Oc;P{)sb~jZs&^P-%hilknXmft8tpxHs!#R>(r~6(ktF$L?EsUTwpT!Gn4< z#92;JAU}I7-A#hVml$Kz`q_HR39kI)99v*83Plx+%!wbL3%2M<+iTT)WWV4sXn43e zET4LxL#J`4HRo?}R!l=f8Y`%|+ej+Wv*( zJS5|4xK6V-1Lbni6vWm&e1OaF?sdXU zGkJ8{`w{#Lo04fo-H#u(1B0@5;-_kJpDriy=Z41@!K|m-9+9#q&&Oa(uI9-oRtLh< za!BTG!5%ZWj(v@pHJd!Tbdm1KI)szwjI%>9vF-BdHJWb6Ty5|=E zXg0+b3BDM)c~X#FxEJi6nSFO;G3;El_ttv!98J#RJwUAJx76egWHelRn6;{(%9niU zZQwAOilkP-Kjc=$Z$)VoGvO>_jJq27BUt(VBUl04<~(G2?&YT%EC>4&BkwJS$GoM& zXRB%44|TT3$Q5awIbj1PPZM#7*qxQ)RNF_Y1H-9w%97HzkA2>f z{LS~Vd;1#g$6rvTP@4O42SQMEZ1E})j?Drqr~2?ckc zW5-q4e0R)mNo#%?X@27T3rB`NjX+jYz<#r$f0qX8%Sx%{O>lwt!gDdb`(87f;ucs* zZGCveYCbQWeR?e`>Ta9Gy8By=d5o+*v@=CQbd0gc(){VYx6EA9^}hr2ILC@m(k+sp zb-ot`qI=aaT??&surlEB0KM?FPH6ykoPaz-F`=-CKd-qliX z19UST5if2V-gxxzEh^>hZ7GKERkZvldRyH9d^a1*C$9K{=g6F>GD20qnbNwe>c0eI zc$4oc&O_6hfuBwkd7Y|K~?;!}*E}!_mwD!1N-5t{ytMhobR`A}iFTLYD zdr;8W?NU;AreBd9OP(^(*`R(bH6{fFAS7&0G`d9LtS&A?jdQ0LhvRbw+o@)62fa1- zE}1~lOQjF#t7t$?1*KtsUV!dW#Hk`z_MU%6#^|Mj2d%WU<6C~To2bbZEsS^!r9^g1 z`O-2OuKzYgJ-$*WZ?wsIMp1AT#-=BW)`{XybWeqi#;heBr_YGb2)a6^TP|xYdSH)W z`w=)X^d;jfl*6NNr4A!k!L~{dGf{pmLdXbmM$L(D9V9tJ(?7w!B9e+xr6hp5DKM4m zjcD#W`~pTSV0rJ-4oHmUGSkK@59s^U&|fR-zHV%LTM!L9d~9mkN5h9A*u%Z@1!oMn zrFLIbb+8&?M7T^mjQ@JJO1uxQdFLe3*DEd}t#v6e!dvk*pDv{)P11gQt&yMl&P<5E z71xl~cU8LZljfYXf`t9WFZ*K2F8j*g(YXy_B)oeQ*=EIQ>zl14h1mi%u){rOkZbo% zdPJzT0c0ry!LB-irg45&x1LcBF}XAbVsrV8T3bBk!22=m=3Dc6A3i<852}D~-YhiZ ztJIBDvt9#y0GPp}<@{+Ytez3Zq#w%&g>XRXtWfZYvbOd_dQ9Yev(ACI zPd!BdR|Jg6mS$(q;M`Iu=~{8}civC!OyuN0=Mpo6;!sw&sm%O>nw(J!4d0^kc=oiz z;||pk^bzbsNZI$nBUo=Cb6`fp3a9% z@iWb15e0*?!uPiu&I7rcC_L|cG8vl|WS8Lc*e~7koYbG^>m;rjrD*p@eaEUP%2^|( z1K{}3?9!XFzBm4}i$NILIL@RxUTVC$vByOW206~CAe$8BxJy>UngjmLci}=)#7Pyi zK@u*tk-;HX7QcA!3b0#}Xds2?UMVw_2~NNf>Wv$Y!$DKI`s8Ph#E1-x+%R~~Z;1TM zsDIY@lU-%w(zo9|-ySAhBYstfCtcVXwS40H>?qY@Dz`mKIG{$NwgjD@D1Awh+;O?% zsFoc;y|$-iBiMo_cQP`^q(fSRWeq=6t#CvyYCfOPa_4;=bLvTIb{k(e*{}nga~V*5 z*Cp@Kj*}kseDm4p>dj^g*mcpRQ&lncI0rik$i}6|Tvp2@*($YqR@1bnyPwXUJ2TQA zI%nk`KJOvV8Oe2?2n;!mp%u+bZ`a}(=@}n&D^*7{FGZ6Y*U@{!5*>wld*x_T4n&Pj z#11V6#-2OJw<@%<>86`PjtA_IGG~W;FOJdYy>&HT8KRi6XS{oul}|J3F)?Mv8KG&s zGL^3UW~;Jpn;b;J^#A~kKVKijxe1|%eVmGzl*{KI&}4fOf78XU>EIOyFSvuyq+_%A zTHqWmS1CaJt_=eoPOwgV+l;#A<-T2;SSXm&pE2|2>_BoYapIUyB?)X979n;GfZGjfIJF??Z--Q9>^_^!YMspi$LE z&i6zgiPUHkcj*i>q520_$)ifkGvJ}h(hAdHt?Em6nRimsUZ*kVmR~dEp7Dj?$c88l zI3Ak%(WV*of!{WW#{W5e2U2kN2i*K&MHH)2o4HC~qvZPVpoI?aQe9{2BNC(zzmo21Ra_3C_Zn<1b-mb+c*iPk;^G!syO5viR1=*a&-lk( zr{<&iJa43Djv`Mom)0bQKxL(A4h{ZaQ1rOd4XqC9Q2Gi)Cf1Mj=> z{L^pUrN&HMS{pWO1w&6MtG(~nAS3QrJ5EE5u?h*ZKNwBCeK&)7E_PNekGKYYs@}>g zGezJ`-HitloC*gN`6i&oB}KccKerW8*1V4+e{>a@apqrn97iBSKRO9|T}!_B^h;q< zbC@&Y_<@;}2%ry2)QWqn^5m2Jkagb_CI(b5JpzNhI}h)W_FYEIC3hWu#Agg`70sCg2LXlse9wrT45Zgc&z8@hLZHAQ&HDE1hOt>E* z4JY6f972v*;E)XN8E?uE!v0}v3d<4*W8k|mMclBq9lef*+8S>N;^^b*a{z-fdBnBsp>}% z>Ta%K-foN{Swv`YT&wx+oBZYh2Z{CLVT~?vTBotZy`op`s3_@a)JKAy;w`&3Jg%z9$WV?u z2a3D3vK~6=S!c|7l4r4PWn3HgyD|P7lSSwABQ!(SCEDsJyyMx3!0y6hzs>HJBVvD3 zBKG~2?SKO7Pzk9Qq$3M2fg0(ix=Y$vceB*Ar@`A&zHw=IIOOUuAL-b8;WH<{L!YW= z#tCt)Hu&=D-|?OO2$3frv z3W=iy;7gM1hu7T=)RHvSwIfaz(Ysd8=66p@faRvcJhVGI^Lg^TK041cmTT1DcE~N$prKFMW24P@;XOHK7Uf2D;&sy(# zKg|bNv-aL|?BjpLFE-hKQ0Gc@$}M%Cb3^f!s7O=wkC^Z|9~P8%X7w(G)?nJ>5h@<# zDsd9rC!_u#qajV58J?@K)Ys%=qpRmE5(E-H5geXQw*Q6`og`^~AMa6?^+=HNJ`AL~ zR#CTEws}Fd4#==Ix7OJ9iD<*!J}G~LTJ^{iuzcJHa*H1qB(*`M((C(MF8^U9HFD6) zluFfDk68E%`CgHW*H~q%LxiEnIipbK69aazsoL&^?{>-=Fa+FK7=hk^#Mxv&#*1>5 z)1=%j8MaRmK0e<5s^t-*_D2I$)bquntfZ#i&*>^UF^MG`v~cr&Je0F5+YJho|02_V z^nb$^Y&_6}wo{nyc?ZEV_LrFFHbFu&xw*GtoC)EPj@v$)#T<@V{U%tB-Q!n*-WQjyTP?Y#y$>rBt>!Ivaj@aF3r$+8gAk9X zfyk(HKzXsWz0sEM>oUH-2apm#$}6&r4d200BhbDGivMW}RvIL<6&QtKvu`3lE}VSR zYu7`cWG1MA#XadGR<%X((E`66LjsdfmY)R9n&TaHWktob!zT z^Z%+egz#+@pRMDZ+%i6r7vZ4_Ql2wFR#Rehj!!K99EW~Xz*cTLJhaDviZp1Gm^vE$^9hT5^-8<%=? z#HW}f)qN$AT3zX>D@i@avvd1N(L(>J_7l4Ioz})$fHnB+aLsC}NEE)IWFyY5qabO` zh@N<4NBGC$+xeP(jTn0Ty}@f4QtC-}!l~+o__kj-;Ky>%xOj~GAP+L1hMs85rK87+ z%2Na7BJ+9wlqYGIsy_I={T4GmASy_GPFBAD5f@e?AUW#RT^$&C@-U&m$Yy!N8Mw4VUEv}Kk-zAcf4pe-kTd@d zGa)wEch+lrb|Z28=f*EfetHw#+UxXf;RwT=iOdsUv8%-Tf<48>>vj|;x->6}CNOL> z4L`@!m-ZuOv*U!s_tuGK=opWt77hjRqcc0Ow$PG(V zes4LT?L_IIdOa9h`-9if=(FU0C+c+otQTNCfB>I9pq3~fowNmMf8@4#cGOvf!O0Li zz0=QXxjl3@ZtGFYTA!~vq>@G&vx~GX&<&sCAxd3w^FBqlOAro0+qJsl%vONHV+wX= ziZdd7D$;gos`z(HY(3agjGu7i!+#Ja?s@`^mzq}8e{@)N$@t2?I^FW$6?@Nr?LBY}{)UkGO7a&usuuK7+R2sNF1| z-bnt|G~Z{#_+$hJrCF&YR#V&co?~VFJJnUblT?f7&!`q20^5Ru&pBf{GcQ=rWD@qi zM5y!QoEg&vRv=W6Wtqqx zj{OPJ3FS*}hzeOdf7B7*MXRp_hxLHx+E@~O*T-#tKtHFyX)05c&BT2|Tk)R8Ct~-6 zqz$FtptChu#^Qm69w2OSkx9q4nrUr@gp600NQntrzac$)L&p5|DE6ruGF%3`RuFA)>6IA z-DSPy3f-Ox`Ru_6q;l95Qj)m(Dyd7kg;&8f`@kwkD5cJCpk*=T?|QPsSnT$0Xjv{F z@!3-7asKG$EP8}fu8(+yPT?kJ4nm5(Dx(>q2X7E#Eob%-%!@x*Q?G97PQe_P5ulU>zl-U^V9K8k&+3Z?QR%31?0He?25=+9$ zBocbYS$B-`sF&veXv^G!PED^$C|HVZh9FXWUBL_S*pV*=OHs8fTsL(k2D0Gux&@NZ zsPJiv#mOykbO!MJiqP?d185Z+s!xu9*J^hOzcEM0WrXiFPV~xSVAIy8z1DR*e*pi& z?@*eR^8Cy+NiOSeRh<~M0@G@5CiJhFDN|wfjMdTg9g#IkDT&~h(414nC|cUv(RlZC zD-qa99{s71Oss2y;E}MtO$c~D5mMUzf%4K1o8MkLEPf> zhc;>TnWWJ{^)cPMoMrQmvA=+&1w^pHrIM`g+mi7CzVChIKh;1Ueu~b+Z3E6BCH{U7 z8cD@U+eT7{^ z_gas}<+Y5qmX3177KieqeOGs$=JbI6Oj(qc_+)RT%PL?@O?r^5O^>#RXMG8!hv{*X zl)YHvYb&xywc2wHnXJZY`6}e*Yqa-g=aU9M|NH>3pY~h;V)tEg-SrQT4t{@chQn)k zoAE=&GWf?m8S5T8L`?YNm+#F8MT6SJv_siyHa^cU-;FxU_a3A)j@fKZDKz`78yO+b z?IS8~I`$r<`zi_?aCy*}_;ggbctjbp9*C^1FMPdJc|+yRu@&dB<*5U^_vB}pknrf{ z8%31j!mOY`Au-@_+3IyfZYwK0#)zGghYn`A!B>T3YuBzuhyp&ifb`jLdDes05hIZu zv69;tR()M>$QP4WW6afodYS*L^}C1XE z>tG~WZE`?zXHM)W`bhX$5b3B*j(l6_vAG3imW6F|?WB9zjn5Da=EPH-y#90JX*P8S zD{dWrMk>2uTt=TjFUU|mr7ySo(qv8dm@g7oTq-Sqj=oVQ7!_spxz2tEq$eG$`7Gqs z*`#7byM%{KcJ0o-y$TZaUKkG@fexx6ipP!_6Jq+dEjUhEXJFZ$3;>UJAX=t>C7Ir2 zTGHx!22f4(*`n$wZe+b+k?jaD-q>1-Nw(cH{p<)~M{8r~qJ{iHl+JaY`>tld=uy2Y zgOS;~{+9~htBdbf^ShcM6u$S4=K0t9Cf?Lilqqi98u^M;R@ZW?BEPrrLIrf`bieX= z6?5{R5L(*9GHsH{r)_BmqASurbJZe-it1l)`ABIlNnwo`@W-c%F@Bf2CJ|pZ7RwPk zs|#M=a`0#|tjQvn9*o9Pgyp$4%q}OO{5DtmRp#{D)#IeTp2Iergq}OstU!{+OHyG( z>d6_igak=*j1ttxz6e&Xw#&KNx8o zWP}h-?!`xQJtUkBPcJ$ArhZw_CEYFeYgnuN_?5z)*Hz`h1N*`+8_Kz-qhpeW;L59K z4PV-Lr=gRt?v42tYpOnVS5D+6A}7GX3Y4b7`sweHR|~$@F>f{Rb}TI$1xREWb~H1W zI6`kG?gVaHXrSE&642WFku(wJo?`DN@vwgCmPf%pXrRAx_ct^)Oqm#HOpyrelI9V3JA}jldC;^QW$ub=Ee)?u(wWDQF~kJqi~V?R%gme{Xk| zbcVFAFJl6$5*Zs~y~MZ_f42cFg+=T5(UV{J8SPQicQz*@(> z#t?^BSMBdbzoic>Z@V?#*%O8#fxEAXAQ(gY9$C`7WuJv+d+bCR#k_O`ByPZLYxJFE zGM40VMnq|7k}IzYcEw8k3zPcj2Vy1n{yxUPU+DV0Gn%?2kpQM@0lx0B{;-?=eA*H4 z;i;{q?@8PpwPh@*8M%ylLu1X}Qp|a0YudRPkiOHlEl4s==BD_H)7_jG2nRXOS420oVj0xo$rH?CO;wxw?~QW`~;MoD80956z~I zOs&D?>C0UXtg5gk0|%3q0?BEw;pz75+aG0JdIA%LDaPrzJR^lK+5`d990s0F5=W!b1{}SBy7OYbr=D&VhT+)Vv;~_~QBZ$1~++K|hAKO;6X= z8Mb3e?Yv3?{3`^7{CMmQfU4UAAM=l>J=z=xh4PIU7L zLv4it2sxmtGUu<>aq^~LjLQY>igJYHn?rjJBE`olT6IScK1T2%&bL2$KI4lqe|GFk zbtjP?`Lr41g8*oSj}>Qx%&Y*vpX5&{<5n(BzjM>dGrHd|F_g&RvF9w2bAr^yX1<=& z)X@p6)xx*qMy@XPUqO_lq^ftfn8U1qmvM(y2+;tb7OH zMXkCao4S8>aP}*F{z>>z$%CB3EPkw?eJFoliFc8TAM~?&dcHpU_l5rVz5e*9b4v<6 zQ_h}U0IV#vpXecP0UE#LUhN2Y>tZFQGH6d5qm~%?Vy!|%WopS`2~Aw`@(5OSeX_Uf zIo0TF0j94Tz048L<6r?Fn z7k7-$XWncpKaZRC2kadX9-yjHy0oVb8ho4jQjDjO71Cz0dn?gfd*QO+3&oKt%pUBt zeoUzX>q*9CE4X0yG#S-e^&yO}j@S&x?!upRD))c_k<^X+Hj*uSWYW zDP>GH8jpUn=|h~|@NxE0kFVtUbFF)rLHj|^=;EkJwFp@QL269Wa>qc7pX|;PvIk>_ zm6*=aJ@dXGk72w)%d9uAr@z(N`^1WPK=ps$_5XbxcDw|yJePuz(Lm2gR^u~&641(s zd|KnDG`}THyG6VzueXIym2+A^!{iHJcd?~dDV8gcjvWoKMv@O)QHIDJoi91dro{;h z0*hxV(h-1f=ZaY?kNW?4>zf2jR~;A25!^l4H9m>>@h1s+x}s#+)&n<$l`KhBvf(kt z(vZ1oS;c4r8Fgu^SSmv3OK8xpt^ckKldDp<8o@FdqZHkh5miurCkI0XVC&=t2pFt+ zLivaO?_2$E0{ZXYXlXE4j~~|80i3B~VC~2^xF5I2GAJL--vnlZyhPwDt=^(qbEwD* zWNEkXUy{z4p7Sadykf!#+DgKE++U00B!kTf7M8{01zC?KYIKJ-0o46bKn)VmR*|Uf z?m+YLjr`6g%0H_`112nRWb$ziGA+mUE)7FqfPBE9)f60O9w0?21LlSS=fi){hU4g^ z(pJvRR?hK}8L3yl>?qor;`LIunf;^A=jT9i=)gAzn8GKc9ewNdf5a)C`QM)VZvj3m z1E0HVM?8ClUksbM#~W6j8PJRL4V*3B>@AL>b2_CDARnI20N4Y^Bsdk+SdpWRbw<%k z_*d;flLVgMbMP>%eZ8kyb&JfoRbT}E(e($~DeLKRT+A*dZ+B#*bdJPyzdoO$1MdjZ z9A!B9YN-m3Oz+OY-u(dP@W1Cf`q7qg;>3=axD2oYW=1fDSA0>gOrZEgT&zKfcjB)p zRiqxYDm=`t#|*Uoq#>EA1plfmHlN6!(kn}ZqeQ{Zvg^W5yiW$j6-utb)Rgl?nz7R( z^F4pilQyP|0-Utpr~J3a{F({OmH43Fm|K8V5ft556@{3@U^Y%={0YD`t;&VrfC1y~ zLbS$&L?@trmW6hG;uN4c!sDw!o|#T z4Hdf-QFW4#v)ZpALpI#^Qw4u6OddGlYa9Zl7^uRG?rKoQ5{#sh1r~yS)3pdqI1o^< zwWF$JEqTP)IK<|hWF-MJpwc?mTulG6g2uk5`_*!SqwHxZfJVbs-I&S_rQ3XvnY$P_ zsebhtV1^=4P4VOtePDtrSR%^>!6|_O#b+DJ)?usE9_QxiXIc^x<#YfHT6_!Wrb^J>=zIPOUaS;6Ckku@qVv`lk5IpfbKUt@jSA z?RnVF)c|^pWm}vD+Xh08M*s`Js(6>)`uP5M+iaRt%*#Bn#v+z!Q$VFFg zesXI!GdJ%eC*WAAbWObGV9-9NbD^E*z+ zQ7UVv6r?l%*j^uNGLN=GSuKBJs5l=wPWcQQg?l}agHl-F&39`DL<6ib?}NVgvCD^n z0K*dwodV8l0bRU6z}Z`f*)tT)!z?mECYk7`MQ&sc)_G)Qfy!jw->g7xSmpt!R*q|! z4jU49q7D?9bV$qsj(}TvzrLfDb;$mLIhO)jl6)&^EfJ{v> znwBY1Nz;B9yrp`3s;c{VvET9)j=1;TXVU=6Bm);ZYghZdk*-YR4G^C>*V8%51R8p2 zL&&wA;K{db&>8Fd{D}omdH26`T<`fhJYLE^E3?+#SXGUnxrvCtIDbSBh#NLxp{Y!x z5yqz5e4_^UC5TpMbYKt|)#Y-K)Q0ubt6riO(u5`cw+$3^D)a|Z;;Bu7_2u|M1BlWYf zngKfxB!~u9{sA`5X*!JWo=BPYUjcc-y4?*$10+dnE~(dY)4`*6mR)QK4Qjp;U0(xA z0YgL}0URGbHTl@#LCBrEYaRN>dSO+y%U$YB1PjbC$*L7IW3BF5S;Y8R#mRm*H<@*H zEhX`C+d3_|6K0Hl^f&#j%QdWDH@#)Q%38I!p+8rq^k7FaZMn74oM#tj*06U^0sP$X zu%qwFgE3%1h?sM99b)u5+;2I^zPiz;f?KR;@}K;u{v2c-68%|r1u2>GdjPbLeq62( z-k_|VvEOlgdJA70{9$Qw7nFhMa?m$o`;LnDS~tj}h}6PwJ3*^LU#^+lti4f6gs|NS zp5h(4LXeEKi{SbH`CiI7m+G34lzCELub^uJUcX@HQM?RkkmT3{um3yqZl3i5B)7J6~$P=nee}E>KNlz4nHCGn9T0X+0^O zS0#Ke@Sil7^df+s^c7zlz!+W2BGTYEG-3}9oD*=C$K&?OM-ki^cuXABF|^wkjW6Zn z<+2hbrm`z5bi4a9D2z~q{g0qfmqW@kYpEh-Cw5Whj45(@O3EQsr4Ombj6`CtFiq!f9Mumt9a zpO&W(x38TW?Pg)BN@bWOPKd8TtCX6?JP~7kOF-9?KBaSwx&p!gl-CNY-utFwsEgFI zP(j;qMS2;g*Cvl7(n+X}>O2+Tj3{4zGia4|^*4~=2j_4{^ZV7TTd|XXc*Q|jR!RpC z2??xV;#>4=Kjfm5??Dy{HFArJ7ug4FI#q5CNpGtJ!O^0eSyOZ<$_$ihWMF9{?Af1H z!1Mihbu8z`?d>bj@7J?=0@W-OC5_$7z()4;ThOrL@)($_mcCXC`4p%!zVBy?aY&gh zu}Wb#zF9%9g|%Co*U%aa)WcNL?gzuxQa79%7W@Y_&8cdp$AG~u+lsboLD22GHvbV@ z>qT6QZ-MdZ_H<$dweg=o-6jjV@K7VT!IHIyl$I@Epmk7oT*JGZ)biz!WZNi&J^fRn zb;fAsIvc2E!Tr+s2z*e)Im`xAnu@=P_OQ$G`!ld2W0+k#>1YfpIF3@UWNv*tr0D6X z!=t^yr@6MhjN6mruB6^-yUuNV6dwM|b8)u}Md+7!K{}R5lCXF^znC?(96Y(Y9!Q!N zB`A7#iB8*XGgVR~`3EG1q16f1j~ z2;TB&`?C7}+`mE9mQgh8g!TG1p@nnEZ~>j;H2#db!ftco+JQQRr!oe*4Ir zybIj&b`#@*tuA;|Uo2p_^WIxazrfw0jUW7`H9s+>Hu$YEDFLW96G12GbDX&9d?)E6 zX|^e(*BUkvK2hjs7tOsj>=6JLFIGd*J&ec_@$39PBc7<70LDQyP`B$+z}V%eEBScv zeZe1-91_AhX}XTeEKAo)+>kFFDIRh|*y@!<-XiUi?ziZd_$IY0r52HPVK>a?KcO!? zukdJltM5V}uok27{14lS2YkaLxhHg>xF~!+TvJyp}iasNg;jh zVW?2MDw}T%pDhtVmM>nGbLA`ox|@}wC--KLYH<|7GnW+5jEX;6X}in6Un^Wnenk(=F-5`l*9Up}vW zI7j#tt3qWLJ+h9&Rd*di5qx5fGig7gBuGCmwtBwA88vA zYM8CO-_TOET!~)kC(WOv?xMxE)8qRSGUIPL1b<4=EA|!Tfn@*4_KoKq1<4Y2OygQ+ zS$y7WES*Ue%}CP09P*OX}gaSNM8fpU^%?&H)Kvg-t^J~VxqGb-j6V}IR7|MwU;*)C3g z0vG>J!~2#N^PWi+ErY~U$h|Pd@UyntM%nImc3sk2T}WukC=E`2C0 zQufKSIu;La_6^+UfGnoSldeAWCW)PZmQxJt4AA~r(uNbLH|yAlQorEFe4@@us?(w# zat@?vui$EwfFsa1vknk*GExG%GPl>1EupzwQc^fhfW^v*_e37w#dGOzIPncPgB_^B z))nbBpc`OpEg0GrFw=d967&F+rU;4fs-EuEjj@$&CO}G$>`EPz@FEA_$RKCcF(_M9 z&5qFs>Arf4crFOli!)KP!q#Q;n$g&pH^u^Brhe6%-A`o57}5pI56uB-_Dz+`Rfd>6 z$muksgmU5e+y+>8fLHKyZFgOHvI)h~F#dL#r|BgCXErlWX6+| z?4QjCA5!>9$dDwK15<(hpm{6rn5oxa9}%dYbcceVeMJ=6bdp6RQS3^JhnBmVhGs%B z=1X`|MS9o!*HyQF9B&(H_Fh-uW&05oC5;U6%bkV|z1OmqY7iVzSRDb$!gDUii&rzh z1Cn+X$1KEm%s|s?6G=Z7qeau1Q1_Bd ztCqa2Y6;9z!dKlvJcjF|>@FWAfFiKGwf<<>quHuP5f z5SGX0gSJ5QX7Bmq)MGJxVLRqvl4g=P3MVjGP7a$p)>pPxcN(D4Qq)CM@d~gg;^N83HxYj5>RYZ0^^6463RZ0@i1*|$?ZUvflUuN zV1td)+sRnl?UD5qe{!kHxFZu3q>)4>Vy=vfmmCez)M zS!CftXW$PtNt2~PDIv#BgvoDWY^`Yc6QeoDj;)IGFS(Vd{8~q{X-~x4)s{LnL>zsg zy=(}*ZsEUKm&1`T`!GDqHG4Kpu*jAq@Z+<+5Bj?O8X8P8t66a8)L6#CX%UzGJ$+BEt`BY^$?;-qzxC)K#UB~c zg_-+hB{svHM-MQV>HUXZ6Z&8JZo?Kker;GT#2gPve)+sHaXR;8gF6eIdy|Sw`714| z;#VZsb`0?+3I`ran()*2ZBJFVBzw#y=n8dPa6AMFMlTJMvW67LI~OH>;gF|U{B1H* z>{fVCeRi-nWiPrT1*wD+f!_aTR`XmYfYKtCyG8+_$WQh`sH@wP=~92D`a*?lg8S5@-$_<+!-})L-x!{@YM3~qWuF>CN_}#j)Im6( zGV>?oE*sg)AeY5;zVPQ1ks^1V0$NR<5yp^o=+@Np!30WGkn_8(u&hTVVvOvEDwIg= z0O(gnvCilyQOVU<*%A==C`?tWEBmy7U3-65!{*U2o;I?^MY5Xmg){gT zIl_Mwa&X(@5Z-$DqlnMX2;*_8#~qc3jAox>_xs&INkAj@ zM9T_RJ3hcoV{%ratG!U@*%^vR@laeHto1svlHeEgW5iPR;abzrnN;%u%Jq(X@7l3I zcvBdvTHKWP-v}HpO-uoe40V5H)hl^glm^V^B#V>=ALM=ZjLNblaL(vIFGlO5lro+4 z7F*hJt)=BzZ2#~KFnCwYs7NmIg#6@Ly%-zi&-OY4PZe&)zQ>FO_h1*TUIO^AfnIF5F-@lj z<0aNTnwS0o1Lh?D<+Aa3GV*-3fW0T(Hj&4+&nXN)ToZ|{{d|2%?NAmk>#1URo|hj3ZY~j{iE1EE z(J3`b{WQjR*|~A7o@imeIudQoeitXdRJp4T9uzt%W79cI4R7U%b>s#VyO*8HXkNcw zW2f{`B_OGjiFff?yTA7-KTEt}37GE%#z^+7T#oMnWT*_M)_8$3|3)Ob9;LD~KKody zp7wMkft^0(aHi3DMW_rQ9JhP^7~nDiH$Q)f&Enzzxe+Bey;LY*fExjnqVc`7z_6iK zL-qBBMRQmqx4e|KZ$=`z%aWsqZchYZI{10n5|E~tPwT8V`#j)}6f7D)DSl|H&7WzF|g->_~$e+#?Wl@KkMZVmpE5TS>bWx7`a5WuEpbhzhoxUb=GY;GfJ zqYj0x{B_)mJLLLVd8U@0A=CR$>h682Vo^U}*=X3gq14ffKs}#S21<(I3_n5h>KMd+ zZ~!y{*}l$4>iy%r!On}Tw+_KFKgZN=PHjb||DVwa6rF!h5^;3`ZP-UQAVGG$eRiStoV;`7z%7@;M)T9F z+2@^p5AZQg$$NUb{DQa2(se*t+6NH67MPTpDF3R}6R63tp?lM8ZWszGq!af6Iw&vo zd04scmLo@$(yV>ihtftL zFj;$Zak83&9I|fEF8?`ivc4We&LkkCufrX0GWL`x$ZWO}@wMgg@z$eMS{ake(G<2y z_*v;m+kM|tMFF4+aw&@{rnu3R1X>`zn-{5pP6n$ZcZ)UcKIVB=wLI6$t0V8?cBy0x zE)tj{|0n=IbL1T1x~6cQY1#KW1n8zOEp*U|q9vC|xJ~5c_lQvFHY-`kF~yPf+LB})<=2M}9mtFh{Rsv41VTRhRq9!SMJ7%b+KtrKopzjc zbuui|J(1D_SU=`I>OpuMgsAlM0l-5ZD{XGzoae;4Lm!069s2a{nrhCAg!%J>Gl^+h z*Nh_2nyCG-u8?)=Bpa8ku89h5jH>1=g_ZG&_oAd)i0FMu6GjW5EnkUwuBm_R{C3DB z{ezU+smgct%nPPrYh{@hMZhGO``@A4(`Cr7$;B@`MO1Evc7D`~~%+I5c zK96A_aa|Sq)Go~AdI`;)PWl5#UN`MNT=It7k7VW%BNY{!zS-T=Fzh0|p~W0MWOOXE zeDjF!KnE$Fj=79G`9_8>;zXW9q)^>s<@LGYPoRw_1fLBJ?kS*;Qm8e<*&}=Z-m(RV zCkE>C2p|+9PMs&Dc=TJt$!yKzt4+#X1S<}Sa!`%3Gr-$b)p>^E;zFJa_S9<2;3nH1 zH1ly4zzK*lHY0_HKW%SZ0i)`sV%gGgL(el z4RyX_>O9AHHQMu(wmLZQmd+mW2(-M8zsh%$b|_|yAXk&l^)&s86^`#l2+DW*F#vr~ zH5Do+gxT_~B%bLEATM6i zq5LUcdB)(YH>sgu!ftnaWGE+}OZ$QeOiD^*8s8dT7t`YQI}qQ>#};Y#T%+d1+tr}q zKG$^9H-rn@m`**2#0U5!gIaAlfp^YPAKpk*Kh}Qe-O_c4)V+{hA2ziA(UC zs}|-Aty`&xCmcrW)h5`zwycR6meaQ%bQLmlsTnjlxhk~u%L+Nn8KrA6hW^sYECgB* ze#nfxVNHu+{N9iPEZIe%w{__fa zj2K`45c4`}>o;N6mzIXlcq>`iuBor@`E?lCWMA=KZhNh03W-Mb2xAED zq;efvMTt?3pjYeD70n=z+I(Kh1A_{$6ZBMYQU>-4n*B>)G1zWNS%}$R2p48fVzz-`UzZ+I zu&>GaDs&)_XFxJy!ucZ7t3jN(!@A*()bz(RE_;322fJmLC~&&D%^q;MjE-)Q6{cy+`#MGZQn)xSmO?aeVZE+t(PW1*Y4n;-3gaKB{9 zPkhS2hQfObC=812RlZ3%-f3{DwpV{qGe138;*@hW7mDkPlzQ*+p`GHNS`~Nq|5dAU z`)%~?76*By{^xaj#B5p|{@Ak7_h4%l8~I>yrT>um6br?KO5Y{ohbWD*+=YJ|{1$GK zNNN|{DaYNVIzt2#&#jk^FiS}C&8Bo1bu)!t1&YeGFz6`sN+Kt+R!N!tfdlVwa9|M9e0guX1}3M5sK1ghgk!K!iH|m z&k752`(fMxF5#jMo1cz3`!lvnF|0q1aN)SsgdWy>LfmE?G0}oHPz+-~Kt4aizf3L2 z*Ki_+yfa7GRC}=@Kff`+&5OPVQK@*J?zeoGNo_u^#Z>7wfTF+vnXiReu%z^-v2@3og(5 zQ{gdx^33qM{~VLlQ(9Yoku*xZ!|PB@p$+P#uqVPz8WUJ}>>%8N&eyhsn)|0d-m04x zvzw@sk;?8gvV0;@bTeL5?O9Y(R;%R8L*Fr_N%iV~sY zXJR8?&6(m@d2|JOyAVBXWzliMdYvdhD*T^e&|{pbwtic=IkUnnl78{H#huefd*0IP zBR>^KF+JM?c84M^;E4lbac;z3wb=fbPw4CA_W~T7yJh9 z6s9-)NFZ4gP*&#~yaveRTw9~Z&gu>Om{rt;+Rc7E07bXQ3^fd7zDbT|&nQwGf6!eS zBeTIa9OZBLm5_6zMsH?3)a1Y1;bZ5t!e#HF3vq{Lp3FwLk640bKWtd*HTYymIOVnC ztQxy#myQqbNgrlm^0qy9D|^Eu0mxS|BY9d8*4{y`_C{dd+O|r9!w3i5MoN!YiM3T( zQ5$1)wZ>p0s?hE`JqhK}h>=61Ypi|2!>TL|ZMZLOIEq}>otRK|(X=JDr14?W60j5X zla$>XTW}wlMT3znL(C<96J;>Ow7f`Lfm zNF87kTX5KU=#a=WhRUdk;8k*#v$<|gX(9gUg0#-_JY6yiW}GwZ8*HgXgdu8;-W_>D zB59?;)|&d;4mV%{|3%XCm!B(A>y)!n^SL5(tS>AWC3;oN7>+*3TS`q$Y)}`{s*CzZ zvU^C3hk>;28OFUjugEqzj!)5ALYo;N+7cn9LHBvu{VPWXdedh`EDa^xzaydR#A7pZ zxSQL9ge!okn{%5Zy;cg_Sd4t_&@aE%yp`0A9MN63x%(#`hRhvhM8?mY5{>R3*lvo; z-e+xnj^b;l%U9ik=AfRMY`4+3e76GDMAne!S^sMsBpcwPl>va*qGM1Dh1e1GaYs9i ztW=~ko&jNH_au0lu|(NTKSF>y)^am-W-j)?GZtUQcUMX2L#HqT5AGWjUqwX<)+Bm| zCx`nnmWr$g8(04QyU{>KMrW;fZ5P=O5ml#gZ1j9jni^`o9SV8lTaDLn@;QND% zyU7-EDo381*T!}*5%Z+?=dd7%xYccusPM0|BwvL3oUHu96v!9n| z<3tCC6Rnp^T%!jz0Jg6;^?bBV$+8fp<0GB^5?_L5xx*xTzX}v;|6Z^e^~YtGg^vC& z6M*WJwuJTAo!5J*`K<7pz;jt!pRvl#v!#|@_*utr$e*Pp(nLuxqfu44Q@cv-an5Mx zLv-w25}LrL)yc+fi9x8eUSk`}zBui*00^i{6U{K-_DAS-1k?su58S!=2uHOBAX4%N z!FxtuSSCx3#~@;Hy2Kao4^@R{EKy#EfM7sWm*O~KdT=Nq1TVQ@?8V=SP~F+gj^bAuWE_AiL(GoW5pf7hJS^a#hupZ6EHPCof({eHrWU{Y#Z z{1kdVQW{*$FPmY6@V(cR`|_}$cJQ;KUua(UblistDe1;b6)gWW;TzP{k#4a@W>;XT9V2|IUVD`ToR~j#}fG+ z#{Q=x|0v{swiZMudBb^~=ZAfCHTlfzN!mY^ZMJ{EE#CSJvcALO#8^ zoc}|?jkx@YoogrE!1DS%6-nwQ*$-AvT)AxByud0clA0GX286&wo$2L=9N>fTf|Et4 zkPMXXDUBh!#KD96Is*@q{h1g71LbsqAKc=X$s_ zjdzF4y~g#j)TylI#YHcISjW)f*Bg;h>ECk=+#j?-YcGg>;Wa+Eq~f!FxD(;>sgVxcYtqtS_J zD4>sKK$J)_r7j+uN=0fJ-i?`n#Y|i%&A}kxoUk02MXL2KjLv|1_{_R+kW6y7>T3z< zV?P}CG=iSJ<@HI@3c%dp%|LitL!I7FQqx+p8HU2ps@5pIC&hs1mz*L3zm~%&4Xx^E zD45(h2EO@#w|uhnCWVYov6j!S5s;EB5%^u%nxPck_3i+4))0{F)YC@HHF4H^rit#|A&+dH2Wg4*rgW3`>wc}J$o7;rp> z;5I4FLlwK2M(gwERBQ-e6!MLqn<*YjJF^yQ`r&e&`x11pQMStm1~GOVu@7S@}S}>ZnX~yLTELDCl+IEk~ zlm>3p9SeGBU#Aa~TdRlntpX0zJvEQ7pIQ!S>h0}>^@t&`PXM)~lLf_HR$8QB46cOz zx4F3kl0UD%4iB4lNTqspd`g5Qsmz~V`}nD>U-zcYj-RZ1&15=mX689&sD)It&skKB zu3YlC=Q0?HShlNpv##hd?y5*`6>QT#f2PS!70iQJzLv%u#KKYE5*JSVlITyfNLEy! z$_xi8$k|IDDV>bFUK<+|s)6$V5PyIkrRoDgRqO{xF)Gsj?Ls$ze0@%~(q@So`gO52 z&T>x*7z*5r;LO5Y{If~&gI9q4ci*F5=&89?0fJ!pqnv=bV>^2te+8bhLOpnR+xEa>tgr)m{?b#d!M_{|UD- z>!G$j*+Px>1BSPc8k!)$4(F8ytmnCY7qUj#x`K<>_+GT9#>2GL!PnM@CG3kjH$n=* zM;rB`go9Kh2^RT@ivZZ_=?9O*1$JQn^WrrrXc)nuV|_^tUghp;s{~fvpLr}M6>ZIH z6cs#?5u3iW(~5@yIZ344mD}IEPS2=YIb_s`yZI$$Lg?v~0jSHg$d z#rYa`8^8Uvn!>f#f}j_mRm0j^aM_<392zE!myBp}fE~T-CZX4)>iB-TVO9Gz&gk9p z+qB(}_Kp;z+deea)5V?(05aHir@S>EEg0xd!Fte-`-z6U9e~GLL z%qQnru{522$i=!FODK{+cvLF|J2==2(tfB!Ilk7|NI86aDAwg&)BRY=n?00u&VUK= zT1q&cQ$BtVO92+`=soq7A^HE1_TKSS{{R2DGdRb{IYvd+F*36f83)IT>`^GnPKh$Y zA?t|DIIk#0W~8A|5-J@dvyc_CXCxdWTi@r^Yka<+_qTe#Zol7uZf@neuIG4+`{Vw& zKipZ946R?!=y0D@TR8mq_ysmLULm$V5exY8lf=iPM@u(^duvsCy>uJZ^pkilCeNM? zbC$5=`qXCWKBegF_%3C(M&$Oe;3==SyUV{;T>_HdhQj#y1E?*>*vFRuPg~e&(m6$M zYB5ReRd1A`#!Yv5yBywcEa~pPXAWv;WZu70ZF*+rjP!*`u0;jf_gN+E^dTi4)s3f@ zZ9_L3PK5J#xNBDSt98D&v}x(AYszoFqx-sI@ylYG2(RCk`J{zSSE{Unj_cDgri$2S zwS^I`CZLhjdGGTx883L$4cfmhnQlB;ZM>Tsay};N*vEjy>x*aQ42s+hEarlV4xex3 z;5SksHguBM+;yIpDEjDwLYigLFIu0l>Y`Dc>tu;pfnH3M@RNeO;A~k3Drt@jj;FCj+>xy%*|R#=Rb9oPo}f zP4ZN`QcX$Vx9R5mJlXeeaxdPx`R%|C;QC0&C%iXLl&#}jlo)voc-9c`{f4oy%l+Bo z=b1BZi3^N>mQ{L`S&Ddi8s~ELOOsw+-(0$ufY0>eO}eOh5hWJDlP5rVs_#e*|$d)_)D)H`wApgkdKg+$}w zZnKy)aE?5CHq|-y@rqe-#&hDQPlGqzY0olyNKo4$6>Pc5KIYQXU!Gfi@X(O|*<%@fXa~(JJG$2g$SzbAOC|(N%2RqH4*K zGMC|N)c6ZwZ#O<8aHC?oB8TiB@hU#aV<6zZ7eotbhHFQlwXD%e;R`j!J%RfcpFPt^ z;+amKeR7ri@J{z$_^heD70lVSPDEwta`5q@y9%W%%JT~LH&`XQzuqq{(3p*WiUnVH z`aEsW%i4pzs)rh-JdFGbjymc#2i_gdUg^$>v&wuN;C}K|cPzlW;eJof=V=$I;1-RI zGNqRS_L#m}e}A#1#gEM6$*8bgMTlZe=CPewJ>h=^Gd?Pv@na8IhIF zIF(b`1|J9A0eO#KC}hl@j*Fm)_OGA2cY-T&Up9M{mS7mi(fF&BZUu#Fbhbhz7g&bZ zjwDpF%lbR{BkFU!g2tc*>RH~z+4teBDsNQ3p3$|WgIc}h;Ib`;##o>H4e9~E>4zow z0VPjCYA=kEjR}=X7<4JdvU&H+xySNFillO+Rvm1ai0IulyHKQepOuKC; znj5r?PXlBo)b(w~*0_ks%S$Q)pi^j`X>SIJ(w#tvm$OkpX>b3tac>DgxmBuRwH`EJ zm7b7Fd`f^CGaD8_$0B1`?lH{J8PgQ*OfX4|hF9<<)y z!f+p`;eR*>h`~qe`9gzMKA6#>4M3CD0dOd9yO1Naz|VixYYQ}xJ=7vFwX9_O+b35Z zny114cQfXMa7R>1x;R@@*$I;c(93psh)SU0X2-rvX4WQ*5QM~dd-zEzw;MCd@CGo_ z1I668^Pt0m@omjM=U1ZU|ML{^FiLmKkLJr)f&rkHr`ma&CKh$@k1OoRz;F7< zgA~5&0&v=hgF-wZ3{ak{>Ov=UM3k`WZ9SlmAhq6o;LSm&OX)9>*bhdW+ z4ON>+dz8t^vXU1Geyl54>RGsqcf4&J*AJrGr;8-8_wxtGP z32LF#w|nzX`StGi0AOhsy^bgY4m7Av8%!oPCd#a_9N}V)zVb5T11-6pRp%|#!RU|2 zTF0w22{Q68I6^=!id1iO>I1_(qK# z!+GQ1?f+yPO^U(!dW15K^BUQ(zr+W|wyqX(eZ{~`<4%EfnH)Y13-BPjbJ#Z(wy9{L zt9PZs>#kAy1}M*1aRnh|f55!xCH#T!r1nrfSGuh71rro=+GEEF|M~(5gaw`U$Ik*? z(-SwP^WX=AomT^eoy4%wBBA9+TUzDRM;$cHjmKrUpGQO`=nBx#k6KzO5^3Ro+@PQH zRUegLy0-;2fAvsl8vfN~r!e3s2`H(Q$}gwpQ*Y3ki+1j2W~c2{n`>B6a-;99taj2o zxO8QkMOS?bkW~wDl#YvuIDwrqg8*E|CJUXw9ritCVv<{melY{=vqVKOblnSR68!vj z|A*C667U>}+-s>T`Nyu8Y&do%Q_DTK-1#(jr2P$@cLIgEy+c*mZk7=1PQBz+0E(0F zXj5)7hdMjzRz(L)oiznmC6r;g!$TQ;1FDkSbn5vhjk=OzZ~mwM=(lIgUJVWUxIUip zf3Lzz9ugc&xx>e%8kS7AxWqum&RBbeyvkbB`y$D(8=P9M&T#>Iz}iJcy#QV_Ao{RdnSb2qM5vr?p7;C^Bv(Ym9zHbx3% zYR&pTU3e)u^uyd*eUfbu`6rY6y|t^;{Si?31JsmoGx0h_f`PoEb$xzpYT(kxE6Gga z+5Ia8M5s9*p-oT$ zIYa+rpMS9rGRp9Vxn63~xsH2~$DdmE(mIFJbO_rzExhv?1-dt-(n;*B?R=sM38w|# z?>Y>09kl=O#A%4(WcUkhhi^xW-*X)pp~(5Q^9#1@3R)p5GY?XYt7#lVm?jlqPperm@(q*S_a@Tl}BDgnpyhqh2MvMgIMtO1ZD z#rQny6Tr!~3~|=xHbkrJ-1<}7;?)@c<+^`$v9RcOyI=_?`&?2^wVwjm?i~~Z!g*7a zt&JA;?`1M8zBxgq73+n2o05T3=^MJ5cA?^2csR{l8hZOFT>&zymaK+=P#BkR zjMJjU)!O~s4$*fHB}>IdLEfAv@N@R@JKUl>|H{h{>@Oi()W2_Cdb2rDsO&}`P|3cl zVf~MxkGq-5*qGPVV;NXRJX53y6|mb%yeS53G}X0cFZmicROa;2k#Ks02ROFSE%cWT zi;6W1O4`LrrQpp^L&i~jA;cEBfBOb%Xxxjbgeaplg*)%ic)_{?o%z)PsIy-)aV09?4)vI z=29(-u4pghZ|$qF=(jcD^49E!fBN)4e`$Y;UnXu8){9r+EgP${lX^Tr->|aIVjN31 zI~xRawA6(img6(onIqmN@Ci>(s_^EXrN9LE#W;wT+T~-QEA^JSlxRWwI2gMI^okNY zb{*~~|4{Ddg*;9X5gjq=K0>x49V;t_S6KmS`f zpF$og(d>I(>tB62hMopbpF-_Qu>b2IP55Va<|y+z2_~$JAfSnM#7&Tq~dPB zW=9Lfo(=;+EKtC){(6CIOrW9@xpvwy3wH+0@b((A1f`xZtm~jE1ci6d+$Z#SxfBu z93rlTcCRgY?()#)J#bzWn%7=C!c-0hIe#}7x7Tb~DIP7m@ikv{Ky8e9Q{8NwW3KOfs@fmi?x6BR zFi%s$thq8429$~PsT3eflIKoVX*D;u7iXSp1D~-cHY#2l1ZZ(_pxUpbo z6d?v2*sZ@n0Pl0tG~{`w6mty~zL}kfE1prgmng@$`}2|;HeeuQH53x#iq3*$nGj-v zxzPkzHq%jE2D)n2BVKx_(ffH^7hlQpJx}Htl?LCqhnZxGKVX}rL;45b`N@Lp;UKZT zMH~zk;{|BO%LA=br|J6Fvt`I22QzKtSyvy~zd3cHiNSE1rsyt;z*!8mp<>R~!#VXF za1#iYykyETxIUR_B9Tj7OlaJgqkYnQ`bVf1vNq!UL!yZ>8d`{=4>=9LTL{KDun;7D zpZXd|q`(xoYw+h6L;8j0Qx1|`XB)n~&Rj;sCh|q7X?!anlFex_2MH&_cxaKWYfJI; zVuICFLD>*}-JRN~1q)?!JU1A7THdBafFfmzCO1q~2>qb5 z_joKStBsjXjDdJH7uBZo;rjL$z5S6Xn&Atl&G^6XvXwezb;uM8KR<=w)Q<_{anwab zemI5EN8};=-dbtQgVc&U5$JqSivpG=^*8@e{c}6$pzScU(9!tac67twd9f(q+Q7iw zr394oH*+CeeF_s_5?@3DW&SK7dw84Oj)8F*r60G(HCq`O)Onp%5GICk7SRy6e!H55 z&cDA%t8bek=arX?i{H8c8c#0`_GQK_7b)`3MV5)KA8Zpp5*(5Y9St$}%Yew3>SbBT=w-c@X#h$~_h2}d6e5n#pf z`^k{Y{B%0UOhx;X?^S0L%YbgzA`d2)4U+8w#~z%C!uL6~zdIA)3V}0m^6pc6UVFp0HM;pd%S)2!L#z;-)B^(X$&AiI>a*rDdS9yKM)Hcttne3* zUmftQ*)>hpVs6}Rx&iePQATm#V7xu|Nc7zA4#udU=|duvNIkrJ)0F*e$`va`+?y%R z+i&#zRfnZq5F_k$FP(Hn2xVX|xJy(t7!Vi5W!ah8t zntZei4Ho4+DE_B&%_dsE^NTYF82V3c=AXX=E*KmLsg&*nR5Bf)j@~XiHw7174Bis@ zl9Cgyc%svDT(=k0DJ1@1svN9*_RsZ|}m(0>cf2W`!m09X?*YJBH!-U$SSQb>JJGM@6S zuSrmuyXCTOE{^Na^(%C3!qLL1&DJ3CxjUJ#fQU{aTl@#q@o#eBHX3IxXNg&wt;3<2@9-x|>116twk!f4ur?3-tHfJ-6u4O;^~lEx*`J zHTXW$^{Dy!euJhe6rb%_32)n(F`ziF59%Hv9XD5{Ue5l|MJf&Qy&i__6Y*@3{$4l{ zH2-?_=8LcLPkb+G!CA>+NFf}IUXSpr*L5 zlZ3lCfO^mOV>>{ZtbB6moR3+PXgD6u&QMi?oha= z*?p(GEzYbGV^)t(9^WHnYkj6QBfWmt{e*=DXn+xv*dq2ldWIB|IfP{Ay?XVo*-w@b zTG%#bl5r%;5^tD+FMmSBg_|b|F!>rpNe4z9cWc|w$|la-x+I;zYt`lVKIZLhP^uE;l0H^ z({uSFi@-u-q~zF4Eb0Q5l~vIZ;n&y0X{h1|{~FCUo!_Dp8pM%Qe7?Kj0sRU9zyLrXL5k@6Djpph1=g zoB`u;x83ZgD?@8h&j+`tv9y2@$Q zN+fVZ7ZKj8?j;H0#`VuXeAnKa#+l`o&eKl=#Q5-6l``CP$^uYkh z6wP)%V=f1EPTx!WHl1$<|B5vwo{hS$_A3*y51x+3jHjKTw&BNMTsayH z;js11&gHupp^qjisT#ILW5Y z2NuoX@Y{s!EM=wu)w1#%t-@*U=1#LO=PPMxXFwZ{MCQ(NKI133yhD+w!Fs^*vUwT( zY;*2q{o`)`!2s6**4Wl8X|LROW*Zh!fCK?-Hy>jw<^$cxL zYGl|ND>+p{?Zj7X=hLv9mku2nB~WC4zKN%k5)H6 zgIHE78kIch!*UQp_im`J_CNb3Z)d&B3yLz?J_+!6H}JooTLcoA6$vlFraXKthW9*E z2a-6c;$ zwN3R-XWpLBBaLrA%QKIltsBlP?wqbUjY+AC*27LQH8e#IqOn|}YdTrcG%PFvPOSa| z6~0}yoEV{|Ubk~H`)wqj%YA!fx9v7yNk4RthEl2ptq&h|6r?N~V7OiI!{EVJ0gs>Y zLfLF`%IjH|t`NY8`6k9)6v^r;V+z%U7J-_~A?d2VVa*}_;1q7;60W59rs$4m3)U+xDd6@*P6sYs@K_)2dfcLem<5+8(H}mHXBV=mFCQ<%WWIITVNV#frP*Y(-Si|0++QQ zLt|Z`|G%T8zrAFZ){o8HJo8p70(nonB_k-5A-F$j{^G`m1Y^Rr9>QFv-^@Mh4=1T) z3ewQD^rQf;8W!p2-f0+C8GlYqF&t6aL!IzE*FwAnocpzusZtx)w>5R_yw)eY0AHkA z>fT4wkOU0ioZ_8?N{<&aQqNA_d?NmTHGy*aS`+ z*qwZF!!fTGj3WJ@lDo>v!43i_4F@0cuL3B@)sybh3gF3wxiOH`&R2K_i*!&7P0JePFxcS#cS=l0aO-qpU-5aKX@U5cXoltOTAjC z?p|7CYRR;JUIQRaGoxU7%)%hRnwuWK7(5BK0%#7{F)NLe#gkkBe%kbN9d#|Lk+RA0iN>ba z2Bhy+gt~f!e~tz_fBN~WD|ljj!!NAXnd^>(fXWW`^gg1cZ&!^7uIIh%t_0$=89#%Uvri2M&d_%s$Sc;fzmFEhGwnV) z_8;lR-xp`N3bGG(fM<1?>3p!FJ2SpmE^vrEB@#MhV^2xoTMvzhW#1~&Wy~@+#+pLQn zb$0V|biVSWaB_ufgty;26rA=I&Gb4rI*KpKAnDfprMFt?wO3v(#C->4fXcwp*tXAYRJ_r+84Bz`IYofiy$EIcA8WbUAhk<8AqUalOEr!i|6cMWyG>Q z%?jIB6^2*b-$%JRBQA9*(Sdt!UevCUY%$@s+nWVv?%%DjD{>X+O^t~e)=j5ypE2a( z3P+3`bcl$eW!#h8`^;5jHf#pG!sD$Ot2b`v-?0Hvz{O8PJEa>tp!rE0isd~reY;Nt zKRHkaRKjOqT#Cg{hugF;k9Pt_R6~KwdxDY&BO1QSTG2+!;XYpm(|+5YcAT9mSEai& zM41O945@dnfJ`I-&7^Av(O z2bAiM{@n804ZQ3&p= zee8lK3mPHF5ZnVM*7v^mS94VJ#F=P zW74K=$U*X|U(K$=$$*FREQAO}cwe;6*9~*Wq=4wX3+kb{j|W;p=lovuL3xy_AiM@r z+6k1>dDL+gc{MDox&}))^sB_VPY5zKf=|2Jdy1XTSE>uZ95uBO%cLGT$vLqPjH3pF z>P~4nwB<|U`UilZuWua!<{5jRfaMm{Ycolcz%(_Xwnj7eeK(|0uPcVu;mFek%I3bA zMacYLDAw-B1b^1TD831oOoL>pcei-jf5}q^&Nw)hXCTwH7YIy0q}1Fr83LNgQGpNZ zk_cwR1wPU*yp#ejbmkTp(U`5UjNO>VUO{o^5t<5`y|mx&OcO#a4{NhEC~g&h;0q4h zbkikfkz^=g=w0W0Ot@sjqlAdUo!s@gqcw_shS%d1S{>dZsu8Yu&x`9^uog(Ko~J2Q z{`^CdM@|Mv15zL`@q&>r$iZ#`J%ktEptkf#u+I~Kl_d^w9B!-lUswmEMZ1?zUM)5~ z1yQlWfV+Xc9%S|Ck6ihM)ytBETo&HG<&KgI*slVcjij-Q42&g>BTk9;2}b;dCTVK= z9U`SYF;}EaBT+3xdzrmQ?mVz4vS^Q@siGL>iXEu!UN%t)IsfsAw%tr{*f|`jxE;`4P5_ zI#fr{Lr98Rl&#Nhbj1pd+a($#-QwEo&7!=-is?)R4MF{5lG!RJPJtL5rp0|u_mVwL zI6^}ZU(^n}Tzj>rJW)?0UA9MTE5~jmJLmI~OV`8W6TomvfC|O@OcO10>L7$nSY#|F zR|G-?l&?PhFci0`Rgz)4@^dIFn>bz=csw&?-+mc(2xk^L3a^5a~1FYUGU)Y#42 z<0iI`W<9u%W%tv?Y=89-_SxiU_D;?#syW(SC@e2g=8AxV3~tqkg@n?MkH&&oJt$TY zIHGdRnaNAk{dviy>Gp~)bNMv^7=64VfB^*O1bwQ1ZUqHz0n3R{+D2o*<$bUo)Z#*E ziL@sx3n1=0ihNHD_5R+kTacANN8sY2k#%IRMrb^B1W%QTUZYT=Sv%>;VR)JCo-zTw z+5}9ol5HReJ6yU8PT;$tXA_`jFKGER{o>g-p=V!AmE*lamK7ijykr{OqP!%=HeFmdsQ} zzKw;(a73MbtLjM#A|e(~4}`Ud5zYieWI9xYIUBWU}Q`;(qc2^8`<2$ZgwxymEI-cuxn zn93uWQxa~q*>+K`l$lhCjKVScd?0!-Q!T4k57*H~yFapgEDnt*Q39g}zHsRUod+L2 z4l-5_rOX?0KTp^>)_;6>Yvxd&8+|tJ5qD}hV*T=5<9hyh0cw_oYa!00!!n{`^SR*pfm^pOLS2Eu&d-x z!zP)7kR|dgyJU&S?IYLZ=hof4!Pq&zI&JVoU6a=7VNuawrVe_IylKKz_kua)3{92H zB<`%cqN^`rl|JmElsi7Gc&*OZD7!_`68{5c&QN`s7kf8ZQ8Wwgaf?ZCPmDmoidXh< zr^4Y^mawz0H#zwDW|j+2zwXMw=>f=f?>iVY z;exDW%s=qc9l(+P(6C>6e|TQ@1Bn6SGu7hZ@mw2cDPoG{5Iuh2bIVtYhVS*pMlI^A zYk#b^s#eyH@?N%7jc*!hSIot6W8)b|!jxT=+jJMAF)ZAF5>Wmad`hH_9`u=fr+gGT2!H5;gD@U^rse0^*f3udczo3Q(o_mPn{YBHP;}i1 z)rLoB(PyE^Z}N>2GBtTF&ns&p)yj)pY)?@syEHZ7y6%)gbI}S!Tf!}Z$|!OSZJZvr zvnC_#^s(TCMJw@^g2&18N_4Hozlah3IvX;}$jNuN!M`UEaVd#@(a&3 zpTMwi9<1r{$@E%@M@7KsaLlGYtvbVKbbzS5+KJsPW+eLk#&UbYkJLE=*hD98&katw zGo6ahJAje<`N{k9w^#4blwSrVi#v+NmwbJ@)_SnJ%&|-jL;3gkf^p>`eIJ+v^t9C* zZn?kKerINoBK2DOiVRi;j+D<6lkzml>haE$<1WiL;^x&(Yy1n@MPX8&CMa#YRz#f9?B+&WtXz7e{sqF`qV!t{pCJiVxs^a`Z52I z&Q&x+C7=rQTZ_?D;QCn?h4vlPqS@bT93~N!lN?#8t$z^*{RKC2sKMQz18CI!c?6-2 z9s2`x+ep8bDgk1IVcoRr{c672471B06`NC}{{wZC{R?$7Rrm*W+i!(G7GL@MW0OvR z968uCUj6_70NBaj?wb&FEg%nUlCc%`_@)4kyqRyroT;!Ly!gHGtJ7Vh7*)0Y{Mt9b z+M+mElT$T|N*>VHMyB7`MIU~#HufHx#S3m%H#THTrMw1y_ir@fC%1w$!cS-k0p%|j z5DL41@w6-a<7;U-h=9<=729RAR1f#!juahwZe^pOI(7TE2;*LX7>#IT50+UJkArL1 zqGn6L(HvT);_6H-&UTnwTPQmFA*W(A+iwGecfVOsN)e0wqdZV;y;1B`-|dRyAb-*| zBrxJ$n51#5eT`=A&%c&_nZZevlP^7M-%GnAk8R5r)c}(Gui>A?|MKDdBAy^Nzwy8# zzZBq=nS9wKy!!g)AROVh)$m>LSnhC?>PbQgsneG`%3zF;U3aSsgTJNl4XJ60^VE*) zT<(avD0h0ay%h=7P%i)${y|U!+%N>@_IKaS!3!V%sx;;RO1LgtYt+YY=}tsbEI!bR zj#G*5>+43pbw#o_o}RXB}v7O9o*{g77&)oN=JYx4F= zpPr44(*N*Vb4OWVZLl-|f%~}_+GzR{ri5$uSRULjz>5Z(x{Mg-^TNX6e7^8PP`8#p zibU19RHHGBdk%;`b8R)Y265C+PSHPKe3e8~9$<<0tkYWZoGviN6}Cp&0bsizXgFg_ zU0$s`UpgF7Su%ZB_=4&fzb1l?fg~W~nMo?{&{YZUWZ65KcB?->a|0^XK*8H>S*Ih< zH~-5yT3`Vm$Sq~mq9&lRhs`rl4SV@awd(#rn7o3cv%5tJVekE%T7Zb2bj4$7@}n7$ zRkGp8?UM4vtb!nl^v(lnD{{e!8w4L?8Y3{}-x@f|0t-$$aX}_valB%bUuhGK#&ezu ziwh5JxkNeqh%1NQnR}<_bD|n0__-jyjlf|~h`3r(o_~#_N{jW5LY`8>=9)}`LehB7 zdmn3R*n&*(#&S28!=3+fP_sp3TwCru1z6urBZc1F$+fgQ2ssYSz=j(dsi z%Q2FEqgjl{MgTa$@h+0Zbq3^v%lrfx8Mbo_jK%WX9SK8y&(DK`X#XfDChYe<`RZ*N z30??k2C@H4QUleBWWUWo`+p_IsXJ@=Ms3lo#|^A2g921-_o0})a(OOs)_x#!n$-F`~ytnhLq6M`e&*`%?Bw~wl*8&Ozn9FUn~u} zhC%%IyNg((8FmL~{DKNJAB{Acghp3HF$P~DJau8)`~`; z!kyp3G12x|Dv89h|2`WI7GS?o?4?7F=HYYnDO=9biE9GiNi6v7N8(5hLKIGn#XUnY zGze`3)X4MoH-kcJk#pygK3)8#!`DFE5dBPl&T51|hlU4FQyiuMN3JgWm>4x)Sr`-G zuo}(Hq_S_Yid5H>oa>m$eRM_oH%kgWo=FMjy)=~>8e%{khMlOwW`|wYzZAyJp57l? zdMq{+Nxzk*sk5Q$Rd(rOHYsNK&J7G+MgZ=?AhGY3VN0MMlQyc4Gc)E1umcHW@qpy< z?vB#4ypT@j|7POM;p3Yi00#Y7g%Z3Cy}Ek1#7u5A`Mr^{?|1J)GrX^iPqZh6kgenS zx`GEa2i(M}&{!(Y1AdSk^%lc7+jG|9=?3X?-H~L9NbqXEj|oHy+08qH`)|+P10SE7 z`ZswiP3vd=V+FS5PoEGeN>!ZX@M{v0G)PBUMAb9#oK+6tNJ-hTsD&cWk?O!Ygx7)p zvdVn0h^QDg5z7%$zP5D(n~zCLM%=5Ah?t&(2>>Jc|DLb@*3M>7w$_(yY$W;F$<3gc zz|P$;1Rkuu-&NHl%vR6P(YK$EAHU zeB%RafVc6F5BtA=Txb()JI9=`8^bN7>NndXzDL{iv!voe3kbqQ3R^7=#=ni3fXdCq z3OkOZxJnTA0KxWNTiz#;(Zd8DE??m!YtGiv1B`p63Tz}N0=ikrl!pCn z(wN8h@DRL}Q16lM#i5%TQ<1vdv&F8?B+U{WU;`*$rc|shf)iuoG@e21s{!Px} z)_m#Qc>SP9UrDz&Q-%|?{K7w$fAXatSdO26Kxd;(g70kh?;WxzyK(;%>@`{h#tp2!G%^1jT1*y#I|2-bW~Mh!uy;%8m$ zkb{Wllyke&Hx1zuj`Wu{@(w!=m9eG#^x0&}5rMX&%nALV=~~$Mjy2?n+VgdQ-OAL4mf)x+D+fWb~uAjJfY^Q=xLIsh>uoC zx_htS^y>-+46oEFuQdS@i%C|J^lO&ylfj5zeLWib`ib~I9b|AV!h3ssQH+IGKqw1C z9!tc?TkXNc^Qu{TC0S3>Yc5YO%3lMR7t~ikkQdtFOz=XFWtx4K>4HWkd5RC2nR9A z>X3f@hY7|1=hq!a8rcu-JM)M`Q?i&#htc83a9A~5X}c1M{*$>9jmCEN2q+F;kya+m zt{oeJ37vR=<?qYR?m?Urw3xeM1Hw<)N{1x1u5ThHy_&oHzH#=FxiaPAZ4%k(``t&_SmfsO( zd~QrHEv~xOx{5&Vxlh&VZ9ro8oz1_O`S|9M_Sh(>+&l5`(UXVsUjbRxCwP8$^${Y( zHkFtHt$?rb+tVgPXp?0Yz&nNR0^N?b?k__7;Srsz4sP4OvS0M|XCgzHntZF{n`t2> zciBt@6+m{HULj^#Vu=@$fw3h&zKM?ZBxLh&$+KliJEdY0hQlQNf|P6lihri%&WW*! z@~_>{AoLSuo(@oPtVy<>yJN0MV-uQPAPpvWZqBS7e`NXGc$@bU1;(Tu>=@Z#rpt5O zSaqcn7Tl*aR>i1=)re}?Rb<{h>;VrqxR-;gi&pqBS8-oz{YAyD&5K8xdC)=u^Fc!-^ zzTNoI=YuYwo4hr)+q2*E^C2qd_b`B}yTl36@w3`%DP}E%p|LD{MICj1iLy5`3I^{u1+Ov8N|%0JaLmnBJP0;A^b&WdXuAh6WXxWu+kl#T zFX$+1K7IM?afq(5*qN{Pe3hIqALTe`I0~j=1(!oC5c!X`7GSb~-3`goo}8k{eIL); zZT1}m?k{1gk10&?GGLk>Hrg&7g1A^N z6sd*2BFgd>e)W% zHqmrrl^=^^!iFjA)exn>Dx(3W1l$!?l(*t-u-;m5Fmx1>s;+@p;>*(=Hck&M(xd^g zHN4#j&J{yYu?t*(>EWsm(KgC=Hojagd#dvZ8pP=hm`C4=rtX3IU(og!J89{_4{?tB zu2*yf$k8LCfWTNS?PCnUYMXV4ILo{JS$DNpokOq{Fi{bocwfkSV6ld3Ca?W80im?9ofScS9I|KyweEwyGo9TahydmEpHM=g7049{ zW1i=@MLT~&2=S;hu-&+gn-b~|{PGy8r>)#Z1RoVB>Uexp?-sRr04nXegE!~8Q+KuW zWCfrSG(oA+(c$fD^E_)H!+zpwOK}6N4^be2d*WhB_iI;tiD?fJ&31OmKsxlrfr-GP zEA9E9>Sm=dF1hsL>FVI+6hN}n1@nxi)Ly(A-CZaOsDJ@KYO>{188&Y&uPr)lKF?SE zdXBTtYoPH}z#7EW5P!OuUe+j_mJEt-H$=ctfCw93{8i*`Su0zuWAKGhzh+9hgr%J+Bxpveu)%;$b!=Ur)(xloW&YAmj zduMO!m7Z}FSThrmxm?^)2Xc%uLynQZgM50GtiYleLMc(xwhS=e53jufv%kHLa|~aa zPrkR{IsS)kw~*^bs{9Q0jeW>z|D0lfi0$7b2S%U(q3^9cf2-G1DW9P3Pez+}hvKTW zlCFM@5-0gpF4JxLH(yo*6qY8)FAS-L+u2FP>&?nxLIx5|Wsl`01w4BiH_uwRxdZx2 zUUP?TQ8Bmn4CyM_jDV@`_UnLTzetl=#c|b~xHcgjdLq)SvL2(pwXl&f2+rllb7FX= z$qujhpIuwqKP?PS0niHf%2oq#c0G~ z`SXW~SP78qm+D2Mgm#HR+@a>ZZ`R&MJUQCY3h1RPJCHmx#Qyy_bJy!zuWQQT*V9H_ z-J4b)7%-})0ZZ8ZZ7nIMMd-Ku1{JD#VnRv}Yy!4cUkkZ3=<4M`s6*k4I9ync-9})- zXxEK}1uy~f9>e3>Z7>12)w@jtbpuSZKQY3e_4sEYAQbHzGhfiM;0NF$1v7bqO1`6- zqq&DUi_z0;q4hTNva7GwAyRw|AJ_H=R9T^41Zp1|!4%y_R#+`z5hUt`yK27oG89*f zzx!UO{Ol4ps3ijk7O{$uths@9rmcl~OQvcsH}$7h*IX^t9C=-QstHsv-c4T#(7O3#q1=g(iGwxyboNPM-1#A{< zV=HISr>~wL3{pQ0kh=*$QImv9-`uyZErgXRvAc*yMCBQzbRTzc&+o*4)EIFPRpWR1 zX+%I`fqbG}t&-1VGSo8f{(&)K9JkySo3QmW=$nnG~$Jrnn0wy0No%U8_q zP$~9O@roAt_W8LOSUBmno`rSvW6Ui6wgPY0jyyd6=%GNZK7*Pb!zesTZ}m9D_OICP zgu1tHO4|*3n-R}u7g4do&}m>@gFNR5VP%IQG!B{`7%KI+a&ErxDY&RzZ}>`;UxG#x z2G@H`$2pqRXKUE>Y~RHh}1&d)Sx zrg7?Jpv=qX+oA3eekA$+NlpKpm%LKf5LXr36FyUDkf`t@M4VEhs-xCyziw_;3&(7- z{Q2&!fruz*s_;tI$rf`0dyi=^d4Uo#>)zODQNXmj6g}Cqg%hIz1s$IJrAC^XZtnqN8x*lU@Mr3SF3=@9w=<+ z12+k52dr9m_YZac6VPHT*vpz#08gs^&GRMTdofO(F~u4_y}`Z8fH5ul>G8Q{09;r9 z)ic@`G6oJ~|Di^W=Pfk;10kCO2-$CR*kT0+(A>H(Ijgxe0XQZrk(EEET$07BO!RL6 znbn2}P-J_3R#IzV_p_P8s883ZBbd;#`l`nT+BD01Y~0O4`3L&x&S?Q!z2nlC;YxiA zqJ4876xys5on^jh?C>eCvI$a?56n@N-~}C77jJ+Dp3(|2{IZV0C#`FLMx+z-*X-6- ztrQa{fUP(aDz$QX5{#{pf+S*AoNm;Dw5WUjR@EiuiC0Rs89ry$PTK+$R8{(FYPEk2 zq#CgieCSrdH{K3*-i)O?Q=Rh_gKFij@}OCa8q?psPThWMn{S+c5{%RtdTx1PBzK`r z)8(hlknV@zU&n_P4sm*K0G_8((xz*D=2;k;uH=E>L9E2LH4(sh2<~?^th)>O>igjZo+*EqCN4NM7Z|snoNeBnDoh#`=Hk`uAaF}h(!@Q0xKQ^ zW5=D-I{>Gr8C0Vg#{xpd?hJX3#)x!(+C`5+47kOtHhmLY=xuhz0VR-)R8 zE?LSueCy4poxv%UL280`9jEKD6syX`8!N+OlS4kCPN??7ol6(g(vDjd2q^;I-@|qC zT-UyWK8{#$x9I}UuH>t&Jg8XVUMgD~jcaZ`{p~5Qh50Yz$09Q{l$Kl+09AUIrew_) zB>|1vC^S>!s;(jE<0{`iW4BC-&rj40k@_l**JjTW9EE$ZPWE@Ss><)jXda8E(V+Zb zn%!pqhQ@HyH6u|c>5|aSyQ?6+AKwaa7Zs2<5283J^{)VLbpIRpcp>^;zg&Nk8FNYq zXka_}!aCMuaubRJYy+qBWM3QyUiAO4_T}+Vwr}5-u`gq*6lQFN7DV z9_Mi!-{lBCmtH9gB|W5j(j3*!noe2Xi_FW{a_UB#onv0Vyl1{LQ5MuA;ILP}DGhbY z=X{@6P=<=wu6hv)d|NFMhV7rnR8AZ_|DxU6!{};!Ug9v|X1Bzd+%?X9o8@XvCx#3^acmjxu8 z8Yic%;ggr?N3PwHHip219~bGMwgD|e{B17mqyCXO3ohJO(P5B(MVD?RZx#Y`^LGfZ zgpFq#A$qb+=WY?3kL4bR_`hym5Zk^P(x*Aj_v`|pSANePn1cM;7sx)|Z9tRin&-?m zO0Oc>UU@?oEJRst#Qj@TfDa43IQaa#hg@gpdt_I`BK1eY$+&rG_kot*{ z0B-@HEX}F2f|%C`VJMMo8Fdsph9H|*4zvWBGThNO*nvuaJJx-ybO2)?SXifB*g+wS}g5@+l*X z=(OI~VECrL?*~G_$$mF{q#DXM;}f#Tb*g#WIay1((a)jZP$p_0D@^RUUh;_LGoIqQ z2xLudO)$&cL3jk8Ehv){U9#mBK{G6CE?OI5tP3U#qC+18G59=~TJsRE#2vucv?-ziXMsZ#&w~dZN#;+6!NNUgQc)0tTE^~18!mVi*e1A?YdFIv7 znrsmj3hjH|y?AC53*;?NLj*tp2TXLbT0lu_JRL?L=Yxg`^~z_EAP3;yuDMTO+V-z}XQphEtt zL)86(tr2%A#HIUxz(aL8^#L6c(5(?9u7rQWsmf+^#AYzxTWEC zg%&=Jrb`NAL5cenib!j%5fFQf`#FX3q7^6mDjATz#AGh0uV8|g<&mkZm{kBWw5jZZ zHhYhJDJ9V5HU5xl{mYS@E*wcAFnF*W`EkgAPV7MlGqb@PLGLhtIsNtSo)%z2c_; zx-B1oz;uhTVkJ^>JnX~V`?CGdgf0@llR)9~X}#b(*ZA%8Vk>u<;dPUKt416i00i$y zx{$S0$F1k!Xw+aY)8_Tt3gtixF3-4{9Unu#)r34fqD9beo=eVn)`YYA|vE8V%IhPf6|xx1FT7QsT%e^%Uo>k$Lrtx6c;+kdQ( z0?_)F#X!=Tsq-HyBm|3<!M$T^v=Yc@Fuz3q!gP>b*n&^GGjvsZE-`eZFyjX(x%1K7PClYB(>GMG%4)2_5C z7b)xdtMXrR8sR%u@Hc>O?Z47YHGec{)cc&Sqk+-7ZcQ$NJV}IxX5t&tghUy3I~nh-B5wyy?dzw1auRn-gqg;BnI-i*Jw z&CTznFuA@g^cOrSqNZg&K-1lC#%rN&ez$)qWUse@T739--RdLtI9~QW> zB*;BWfW;sU0VSNe5KuDazy0z6B+!ie*_Cc&eeYwE!sTV{+49iY9X{>fcHRm8{{^(n z*i?7$Pc``xxHyasreNp0Cn;`tr1#$N#D(LF`8GYZ8T^uuHJNLut3PtEXSltk^@HKb z9Mw2w`Pqv{@?~D-#6jHglIzVY*@ppkbK$Q?n&!8C-0$6{G##S}S9Sl0RIvK>NUQ<4 z{|emxC%$w27q~Kh6DVjsz5qhEE2U}0Fojm@)LC;w3$<$&{K3N*v<|kuKv`J1I%6>? zF6*8aJ&hojG)Jdkjm8$YVjvCtj+qVy(L0~w2dK5ZLC*ml$5`walK0^klJ|1S|LY4m zNJ!$3KLG-u15n=9ZhjPcq2MH`o}GiDqN+Ig@=ACfE>abW9O;NutX2#(oPL8rM>JjIvKOUF z*GcHT9$D=Mwl83vLjbRH#T?Ww;&-Xzw9d*YJ__u*e>kJ<&syTUz2OqDpxwn!>9Ix>_8gA4uA7?GD89&{_ksoLN6HcR{-S$_srx4r@Bh-(cidCr2_yhhE8D zllm%)yahzIu+$$9Euwqam%p?fg!8W|`>fAD1Dzin=S64>b5eQ}OMiQk!S^%&H{f&V z{|op$ZdU#ga6pj1)DK)Us~4OmE8J`(f4dz8agQ|t%*X%#PT;lua7jo*!%&T&&UrAe zA=KqxvV9Q;!VnMQSpf9H2Y$Wqfu)gwzkA_iCa~KqvkrqYA?q+K@NGa;x&J=a-X(`_ zkX1!fV+La;*E2;fS)^Ci8w0jk$==Q_jXIi_-|C~~4+Mwj2jT?t4JJZAL^BDV>d@7} zn4I`D{`wZ!YhC6mqHSrvpz>K zPCWJ50-T8p326KAURi|jDT`zdaT?ls-boNo0RXb1B@FJQ8Pn~{gpvzx~_*Y7fQ^~ znDS6S%CckpokK@(g4l2dyGp&7B`}7g2W%kWQ>kB79qSkoPYBQT-T0qAgiqMYo|7Cz zh3j)dwhV&2fm1(%~8 zx5Ral`frJ`m#XapE03!-<#lTPq9*-LicfRj*T{O?eh2 zCO4N~gO+sv8(GkJ4136#kE3?6eaPrdwbQ?>9@bc!&-p0ugdf=wKxt_Z)Q}VRF6E!L z4GT4i#EAeoi6LDeBg1N%PNFHsv+b^6E?yPg-%0mT4{6E8@R;f(VBVJ}WLs6?bkEl@ z(BDeITl8ld3M*Q))Lr9@UXEzF#vX50XlnqS{t%Nt{uf21FTwyM4H!jqV>pdP#7$he zpH?sSS?e3;bEAA}T!zYg|qO($y1VIA6c3$3^dr^6(L-E1qxT8>5=6eIGE|Gs{gt zyx#|~+1t_&f>0kNgr%c=0viwpfiDz+MM(cO>S{%(araBMnlEeoPqhC?DsS)N>x00S zVD2G<>jvk3Td`2kq&cFdi>N%1OzE7VRuGGD?<8#wOivgi#v6w&o z+D`UCa({y5M<;}u4uA813Rdm^OdAJ`Y9TdAEa(tfgDwk{e;+<2$fYl=5!HonR8x5a zo3PV9X2H5)91!5-P}KPslLQn2^fda69S+*3G7{&^U)U(F%7rkIEb2)XgFFuyfDnl1 z&+8kK2t-c51gdHkuZ{`R!qdO*Q`w|A?+2ISgJ)@JlNKI=)MiXZ_@>CQvs^jl(>Pjc>`( z9fNpn125x$-%bDb*M;C9H69>sM`z)kIjRG;fk(nC&-X_~vw_BP1T)b=$05dx-(RJ~ z(VgP@@f17k&0CS`EW;9k>VWDnW~TGzFa~=BuR-87@|d2AoXLq3rXTa}7F|Y;|1lL% zqp3XuxMTpx)C9^+&BpIfm&9_BomA8~ihrA3veY=OM}hQ_-9lMOQ2v4ov&Rt0d)7uP zFpNH*Gsg3LUHDtoil29wxtC2o-}m_C&j?gG8pi(^@_s;mMSqc3-}Q5J1~kZ>W*jtS zWV8cBY+=n=MsD)k$L2Sd)c{w!^PIlqc|(V)kY@oW;BBfn%XGZ_0q!uWYFVfo*6yV^ zlN>Z#H>de$h2>d`Ym8P|haZH7!Mb@)QIp6qGc^4iVy=1#fvR$T4mnx^H*kt_yO0f? zCU2N?l^~2(D==d}Yb&jN_u_#q*^p%(pr(Gr+ui>n7_=UMW#L=BB(v=Vzv6$`u*x)( z>rx*Hfu-X&fqXfKqWVVt{63b_mCf#^ZEXh&UxyPnZ+-@Z(fW=90ynz>3v207Rh6dm zMX`l`VM%A?O=^<|Az|#RZV1@PXS@rH9Q}aJWf%-Jr6DnY&x>coO-d$s$fh4uIhnA4 zLroyR##0>54|a=2By5l;(Yt(QZ8p8xdj^=%BXfnBp%ZS;6`ahTqr6=QfK{4_26fVj zcIG)0-{*k9M9)=PdrE=05W~6jB(!9+_*K+oP|Dk&7sr67D93{ka{d0%h*~Mjge(D~ z4eH-S-oC%9Z@6q9sd1$?sXuX=9B*i!6n>g@QJNxiq&U8yC9qb>k5XKqsGd`0oz|&XY0fUTRd3 zsMIGA3h&=Us@`{pQmk43m8P4;+$&=McmuS=xql*Lm{K&ChooIolH7;%@&6Y^`E<5{t=+{BfbAlX~GDuzTmx_Xaul-!ExeGbCE`%kAAJ z9lSl9@z<5K{~0wSjK_hIm4{v%2=fS(n_^yp-x@Hii{4ZV{q`x_VEcpO`_SJ}8LHJ>yAjh`Qel^uJyGbUe9`M{UK%F5>~5-el$D|U>lR6hwOgQv%_beB$N|@ z{f|$!?+l6*B0}E0`%LG4$hg~c4AviDm}5f1)WS5ISmq=Z8-L=xkjLmcI_4zKorn}I zi>g=GR;Mc-ax=nDIjgBv;kMs$R|`u{3UP{jY>y?Za^j~1FS6&qL1(MTo3k4)2UPy; zsf|)IhdsF`TG9xAF`zSLfWLp){QY1^SQSM2lL6ZB(!+2iGuMx`u?=f0j(eJOlWt>6 z(;z(-hcpnO7gjE#4Ij{N37;Z*8-AQFu=C#~Tk5@j%&xYZ#LMHbxpAr8E1COn%BDK^ zsVqL{yUc8`nlp*vC(-aQVw8_BH_Lxmz8$gqEt%w3J(8?IO^Ti5Z8|Xm44bThFG6n9 zw-NslxB&IF6&9bicEOX0lPevnW4mYlD>e$e@~);s8&BuOsm%Ac$Bcc8n{QiPHguo10a49xNVs$+@4beFpQCF#bx}FJhub z_i^GAFS7725D9XP&pCG$^0D~$1^VCqm@THJ8?AwU63d?LD(CsNr z*=ke_er-iS@vAO69-E_u=prMtg7;?v7`{gGBRr|odaAD;SFW8A@^3bP7%!fgol~`p> z36QZs5bY1w20U`FMAY@(qC)u8>-(iiOI7FC*WGY(HouGrh|k{=6=M0(N?-%ZuJhEd z7k6q`0KsfTlg)Ly$NP?5bsrtY>S`kDknS%5-jFeHH}XQlIf7>R3Aua&F{O#>eeiwJ ze_Q&fAz_UYPxP!FJ+A~r)?nH+CEk02!B@B_uA{CP+`okaO_LCqm$Q#;!zbp0=fYs= z_e;ga@4_b+%a`=yUXy(pRFM9H?JENswxY3MSsjXEt{nH?n_RIoTv6(JE2!0>EAaZY zcRR1-`N7Q+8RjveTbhU})dfaI533E94OlWBLuTaOOy-KwOp`r#>oEHSFo!vQP5<`S z7qNMN8*2h!_c;XPdB?^e+Av^NInEjNs`B$GWJi#{#aCR0hP?o~S4j-;H2&-WaOWvN zw7CBn^2sEnim7Iv93Sh0OmocuxV_P%(6)FA1Sfa^)dmQK@sPJvf15XN>-2U&c(I*e z{0;;Ny#zkXQ;>x)@P5cqS_I7L_o(%J{E1w@g*$WXsypGA|GRjhpjs>mSo}>vHmnQS z;R!_FtOW7DMevmx=4b)XR+%(=}2+y-V8rWt}Dktkc|Q1VXoghKP+> zj#`9gQq@v~5gz8Mo}hsY&OeCPyLD>YZUz4w_#c5>qydu5{Y^#-&aG?sB=2VQ3dBY% z)w$@D^kWBNJCNQPeSRl+$sr@}*0@{JwyDx;ho-_L3GU>i?L|d1G=(8WLj%N`Ef$%<0&17qEsT7)A{=zDp!;mIB5Ht#Dr1K z8H>O~&Zn$!5%S!MqlKgLwr+`rw;n8jQeIXic^Ete?iY|3pk|u>bwAMj3>hSn;+FYWT*>; zXrpTtn(&|=}nW8Zi?7}ZU}6SL#B=>3UY8flgIX(>i7h%=u<#~h5I!9kf_GzgLtSK zdOESio1MV*(!xZjICGGb7*%6DO zpdC{nT{L+MIA|C>(qQ{xzJ*k@Sn0gy%K zsqSmCb*<4f9^CO|*lwM`V=DOX4ZCC2f!HRjea{$=;M< z($;18C}4p3nmJU~ec}`yK1YO4-^Bo$&!*|MUyb6el4_f#eJ;2c?LqC&u|AvSU3%ue z8C~^KjuxEUCOu4wrZ4E(Ggn?4+Nc3JH!vMPjLw(MFU<7TziL2eIS^cT>Q|dS2)r-~+dj zKyU$$oZifpWGwKV)E`-Ue=oML{D+*2V~-PdduZ+xC%?ZRNE+g6;h1uW!pr$0FbGzsXJ*3wBVN=0NV=xRrjl zST|S_H8iHn<1;nTyKD*qky4eoMP{@&5NuV0q{kFzu|d7!-*4J0u(p8$Z7@B`tfh1c^P z=T_w!Q-mO1h=nsdHdOB2l`wMonMnbP{{aJgjQ_W%uP%?u5837CTvZ8vDaUlb`HInv zE2o1a=1!mlFLG`J>42Tb=8QJxdL)SPAK@mdykoe^G+`crglyqrRMYVVVi`+KEQ?X$P(2GhDJkOaki)e)8ns4D$i#0Uh}`w zPF)89HDAAcxPNPJXCrr-gE$P$Qt&ua4TfHIOf(E9fq~pDKwb0d(4!oGMQI;kK60$j z%*Rm)%(iA`IA(Ysvoa=#syaF(P|eu+HZjnvs+s$jbuOu1p(0-{8yLk$twK)1aUH?Z zb<_DLn=KwN{O|zgfqmEs$TiXXzU!WG4hIg09i@D?j%7u6vXVwP4!q$bgkn$Oy2-^? zQ3Q@yVH%oo>UGw)Z?$}rk>=+SXH<6huO)__+&{_)&%NK1HM>GA`J3w>bkl9Q1e4Cb z$_FudwM$QGzCllEseENtsQN4KLh-*{z)kI#bz+7C zUYD~D@yRirn<`*R_F$&-`T|6l?G>tDRcLqxxa&Eo_v%N$%$})CJwJQvs4MSm5-BGq5#i< z$Jl}-Y`aeM*j~xK_pd!ouka^rSJ&64dXvvu-YSBp6$mfx>HSm2C_>g&=);xpG zJXyH+jbO$MgL?PFM0K+AcevV}k|=FA?xChf zp1SGTcTo@NuJ_y+vVfHm()@7v3oUBbX_?SP0VjhP8AZ_{&|sY*p+a^fKrp|%%{b_~}^iAk;oBi8%*d;P1P)!V4f880x=y}F#d zH$h2*DSJJn#%Ar+Psd(@ofKRpy?cwk0ptiNR83IWScGOnSSszKfqR$|zrzC+x;S+G z%);rGSDC0;o2r7QUPSuP8964|`1e-P=3XBxb~Ir@5&9JJEII<*9-}Oy*pe#rw0O^^ z2)udhlq4902t)Z2ofjqNM?U+Ic{T4Kc6m`9RIM=1j8OgI2Y5Pmedb(=g&4N0RTl*6 z;t9|IuFe$692v}Sm*GDbD3A($n)0}X4)Km#zy>wy{fuFGHU+G{dnmhry&gPjYfxZh z!YPl|gdX8sN3x=}OBz{ytKb32+7c!<+EkVtzRn*QjjswFyypsT`zgRIw&$ThldejO z?)0r2zkv6m`|t>(Rx&~g$%oJ`Q2f~N^Z8|kugi&|WtaTEYokSX0in?9aCGl(!YJi7 zPu*sJ1G*PIoMV9@sy&Banpmm_oPKcs`Bbx*32rl8uu+n<_&S%~raYJJS?+hON-a>G z(RZt`TJM!-%jEL%G0oXpCZa}hv^lTuLb>X)8g+0Kj*irQ@KoN#W+t3L5L+r2r8v4F zZ^73+2wy^c%%GBL`t6UKCXkAe5N|3$teU$E4MLEsB3A_EUU)&L9>@aa-YWb(FvOA0 z)T-JEl9CVF8 zMr+(iB;mWOYM~)Ai-2Eup?16=X~#k3y(RAF719YjAV>S<#PxaIaQU)NB=V3KL1f%F zC@9^461U9#iuhpNiaEDRIr`KE0&bTV$OMATU$G%8v|fFcr)4-bwteq!e1Bw48Se~z*_jV|+mRMEfI>Ue z@XBMg{TR_1)Qu5lY-`YUETSlVVi~>*HDVrrHxhsRbZSkfaOFFVd6)Z97{VXKCQm8f zF%~{i7(F?UbZWKjUPXZjBW#BlikUatnKi=K*%QXVo$aWX)j&^A2XW3f=Q%RQ5e zJjB#~QuYpE45WYlC4SrMk@)n92C=gNl@;{-5!{z6RdY>hM)d@|z4|AGP9wEm$u}=t zxgefiqlT-Axq0LYFm@-`1-TLr2IwO_i0bsBxdt$u9>+36XuX#5!1A!#kI6P9x=?VmGTB zGDp1W5X7gXcWDd=uVkg%N>XfY#C%T7CXktQF5jT$FE1ZqvLO{hOH>t;%-K)8FNFTK zpdBkVR<{fd6etA+dyc@JS7rlwH*3SbSJ5IDe#Bnnns^G=-26=l9!A&k-DP!IqRdmI#La-bu>GLS~C`Etw8A z)tV>OjDrKohnxfYZXbR|cl?kb6~nCPGi?pp!;^N}aq?j@^z&gdv#&4m$mpTM?Ef4`>V=Z` zTt0~*qH0~*OSo1I#vS~D0Dcd1blHGpRSPAcz3brhc*XQ(mIK-LBJd$z>diIBJek%T zESKK}8JVNU3M-03e5{OyL+_;TR#(zpZ!CF3Rh@IU)o;K$-b3NLyWyRh$}Ok`GX?a# zHl7N@&b2c=m}b(^w{TwqZBFAocC)p2Mn#lNE-x|&tHU>ds5M1_Vi-aDuDtV)yK`!Jb-!M0II}2u8OvPP65%cE#G#MvN0WsyQw!GUGiJ<(bgSJ%eint56tvZK^H!F5y^_{W;)t-EiVmdll_g z-q$Wx26p~r#W*tY)M!A56bm=G9L&TqTMrt9-6V^z1H}aTn~Ea=hrzET!rTk7dGMEA zE2$Go6$OJ|>LJ12BBV9Hd=yQth8L$>9BpIP<@TDvE{)|l`Q6z7t|^B5+|JpkN>7P1TED(t%bGJxj;`$2LTUDPyx>P4T4gIYb2M=y#nGs)Ppsxu;1 zV#Z>##ZHgNUt+7ipptui+$F8=^P_9Qb&v7Xv6l(9`75R$b=tj7Zhz=tXA~y zhX*jI<7C@W1w)^GN_sAQyH`FT@EzJ1>n`T=tKo1n?hZ1f3a4ZiPSp8mX%vkI#h|>3u7>@pjICO?LNhKVzu1-zyU$~MP>v6=PK{E>F+|l!GWE_ob;ig7b%smw-e<%4cp232`E*kRI}Z@~XvEke zjvj^|yez0EAg1C$y8hm^u)6kkVUV%|@w5xNgY=@W{C2mUd+2|x=KsvRfBlPavec6* zT0Io;=CECOANRswQ5M~CMnz&G%si{`3H$sQsy^2n6fDJ9T&}2W?s{z~yaeMo@o}n& z_2q6C2l{%&wi@x~MEzs7WBe^yLL=8T2{^c85S`x(v78^|wn4a=(wF=%7&gbD;+!!G zHpr5t-e~9v{Lh;yfU4pwC9VL52qesM z5}H^8 zj7}IB1i|TfS+zQ@(sFpVdeX9{a^T6yLE?F1Shd8Xc_`sU*=K6ECT%Bh(((z9}Q4e)ypU!7kXv zN-K!Rl}j)xIXh89YRiu~Fg(z9;BdU@w>L4Q#|2MI|9IEv>cCc&#?4XgGx|Pd%#p;7 zaP0uGi&cqBr-?C4yWhRHUEF-}dx~wYrd7}J1xv%93O?J1r}HSjf-$eI`1qb1Ag**p zW;?FN$xH;udv{jz3Z>oU2@oU_B;Q1_-Mqvr^guj?_em(}V|n@88FhxBSgJb0n(p_m zSL=nva>1KSe_l8q7*X}ZnBinuzC)M4U}?rVPkIq z1+l`oD4v>0`0xN_kO46%tIc>5a14V+GdnMQ?=b`s5otQvbOTG%S-fD zCw|c-O;Ha<99U;Xul)GF5phn)cLwmO+?Q$O{&nwk)`TI4K zS5?=Ec|TXg@Q6sH_c(oXQyIAOctm-GsYI&jVml*+XxU-Bwz7gaRx9Tk^%S9&Mz)G$ zog+*|;F>z}H0h78Hc$9rFlAV2K$AH{$u^M77kI%+PewL0MZI z1D(M`s`FPY1SEW)dgUl^;1Gd4?r|2HJ#Ij{;t53e*bM-i6%I80!y;Pn(~$X=Pmu6V zXpIO<*<8~@q204{Ua@d5s5meIvEEI5&cW>S`tl)H--d}xcZ}Rji9>rpTly1Zilg!s z%W47*`$kpCPx~tI=1FRS*7(Y`bru9=*Vp}!0MU@ae8_9Onn3k9s-BTwO?-MXgz#G6 z=E|YY08%PPxqBdwYB~OKg9m7-8AT{}@vdXD0XpqpKU zXLst)d#$pw+BHopltP(c}?-ji3G+_J~k zm>7LD4}Qq$7137BOjvN7XRRpdpn+d@4PcWLyu5NW5U#H4&hWrBwJ~2^?#cmInCLV9 zMsxqoDINHh=0CJ&To`8_iIS@t-nz6Rl-)CwS~n5Ye7bIwsMk%5go49fwF-+sYBYS;H03&~PKFY@S~L-6bGAmkD;Fy( zWJpr;qm`9(2p;KcYWixogILAier~@oz@|ymjBQ7)6^?>7|A{B-AL2h}tB$Mt{X^L+ z%|z|@l#)M?j&y!guzcvq>{#Y*>umhX)QxDW4<@Ph>-GEKMuiV|b3u>^1pfS0RYAT~X0gXPxs^)~lOV=_o*BZNb^cj>*2srNO z^K4!LY=Tvc25_W=SiZnvcqcHejVL~M{~1qSkxl!n{o&=S-!3GW8b0}lkWdAK5s!`E ztGkz(#I+}y;1O2Su>bn%P#_(6WFUzKk9A=M-;z}cR~qf2*sGZ7dx`>vK;hV zo&-?`PxhQHQ??E2c7bW`QK)ifXCN1C!(Q^;lO%=|b-I-z0d;xSCtPQ%IK0Cy zD>WZ_pobXpmKi5h2Q3(60N1A}9row?e-7}!`l-@#S?Kp>5Ky-u1*_&XCA-;5TD<+#w@xC!lvdCjc ztW~8LtX0_vESae|6V$c?nylk*$bX>L`-gq@tF!Qootm-?wNXl(z$`5=`XmJ&GJzKh zAky}D;&_HEP$rE`QSQe(B%8+4^joH z(=>BfucS6|xmWe+oiF2aBt^Z5$9sAS&0c>QP(^$2*<<@EH8nMjFd0skOD(D5!K}*3 zntrLg8fPkwvPi9!yZ!{-0KE-hXHuZDM_DOjkt)yYspb2J%<9*(){7)B?ev;BE$jkJ zx_C(<*SxY~^T%>~SESQuvc_Y&D1~bTZqAsoG&baC7phsIwd4Z_Eoo=%Pr_*6M}@3| z^v{?H1u=3tlVGs(&y2_H|CI0lif%$Q z@eVb_l=O8ceH@Q9@m#k-y|k-Cx$Zg5?lK`m>xJW#$;}_N$$C2Lo9$Tt?e!qf zC-ndLwiJ6fs~RHr5|_kA0VDHkNd<7LybB7EuUI_X++0eG?1;i_p&$1n< zsy&nFT9|)OOh3|da?Hs)$tzjSnoY1X-k02Az+J1Yma>qeZ?$ zBNf+UXsJV?L5nKDehmOpZF4XZIs|_vd(!+cn`siX=0@y{xSuh4-izc~w zIcY8^oh`B0Sl%{Sl{_H6y+gmMM*PN5yrs%G7{*j3wp0U94g4F%cPa)!^wNA@0q_*! zJ6PIGhD?m#cdqir{+kPe+Ml&lwH``da<6LGKzgxpBj5aR;S^R3C`^C()IL67sp-+?(GXfXKsn1_pQ7*aA!GN@tvhH{CWWiuwF}cyB_?^Z(iOS*|L)iuB38{&8 z7tPsz7vCt2gIJ}#*=x2zNQ^u!6TOhFjbVr^=$ zm$zZJ3k|FZxKVl1t=E3}8S6baA0k!;(;aq1x0~yBogH9%5tT2owT}#cB#o^}t}HpL zM$ff78~pGhDqooOh$~|^8B9mIFLX78vm*6qgFVDy?zZ&E~Xc4fit zZM5^}=WF+RN3+EQ;3GCsrEQ{4JGEoGLFl{_CA(=$$8xaGShgoB7iGPtFKi@zK=tRc zZ}v))IYkx>a}iTt_`Df+NaA{*DaB<=>j`292|^#Mxam{r51l?+fRL(*w+GW@ z`m071w+n021xSFLvEE6Im(Ntdvo|j$lrC_)u6~j6W-@M>4Z`0Kqg4m(DRP$IY+11rc+x_=bUN~mP z6t@7PMKWHw!K-L#F1Rq5wVdcBDVWY$I@yV^-fs1e&XqrLEL3OPAy3_8_T9Q&%KUB@ zMt;6bZ!q0-!7fypq~DV!u+ZY9>X}j7TT|h;9r^BT?a?B))T7+2{2StdlPNluq!lYF z-@@w96U~iJ71DH68$TF?9N(C#AJ7gF=&GO&8B|yp%q`vP7GfDdZX0ZVsjhgf$v4;+ zSxRtBM%HQ`To|$;_n2%OZWc*NIj$P=bsLK97UkqN>|WiT6|h0>+AXN)-oh^T!}i8L z39}!>)@~l19+jSH8Kwtn5$2!^m_^@_HW-G=d-3M*0@`W_C7_-8-BqQl+7`uKjZ|Mk)Lm`}UX2*G-W zP2~oCy&KSvFI)SN^~Ayzq_2ai9@wA7ub*ymqYWJct{mP;N^KrHdvCYsyZ@U|PsW{> z*g}`P*Nqn5X!~1@1g9@8bhTx1dnpq8O?c|TP4BXp`4y~-* zYrItHOsK-GzdOuk5MD5tm@LAmNn{kX_NHnV2#CM0uy*MPT#ClW27KtjfIIMa&nv-nLb+I}9O74zt;t_DQ~n z$*HmPwMHA%##ZxAAZ)IVR_NV9es%zp^3dxClIodup{*&iXSI8y)Xc)Hbh?8Bpzzcy9rKfpBehKodJ9iWZ9~OtQ~c({Q&`?9 zJCYIS+=&+L#01Bf zlgWliGx=G<*g5)$*^a(Q-$tYDA_4EAj6TmSeu_A_TH2}as@!iytMzzpzt>%T-LiFE z9-iy{t$A+OB;9ZB=c7md^ZL09_D0@@4WJN zTr!tN(SFuRnG75KaInW}sZLBAv{klZ+CJ}W7MtIWjP2WuJGJ8U9upaAij9Ad{jl4( zb!@IZyV7khdOLR*`(sySH$pi1NUQ*V>qOq_C4X7WBW59y--o;oJQ5dT92x`C3QYnFPN( z_4JrkLxFXq+2j}aK`XnyI8yVaUNmJ;`~4v3nKhNK4R%!cnYC41Ypq2q&s>;?+R*i3wG+M8 z(DZpX!~a;Djr{D{H6_=t(oQ=cH_eUxo^DB=Gxo{r49WIvD!cpohQMIwd%GU>ib#z0 zSenjkeEtHu6d4ySl6%)(aOsSy_vX2umFk9QT(67a*rAl)N<5Wg^+n7Z=aJ` zyY(n?es0VHOZn`{D`uarhlKh)$TQmD>zLggie&AsQi;4zslII;U^ zqBR5`>unV`foJ{D@)c94`F2Zfd);_R)+}>+S5K_c?fL?;w0zef*U!CAW{rb#w3Z+}g~?9KL>v=2`bv^_{+n#wZ&ULveR+h5 zZ?=1eo`%PI8F}0qLjVpssm^#-9IPA;JK-~+iyPG&DV-V&1lB? z+w1WaT|{VHO^9hSoc1?Jzq`nwIdKEjbGS(mZ>o`IopH*t|B}?n$w#?_)2J=1ForCXX zp*>dnDex1BWK(^W##nYIa=|WQBxq_^WCPinV2r)J)1(;iVYh83^v=6sY-0bm)Z#?) zL?ZUav~KC%SPy#k$Y~5;pHCk;H7?7Kgut$4J*v3Q0N+G|m2(heF)z}qFb_HK#_Uq% z`dB9#MfT3u{!AJa3qBitGi&>iz}mOB?6W=RR7FS6uNN6_Bq_Vg^D)2?sE0B{zWrZejNv`Q@?PDZhs@^awG};|y%eP5@K$Ik7!TH3p26=K)3c|) z;3IIQel2}RGep^4ZP0D8C|kF=H}jFq)(p3<4{25=IDNf+_vzK`$+0eWYcJ8cSVL@) zo`AL2clbu-NK)5bOkRrQY)sbrf%TXKCde*BB(gqr0KWa-Nim|uNqfEqcJ+H=TPd@eQq%Q#`ZcL z!ttbY2OPg0igv%UO-RkLuUt=YO8T(g<79qhpuw|9@73 zkqF`|5G05s0fG=BgknMf2?-&S%9(AgQDAxphf-2&-bOXJ;Ht zU2ZKmY^QXus>AhH9Z){`FMk|#WD#7Gos9ox#RV%TPH>Ao^#g0y7*jGvMOhK9`j$e> zijU(Z-a~x7tz%Gy>Ru3Q-nBt5JsW zjVQ76kr^v@#CTcffMkZlu&1@48Vag!lyt16a75=P5QXA94ls~$n9$|RR&8}MI+4#l zCQ^YqZX_;89$wz4Bs9;rs^;Xm8S?oi6Z>f!?Xx7zaTeJAI1v5&ed*~9F@(U6Za9*o z%|n|Hk~IVe%hl;9u?NRrjtim0?WHL_K8U+cKBeahB73?w&UEV-t50^C;jyAczC!Kk{AOAkkXlMGv;;)&MQEK z&l;hz+_#7Pdl1;*+d~k0SfL846_)w|eks)yD|4I&bP_}1uFx6F8BB!n!fk}?Yr2;< zz40oKJw8Dx!k`ykCrxziPe`b|DBC4r@hzRLzeS<9vdD?|Xz#g&0cJsXRaV9p?AJF< zl(ih5DgC7w7-zVd#C^lQ^k*ULGQT`K@l&jvQ$|X(@j8Q_Hd68IQch9vE=`ila;A zwHI#aXXq^9j76#fUxDhr4rDNgfr$lx$_e4O-filiw0d)r=bt83wY_rW*O|QfQ_4Y- zu0BO8=kiXSo~!v@@|ABpt#;(nZb9m!<;%f6k1X{xq`mn%z$dlR64A%dQvqa*xaQT? z8n=I33SYGrM=sdXvD?xAoA?!4{|%oihhBLD(f(%k&Bg$>TW|h4GIX6}^hz!MH6WAy zFY(7iaq~(S)Pd5MZb=-7tZyH)@iDNN3(Lcq6>ML&(;_Z!Oo}yV@n6x#%o}d~jj<+ij!3IcfHz z2Y)d|GL5BN=R5B5Ax7bH5H{n{LI|b!i02SdP2s`wPl)t4mhQBE5)j3MP~F=5=S^1v zW`PKI?U0O6?yqH&Y_tod`@FpvXyvNU$KX5h$L}`1)8&f=F#;6Fe{Ptd(UdUgr#V=o z?b21zR64vq%cVx@Zqxj*f6WbT5Mi}6^Omkdrsj>KY9%hS(vwk6GJch0w(u#+HI*Q! zMuU5(!{3_J&v6$o-=Qg~zzAU3HJW!+e`X*+@12KR*sX28k3RTI?u6@f!;qLt3Uj`e zW|RW*?t) z+g2#8=Kn>&2ijF^s2-gy;*)3mED*9lPXl%PjR}kGmJn9FNGfQNoAJ)=MU(if*gI3r5PkS`zE;N zCwyuZGm%tRyFB{Enu)>pZ{AvamjW*W)wkBMB~~|d8L$&pG>kbv$+>~l0{lx9FR(H+ z-PU6qNK@Z($(%Wd>-wLc{s|SpC*JRHk=~TD4+BZIR8R4--?c(3egF8h z_aU^5_(#cv+M0K)KNkJIWj)SvvJ6`uqc0LeHE84Slim!6;H3uDUtC{BM^c+IoN1J| zS)1-11*LwSUT!E#Pu$3{R`zoomX&p%drYSZ&(8tgKrOhrdiR2yw6Cvz`!4A2jo5!$ z2O}kW9n|h9_MJD8EJAyxtR{N1Mnf3QT5#p2WDnkVBf@>;qsa{B_n?U{DHsNZ)jz>~ zHQ3C-YLX9+ilJ}|3c%fKjNpAyvfy}5W=D8DIJb=$zqL8qqZeA#UwB!P`XrB2GTqOE zN~VY55A3`DgIxVB2a&5D%B0HmBO$b%M-kB#I)H~TZ=y|L_T0qBRBVb0!(#!vJM2Wf z6kmzahP4|A<=Da=%qScROjtq}$iI;6&7yOaWP`QK7^q`H)-h|a&T=g$Kl%1ji&P~g z(!k=)+)RisO#^#xz2L6Hi{v=0)^pbEiK^qspg-X$wrn-i)ZjjZ*FPmxeQ!hFAD*a2 zxBfOkL0SNu24ZL;rYRNfdk|?p&2?;qADo*OXK6qaytWYNbzOUFCuSLP?fWKj4{vwE G<^KZND)55< literal 0 HcmV?d00001 diff --git a/docs_src/source/tutorials/arbitrary_dipole/SNAIL_example.ipynb b/docs_src/source/tutorials/arbitrary_dipole/SNAIL_example.ipynb new file mode 100644 index 00000000..6ae5d600 --- /dev/null +++ b/docs_src/source/tutorials/arbitrary_dipole/SNAIL_example.ipynb @@ -0,0 +1,479 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simulate an arbitrary indictive dipole using qucat\n", + "\n", + "## 1 Generating the circuit\n", + "\n", + "This new features of qucat allows to insert an arbitrary purely inductive dipole, simplified at an arbitrary order. Only the labels must be provided.\n", + "\n", + "Here's what it looks like when constructing a circuit with the GUI :\n", + "\n", + "![circuit](Circuit_from_the_GUI.png)\n", + "\n", + "Using the general feature \"Dipole\" is only possible without specifying any energy : Only labels must be provided, so the values must be given when performing a specific calculation.\n", + "\n", + "![Help_GUI](Editor_help.png)\n", + "\n", + "Once printed, it will look like this :\n", + "\n", + "![printed_circuit](printed_circuit.png)\n", + "\n", + "\n", + "The diode-like form shows the orientation of the dipole.\n", + "\n", + "\n", + "The number of labels the dipole has corresponds to the order at which it is simulated : Here there are 3 labels, so it will take into account the fourth first orders, as qucat usually does : \n", + "\n", + "$$U_{dipole}(\\phi) = h(\\frac{E2}{2!}\\phi^2 + \\frac{E3}{3!}\\phi^3 + \\frac{E4}{4!}\\phi^4)$$\n", + "\n", + "In this expression, the $Ei$ are provided in Hertz.\n", + "\n", + "If this dipole is a Josephson element, we have, forgetting the constant term and expanding at order fourth :\n", + "\n", + "$$U_{J}(\\phi) = E_J(1 - \\cos\\phi) = \\frac{E_J}{2}\\phi^2 - \\frac{E_J}{4!}\\phi^4$$\n", + "\n", + "So in this case : $E2 = \\frac{E_J}{h}, E3 = 0, E4 = -\\frac{E_J}{h}$.\n", + "\n", + "Notes : \n", + "- The dipoles are polarized, since odd orders are non zero in general. The orientation matters.\n", + "- One cannot set an element to strictly zero to prevent qucat errors. Provide very negligible values.\n", + "\n", + "\n", + "\n", + "## 2 Hamiltonian\n", + "\n", + "Once the hamiltonian decomposed into eigenmodes, the hamiltonian of the circuit writes :\n", + "\n", + "$$ H = \\sum_m{\\hbar \\omega_m \\hat{a}^\\dagger_m \\hat{a}_m} + \\sum_j \\sum_{n\\geq 3}\\frac{\\partial^{n} U_j}{\\partial \\phi^{n}}|_0\\hat{\\phi}_j^n$$\n", + "\n", + "with :\n", + "- $\\hat{\\phi}_j$ being the phase across the j-th non linear element\n", + "- $m$ the modes of the circuit\n", + "- $\\omega_m/2\\pi$ the frequency of the $m$-th mode\n", + "- $\\hat{a}_m$ the annihilator of the $m$-th mode\n", + "- $U_j(\\phi)$ the inductive energy of the j-th non linear dipole, assuming its minimum is for $\\phi = 0$\n", + "\n", + "\n", + "Using $\\hat{\\phi}_j = \\sum_m \\phi_{zpf, m, j}\\hat{\\phi}_m = \\sum_m \\phi_{zpf, m, j}(\\hat{a}^\\dagger_m + \\hat{a}_m)$ :\n", + "\n", + "$$ H = \\sum_m{\\hbar \\omega_m \\hat{a}^\\dagger_m \\hat{a}_m} + \\sum_j \\sum_{n\\geq 3}\\frac{\\partial^{n} U_j}{\\partial \\phi^{n}}[\\sum_m \\phi_{zpf, m, j}(\\hat{a}^\\dagger_m + \\hat{a}_m)]^n$$\n", + "\n", + "\n", + "At fourth order, following qucat formalism (applying rotating wave approximation) and adding the third order term:\n", + "\n", + "$$ H = \\hbar\\sum_m \\big[( \\omega_m - \\sum_{n}\\frac{\\chi_{mn}}{2})\\hat{a}_m^\\dagger\\hat{a}_m\n", + "-\\frac{A_m}{2} \\hat{a}_m^\\dagger \\hat{a}_m^\\dagger \\hat{a}_m \\hat{a}_m \n", + "-\\sum_{n}\\chi_{mn}\\hat{a}_m^\\dagger \\hat{a}_m \\hat{a}_n^\\dagger \\hat{a}_n\\big] \n", + "+ \\sum_{m, n, o}(\\gamma_{mno}^* \\hat{a}_m^\\dagger \\hat{a}_n^\\dagger \\hat{a}_o + \\gamma_{mno} \\hat{a}_m \\hat{a}_n \\hat{a}_o^\\dagger)$$\n", + "\n", + "The modified version of qucat returns also the mixing terms $\\gamma_{mno}$. Note that only the terms with $m\\neq n, n\\neq o, m\\neq o$ are likely to conserve the energy.\n", + "\n", + "For further orders, I added a function returning the full hamiltonian as a sympy expression. The simplifications using the rotating wawe approximation for example can then be perfomed afterwards.\n", + "\n", + "## Example : the SNAIL\n", + "\n", + "The SNAIL is a dipole containing three little Josephson juntions on one side, and one big on the other side :\n", + "\n", + "\n", + "\n", + "*SNAIL scheme taken from N. E. Frattini, V. V. Sivak, A. Lingenfelter, S. Shankar et M. H. Devoret : Optimizing the Nonlinearity and Dissipation of a SNAIL Parametric Amplifier for Dynamic Range. Physical Review Applied, 10(5):1–17, 2018.*\n", + "\n", + "Its inductive energy writes :\n", + "\n", + "$$U_{SNAIL}(\\phi) = -E_J(\\alpha \\cos\\phi + 3 \\cos \\frac{\\phi_0-\\phi}{3})$$\n", + "\n", + "It depends on :\n", + "- the flux bias in its loop\n", + "- a characteristic Josphson energy E_J\n", + "- a characteristic coeeficient $\\alpha$\n", + "\n", + "Having $\\phi_0$, $E_J$ and $\\alpha$, one can find the minimum of this inductive energy and develop it around it : The developpement will give the coeficient to feed qucat with :\n", + "\n", + "$$U_{SNAIL}|_{\\alpha, E, phi_{ext}}(\\phi) = \\frac{E2}{2}(\\phi-\\phi_{min})^2 + \\frac{E3}{6}(\\phi-\\phi_{min})^3 + \\frac{E4}{24}(\\phi-\\phi_{min})^4$$" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.constants import *\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import *\n", + "import numpy as np\n", + "import sympy as sp\n", + "import qucat as qc\n", + "\n", + "\n", + "## Parameters for the circuit\n", + "order = 4 #order at which the SNAIL will be expanded\n", + "alpha = 0.12\n", + "phi_0 = h/(2*e) #the flux quantum\n", + "L = 1e-8 #the Jospehson inductance of the small junctions\n", + "E_J = 1/h*phi_0**2/(4*pi)**2/L #the Josephson energy of the small junctions, in Hz\n", + "C1 = 10e-14 #capacities of the circuit\n", + "C2 = 15e-14\n", + "C3 = 20e-14\n", + "\n", + "\n", + "\n", + "#We use sympy to create the derivatives of the energy \n", + "phi = sp.Symbol(\"phi\")\n", + "a = sp.Symbol(\"a\")\n", + "E = sp.Symbol(\"E\")\n", + "phi_ext = sp.Symbol(\"phi_ext\")\n", + "\n", + "U_sym = -E*(a*sp.cos(phi) + 3*sp.cos((phi_ext-phi)/3))\n", + "dnU_sym =[sp.diff(U_sym, phi, i) for i in range(order+1)]#Symbolic expression for the derivatives\n", + "dnU = [sp.lambdify([phi, E, a, phi_ext], c) for c in dnU_sym] #creates the python functions for the derivatives:\n", + "#dnU[i](E, a, phi_ext, phi)\n", + "\n", + "\n", + "def make_dict(E, a, phi_ext): #constructs the dictionnary to give as keyword arguments\n", + " labels = {\"C1\":C1, \"C2\":C2, \"C3\":C3, \"L\":L}\n", + " phi_min = (minimize(dnU[0], 11, method = 'L-BFGS-B' , bounds = [(-1, 7*np.pi)],args = (1, alpha, phi_ext)).x)[0]%(6*np.pi) #The point from which the potential will be expanded\n", + " for i,c in enumerate(dnU[2::]):\n", + " labels[\"E\"+str(i+2)] = E*c(1, a, phi_ext, phi_min)\n", + " return labels\n", + "\n", + "def make_dict_vect(E, a, phi_ext): #same function but vectorized, to sweep phi_ext\n", + " labels = {\"C1\":[C1 for c in phi_ext], \n", + " \"C2\":[C2 for c in phi_ext], \n", + " \"C3\":[C3 for c in phi_ext], \n", + " \"L\":[L for c in phi_ext]}\n", + " for i, c in enumerate(dnU[2::]): #initialisation of the lists\n", + " labels[\"E\"+str(i+2)] = []\n", + "\n", + " phi_min = [0]\n", + "\n", + " for c in phi_ext:\n", + " phi_min.append((minimize(dnU[0], 11, method = 'L-BFGS-B' , bounds = [(-1, 7*np.pi)],args = (1, alpha, c)).x)[0]%(6*np.pi))\n", + " phi_min.pop(0) #I struggled with the optimization, these parameters work for this example.\n", + " \n", + " for i,c in enumerate(phi_min):\n", + " for j, d in enumerate(dnU[2::]):\n", + " labels[\"E\"+str(j+2)] = labels[\"E\"+str(j+2)]+[d(c, E, a, phi_ext[i])]\n", + " return labels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At this point, one can simply need to construct the circuit (the one given in 'Generating the circuit\", with every element being given a label, not a value :" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "circuit = qc.GUI(\"Circuit_example.txt\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check the evolution of the derivatives at the minimum as a function of $\\phi_{ext}$ :" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "phi_exts = np.linspace(0,6*np.pi, 1000)\n", + "\n", + "labels = make_dict_vect(E_J, alpha, phi_exts) #labels is a dictionnary where each key corresponds to a list of values\n", + "\n", + "plt.plot(phi_exts, np.array(labels[\"E2\"])/1e9, label = \"E2\")\n", + "plt.plot(phi_exts, np.array(labels[\"E3\"])/1e9, label = \"E3\")\n", + "plt.plot(phi_exts, np.array(labels[\"E4\"])/1e9, label = \"E4\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The unbiased SNAIL has no third order term since it's has a parity in the flux.\n", + "Let's look at the frequencies, given by E2 :" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " return array(a, dtype, copy=False, order=order)\n", + "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " return array(a, dtype, copy=False, order=order)\n", + "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " return array(a, dtype, copy=False, order=order)\n" + ] + }, + { + "data": { + "text/plain": [ + "[[],\n", + " [],\n", + " []]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "freqs = circuit.eigenfrequencies(**labels)/1e9\n", + "\n", + "plt.xlabel(r\"$\\phi/_{ext}\\pi}$\")\n", + "plt.ylabel(\"Eigenfrequencies (GHz)\")\n", + "plt.title(\"Eigenfrequencies as a function of $\\phi_{ext}$\")\n", + "[plt.plot(phi_exts/np.pi, c) for c in freqs]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "They follow the evolution of E2, which is expected.\n", + "\n", + "Let's look at the three waves mixing term :" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " return array(a, dtype, copy=False, order=order)\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "three_waves = circuit.three_waves(0, 1, 2, **labels)/1e6 #In MHz\n", + "\n", + "plt.xlabel(r\"$\\phi/\\pi}$\")\n", + "plt.ylabel(\"Three waves mixing term (MHz)\")\n", + "plt.title(\"Three waves mixing term (MHz) as a function of the imposed phase\")\n", + "plt.plot(phi_exts/np.pi, three_waves)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It has the same shape as the E3 term.\n", + "\n", + "And now, the self-Kerr terms : " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No handles with labels found to put in legend.\n", + "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " return array(a, dtype, copy=False, order=order)\n", + "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " return array(a, dtype, copy=False, order=order)\n", + "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " return array(a, dtype, copy=False, order=order)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "kerr_coeffs = circuit.kerr(**labels)/1e6 # in MHz\n", + "\n", + "\n", + "plt.xlabel(r\"$\\phi/\\pi}$\")\n", + "plt.ylabel(\"Self Kerr coefficient (MHz)\")\n", + "plt.title(\"Self Kerr coefficients as a function of the exterior phase\")\n", + "plt.legend()\n", + "[plt.plot(phi_exts/np.pi, kerr_coeffs[i, i], label = \"Mode \"+ str(i)) for i in range(len(kerr_coeffs))]\n", + "plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can clearly see the existence of the sweet spot, point where all the Kerr terms vanish, but the three waves mixing term still exists, allowing to make a parametric amplifier without beeing limited by the Kerr terms, cf *SNAIL scheme taken from N. E. Frattini, V. V. Sivak, A. Lingenfelter, S. Shankar et M. H. Devoret : Optimizing the Nonlinearity and Dissipation of a SNAIL Parametric Amplifier for Dynamic Range. Physical Review Applied, 10(5):1–17, 2018.*\n", + "\n", + "The other features of qucat apply otherwise : the f_k_A_chi function, getting the full hamiltonian with qutip. It is now possible to get the hamiltonian with sympy :" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle - 2268433.92223772 \\left(- 0.723217903073783 \\left(b_{m0} + b^\\dagger_{m0}\\right) - 0.854359675735641 \\left(b_{m1} + b^\\dagger_{m1}\\right) + b_{m2} + b^\\dagger_{m2}\\right)^{3} - 161131.306189082 \\left(- 0.723217903073783 \\left(b_{m0} + b^\\dagger_{m0}\\right) - 0.854359675735641 \\left(b_{m1} + b^\\dagger_{m1}\\right) + b_{m2} + b^\\dagger_{m2}\\right)^{4} + 3586103050.56997 b^\\dagger_{m0} b_{m0} + 4144027457.67397 b^\\dagger_{m1} b_{m1} + 5077766571.52978 b^\\dagger_{m2} b_{m2}$" + ], + "text/plain": [ + "-2268433.92223772*(-0.723217903073783*(AnnihilateBoson(m0) + CreateBoson(m0)) - 0.854359675735641*(AnnihilateBoson(m1) + CreateBoson(m1)) + AnnihilateBoson(m2) + CreateBoson(m2))**3 - 161131.306189082*(-0.723217903073783*(AnnihilateBoson(m0) + CreateBoson(m0)) - 0.854359675735641*(AnnihilateBoson(m1) + CreateBoson(m1)) + AnnihilateBoson(m2) + CreateBoson(m2))**4 + 3586103050.56997*CreateBoson(m0)*AnnihilateBoson(m0) + 4144027457.67397*CreateBoson(m1)*AnnihilateBoson(m1) + 5077766571.52978*CreateBoson(m2)*AnnihilateBoson(m2)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circuit.hamiltonian_sym(**make_dict(E_J, alpha, np.pi/7), modes = 'all') " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the expression isn't simplified, and uses the bosonic operators from the sympy.physics.secondquant library. To simplify it (normal ordering for example), one needs to further analyse it by themselves, I didn't found any built-in function to do this with bosonic operators (it exists for fermionic operators though).\n", + "\n", + "The Keywords arguments are the same as for the hamiltonian function that works with qutip. However, to further Taylor expand the hamiltonian, one should have specified the corresponding number of labels for each arbitray dipole in the circuit. In our example, we cannot go further than the fourth order, unless we decide to provide more labels.\n", + "\n", + "One can also, for example, select the modes to be taken into account." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs_src/source/tutorials/arbitrary_dipole/SNAIL_scheme.png b/docs_src/source/tutorials/arbitrary_dipole/SNAIL_scheme.png new file mode 100644 index 0000000000000000000000000000000000000000..54f1175250ffc3b84a1082c6ffdc8af92c229770 GIT binary patch literal 268299 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 z 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

KyKfIrOn0*<3YZB5t}BQ(2fCF& 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 literal 0 HcmV?d00001 diff --git a/docs_src/source/tutorials/arbitrary_dipole/printed_circuit.png b/docs_src/source/tutorials/arbitrary_dipole/printed_circuit.png new file mode 100644 index 0000000000000000000000000000000000000000..9258e897c5648a9f26e79c55dce4c42ff6944151 GIT binary patch literal 3596 zcmdT{d0dj&8phkCl}oo}nroJp;Z`n_mdm(JrK8|NVP@i%sbQc(XfB~*WtdZDePHB< z(}HG+nu=*IRFsB_=7t-}pr}oX3yLO&T&lUhxqsik?tH)Vo$q|h`<(Ng=Q;2Dp7i6M zF6x_hZUTWo>JV2aI0*C)D@D6~G_^3^6CM+T z{mIPiulJ@H9MUWWbkIpL02IXO$jSIT(Qs0U-gtn@+-yY&K(BXGZMjNwy}{U{`=C=7 z{^;l4N2l}-Z`oTVx`9=v{yTSJ}` zyN0M-Nwu+vMiP+iaT9HA1JzYk+d(OTyQ(`? zL7?)SR4veN2VSd#-hVGp27UMyyABlNT%!bfq00k-0=7hfQc5>ifqwS+KmBZ1W2frN zK_l9(0%0n6xeviS-22>w4T0Qp75_}Xc>W0i4^Z?HD!9_Du)-v#DMAfbnh_?=bQ2Fl zv`ZKcb?$N_kzgN#JE<`~8xmQpGjTt;-}M$R<}q2^0&nqvXuFAZAlfFh`iJC-hZ1I~ zIswd$i_v%z4Rh9J*|xBLLu^{m++ht{4AIHjiIB>Qo*gr(cBAf`(Gtp5L)k=TG6<~T+n6Uc>55dA^btrn>WS~-;^VgmqV1OCqYb zQo%?r0_K6c1azG1zn*BUKzRshEaFO&Aj$h#fju-xDW^PmAV2sa?kvDZEsS_W6J$F} zc4*v|25Wyza~^%?;Q}@4I~QM>tj}Ig;zv{9?JzNWX|V}073NhYYXvihsDXiK*-IyW zu;x3xyus*XdqKZYxU}%_qEM{AX>SNR4r$^IolO zt7QOhU}6>Bx>(uNvw7jTqw!8bp$_woz$5t>U835$$P62ue@i3(kO_ktnL%;mPI7M% zirAT{XOld-g7NfNZ7H7YPKztciBE(WjSJcBh^Yn0T9v&lzc``N;Tz=kFOcsCmp$Xi z@LL|ZU_kC6E><)6T{im0u#8=9wOFf$cSY*igglT_{P1pQ!g z{dlw^vrWvuEvTEPz&N>*`(Ja`(V79YY84PfQifL*FN{vrAtDnF~gMnP(@?d;fdicF#`yviPYJAjHO-vYkG?d9 z!vHFzyc1BHd-(0sZRL#-{!1quRXk;%2_Gk478k4s^NdUV%%`_Zx6K7C9ggN5iLO_R zPPB034$hlCAhD?7qC2AFQwP0dnXr1x*2PRpgm&Lxh|j&{c;x#Zs_?5*i%9q;MVN!t|r(auW->A>7o4Ci_LQi_Z;75pVRA6SO{}5hl)ootO zkIZBD-4w-nFvjNQl~0dNHAYGyYe-bKMlY(gK>I(0SV}5?Pt9HLjZTWzttSIWpaPE@IGQ{Ok_J#hmc>3%mc4H=O#O_ z_VOwfQgL78AMOo24IQ{6{JiwJ{f{*@14He6p#U7@dyRSH&-M2e&BbqZ0^C>KtdsLW z?uwR!S7*ct$ABILlPZ9wu*`W!76CQpd)pDtLbY1j-41tLG%=&Ofx*4d@!={x$qQia zrWA2MPJXabLZ zjl*h&CW9fRPZ`Oz9;*Xj00;3{jjtXk;yb~)sTw;r zKeYeG3q^FC>py``GG_%3O<8udG4*sf&hwOuLe_wh<9vOKX5@kceV?-FB6Oa;oPD7V*@ze?3Qt);M4 z-lDMenn;v|zN>8{i)ByC-9c@8cx|uZ9{Ih_dU`0IMXKM+PNI>Q>0O5|-&(n86Z4vL zWj`&#j5dwRjLU*oW9D>C$R3T!rG_+r#$Ahk;S`dS1&<}eqarggCba4P-<=VL3JHt^ z-GJ5j`eWR17x9S~0Y~1;Fkh$KB$@xSrf&Z96p}uiC%m%s=?Yk0bGfzRdP%`RJ#z=| zi=G-ZdU4Fn6k4Oo-O+U$}^ z>A)jN<$>sWre(C@ka246TS+_E4Ppw#xdCyJ)1$_D5`<$WUA(C6Dn5YLjMyo$7<#MO zh_W$Y2l&cBbpyVRl?enB>mWCJ1t&iI0KE+nWx*NxN;ObHxR_x)2a06nJfPWe9`(o literal 0 HcmV?d00001 diff --git a/src/core.py b/src/core.py index 4c9f7c3f..41d877ba 100644 --- a/src/core.py +++ b/src/core.py @@ -24,14 +24,6 @@ from sympy.physics.secondquant import Dagger, B, Bd -a = B('a') -b = B('b') -p = B('p') - -ad = Dagger(a) -bd = Dagger(b) -pd = Dagger(p) - PROFILING = False def timeit(method): @@ -846,7 +838,7 @@ def hamiltonian(self, modes='all', taylor=4, excitations=6, return_ops = False, return H @refuse_vectorize_kwargs(exclude = ['modes','taylor','excitations','return_ops']) - def hamiltonian_sym(self, modes=[-3, -2, -1], ops = [a, b, p], taylor=4, **kwargs): + def hamiltonian_sym(self, modes='all', taylor=4, **kwargs): self.hamiltonian_modes = modes self.hamiltonian_taylor = taylor @@ -855,6 +847,8 @@ def hamiltonian_sym(self, modes=[-3, -2, -1], ops = [a, b, p], taylor=4, **kwarg if modes == 'all': modes = range(len(fs)) + modes = [c%len(fs) for c in modes] + ops = [B("m" + str(c)) for c in modes] for m in modes: try: fs[m] From 66935f246ef5fc79550fd247d8fbc4868e89da9a Mon Sep 17 00:00:00 2001 From: Hector Date: Fri, 21 May 2021 11:21:37 +0200 Subject: [PATCH 14/17] Clean an obsolete information given by the editor --- src/_gui.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/_gui.py b/src/_gui.py index 7bbed6e0..2faddbe5 100644 --- a/src/_gui.py +++ b/src/_gui.py @@ -3529,13 +3529,11 @@ def __init__(self, master, component): if isinstance(self.component,C): info_text = 'Specify label and/or capacitance (in units of Farad)' self.value_string = 'Capacitance' - info_text += '\nPut the label between []: [label]' elif isinstance(self.component,J): self.value_string = 'Inductance' info_text = 'Specify label and/or Josephson inductance (in units of Henry)' info_text += '\nNote that L = (hbar/2/e)**2/[Josephson Energy in Joules]' - info_text += '\nPut the label between []: [label]' elif isinstance(self.component,D): self.value_string = 'Energy' @@ -3544,11 +3542,9 @@ def __init__(self, master, component): elif isinstance(self.component,L): self.value_string = 'Inductance' info_text = 'Specify label and/or inductance (in units of Henry)' - info_text += '\nPut the label between []: [label]' elif isinstance(self.component,R): self.value_string = 'Resistance' info_text = 'Specify label and/or resistance (in units of Ohm)' - info_text += '\nPut the label between []: [label]' # Entry field strings From 3a1f3359d6e735c84b1222fab4071143c472fe90 Mon Sep 17 00:00:00 2001 From: Hector Date: Tue, 25 May 2021 22:30:24 +0200 Subject: [PATCH 15/17] Cleaning --- core.py | 2866 ------------------------------------------------------- 1 file changed, 2866 deletions(-) delete mode 100644 core.py diff --git a/core.py b/core.py deleted file mode 100644 index 2c4dd7eb..00000000 --- a/core.py +++ /dev/null @@ -1,2866 +0,0 @@ -import sympy as sp -import scipy -J(from sympy import Function -import numpy as np -from numpy.polynomial.polynomial import Polynomial as npPoly -from sympy.core.mul import Mul, Pow, Add -from copy import deepcopy -from numbers import Number -from math import floor, factorial -import os -from subprocess import run -import inspect -import matplotlib.pyplot as plt -import time -from warnings import warn -try: - from ._constants import * - from ._utility import * - from .plotting_settings import plotting_parameters_show,plotting_parameters_normal_modes -except ImportError: - # When running from source without pip installation - from _constants import * - from _utility import * - from plotting_settings import plotting_parameters_show,plotting_parameters_normal_modes - -from scipy.optimize import minimize as mini -from numpy import cos, sin - -PROFILING = False - -def timeit(method): - ''' - Decorator which prints the time - a function took to execute. - Only works the global variable PROFILING is set to True. - ''' - def timed(*args, **kw): - ts = time.time() - result = method(*args, **kw) - te = time.time() - if PROFILING: - print('calling %r took %2.2f ms' % \ - (method.__name__, (te - ts) * 1000)) - return result - return timed - -def string_to_component(s, *arg, **kwarg): - ''' - Allows the creation of a Component object using a string. - - Parameters - ---------- - s : string - One of 'W', 'R', 'L', 'J', 'C', 'G', dicatates the type - of component to create - args, kwargs : - Arguments needed for the component creation - - Returns - ------- - A component of type ``s`` - ''' - if s == 'W': - return W(*arg, **kwarg) - elif s == 'R': - return R(*arg, **kwarg) - elif s == 'L': - return L(*arg, **kwarg) - elif s == 'J': - return J(*arg, **kwarg) - elif s == 'D': - return D(*arg, **kwarg) - elif s == 'C': - return C(*arg, **kwarg) - elif s == 'G': - return G(*arg, **kwarg) - - - -class Qcircuit(object): - """A class representing a quantum circuit. - - Attributes: - components (dict): Dictionary of components having a label, such that a component - with label 'L_1' can be obtained by ``Qcircuit.components['L_1']`` - Q_min (float): Modes with have a quality factor below Q_min will not ignored - inductors (list): List of inductor objects present in the circuit - resistors (list): List of inductor objects present in the circuit - junctions (list): List of junction objects present in the circuit - capacitors (list): List of capacitor objects present in the circuit - netlist (list): List of all components present in the circuit - ref_elt (J or L): list of junction or inductor component used as a reference for the calculation - of zero-point fluctations, each index of the list corresponds to a different mode - """ - - def __init__(self, netlist): - self.Q_min = 1 # Modes with have a quality factor below Q_min will not ignored - - self.warn_discarded_mode = True # If this is set to True, the user will be notified when a mode is discarded. - - # After an initial estimation of the complex eigenfrequenceis using a diaglinalization - # of the companion matrix, the frequencies are polishd to a tolerence - # self.root_relative_tolerance using a gradient based root finder, with a maximum number of iterations self.root_max_iterations - self.root_max_iterations = 1e4 - self.root_relative_tolerance = 1e-12 - - self._plotting_normal_mode = False # Used to keep track of which imported plotting_settings to use - # only set to true when show_normal_mode is called - self.plotting_parameters_normal_modes = plotting_parameters_normal_modes - self.plotting_parameters_show = plotting_parameters_show - - self.netlist = netlist # List of all components present in the circuit - - self._network = _Network(netlist) # Converts the list of components into a network object - # The Network object has methods to compute of the admittance between two nodes - # or the tranfer function between two nodes and two others - - # We construct (enpty) lists of all the different type of - # components that could be present in the circuit - self.inductors = [] - self.capacitors = [] - self.junctions = [] - self.resistors = [] - self._wire = [] - self._grounds = [] - - # Initialize a dictionary of components having a label, such that a component - # with label 'L_1' can be obtained by ``Qcircuit.components['L_1']`` - self.components = {} - - # Initialize a list which will contain the labels of the componentns which have - # no value (these will have to be specified in most methods as a kwarg) - self._no_value_components = [] - - # For each component of the circuit.... - for elt in netlist: - # ...tell the component what circuit it belongs to - elt._circuit = self - # ...and populate the empty lists/dictionaries initialized above with the element if appropriate - elt._set_component_lists() - - - # Check that there is at least one inductive element in the circuit - if len(self.junctions) == 0 and len(self.inductors) == 0: - raise ValueError( - "There should be at least one junction or inductor in the circuit") - - # Check that there is at least one capacitive element in the circuit - if len(self.capacitors) == 0: - raise ValueError( - "There should be at least one capacitor in the circuit") - - - # define the function which returns the inverse of dY - # where Y is the admittance at the nodes of an inductive element - for inductive_element in self.inductors+self.junctions: - inductive_element._compute_flux_zpf_r() - - # Initialize the flux transformation dictionary, - # where _flux_transformation_dict[ref_node_minus,ref_node_plus,node_minus,node_plus] - # will be populated with a function which gives - # the voltage transfer function between the nodes surrounding - # the reference element and (node_plus,node_minus) - # this function takes as an argument an angular frequency - # and keyword arguments if component values need to be specified - self._flux_transformation_dict = {} - - # define the functions which returns the components of the characteristic polynomial - # (the roots of which are the eigen-frequencies) - self._char_poly_coeffs = [lambdify(self._no_value_components, c, ['numpy']) - for c in self._network.compute_char_poly_coeffs(is_lossy = (len(self.resistors)>0))] - -#self.no_value_components : array de tous les labels non spécifiés -#c = expression sympy - - - @property - def _pp(self): - ''' - Returns the plotting parameters used - * in the Qcircuit.show method (if self._plotting_normal_mode is False) - * in the Qcircuit.show_normal_modes() method (if self._plotting_normal_mode is True) - ''' - if self._plotting_normal_mode: - return self.plotting_parameters_normal_modes - else: - return self.plotting_parameters_show - - def _parse_kwargs(self, **kwargs): - ''' - Raises a ValueError - * if one of the kwargs is not the label of a circuit element - * if a component without a value has not had its value specified in the kwargs - - Called in all functions accepting keyword arguments (for un-specified circuit components). - - Parameters - ---------- - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - ''' - for key in kwargs: - if key in self._no_value_components: - kwargs[key] = kwargs[key] - else: - raise ValueError( - '%s is not the label of a circuit element' % key) - - for label in self._no_value_components: - try: - kwargs[label] - except Exception: - raise ValueError( - 'The value of %s should be specified with the keyword argument %s=... ' % (label, label)) - - @timeit - def _set_zeta(self, **kwargs): - ''' - Sets the Qcircuit.zeta to the circuit eigenfrequencies - (including the imaginary part due to losses). - - Parameters - ---------- - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - ''' - try: - if kwargs == self._kwargs_previous: - # Avoid doing the same thing two - # times in a row - return - except AttributeError: - pass - self._kwargs_previous = kwargs - - # Check if the kwargs provided are correct - self._parse_kwargs(**kwargs) - - if len(self.resistors) == 0: - - # Compute the coefficients of the characteristic polynomial. - # The roots of this polynomial will provide the complex eigenfrequencies - char_poly = npPoly([np.real(coeff(**kwargs)) for coeff in self._char_poly_coeffs]) - - # char_poly = remove_multiplicity(char_poly) - - # In this case, the variable of the characteristic polynomial is \omega^2 - # And we can safely take the real part of the solution as there are no - # resistors in the circuit. - w2 = np.real(char_poly.roots()) - w2 = polish_roots(char_poly,w2, self.root_max_iterations,np.sqrt(self.root_relative_tolerance)) - - # Sometimes, when the circuits has vastly different - # values for its circuit components or modes are too - # decoupled, the symbolic - # calculations can yield an incorrect char_poly - # We can easily discard some of these casese by throwing away - # negative solutions - for w2_single in w2: - if np.real(w2_single) < 0 and self.warn_discarded_mode: - error_message = "Imaginary frequency mode f = 1j %f Hz mode found (and discarded).\n"%(np.sqrt(-w2_single)/2/np.pi) - warn(error_message) - w2 = w2[np.nonzero(w2 >= 0.)] - - # Take the square root to get to the eigenfrequencies - zeta = np.sqrt(w2) - - # Sort solutions with increasing frequency - order = np.argsort(np.real(zeta)) - zeta = zeta[order] - - else: - - # Compute the coefficients of the characteristic polynomial. - # The roots of this polynomial will provide the complex eigenfrequencies - char_poly = npPoly([complex(coeff(**kwargs)) for coeff in self._char_poly_coeffs]) - # char_poly = remove_multiplicity(char_poly) - - zeta = char_poly.roots() - zeta = polish_roots(char_poly,zeta, self.root_max_iterations,self.root_relative_tolerance) - - # Sort solutions with increasing frequency - order = np.argsort(np.real(zeta)) - zeta = zeta[order] - - # Negative modes are discarded - zeta = zeta[np.nonzero(np.real(zeta) >= 0.)] - - # For each solution, its complex conjugate - # is also a solution, we want to discard the negative - # imaginary part solutions which correspond to unphysical - # negative dissipation modes - zeta = zeta[np.nonzero(np.imag(zeta) >= 0.)] - - # zero frequency modes are discarded - zeta = zeta[np.nonzero(np.logical_not(np.isclose(np.real(zeta),0*zeta, rtol = self.root_relative_tolerance)))] - - # Only consider modes with Q>self.Q_min (=1 by default) - # The reason for this measure is that - # 0-frequency solutions (with real parts close to 0) - # tend to have frequencies which oscillate between positive and - # negative values. - # The negative values are discarded which changes the number of modes - # and makes parameter sweeps difficult - for w in zeta: - if np.real(w) < self.Q_min*2*np.imag(w) and self.warn_discarded_mode: - error_message = "Discarding f = %f Hz mode "%(np.real(w/2/np.pi)) - error_message += "since it has a too low quality factor Q = %f < %f"%(np.real(w)/2/np.imag(w),self.Q_min) - warn(error_message) - zeta = zeta[np.nonzero(np.real(zeta) >= self.Q_min*2*np.imag(zeta))] - - # Choose reference elements for each mode which - # maximize the inverse of dY: we want the reference - # element to the element where zero-point fluctuations - # in flux are most localized. - inductive_elements = self.junctions+self.inductors - ref_elt = [] - zeta_copy = deepcopy(zeta) - zeta = [] - - for w in zeta_copy: - largest_dYm1 = 0 - ref_elt_index = None - for ind_index,ind in enumerate(inductive_elements): - try: - dYm1 = ind._flux_zpf_r(w,**kwargs) - except Exception: - # Computation of dYm1 failed for some reason - dYm1 = -1 - - if dYm1>largest_dYm1: - ref_elt_index = ind_index - largest_dYm1 = dYm1 - - if ref_elt_index is None and self.warn_discarded_mode: - # Sometimes, when the circuits has vastly different - # values for its circuit components or modes are too - # decoupled, the symbolic - # calculations can yield an incorrect char_poly - # We can easily discard some of these cases by throwing away - # any solutions with a complex impedance (ImY'<0) - error_message = "Discarding f = %f Hz mode.\n"%(np.real(w/2/np.pi)) - error_message += "since the calculation of zero-point-fluctuations was unsuccesful.\n" - warn(error_message) - else: - zeta.append(w) - ref_elt.append(inductive_elements[ref_elt_index]) - zeta = np.array(zeta) - - self.zeta = zeta - self.ref_elt = ref_elt - - def _anharmonicities_per_junction(self, **kwargs): - ''' - Returns the contribution of each junction to the anharmonicity of each mode. - For more details, see the documentation of J.anharmonicity. - - Anharmonicities are given in units of Hz (not angular frequency). - - Parameters - ---------- - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - - Returns - ------- - anh_per_jun: ndarray - where ``anh_per_jun[j,m]`` corresponds to the contribution of junction ``j`` - to the anharmonicity of mode ``m`` - ''' - self._set_zeta(**kwargs) - return [[j.anharmonicity(mode, **kwargs) for mode in range(len(self.zeta))] for j in self.junctions] - - @vectorize_kwargs - def eigenfrequencies(self, **kwargs): - '''Returns the normal mode frequencies of the circuit. - - Frequencies are provided in units of Hertz, - not in angular frequency. - - Parameters - ---------- - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - - Returns - ------- - numpy.array - Normal mode frequencies of the circuit, ordered from lowest - to highest frequency, given in Hertz. - - Notes - ----- - - These eigen-frequencies :math:`f_m` correspond to the real parts - of the complex frequencies which make the conductance matrix - singular, or equivalently the real parts of the poles of the impedance - calculated between the nodes of an inductor or josephson junction. - - The Hamiltonian of the circuit is - - :math:`\hat{H} = \sum_m hf_m\hat{a}_m^\dagger\hat{a}_m + \hat{U}`, - - where :math:`h` is Plancks constant, - :math:`\hat{a}_m` is the annihilation operator of the m-th - normal mode of the circuit and :math:`f_m` is the frequency of - the m-th normal mode. The frequencies :math:`f_m` would - be the resonance frequencies of the circuit if all junctions - were replaced with linear inductors. In that case the - non-linear part of the Hamiltonian :math:`\hat{U}`, - originating in the junction non-linearity, would be 0. - - For more information on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf. - ''' - self._set_zeta(**kwargs) - return np.real(self.zeta)/2./pi - - @vectorize_kwargs - def loss_rates(self, **kwargs): - '''Returns the loss rates of the circuit normal modes. - - The array is ordered ordered with increasing normal mode frequencies - such that the first element of the array corresponds to the loss - rate of the lowest frequency mode. Losses are provided in units of Hertz, - **not in angular frequency**. - - Parameters - ---------- - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - - Returns - ------- - numpy.array - Normal mode losses of the circuit - - Notes - ----- - - These loss rates :math:`\kappa_m` correspond to twice the imaginary parts - of the complex frequencies which make the conductance matrix - singular, or equivalently twice the imaginary parts of the poles of the impedance - calculated between the nodes of an inductor or josephon junction. - - For further details on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf. - - The dynamics of the circuit can be studied in QuTiP - by considering collapse operators for the m-th mode - :math:`\sqrt{2\pi\kappa_m(n_{th,m}+1)}\hat{a}_m` and - :math:`\sqrt{2\pi\kappa_m(n_{th,m})}\hat{a}_m^\dagger` - where :math:`n_{th,m}` is the average thermal occupation - of mode :math:`m` and :math:`\hat{a}_m` is the annihilation operator of the m-th - normal mode of the circuit. - Note that dissipation rates that are obtained from this function - have to be converted to angular frequencies through the factor :math:`2\pi`. - If you are also using a hamiltonian generated from qucat, - then it too should be converted to angular frequencies by multiplying - the entire Hamiltonian by :math:`2\pi` when performing time-dependant - simulations. - ''' - self._set_zeta(**kwargs) - return 2*np.imag(self.zeta)/2./pi - - @vectorize_kwargs - def anharmonicities(self, **kwargs): - r'''Returns the anharmonicity of the circuit normal modes. - - The array is ordered ordered with increasing normal mode frequencies - such that the first element of the array corresponds to the - anharmonicity of the lowest frequency mode. - Anharmonicities are provided in units of Hertz, - not in angular frequency. - - - Parameters - ---------- - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - - Returns - ------- - numpy.array - Normal mode anharmonicities - - Notes - ----- - The Hamiltonian of a circuit in first order perturbation theory is given by - - :math:`\hat{H} = \sum_m\sum_{n\ne m} (\hbar\omega_m-A_m-\frac{\chi_{mn}}{2})\hat{a}_m^\dagger\hat{a}_m -\frac{A_m}{2}\hat{a}_m^\dagger\hat{a}_m^\dagger\hat{a}_m\hat{a}_m -\chi_{mn}\hat{a}_m^\dagger\hat{a}_m\hat{a}_n^\dagger\hat{a}_n`, - - valid for weak anharmonicity :math:`\chi_{mn},A_m\ll \omega_m`. - - Here - - * :math:`\omega_m` are the frequencies of the normal modes of the circuit where all junctions have been replaced with inductors characterized by their Josephson inductance - - * :math:`A_m` is the anharmonicity of mode :math:`m` , the difference in frequency of the first two transitions of the mode - - * :math:`\chi_{mn}` is the shift in mode :math:`m` that incurs if an excitation is created in mode :math:`n` - - This function returns the values of :math:`A_m`. - - For more information on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf. - ''' - Ks = self.kerr(**kwargs) - return np.array([Ks[i, i] for i in range(Ks.shape[0])]) - - @vectorize_kwargs - def kerr(self, **kwargs): - r'''Returns the Kerr parameters for the circuit normal modes. - - The diagonal component ``K[m,m]`` of the returned matrix correspond to the - anharmonicity (or self-Kerr) of mode ``m``. - An off-diagonal component ``K[m,n]`` corresponds to the cross-Kerr coupling - between modes ``m`` and ``n``. - The modes are indexed with increasing normal mode frequencies, - for example ``K[0,1]`` corresponds to the cross-Kerr interaction - between the lowest frequency mode and next highest frequency mode. - Kerr parameters are provided in units of Hertz, - not in angular frequency. - - Parameters - ---------- - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - - Returns - ------- - numpy.array of dimension 2 - Kerr parameters - - Notes - ----- - The Hamiltonian of a circuit in first order perturbation theory is given by - - :math:`\hat{H} = \sum_m\sum_{n\ne m} (\hbar\omega_m-A_m-\frac{\chi_{mn}}{2})\hat{a}_m^\dagger\hat{a}_m -\frac{A_m}{2}\hat{a}_m^\dagger\hat{a}_m^\dagger\hat{a}_m\hat{a}_m -\chi_{mn}\hat{a}_m^\dagger\hat{a}_m\hat{a}_n^\dagger\hat{a}_n`, - - valid for weak anharmonicity :math:`\chi_{mn},A_m\ll \omega_m`. - - Here - - * :math:`\omega_m` are the frequencies of the normal modes of the circuit where all junctions have been replaced with inductors characterized by their Josephson inductance - - * :math:`A_m` is the anharmonicity of mode :math:`m` , the difference in frequency of the first two transitions of the mode - - * :math:`\chi_{mn}` is the shift in mode :math:`m` that incurs if an excitation is created in mode :math:`n` - - This function returns the values of :math:`A_m` and :math:`\chi_{mn}` . - - For more information on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf. - ''' - - # Compute anharmonicity per junction ``As`` - # where ``As[j,m]`` corresponds to the contribution of junction ``j`` - # to the anharmonicity of mode ``m`` - As = self._anharmonicities_per_junction(**kwargs) - - # Number of modes in the circuit - N_modes = len(self.zeta) - - # Number of junctions in the circuit - N_junctions = len(self.junctions) - - # initialize the vector of Kerr coefficients - Ks = np.zeros((N_modes, N_modes)) - - for i in range(N_modes): - for j in range(N_modes): - for k in range(N_junctions): - if i == j: - # Add contribution to self-Kerr - Ks[i, i] += np.real(As[k][i]) - else: - # Add contribution to cross-Kerr - # Note that taking the square root here is fine - # since Ks[i, j]~phi_ki^2*phi_kj^2 is necessarily a positive real - # since phi_ki,phi_kj are real numbers - Ks[i, j] += 2. * np.sqrt(As[k][i]*As[k][j]) - return Ks - - def f_k_A_chi(self, pretty_print=False, **kwargs): - r'''Returns the eigenfrequency, loss-rates, anharmonicity, and Kerr parameters of the circuit. - - Returns these quantities in the form ``[[f_0,f_1,..],[k_0,k_1,..],[A_0,A_1,..],[[A_0,chi_01,..],[chi_10,A_1,..]..]]`` - - Each quantity is returned as a numpy arrays, - where each index corresponds to a normal mode, ordered with - increasing normal mode frequency. - All quantities are provided in units of Hertz, - not in angular frequency. - - This method is equivalent to calling - - ``[_.eigenfrequencies(**kwargs),_.loss_rates(**kwargs), _.anharmonicities(**kwargs),_.kerr(**kwargs)]`` - - For more details, refer to the functions - - :meth:`qucat.Qcircuit.eigenfrequencies` - - :meth:`qucat.Qcircuit.loss_rates` - - :meth:`qucat.Qcircuit.anharmonicities` - - :meth:`qucat.Qcircuit.kerr` - - Parameters - ---------- - pretty_print: Boolean, optional - If set to True, this method will print a summary - of the system parameters as a table. - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - - Returns - ------- - List of numpy arrays - ``[[f_0,f_1,..],[k_0,k_1,..],[A_0,A_1,..],[[A_0,chi_01,..],[chi_10,A_1,..]..]]`` - ''' - - # Quantity to be returned: - # eigenfrequency, loss-rates, anharmonicity, and Kerr parameters of the circuit - to_return = self.eigenfrequencies(**kwargs),\ - self.loss_rates(**kwargs),\ - self.anharmonicities(**kwargs),\ - self.kerr(**kwargs) - - - if pretty_print: - - # Number of modes in the circuit - N_modes = len(to_return[0]) - - # Setup a template for the mode/frequency/dissipation/anharmonicity - # table row in the form `` 7 spaces | 7 spaces | 7 spaces | 7 spaces |`` - table_line = "" - for i in range(4): - table_line += " %12s |" - table_line += "\n" - - # Top row for content of columns - to_print = table_line % ( - "mode", " freq. ", " diss. ", " anha. ") - - # add all the other rows (each row is a mode) - for i, w in enumerate(to_return[0]): - to_print += table_line % tuple([str(i)]+[pretty_value( - to_return[j][i], use_unicode=False)+'Hz' for j in range(3)]) - - to_print += "\nKerr coefficients (diagonal = Kerr, off-diagonal = cross-Kerr)\n" - - # Setup template for the rows of the Kerr coefficients table row - # in the form `` 7 spaces | 7 spaces | ...`` - table_line = "" - for i in range(N_modes+1): - table_line += " %12s |" - table_line += "\n" - - # Top row indexing each column as a mode - to_print += table_line % tuple(['mode'] + - [str(i)+' ' for i in range(N_modes)]) - - # Add other rows - for i in range(N_modes): - line_elements = [str(i)] - for j in range(N_modes): - if i >= j: - line_elements.append(pretty_value( - to_return[3][i][j], use_unicode=False)+'Hz') - else: - line_elements.append("") - to_print += table_line % tuple(line_elements) - - # Print the two tables - print(to_print) - - return to_return - - @refuse_vectorize_kwargs(exclude = ['modes','taylor','excitations','return_ops']) - def hamiltonian(self, modes='all', taylor=4, excitations=6, return_ops = False, **kwargs): - r'''Returns the circuits Hamiltonian for further analysis with QuTiP. - The Hamiltonian is provided in units of frequency (not angular frequency), - such that :math:`h=1`. - - Parameters - ---------- - modes: array of integers, optional - List of modes to consider, where the modes are - ordered with increasing frequency, such that - ``modes = [0,1]`` would lead to considering only - the two lowest frequency modes of the circuit. - By default all modes are considered. - taylor: integer, optional - Order to which the potential of all josephson - junctions should be taylor-expanded. Default - is `4`. - excitations:integer or array of integers, optional - Number of energy levels considered for each - junction. If one number is given, all modes - have the same number of levels, if an array - is given, its length should match the number - of modes considered. For example if ``modes = [0,1]`` and - ``excitations = [5,10]``, then we will consider - 5 excitation levels for mode 0 and 10 for mode 1. - return_ops: Boolean, optional - If set to True, a list of the annihilation operators - will be returned along with the hamiltonian in the form - ``, ``. - The form of the return is then ``H,[a_0,a_1,..]`` - where ``a_i`` is the annihilation operator of the - i-th considered mode, a QuTiP Qobj - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - - Returns - ------- - qutip.qobj - Hamiltonian of the circuit - - Notes - ----- - - The Hamiltonian of the circuit, with the non-linearity of the Josephson junctions - Taylor-expanded, is given in the limit of low dissipation by - - :math:`\hat{H} = \sum_{m\in\text{modes}} \hbar \omega_m\hat{a}_m^\dagger\hat{a}_m + \sum_j\sum_{2n\le\text{taylor}}E_j\frac{(-1)^{n+1}}{(2n)!}\left[\frac{\phi_{zpf,m,j}}{\phi_0}(\hat{a}_m^\dagger+\hat{a}_m)\right]^{2n}`, - - where :math:`\hat{a}_m` is the annihilation operator of the m-th - normal mode of the circuit, :math:`\omega_m` is the frequency of - the m-th normal mode, :math:`E_j` is the Josephson energy of - the j-th junction and :math:`\phi_0 = \hbar/2e` and :math:`\phi_{zpf,m,j}` - is the zero point fluctuation of mode - :math:`m` through junction :math:`j`. - - In the expression above, ``modes`` and ``taylor`` are arguments of the ``hamiltonian`` function. - - For more details on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf - ''' - from qutip import destroy, qeye, tensor - - self.hamiltonian_modes = modes - self.hamiltonian_taylor = taylor - self.hamiltonian_excitations = excitations - - fs = self.eigenfrequencies(**kwargs) - - if modes == 'all': - modes = range(len(fs)) - for m in modes: - try: - fs[m] - except IndexError: - error_message ="There are only %d modes in the circuit, and you specified mode index %d "%(len(fs),m) - error_message +="corresponding to the %d-th mode."%(m+1) - # error_message +="\nNote that the numer of modes may change as one sweeps a parameter" - # error_message +=" for example if a 0 frequency, spurious mode becomes negative due to " - # error_message +="numerical imprecision. Adding a resistance to the circuit may help with this." - raise ValueError(error_message) - - if not isinstance(excitations,list): - excitations = [int(excitations) for i in modes] - else: - if len(excitations)!=len(modes): - raise ValueError("excitations and modes should have the same length") - - - H = 0 - operators = [] - phi = [0 for junction in self.junctions] - qeye_list = [qeye(n) for n in excitations] - - for index,mode in enumerate(modes): - a_to_tensor = deepcopy(qeye_list) - a_to_tensor[index] = destroy(excitations[index]) - a = tensor(a_to_tensor) - operators.append(a) - H += fs[mode]*a.dag()*a - - for j, junction in enumerate(self.junctions): - # Note that zpf returns the flux in units of phi_0 = hbar/2./e - phi[j] += np.real(junction.zpf(quantity='flux',mode=mode, **kwargs))*(a+a.dag()) - # a = x+iy => -i*(a-a^) = -i(iy+iy) = --1 - phi[j] += -1j*np.imag(junction.zpf(quantity='flux',mode=mode, **kwargs))*(a-a.dag()) - - for j, junction in enumerate(self.junctions): - n = 2 - EJ = (hbar/2./e)**2/(junction._get_value(0, **kwargs)*h) - while 2*n <= taylor: - H += (-1)**(n+1)*EJ/factorial(2*n)*phi[j]**(2*n) - n += 1 - - if return_ops: - return H, operators - return H - - @refuse_vectorize_kwargs(exclude = ['plot','return_fig_ax']) - def show(self, - plot=True, - return_fig_ax=False, - **kwargs): - '''Plots the circuit. - - Only works if the circuit was created using the GUI. - - - Parameters - ---------- - plot: Boolean, optional - If set to True (default), the function will call - plt.show() to display the circuit - return_fig_ax: Boolean, optional - If set to True (default is False), the function will - return figure and axis for further processing using - matplotlib. - ''' - pp = self._pp - - if isinstance(self,Network): - #TODO recognize if the network is of series/parallel type - # in which case the circuit can be constructed anyway - raise TypeError(''' - Plotting functions not available if the circuit was not constructed - using the GUI. - ''') - - - xs = [] - ys = [] - line_type = [] - for elt in self.netlist: - x, y, lt = elt._draw() - xs += x - ys += y - line_type += lt - - x_min = min([np.amin(x) for x in xs]) - x_max = max([np.amax(x) for x in xs]) - y_min = min([np.amin(x) for x in ys]) - y_max = max([np.amax(x) for x in ys]) - - x_margin = pp['x_fig_margin'] - # ensures that any text labels are not cutoff - y_margin = pp['y_fig_margin'] - fig = plt.figure(figsize=( - ((x_max-x_min)+2.*x_margin)*pp["figsize_scaling"], - ((y_max-y_min)+2.*y_margin)*pp["figsize_scaling"])) - ax = fig.add_subplot(111) - plt.subplots_adjust(left=0., right=1., top=1., bottom=0.) - - for i, _ in enumerate(xs): - if line_type[i] == "node": - ax.scatter(xs[i], ys[i], color=pp["color"], s=pp['node']['diameter']) - else: - ax.plot(xs[i], ys[i], color=pp["color"], lw=pp[line_type[i]]['lw']) - - for elt in self.netlist: - elt._draw_label(ax) - - ax.set_axis_off() - ax.set_xlim(x_min-x_margin, x_max+x_margin) - ax.set_ylim(y_min-y_margin, y_max+y_margin) - plt.margins(x=0., y=0.) - - if return_fig_ax: - return fig, ax - - if plot: - plt.show() - - plt.close() - - @refuse_vectorize_kwargs(exclude = ['quantity']) - def show_normal_mode(self, - mode, - quantity='current', - plot=True, - return_fig_ax=False, - add_title = True, - add_legend = True, - **kwargs): - r'''Plots a visual representation of a normal mode. - - Only works if the circuit was created using the GUI. - Plots a schematic of the circuit overlayed with - arrows representing the complex amplitude of a certain quantity - :math:`X` which can be flux, current, charge or voltage. - - More specifically, the complex amplitude of :math:`X` if a - single-photon amplitude coherent state were populating a given mode ``mode``. - - Current is shown in units of Ampere, voltage in Volts, - charge in electron charge, and flux in units of the - reduced flux quantum - (defined as :math:`\hbar/2e`) - - The direction of the arrows show what we are defining - as positive current for that component. - - Parameters - ---------- - mode: integer - Determine what mode to plot, where 0 designates - the lowest frequency mode, and the others - are arranged in order of increasing frequency - quantity: string - One of 'current' (default), 'flux','charge','voltage' - Determines what quantity the arrows should represent. - plot: Boolean, optional - If set to True (default), the function will call - plt.show() to display the circuit - return_fig_ax: Boolean, optional - If set to True (default is False), the function will - return figure and axis for further processing using - matplotlib. - add_title: Boolean, optional - If set to True (default), the function will - add a title detailing the modes frequency, anharmonicity - and dissipation rate - add_legend: Boolean, optional - If set to True (default), the function will - add a legend detailing the definition of - arrow size and arrow direction - - Notes - ----- - - This annotated quantity, called a phasor, is calculated by multiplying the - voltage transfer function :math:`T_{rc}` (between a reference component :math:`r` - and the annotated component :math:`c` ), with - :math:`X_{zpf,m,r}`, the zero-point fluctuations of :math:`\hat{X}` at the reference component. - - Note that resistors make the transfer function :math:`T_{rc}`, and hence the phasors complex. - - Since this is plotted for a single-photon amplitude coherent state, the absolute value - of the annotation is equal to the - contribution of a mode to the zero-point fluctuations accross this component. - - For more detail on the underlying theory, see https://arxiv.org/pdf/1908.10342.pdf. - ''' - - # This changes the default plotting settings - # to those defined in plotting_settings.py - # under plotting_parameters_normal_modes - self._plotting_normal_mode = True - - # This will set pp to plotting_parameters_normal_modes - # (see the definition of the Qcircuit._pp propoerty function) - pp = self._pp - - # Make sure this has been called on a - # Qcircuit defined with the GUI - if isinstance(self,Network): - raise TypeError(''' - Plotting functions not available if the circuit was not constructed - using the GUI. - ''') - - def pretty(v, quantity): - # Utility function to print a pretty - # value for the phasor - if quantity == 'flux': - return pretty_value(v, is_complex = True)+u"\u03A6_0" - elif quantity == 'charge': - return pretty_value(v, is_complex = True, use_power_10=True)+'e' - elif quantity == 'voltage': - return pretty_value(v, is_complex = True)+'V' - elif quantity == 'current': - return pretty_value(v, is_complex = True)+'A' - - # Plot the circuit and return the - # figure and axis for further - # editing below - fig, ax = self.show( - plot=False, - return_fig_ax=True) - - # Determine smallest and largest arrow size - # Based on the absolute value of the - # phasor through all components - all_values = [] - for el in self.netlist: - if not isinstance(el,W): - all_values.append(el.zpf(mode = mode, quantity = quantity, **kwargs)) - all_values = np.absolute(all_values) - max_value = np.amax(all_values) - min_value = np.amin(all_values) - - def value_to_01_range(value): - # Returns a number between 0 and 1 - # where 0 corresponds to the smallest - # phasor and 1 to the largest - - if pretty(np.absolute(max_value), quantity) == pretty(np.absolute(min_value), quantity): - # Case where all the components have - # the same phasor magnitude - return 1. - else: - return (np.absolute(value)-min_value)/(max_value-min_value) - - def arrow_width(value=None,value_01 = None): - # Converts value between 0 and 1 - # to an arrow width where 0 will - # get the ``min_width`` and - # 1 will get the ``max_width``` - - if value_01 is None: - value_01 = value_to_01_range(value) - - # part of the plotting parameters - # which concern the arrow - ppnm = pp['normal_mode_arrow'] - - return np.absolute(ppnm['min_width']+value_01*(ppnm['max_width']-ppnm['min_width'])) - - def arrow_kwargs(value=None,value_01 = None): - # Constructs the keyword arguments to be passed - # in the construction of an arrow based on the - # zpf value - - if value_01 is None: - value_01 = value_to_01_range(value) - - # part of the plotting parameters - # which concern the arrow - ppnm = pp['normal_mode_arrow'] - - # linewidth - lw = ppnm['min_lw']+value_01*(ppnm['max_lw']-ppnm['min_lw']) - - # head size - head = ppnm['min_head']+value_01 * \ - (ppnm['max_head']-ppnm['min_head']) - - return {'lw': lw, - 'head_width': head, - 'head_length': head, - 'clip_on': False} - - # For each element in the circuit, if it - # isn't a ground, add an arrow and a label - for el in self.netlist: - if not isinstance(el,W): - - # phasor for the quantity and for the current - value = el.zpf(mode = mode, quantity = quantity, **kwargs) - - # location of the element center - x = el.x_plot_center - y = el.y_plot_center - - if el.angle==EAST or el.angle==WEST: - # Case of horizontal element - - # Text position - x_text = x+pp["normal_mode_label"]["text_position_horizontal"][0] - y_text = y+pp["normal_mode_label"]["text_position_horizontal"][1] - - # text alignment - ha = 'center' - va = 'top' - - # Arrow position in y - y_arrow = y+pp["normal_mode_label"]["y_arrow"] - dy_arrow = 0. - - # Arrow position in x - if el.angle == EAST: - # Define the direction for positive values - # and the positive node on the east - x_arrow = x-arrow_width(value)/2. - dx_arrow = arrow_width(value) - elif el.angle == WEST: - # Define the direction for positive values - # and the positive node on the west - x_arrow = x+arrow_width(value)/2. - dx_arrow = -arrow_width(value) - - if el.angle==NORTH or el.angle==SOUTH: - # Case of vertical element - - # Text position - x_text = x+pp["normal_mode_label"]["text_position_vertical"][0] - y_text = y+pp["normal_mode_label"]["text_position_vertical"][1] - - # Text alignment - ha = 'right' - va = 'center' - - # Arrow x position - x_arrow = x-pp["normal_mode_label"]["y_arrow"] - dx_arrow = 0. - - - # Arrow position in y - if el.angle==NORTH: - # Define the direction for positive values - # and the positive node on the north - y_arrow = y-arrow_width(value)/2. - dy_arrow = arrow_width(value) - elif el.angle==SOUTH: - # Define the direction for positive values - # and the positive node on the south - y_arrow = y+arrow_width(value)/2. - dy_arrow = -arrow_width(value) - - - # Add the arrow - if np.real(value)+np.imag(value)<0: - # If the dominating part of the complex number is negative - # Flip the arrow and the value - arrow_coords = [x_arrow+dx_arrow, y_arrow+dy_arrow, -dx_arrow, -dy_arrow] - value = -value - else: - arrow_coords = [x_arrow, y_arrow, dx_arrow, dy_arrow] - - ax.arrow(*arrow_coords, - fc=pp['normal_mode_arrow']['color'], - ec=pp['normal_mode_arrow']['color'], - **arrow_kwargs(value)) - - # Add the annotation - ax.text(x_text, y_text, - pretty(value, quantity), - fontsize=pp["normal_mode_label"]["fontsize"], - ha=ha, va=va, weight='normal',color =pp["normal_mode_label"]["color"] ) - - # Add the title - if add_title: - w,k,A,chi = self.f_k_A_chi(**kwargs) - ax.annotate(r'Mode %d, f=%sHz, k=%sHz, A=%sHz,'% - (mode, - pretty_value(w[mode]), - pretty_value(k[mode]), - pretty_value(A[mode])), - xy=(0.05, 0.97), - horizontalalignment='left', - verticalalignment='top', - xycoords='axes fraction', - fontsize=12, - weight='bold') - - ax.annotate('populated by single-photon amplitude coherent state', - xy=(0.05, 0.97-0.045), - horizontalalignment='left', - verticalalignment='top', - xycoords='axes fraction', - fontsize=12) - - if add_legend: - if quantity == 'current': - value_text= "|I|" - elif quantity == 'voltage': - value_text= u"|V|" - if quantity == 'flux': - value_text= u"|\u03A6|" - elif quantity == 'charge': - value_text= "|Q|" - value_text += u"exp(i\u03B8)" - - x_legend = ax.get_xlim()[0]+0.4 - y_legend = ax.get_ylim()[0]+0.25 - - legend_text_kwargs = { - 'ha':'center', - 'va':'center', - 'fontsize':12, - 'weight':'normal' - } - - ax.text(x_legend, y_legend, - value_text, - **legend_text_kwargs) - - v01 = 0.7 - ax.arrow(x_legend-arrow_width(value_01 = v01)/2, - y_legend-0.15, - arrow_width(value_01 = v01), 0, - fc=pp['normal_mode_arrow']['color'], - ec=pp['normal_mode_arrow']['color'], - **arrow_kwargs(value_01 =v01)) - - - if plot == True: - plt.show() - plt.close() - self._plotting_normal_mode = False - - if return_fig_ax: - return fig, ax - -class Network(Qcircuit): - r'''Constructs a Qcircuit object from a list of components without resorting to a graphical user interface. - - The list can be composed of instances of the :class:`qucat.L`, :class:`qucat.C`, - :class:`qucat.R` or :class:`qucat.J` classes - for inductors, capacitors, resistors or junctions respectively. - - This Qcircuit construction method offers the advantage of programmatically constructing - the circuit of the GUI class. - On could, for example, construct an array of LC-resonators using a python ``for`` loop, which - would be tedious using a graphical user interface. - The disadvantage is that one cannot use the plotting tools :meth:`show` or - :meth:`show_normal_modes` to visualize the circuit or its innerworkings. - - Parameters - ---------- - netlist: list of :class:`qucat.Component` - See examples - - Returns - ------- - qucat.Qcircuit - A Qcircuit object, see qucat.Qcircuit - - Examples - -------- - Here we construct a parallel combination of a capacitor, inductor and junction, grounded - on one end and connected at the other end through a capacitor to a 50 Ohm resistor to ground. - - .. image:: Network_example_circuit.png - - Import the Network class, and the components we will need - - >>> from qucat import Network, R,L,C,J - - Note that the components (R,L,C,J) accept node indexes as their two first arguments, - here we will use the node ``0`` to designate ground. The last arguments should be - a label (``str``) or a value (``float``) or both, the order in which these - arguments are provided are unimportant. - - >>> circuit = Network([ - ... L(0,1,'L',1e-9), # Add the inductor between ground and node 1 - ... C(0,1,100e-15,'C'), # Add the capacitor - ... J(0,1,'L_J'), # Add the junction - ... C(1,2,1e-15), # Add a capacitor which will connect to a resistor - ... R(2,0,50) # Add a 50 Ohm resistance to ground - ... ]) - - The junction was parametrized only by a string ``L_J`` , - this is the best way to proceed if one wants to sweep the value of a - component. Indeed, the most computationally expensive part of the - analysis is performed upon initializing the Network, subsequently - changing the value of a component and re-calculating a quantity - such as the frequency or anharmonicity can be performed much faster. - - For example, we can compute the eigenfrequency, loss-rates, anharmonicity, and Kerr parameters of the circuit - for a specific junction inductance. - - >>> circuit.f_k_A_chi(L_J = 1e-9) - - ''' - - def __init__(self, netlist): - super(Network, self).__init__(netlist) - -class GUI(Qcircuit): - r'''Opens a graphical user interface to constructs a circuit. - - Parameters - ---------- - filename: string - Path to a file which will store all the information - about the graphically constructed circuit. - edit: Boolean - If True (default), the graphical user interface will be opened. - One can set this argument to False to import the circuit without opening - the graphical user interface - plot: Boolean - If True (default), the circuit will be plotted using matplotlib. - print_network: Boolean - If True (default), a text description of the constructed - network will be printed. - - Returns - ------- - qucat.Qcircuit - A Qcircuit object, see qucat.Qcircuit - - Notes - ----- - - All the necessary information about the circuit generated by the graphical user interface application - is stored in a human-readable format at the specified path. - - Each line of this text file is in the format: - - ``type`` ; ``x_minus`` , ``y_minus`` ; ``x_plus`` , ``y_plus`` ; ``value`` ; ``label`` - - and represents a circuit component, wire or ground element. - - ``type`` can take the values ``L``, ``C``, ``R``, ``J``, ``W`` or ``G`` for - inductor, capacitor, resistor, junction, wire or ground respectively. - - ``value`` will be a float representing the value of the component or will be empty - - ``label`` will be a string corresponding to the label of the component or will be empty - - ``x/y_minus`` (``x/y_plus``) represents the horizontal/vertical location of the minus (plus) node of the component. - Negative value are allowed and components have a length of 1 unit. - - For example, the circuit below, is described by the following text file - - :: - - L;3,-10;3,-11;1.000000e-09;L - C;4,-10;4,-11;1.000000e-13;C - J;5,-10;5,-11;;L_J - C;5,-12;6,-12;1.000000e-15; - R;7,-11;7,-12;5.000000e+01; - G;7,-10;7,-11;; - - - .. image:: Network_example_circuit.png - - - ''' - - def __init__(self, filename, edit=True, plot=True, print_network=False,_unittesting=False): - - # Note: this will also give a valid path if filename was specified using - # an absolute path - filename = os.path.join(os.getcwd(),filename) - - try: - with open(filename, 'r') as f: - pass - except FileNotFoundError: - # if file does not exist force the gui to open - edit = True - # and create the folder - os.makedirs(os.path.dirname(filename), exist_ok=True) - # ... and file - with open(filename, "w") as f: - pass - - if edit: - run([sys.executable, - os.path.join(os.path.dirname(__file__),"_gui.py"), - filename]) - - netlist = [] - with open(filename, 'r') as f: - for el in f: - el = el.replace('\n', '') - el = el.split(";") - if el[3] == '': - v = None - else: - v = float(el[3]) - if el[4] == '': - l = None - else: - l = el[4] - netlist.append( - string_to_component(el[0], el[1], el[2], v, l)) - - super(GUI, self).__init__(netlist) - for el in self.netlist: - el._set_plot_coordinates() - - if plot: - self.show() - - if print_network: - for el in [el for el in self.netlist if not isinstance(el,W)]: - print("%s %d %d %s"%( - el.__class__.__name__, - min(el.node_minus,el.node_plus), - max(el.node_minus,el.node_plus), - el._to_string(use_unicode = False))) - print('\n') - -class _Network(object): - """ - The _Network class parses network arrays generated by the GUI - or written manually by the user. - It allows the computation of the R, L and C matrices, the - admittance Y of the network between - two nodes as well as the voltage transfer function of the network - between two ports (4 nodes). - - Parameters - ---------- - netlist : list - list of Component objects - """ - - @timeit - def __init__(self, netlist): - - self.netlist = netlist - self.parse_netlist() - if len(self.net_dict) == 0: - raise ValueError("There are no components in the circuit") - if not self.is_connected(): - raise ValueError("There are two sub-circuits which are not connected") - if self.has_shorts(): - raise ValueError("Your circuit appears to be open or shorted making the analysis impossible") - if self.has_opens(): - raise ValueError("Your circuit appears to be open or shorted making the analysis impossible") - - @timeit - def is_connected(self, - nodes_encountered = None, - start_node = None): - ''' - Determines if a nework is connected (graph theory term). - - Starting at "start_node", - the algorithm will go from neighbouring node - to neighbouring node, adding all encountered - nodes to the encountered_nodes list. - - At then end we check if - all the nodes of the network were encountered - by checking the length of this list with respect - to the total number of nodes - ''' - - encountered_nodes = [] - start_node = list(self.net_dict)[0] # Starting point of the algo - - - def add_neighboors_to_encountered_nodes(node): - if node not in encountered_nodes: - encountered_nodes.append(node) - for neighboor in self.net_dict[node]: - add_neighboors_to_encountered_nodes(neighboor) - - add_neighboors_to_encountered_nodes(start_node) - - if len(encountered_nodes) != len(self.net_dict): - return False - else: - return True - - def has_shorts(self): - ''' - Determines if there is an short circuit. - - For each node, we construct the network where - that node has been removed. - - If the removal of that node leads to two distinct, - non-connected circuits, then that node was a point - at which the circuit was being shorted. - ''' - for node_to_remove in range(len(self.net_dict)): - # create a copy of the network - partial_network = deepcopy(self) - - # remove the node_to_remove from the network - for other_node in partial_network.net_dict[node_to_remove]: - del partial_network.net_dict[other_node][node_to_remove] - del partial_network.net_dict[node_to_remove] - - # check if that network is connected - if not partial_network.is_connected(): - return True - - # No shorts were found - return False - - def has_opens(self): - ''' - Determines if there is an open connection in the - circuit. - - If there are only two nodes in the circuit, it cannot be open. - This is because through another check we are imposing that the circuit has at least - two types of components, one inductive, one capacitive. - So a two node circuit will at minimum be an LC or JC circuit. - - If there are more than two nodes, and one of the nodes is connected - to only one other, the circuit is open. - ''' - for _, connections in self.net_dict.items(): - if len(connections) == 1 and len(self.net_dict)>2: - return True - return False - - def parse_netlist(self): - - def merge_chains(chains, i, j): - '''Merges two chains (two arrays)''' - to_add = chains[j] - del chains[j] - chains[i] = chains[i]+to_add - return chains - - # ``chains``` is a list of node-lists (node-list = a chain) - # each chain lists nodes which are connected one to another - # either through wires or through ground - chains = [] - - # We start by grouping all nodes which are connected by wires - # into chains of nodes indexed by a integer which is to become - # the new node names for future calculations - for el in self.netlist: - - # Go through all the wires (note: grounds are instances of wires) - if isinstance(el,W): - - # If this element is a ground, call it's negative node '__ground' - np = el.node_plus - if type(el) is G: - nm = '__ground' - else: - nm = el.node_minus - - # added tells us if both nodes have already - # been added to a same chain - added = False - - # go through all chains to see if it - # contains the nodes of this wire - for i, ch in enumerate(chains): - - # If both node of the wire have already been - # added to a same chain, don't do anyting - if (nm in ch) and (np in ch): - added = True - - # If minus node was added to chain 'ch'... - elif (nm in ch): - for j, ch2 in enumerate(chains): - # ...and plus node to chain 'ch2' - if np in ch2: - # merge the two chains - chains = merge_chains(chains, i, j) - added = True - if added == False: - # otherwise add plus node to chain 'ch' - ch.append(np) - added = True - - # same check for the plus node - elif (np in ch): - for j, ch2 in enumerate(chains): - if nm in ch2: - chains = merge_chains(chains, i, j) - added = True - if added == False: - ch.append(nm) - added = True - - # if none of the nodes were present in chains, - # create a new chain linking the two nodes of the wire - if added == False: - chains.append([nm, np]) - - def plot_node_to_new_node(plot_node): - ''' - Transforms the node ``plot_node``` to a new node. - - Parameters - ---------- - plot_node: typically a string or an integer, but could be any - hashable object - For GUI generated networks, - this is a string 'x,y' that determines the position - of the node when plotting it. - - Returns - ------- - i: integer, a unique number corresponding to all nodes - connected via a wire or ground. - ``i`` is one of [0,..,N-1] where N is the number of - nodes in the circuit stripped of all wires. - - ''' - i = 0 - # if plot_node is already in a chain, - # return the index of that chain in ``chains`` - for ch in chains: - if plot_node in ch: - return i - i+=1 - - # other wise append ``chains`` and - # return the the last index of ``chains`` - chains.append([plot_node]) - return i - - # replace plotting nodes with new nodes - # for all non-wire elements - # and make a list of all nodes - self.nodes = [] - for el in self.netlist: - el._node_minus_plot = el.node_minus - el._node_plus_plot = el.node_plus - if not isinstance(el,W): - el.node_minus = plot_node_to_new_node(el.node_minus) - el.node_plus = plot_node_to_new_node(el.node_plus) - if el.node_minus == el.node_plus: - raise ValueError("Your circuit appears to be shorted, making the analysis impossible") - for n in [el.node_minus, el.node_plus]: - if n not in self.nodes: - self.nodes.append(n) - - - # build ``net_dict``, a dictionary such that - # ``net_dict[node_A][node_B]`` gives the non-wire circuit - # component connecting ``node_A`` and ``node_B``. - # If ``node_A`` and ``node_B`` are not connected, - # calling ``net_dict[node_A][node_B]`` will raise a KeyError - self.net_dict = {} - for n in self.nodes: - self.net_dict[n] = {} - for el in self.netlist: - if not isinstance(el,W): - self.connect(el, el.node_minus, el.node_plus) - - @timeit - def compute_char_poly_coeffs(self, is_lossy = True): - - @timeit - def determinant(matrix): - return matrix.berkowitz_det() - - self.is_lossy = is_lossy - ntr = deepcopy(self) # ntr stands for Network To Reduce - - # compute conductance matrix - ntr.compute_RLC_matrices() - - if self.is_lossy: - w = sp.Symbol('w') - char_poly = determinant((ntr.RLC_matrices['L']+1j*w*ntr.RLC_matrices['R']-w**2*ntr.RLC_matrices['C'])) - char_poly = sp.collect(sp.expand(char_poly), w) - self.char_poly_order = sp.polys.polytools.degree( - char_poly, gen=w) # Order of the polynomial - # Get polynomial coefficients, index 0 = lowest order term - self.char_poly_coeffs_analytical =\ - [char_poly.coeff(w, n) for n in range(self.char_poly_order+1)] - else: - w2 = sp.Symbol('w2') - char_poly = determinant((-ntr.RLC_matrices['L']+w2*ntr.RLC_matrices['C'])) - char_poly = sp.collect(sp.expand(char_poly), w2) - self.char_poly_order = sp.polys.polytools.degree(char_poly, gen=w2) # Order of the polynomial - # Get polynomial coefficients, index 0 = lowest order term - self.char_poly_coeffs_analytical =\ - [char_poly.coeff(w2, n) for n in range(self.char_poly_order+1)] - - - # Divide by w if possible - n=0 - while self.char_poly_coeffs_analytical[n]==0: - n+=1 - self.char_poly_coeffs_analytical = self.char_poly_coeffs_analytical[n:] - - return self.char_poly_coeffs_analytical - - def compute_RLC_matrices(self): - N_nodes = len(self.net_dict) - self.RLC_matrices = { - 'R':sp.zeros(N_nodes), - 'L':sp.zeros(N_nodes), - 'C':sp.zeros(N_nodes) - } - - for i in range(N_nodes): - for j, el in self.net_dict[i].items(): - if j>i: - RLC_matrix_components = el._get_RLC_matrix_components() - for k in self.RLC_matrices: - self.RLC_matrices[k][i,j] = -RLC_matrix_components[k] - self.RLC_matrices[k][j,i] = -RLC_matrix_components[k] - self.RLC_matrices[k][i,i] += RLC_matrix_components[k] - self.RLC_matrices[k][j,j] += RLC_matrix_components[k] - - # count the number of coefficients in each row - number_coefficients = np.zeros((N_nodes)) - for k in self.RLC_matrices: - for i in range(N_nodes): - for j in range(N_nodes): - if self.RLC_matrices[k][i,j] != 0: - number_coefficients[i]+=1 - - - # set a ground - ground_node = np.argmax(number_coefficients) - for k in self.RLC_matrices: - self.RLC_matrices[k].row_del(ground_node) - self.RLC_matrices[k].col_del(ground_node) - - def connect(self, element, node_minus, node_plus): - ''' - Modifies the ``net_dict`` variable such that ``node_minus`` - and ``node_plus`` are marked as connected in future calculations. - ``net_dict`` is a dictionary such that - ``net_dict[node_A][node_B]`` gives the non-wire circuit - component connecting ``node_A`` and ``node_B``. - If ``node_A`` and ``node_B`` are not connected, - calling ``net_dict[node_A][node_B]`` will raise a KeyError - - Parameters - ---------- - element: a ``Circuit`` object which is not a Wire or a Ground - node_minus: integer - negative node of the element - node_plus: integer - positive node of the element - ''' - - # Connect node minus to node plus - try: - # If the nodes are already connected, add this element in parallel - self.net_dict[node_minus][node_plus] = self.net_dict[node_minus][node_plus] | element - except KeyError: - # Case where the nodes are not connected - self.net_dict[node_minus][node_plus] = element - - # Connect node plus to node minus - try: - self.net_dict[node_plus][node_minus] = self.net_dict[node_plus][node_minus] | element - except KeyError: - self.net_dict[node_plus][node_minus] = element - - def remove_node(self, node_to_remove): - ''' - Makes use of the star-mesh transform to remove the ``node_to_remove`` from the network. - A node N=``node_to_remove`` connected to nodes A,B,C,.. through impedances - Z_A,Z_B,... (the star) can be eliminated - if we interconnect nodes A,B,C,.. with impedances Z_{AB},Z_{AC},Z_{BC},... - given by Z_{XY} = Z_XZ_Y\sum_M1/Z_M. - The resulting network is called the mesh. - - Parameters - ---------- - node: integer, node to be removed of the network stored in ``net_dict`` - ''' - - # List of (connecting_nodes, connecting_components) connecting the - # node_to_remove to (nearest neighbour) connecting_nodes - connections = [x for x in self.net_dict[node_to_remove].items()] - - # Sum of admittances of connecting_components - sum_Y = sum([elt._admittance() for _, elt in connections]) - - # Go through all pairs of connecting nodes - # and calculate the admittance Y_XY that will connect them - # in the mesh - mesh_to_add = [] - for i, (node_A, elt_A) in enumerate(connections): - for node_B, elt_B in connections[i+1:]: - Y = elt_A._admittance()*elt_B._admittance()/sum_Y - mesh_to_add.append([Admittance(node_A, node_B, Y), node_A, node_B]) - - # Remove the node_to_remove from the net_dict, along with all - # the connecting components - for other_node in self.net_dict[node_to_remove]: - del self.net_dict[other_node][node_to_remove] - del self.net_dict[node_to_remove] - - # Add admittances Y_XY connecting nodes X,Y directly adjascent to - # the removed node - for mesh_branch in mesh_to_add: - self.connect(*mesh_branch) - - @timeit - def admittance(self, node_minus, node_plus): - ''' - Compute the admittance of the network between two nodes - ``node_plus`` and ``node_minus`` - by removing all other nodes through star-mesh transformations. - - Parameters - ---------- - node_minus: integer - node_plus: integer - ''' - if node_minus == node_plus: - raise ValueError('node_minus == node_plus') - - # Create a temporary copy of the network which will be reduced - ntr = deepcopy(self) # ntr stands for Network To Reduce - - # # order nodes from the node with the least amount of connections - # # to the one with the most - nodes = [key for key in ntr.net_dict] - nodes_order = np.argsort([len(ntr.net_dict[key]) for key in nodes]) - nodes_sorted = [nodes[i] for i in nodes_order] - - # Remove all nodes except from node_minus, node_plus - # through star-mesh transforms with the remove_node function - for node in nodes_sorted: - if node not in [node_minus, node_plus]: - ntr.remove_node(node) - - # Compute the admittance between the two remaining nodes: - # node_minus and node_plus - Y = ntr.net_dict[node_minus][node_plus]._admittance() - return Y - - def branch_admittance(self, node_1, node_2): - ''' - Returns the admittance in the branch connecting ``node_1`` and ``node_2``. - If they are not directly connected through a single Component, this function - returns 0 (i.e. the admittnce of an open circuit). - This function is written to avoid calling try/except clauses repetitivly - to verify if ``self.net_dict[node_1][node_2]`` is an existing key - - Parameters - ---------- - node_1: integer - node_2: integer - ''' - if node_1 == node_2: - raise ValueError('node_1 == node_2') - - try: - return self.net_dict[node_1][node_2]._admittance() - except KeyError: - return 0. - - def transfer(self, node_left_minus, node_left_plus, node_right_minus, node_right_plus): - ''' - Returns the transfer function V_right/V_left relating the voltage on - a port 'right' defined by ``node_right_minus`` and ``node_right_plus`` - and a port 'left' defined by ``node_left_minus`` and ``node_left_plus`` - We proceed by constructing an ABCD matrix and returning V_right/V_left = 1/A - - Parameters - ---------- - node_left_minus: integer - node_left_plus: integer - node_right_minus: integer - node_right_plus: integer - ''' - - if node_left_minus == node_left_plus: - raise ValueError('node_left_minus == node_left_plus') - elif node_right_minus == node_right_plus: - raise ValueError('node_right_minus == node_right_plus') - - # Case where the left an right port are identical - if (node_left_minus == node_right_minus)\ - and (node_left_plus == node_right_plus): - return 1. - - # Case where the left an right port are identical, but inverted - elif (node_left_plus == node_right_minus)\ - and (node_left_minus == node_right_plus): - return -1. - - # If the ports are not identical, reduce the network such that only - # the nodes provided as arguments remain - - # Create a temporary copy of the network which will be reduced - ntr = deepcopy(self) # ntr stands for Network To Reduce - - # # order nodes from the node with the least amount of connections - # # to the one with the most - nodes = [key for key in ntr.net_dict] - nodes_order = np.argsort([len(ntr.net_dict[key]) for key in nodes]) - nodes_sorted = [nodes[i] for i in nodes_order] - - # Remove nodes using the star-mesh relation - for node in nodes_sorted: - if node not in [node_left_minus, node_left_plus, node_right_minus, node_right_plus]: - ntr.remove_node(node) - - if (node_left_minus in [node_right_plus, node_right_minus]) or\ - (node_left_plus in [node_right_plus, node_right_minus]): - - # Case where there are two of the nodes provided as arguments - # are identical. - # The circuit has then three distinct nodes connected by - # three components. - # For this case, the ABCD matrix can be constructed following - # the before last case of Table 4.1 in Microwave Engineering (Pozar) - # Indeed, all these cases are equivelant to the network below: - # - # p1 --------- Y_3 ---------- p2 - # | | - # Y_1 Y_2 - # | | - # gr ------------------------ gr - # Note that the transfer function is independant of Y_1, this in essence - # a voltage divider (see https://en.wikipedia.org/wiki/Voltage_divider) - # where the voltage at p2 is entirely determined by Y_2,Y_3 and the voltage at p1 - - - if node_left_minus == node_right_minus: - p1 = node_left_plus - p2 = node_right_plus - gr = node_left_minus #= node_right_minus - # Y_1 = ntr.branch_admittance(p1,gr) - Y_2 = ntr.branch_admittance(p2,gr) - Y_3 = ntr.branch_admittance(p1,p2) - - # A component of the ABCD matrix - A = 1+Y_2/Y_3 # node Y_3 cannot be 0 in theory - return 1/A - - elif node_left_plus == node_right_plus: - # Ports 1 and 2 are the wrong way round, minuses cancel out - p1 = node_left_minus - p2 = node_right_minus - gr = node_left_plus #= node_right_plus - - # Y_1 = ntr.branch_admittance(p1,gr) - Y_2 = ntr.branch_admittance(p2,gr) - Y_3 = ntr.branch_admittance(p1,p2) - - # A component of the ABCD matrix - A = 1+Y_2/Y_3 # node Y_3 cannot be 0 in theory - return 1/A - - elif node_left_minus == node_right_plus: - # Port 2 is the wrong way round, transfer function gets a minus - p1 = node_left_plus - p2 = node_right_minus - gr = node_left_minus #= node_right_plus - # Y_1 = ntr.branch_admittance(p1,gr) - Y_2 = ntr.branch_admittance(p2,gr) - Y_3 = ntr.branch_admittance(p1,p2) - - # A component of the ABCD matrix - A = 1+Y_2/Y_3 # node Y_3 cannot be 0 in theory - return -1/A - - elif node_left_plus == node_right_minus: - # Port 2 is the wrong way round, transfer function gets a minus - p1 = node_left_minus - p2 = node_right_plus - gr = node_left_plus #= node_right_minus - # Y_1 = ntr.branch_admittance(p1,gr) - Y_2 = ntr.branch_admittance(p2,gr) - Y_3 = ntr.branch_admittance(p1,p2) - - # A component of the ABCD matrix - A = 1+Y_2/Y_3 # node Y_3 cannot be 0 in theory - return -1/A - - else: - # Most complex case (discussed in the paper) - # First, compute the impence matrix of the lattice network following notations in - # https://www.globalspec.com/reference/71734/203279/10-11-lattice-networks - # excerpt of Network Analysis & Circuit (By M. Arshad) section 10.11: LATTICE NETWORKS - Ya = ntr.branch_admittance(node_left_plus, node_right_plus) - Yb = ntr.branch_admittance(node_left_minus, node_right_plus) - Yc = ntr.branch_admittance(node_left_plus, node_right_minus) - Yd = ntr.branch_admittance(node_left_minus, node_right_minus) - - # The book provides formulas with impedance: - # sum_Z = Za + Zb + Zc + Zd - # Z11 is V1/I1 (with V2=0) - # Z11 = (Za+Zb)*(Zd+Zc)/sum_Z - # Z21 is V1/I2 (with V2=0) - # Z21 = (Zb*Zc-Za*Zd)/sum_Z - # Z22 is V2/I2 (with V1=0) - # Z22 = (Za+Zc)*(Zd+Zb)/sum_Z - - # From Pozar, we obtain the A and B components of the ABCD matrix of the lattice - # The C and D components play no role in determining the transfer function - # A_lattice = Z11/Z21 - # B_lattice = Z11*Z22/Z21-Z21 - - # We will work with admittances, to deal in an easier - # way with Yx = 0 (otherwise we would have to - # distinguish many more cases) - - # Using Mathematica, we compute simplify the expressions for - # A_lattice and B_lattice to: - - A_lattice = (Ya + Yb)*(Yd + Yc)/(Ya*Yd-Yb*Yc) - B_lattice = (Ya + Yb + Yc + Yd)/(Ya*Yd-Yb*Yc) - - # The admittance accross the left port plays no role - # The admittance accross the right port comes into play to yield the A component - # of the total ABCD matrix: - - A = A_lattice + B_lattice*ntr.branch_admittance(node_right_minus,node_right_plus) - - return 1/A - -class Circuit(object): - """docstring for Circuit""" - - def __init__(self, node_minus, node_plus): - self.node_minus = node_minus - self.node_plus = node_plus - self._circuit = None - - def __or__(self, other_circuit): - return Parallel(self, other_circuit) - - def _set_plot_coordinates(self): - - self.x_plot_node_minus = float(self._node_minus_plot.split(',')[0]) - self.x_plot_node_plus = float(self._node_plus_plot.split(',')[0]) - self.y_plot_node_minus = -float(self._node_minus_plot.split(',')[1]) - self.y_plot_node_plus = -float(self._node_plus_plot.split(',')[1]) - self.x_plot_center = (self.x_plot_node_minus + - self.x_plot_node_plus)/2. - self.y_plot_center = (self.y_plot_node_minus + - self.y_plot_node_plus)/2. - if self.x_plot_node_minus == self.x_plot_node_plus: - # increasing y = SOUTH in tkinter - if self.y_plot_node_minus < self.y_plot_node_plus: - self.angle = SOUTH - else: - self.angle = NORTH - else: - if self.x_plot_node_minus < self.x_plot_node_plus: - self.angle = WEST - else: - self.angle = EAST - - def _draw_label(self, ax): - pp = self._circuit._pp - if self.angle%180. == 0.: - x = self.x_plot_center+pp['label']['text_position_horizontal'][0] - y = self.y_plot_center+pp['label']['text_position_horizontal'][1] - ha = 'center' - va = 'top' - - else: - x = self.x_plot_center+pp['label']['text_position_vertical'][0] - y = self.y_plot_center+pp['label']['text_position_vertical'][1] - ha = 'left' - va = 'center' - - ax.text(x, y, - to_string(self.unit, self.label, self.value), - fontsize=pp['label']['fontsize'], - ha=ha, va=va) - -class Parallel(Circuit): - - def __init__(self, left, right): - super(Parallel, self).__init__(node_minus=None, node_plus=None) - - # sets the two children circuit elements - self.left = left - self.right = right - - def _admittance(self): - return Add( - self.left._admittance(), - self.right._admittance()) - - def _get_RLC_matrix_components(self): - RLC_matrix_components = { - 'R':0, - 'L':0, - 'C':0 - } - for el in [self.left,self.right]: - values_to_add = el._get_RLC_matrix_components() - for k in RLC_matrix_components: - RLC_matrix_components[k] += values_to_add[k] - return RLC_matrix_components - -class Component(Circuit): - - def __init__(self, node_minus, node_plus, *args): - super(Component, self).__init__(node_minus, node_plus) - self.label = None - self.value = None - self.__flux = None - self.labels = [None for c in range(3)] - self.values = [None for c in range(3)] - - if len(args)==0: - raise ValueError("Specify either a value or a label") - - for a in args: - - if a in ["", '', ' ', 'None', None]: - break - for i, c in enumerate(a): - if c is None: - pass - elif type(c) is str: - self.labels[i] = c - else: - self.values[i] = c - - - # Check its not too big, too small, or negative - # Note that values above max(min)_float would then - # be interpreted as infinity (or zero) - # if self.value>max_float: - # raise ValueError("Maximum allowed value is %.2e"%max_float) - # elif self.value<0: - # raise ValueError("Value should be a positive float") - # elif 0<=self.value or or , - Other arguments should be a float corresponding to the - inductance, a string corresponding to the - name of that value (ex: `"L"`), or both. - If only a label is provided, - a value for should be passed - as a keyword argument in subsequent function calls - (ex: `L = 1e-9`) - This is the best way to proceed if one wants to sweep the value of this - inductor. Indeed, the most computationally expensive part of the - analysis is performed upon initializing the circuit, subsequently - changing the value of a component and re-calculating a quantity - such as the frequency or anharmonicity can be performed much faster. - """ - def __init__(self, node_minus, node_plus, *args): - super(L, self).__init__(node_minus, node_plus, *args) - self.unit = 'H' - - def _admittance(self): - return -sp.I*Mul(1/sp.Symbol('w'), 1/self._get_value(0)) - - def _set_component_lists(self): - super(L, self)._set_component_lists() - self._circuit.inductors.append(self) - - def _draw(self): - pp = self._circuit._pp - - x = np.linspace(0.5, float( - pp['L']['N_turns']) + 1., pp['L']['N_points']) - y = -np.sin(2.*np.pi*x) - x = np.cos(2.*np.pi*x)+2.*x - - line_type = [] - line_type.append('L') - - # reset leftmost point to 0 - x_min = x[0] - x -= x_min - - # set width inductor width - x_max = x[-1] - x *= pp['L']['width']/x_max - - # set leftmost point to the length of - # the side connection wires - x += (1.-pp['L']['width'])/2. - - # add side wire connections - x_min = x[0] - x_max = x[-1] - x_list = [x] - x_list += [np.array([0., x_min])] - x_list += [np.array([x_max, 1.])] - line_type.append('W') - line_type.append('W') - - # center in x - x_list = shift(x_list, -1./2.) - - # set height of inductor - y *= pp['L']['height']/2. - - # add side wire connections - y_list = [y] - y_list += [np.array([0., 0.])] - y_list += [np.array([0., 0.])] - - if self.angle%180. == 0.: - return shift(x_list, self.x_plot_center), shift(y_list, self.y_plot_center), line_type - if self.angle%180. == 90.: - return shift(y_list, self.x_plot_center), shift(x_list, self.y_plot_center), line_type - - def _get_RLC_matrix_components(self): - return { - 'R':0, - 'L':1/self._get_value(0), - 'C':0 - } - - @timeit - def _compute_flux_zpf_r(self): - ''' - Generate the L._flux_zpf_r function which - takes as an argument an angular frequency (and keyword arguments - if component values need to be specified) and returns the - derivative of the admittance evaluated at the nodes of the inductor, - which is effective capacitance at that frequency. - ''' - # Compute a sympy expression for the admittance - # at the nodes of the reference element - Y = self._circuit._network.admittance(self.node_minus, self.node_plus) - - # Write the expression as a single fraction - # with the numerator and denomenator as polynomials - # (it combines but also "de-nests") - Y_together = sp.together(Y) - - # Extract numerator and denominator - u = sp.numer(Y_together) - v = sp.denom(Y_together) - - # Symbol representing angular frequency - w = sp.Symbol('w') - - # Calculate derivatives - derivatives = [] - for P in [u]:#[u,v]: - # Write as polynomial in 'w' - P = sp.collect(sp.expand(P), w) - - # Obtain the order of the polynomial - P_order = sp.polys.polytools.degree(P, gen=w) - - # Compute list of coefficients - P_coeffs_analytical = [P.coeff(w, n) for n in range(P_order+1)[::-1]] - - # Express the derivative of the polynomial - dP = sum([(P_order-n)*a*w**(P_order-n-1) - for n, a in enumerate(P_coeffs_analytical)]) - - derivatives.append(dP) - - du = derivatives[0] - # dv = derivatives[1] - - # Convert the sympy expression for v/du to a function - # Note the function arguments are the angular frequency - # and component values that need to be specified - dY = lambdify(['w']+self._circuit._no_value_components,du/v, "numpy") - - def _flux_zpf_r(z,**kwargs): - return np.sqrt(hbar/np.real(z)/np.imag(dY(z,**kwargs))) - - self._flux_zpf_r = _flux_zpf_r - - -class J(L): - """A class representing a junction - - Parameters - ---------- - node_minus: integer - Index corresponding to one node of junction - node_minus: integer - Index corresponding to the other node of the junction - args: or or , - Other arguments should be a float which by default - corresponds to the Josephson inductance of the - junction, a string corresponding to the - name of that value (ex: `"L_J"`), or both. - If only a label is provided, - a value for this junction should be passed - as a keyword argument in subsequent function calls - (ex: `L_J = 10e-9`). - This is the best way to proceed if one wants to sweep the value of this - junction. Indeed, the most computationally expensive part of the - analysis is performed upon initializing the circuit, subsequently - changing the value of a component and re-calculating a quantity - such as the frequency or anharmonicity can be performed much faster. - use_E: Boolean - If set to True, the junction will be parametrized by - its Josephson energy, given in units of Hertz, rather - than its Josephson inductance - use_I: Boolean - If set to True, the junction will be parametrized by - its critical current, given in units of Ampere, rather - than its Josephson inductance - """ - def __init__(self, node_minus, node_plus, *args, use_E=False, use_I=False): - super(J, self).__init__(node_minus, node_plus, *args) - - self.use_E = use_E - self.use_I = use_I - if self.use_E: - self.unit = 'Hz' - elif self.use_I: - self.unit = 'A' - else: - self.unit = 'H' - - def _get_value(self, i, **kwargs): - # Returns the Josephson inductance - value = super(J, self)._get_value(i, **kwargs) - if (self.use_E == False) and (self.use_I == False): - print(value) - return value - elif (self.use_E == True) and (self.use_I == False): - L = (hbar/2./e)**2/(value*h) # E is assumed to be provided in Hz - print(L) - return L - elif (use_E == False) and (use_I == True): - L = (hbar/2./e)/value - return L - else: - raise ValueError("Cannot set both use_E and use_I to True") - - def _get_Ej(self, **kwargs): - return (hbar/2./e)**2/(self._get_value(0, **kwargs)*h) - - def _set_component_lists(self): - super(L, self)._set_component_lists() - self._circuit.junctions.append(self) - - @vectorize_kwargs(exclude = ['mode']) - def anharmonicity(self, mode, **kwargs): - r'''Returns the contribution of this junction to the anharmonicity of a given normal mode. - - Returned in units of Hertz, not angular frequency. - - Parameters - ---------- - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - - mode: integer - where 0 designates - the lowest frequency mode, and the others - are arranged in order of increasing frequency - Returns - ------- - float - contribution of this junction to the anharmonicity of a given normal mode - - Notes - ----- - The quantity returned is the anharmonicity - of the mode ``m`` if this junction were the only junction - present in the circuit (i.e. if all the - others were replaced by linear inductors). - - The total anharmonicity of a mode (in first order perturbation theory) is obtained - by summing these contribution over all modes. - - For more details, see https://arxiv.org/pdf/1908.10342.pdf - ''' - return self._get_Ej(**kwargs)/2*np.absolute(self.zpf(mode,quantity='flux',**kwargs))**4 - - - def _draw(self): - pp = self._circuit._pp - - line_type = [] - x = [ - np.array([0., 1.]), - np.array([(1.-pp['J']['width'])/2., - (1.+pp['J']['width'])/2.]), - np.array([(1.-pp['J']['width'])/2., - (1.+pp['J']['width'])/2.]) - ] - y = [ - np.array([0., 0.]), - np.array([-1., 1.])*pp['J']['width']/2., - np.array([1., -1.])*pp['J']['width']/2. - ] - line_type.append('W') - line_type.append('J') - line_type.append('J') - - # center in x and y - x = shift(x, -1./2.) - - if self.angle%180. == 0.: - return shift(x, self.x_plot_center), shift(y, self.y_plot_center), line_type - if self.angle%180. == 90.: - return shift(y, self.x_plot_center), shift(x, self.y_plot_center), line_type - -class J(L): - - - - def __init__(self, node_minus, node_plus, *args): - super(J, self).__init__(node_minus, node_plus, *args) - self.unit = 'Hz' - - - - - - def _get_value(self, i, **kwargs): - value = super(J, self)._get_value(i, **kwargs) - - L = (hbar/2./e)**2/(value*h) # E is assumed to be provided in Hz - return L - - - def _get_Ej(self, i, **kwargs): - if i == 0: - print((hbar/2./e)**2/(self._get_value(i, **kwargs)*h)) - return (hbar/2./e)**2/(self._get_value(i, **kwargs)*h) - else: - return super(J, self)._get_value(i, **kwargs) - - def _set_component_lists(self): - super(J, self)._set_component_lists() - self._circuit.junctions.append(self) - - @vectorize_kwargs(exclude = ['mode']) - def anharmonicity(self, mode, **kwargs): - r'''Returns the contribution of this junction to the anharmonicity of a given normal mode. - - Returned in units of Hertz, not angular frequency. - - Parameters - ---------- - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - - mode: integer - where 0 designates - the lowest frequency mode, and the others - are arranged in order of increasing frequency - Returns - ------- - float - contribution of this junction to the anharmonicity of a given normal mode - - Notes - ----- - The quantity returned is the anharmonicity - of the mode ``m`` if this junction were the only junction - present in the circuit (i.e. if all the - others were replaced by linear inductors). - - The total anharmonicity of a mode (in first order perturbation theory) is obtained - by summing these contribution over all modes. - - For more details, see https://arxiv.org/pdf/1908.10342.pdf - ''' - return self._get_Ej(2, **kwargs)/2*np.absolute(self.zpf(mode,quantity='flux',**kwargs))**4 - - - def _draw(self): - pp = self._circuit._pp - - line_type = [] - x = [ - np.array([0., 1.]), - np.array([(1.-pp['J']['width'])/2., - (1.+pp['J']['width'])/2.]), - np.array([(1.-pp['J']['width'])/2., - (1.+pp['J']['width'])/2.]) - ] - y = [ - np.array([0., 0.]), - np.array([-1., 1.])*pp['D']['width']/2., - np.array([1., -1.])*pp['D']['width']/2. - ] - line_type.append('W') - line_type.append('J') - line_type.append('J') - - # center in x and y - x = shift(x, -1./2.) - - if self.angle%180. == 0.: - return shift(x, self.x_plot_center), shift(y, self.y_plot_center), line_type - if self.angle%180. == 90.: - return shift(y, self.x_plot_center), shift(x, self.y_plot_center), line_type - - -class R(Component): - """A class representing a resistor - - Parameters - ---------- - node_minus: integer - Index corresponding to one node of resistor - node_minus: integer - Index corresponding to the other node of the resistor - args: or or , - Other arguments should be a float corresponding to the - resistance, a string corresponding to the - name of that value (ex: `"R"`), or both. - If only a label is provided, - a value for should be passed - as a keyword argument in subsequent function calls - (ex: `R = 1e-9`) - This is the best way to proceed if one wants to sweep the value of this - resistor. Indeed, the most computationally expensive part of the - analysis is performed upon initializing the circuit, subsequently - changing the value of a component and re-calculating a quantity - such as the dissipation rate can be performed much faster. - """ - def __init__(self, node_minus, node_plus, *args): - super(R, self).__init__(node_minus, node_plus, *args) - self.unit = u"\u03A9" - - def _admittance(self): - return 1/self._get_value(0) - - def _set_component_lists(self): - super(R, self)._set_component_lists() - self._circuit.resistors.append(self) - - def _get_RLC_matrix_components(self): - return { - 'R':1/self._get_value(0), - 'L':0, - 'C':0 - } - - def _draw(self): - pp = self._circuit._pp - - x = np.linspace(-0.25, 0.25 +float(pp['R']['N_ridges']), pp['R']['N_points']) - height = 1. - period = 1. - a = height*2.*(-1.+2.*np.mod(np.floor(2.*x/period), 2.)) - b = -height*2.*np.mod(np.floor(2.*x/period), 2.) - y = (2.*x/period - np.floor(2.*x/period))*a+b+height - - line_type = [] - line_type.append('R') - - # reset leftmost point to 0 - x_min = x[0] - x -= x_min - - # set width inductor width - x_max = x[-1] - x *= pp['R']['width']/x_max - - # set leftmost point to the length of - # the side connection wires - x += (1.-pp['R']['width'])/2. - - # add side wire connections - x_min = x[0] - x_max = x[-1] - x_list = [x] - x_list += [np.array([0., x_min])] - x_list += [np.array([x_max, 1.])] - line_type.append('W') - line_type.append('W') - - # center in x - x_list = shift(x_list, -1./2.) - - # set height of inductor - y *= pp['R']['height']/2. - - # add side wire connections - y_list = [y] - y_list += [np.array([0., 0.])] - y_list += [np.array([0., 0.])] - - if self.angle%180. == 0.: - return shift(x_list, self.x_plot_center), shift(y_list, self.y_plot_center), line_type - if self.angle%180. == 90.: - return shift(y_list, self.x_plot_center), shift(x_list, self.y_plot_center), line_type - -class C(Component): - """A class representing a capacitor - - Parameters - ---------- - node_minus: integer - Index corresponding to one node of capacitor - node_minus: integer - Index corresponding to the other node of the capacitor - args: or or , - Other arguments should be a float corresponding to the - capacitance, a string corresponding to the - name of that value (ex: `"C"`), or both. - If only a label is provided, - a value for should be passed - as a keyword argument in subsequent function calls - (ex: `C = 1e-9`) - This is the best way to proceed if one wants to sweep the value of this - capacitor. Indeed, the most computationally expensive part of the - analysis is performed upon initializing the circuit, subsequently - changing the value of a component and re-calculating a quantity - such as the anharmonicity can be performed much faster. - """ - def __init__(self, node_minus, node_plus, *args): - super(C, self).__init__(node_minus, node_plus, *args) - self.unit = 'F' - - def _admittance(self): - return sp.I*Mul(sp.Symbol('w'), self._get_value(0)) - - def _set_component_lists(self): - super(C, self)._set_component_lists() - self._circuit.capacitors.append(self) - - def _draw(self): - pp = self._circuit._pp - line_type = [] - x = [ - np.array([0., (1.-pp['C']['gap'])/2.]), - np.array([(1.+pp['C']['gap']) / - 2., 1.]), - np.array([(1.-pp['C']['gap'])/2., - (1.-pp['C']['gap'])/2.]), - np.array([(1.+pp['C']['gap'])/2., - (1.+pp['C']['gap'])/2.]), - ] - y = [ - np.array([0., 0.]), - np.array([0., 0.]), - np.array([-pp['C']['height']/2., pp['C']['height']/2.]), - np.array([-pp['C']['height']/2., pp['C']['height']/2.]), - ] - line_type.append('W') - line_type.append('W') - line_type.append('C') - line_type.append('C') - - # center in x and y - x = shift(x, -1./2.) - - if self.angle%180. == 0.: - return shift(x, self.x_plot_center), shift(y, self.y_plot_center), line_type - if self.angle%180. == 90.: - return shift(y, self.x_plot_center), shift(x, self.y_plot_center), line_type - - def _get_RLC_matrix_components(self): - return { - 'R':0, - 'L':0, - 'C':self._get_value(0) - } - -class Admittance(Component): - def __init__(self, node_minus, node_plus, Y): - self.node_minus = node_minus - self.node_plus = node_plus - self.Y = Y - - def _admittance(self): - return self.Y \ No newline at end of file From 891b133d4323e58eab1a5588662d39765abe769a Mon Sep 17 00:00:00 2001 From: Hector Date: Tue, 25 May 2021 22:31:00 +0200 Subject: [PATCH 16/17] Modify tutorial --- .../arbitrary_dipole/SNAIL_example.ipynb | 180 ++---------------- 1 file changed, 13 insertions(+), 167 deletions(-) diff --git a/docs_src/source/tutorials/arbitrary_dipole/SNAIL_example.ipynb b/docs_src/source/tutorials/arbitrary_dipole/SNAIL_example.ipynb index 6ae5d600..c34f5e0e 100644 --- a/docs_src/source/tutorials/arbitrary_dipole/SNAIL_example.ipynb +++ b/docs_src/source/tutorials/arbitrary_dipole/SNAIL_example.ipynb @@ -98,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -170,22 +170,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "

" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "circuit = qc.GUI(\"Circuit_example.txt\")" ] @@ -199,32 +186,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "phi_exts = np.linspace(0,6*np.pi, 1000)\n", "\n", @@ -246,46 +210,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " return array(a, dtype, copy=False, order=order)\n", - "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " return array(a, dtype, copy=False, order=order)\n", - "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " return array(a, dtype, copy=False, order=order)\n" - ] - }, - { - "data": { - "text/plain": [ - "[[],\n", - " [],\n", - " []]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "freqs = circuit.eigenfrequencies(**labels)/1e9\n", "\n", @@ -306,40 +233,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " return array(a, dtype, copy=False, order=order)\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "three_waves = circuit.three_waves(0, 1, 2, **labels)/1e6 #In MHz\n", "\n", @@ -360,45 +256,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No handles with labels found to put in legend.\n", - "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " return array(a, dtype, copy=False, order=order)\n", - "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " return array(a, dtype, copy=False, order=order)\n", - "/Users/hutin/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py:85: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " return array(a, dtype, copy=False, order=order)\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "kerr_coeffs = circuit.kerr(**labels)/1e6 # in MHz\n", "\n", @@ -422,23 +282,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle - 2268433.92223772 \\left(- 0.723217903073783 \\left(b_{m0} + b^\\dagger_{m0}\\right) - 0.854359675735641 \\left(b_{m1} + b^\\dagger_{m1}\\right) + b_{m2} + b^\\dagger_{m2}\\right)^{3} - 161131.306189082 \\left(- 0.723217903073783 \\left(b_{m0} + b^\\dagger_{m0}\\right) - 0.854359675735641 \\left(b_{m1} + b^\\dagger_{m1}\\right) + b_{m2} + b^\\dagger_{m2}\\right)^{4} + 3586103050.56997 b^\\dagger_{m0} b_{m0} + 4144027457.67397 b^\\dagger_{m1} b_{m1} + 5077766571.52978 b^\\dagger_{m2} b_{m2}$" - ], - "text/plain": [ - "-2268433.92223772*(-0.723217903073783*(AnnihilateBoson(m0) + CreateBoson(m0)) - 0.854359675735641*(AnnihilateBoson(m1) + CreateBoson(m1)) + AnnihilateBoson(m2) + CreateBoson(m2))**3 - 161131.306189082*(-0.723217903073783*(AnnihilateBoson(m0) + CreateBoson(m0)) - 0.854359675735641*(AnnihilateBoson(m1) + CreateBoson(m1)) + AnnihilateBoson(m2) + CreateBoson(m2))**4 + 3586103050.56997*CreateBoson(m0)*AnnihilateBoson(m0) + 4144027457.67397*CreateBoson(m1)*AnnihilateBoson(m1) + 5077766571.52978*CreateBoson(m2)*AnnihilateBoson(m2)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "circuit.hamiltonian_sym(**make_dict(E_J, alpha, np.pi/7), modes = 'all') " ] From 4fc7e9065a81e20dedcef8e57d5047aedd43f974 Mon Sep 17 00:00:00 2001 From: Hector Date: Tue, 25 May 2021 22:53:35 +0200 Subject: [PATCH 17/17] Revert "Merge branch 'master' into arbitrary_dipole_backup" This reverts commit 4314821669c41408e1759bebf16cb0af8ba2693e, reversing changes made to 66935f246ef5fc79550fd247d8fbc4868e89da9a. --- src/_gui.py | 16 ----- src/core.py | 185 +--------------------------------------------------- 2 files changed, 1 insertion(+), 200 deletions(-) diff --git a/src/_gui.py b/src/_gui.py index 0a53c94f..2faddbe5 100644 --- a/src/_gui.py +++ b/src/_gui.py @@ -569,13 +569,8 @@ def generate_delete_all_key_sequence(): command=(lambda: self.event_generate('j')), font=menu_font) menu.add_command( -<<<<<<< HEAD label=label_template.format("Dipole", ""), command=(lambda: self.event_generate('d')), -======= - label=label_template.format("Dipole", ""), - command=(lambda: self.event_generate('d')), ->>>>>>> master font=menu_font) menu.add_command( label=label_template.format("Inductor", ""), @@ -3534,19 +3529,11 @@ def __init__(self, master, component): if isinstance(self.component,C): info_text = 'Specify label and/or capacitance (in units of Farad)' self.value_string = 'Capacitance' -<<<<<<< HEAD -======= - info_text += '\nPut the label between []: [label]' ->>>>>>> master elif isinstance(self.component,J): self.value_string = 'Inductance' info_text = 'Specify label and/or Josephson inductance (in units of Henry)' info_text += '\nNote that L = (hbar/2/e)**2/[Josephson Energy in Joules]' -<<<<<<< HEAD -======= - info_text += '\nPut the label between []: [label]' ->>>>>>> master elif isinstance(self.component,D): self.value_string = 'Energy' @@ -3555,12 +3542,9 @@ def __init__(self, master, component): elif isinstance(self.component,L): self.value_string = 'Inductance' info_text = 'Specify label and/or inductance (in units of Henry)' - info_text += '\nPut the label between []: [label]' elif isinstance(self.component,R): self.value_string = 'Resistance' info_text = 'Specify label and/or resistance (in units of Ohm)' - info_text += '\nPut the label between []: [label]' - # Entry field strings diff --git a/src/core.py b/src/core.py index 7ba92b34..41d877ba 100644 --- a/src/core.py +++ b/src/core.py @@ -1,7 +1,5 @@ import sympy as sp -import scipy from sympy.utilities.lambdify import lambdify -from sympy import Function import numpy as np from numpy.polynomial.polynomial import Polynomial as npPoly from sympy.core.mul import Mul, Pow, Add @@ -24,12 +22,7 @@ from _utility import * from plotting_settings import plotting_parameters_show,plotting_parameters_normal_modes -<<<<<<< HEAD from sympy.physics.secondquant import Dagger, B, Bd -======= -from scipy.optimize import minimize as mini -from numpy import cos, sin ->>>>>>> master PROFILING = False @@ -179,7 +172,7 @@ def __init__(self, netlist): # define the functions which returns the components of the characteristic polynomial # (the roots of which are the eigen-frequencies) - self._char_poly_coeffs = [lambdify(self._no_value_components, c, ['numpy']) + self._char_poly_coeffs = [lambdify(self._no_value_components, c, 'numpy') for c in self._network.compute_char_poly_coeffs(is_lossy = (len(self.resistors)>0))] #self.no_value_components : array de tous les labels non spécifiés @@ -622,12 +615,6 @@ def three_waves(self, mode1, mode2, mode3, **kwargs): Tw += j.three_term(mode1, mode2, mode3, **kwargs) return Tw -<<<<<<< HEAD -======= - - - ->>>>>>> master def f_k_A_chi(self, pretty_print=False, **kwargs): r'''Returns the eigenfrequency, loss-rates, anharmonicity, and Kerr parameters of the circuit. @@ -2186,7 +2173,6 @@ def __init__(self, node_minus, node_plus, *args): if a in ["", '', ' ', 'None', None]: pass -<<<<<<< HEAD #checks if a is a list of labels/values elif type(a) in [list, tuple, np.ndarray]: for i, c in enumerate(a): @@ -2203,27 +2189,6 @@ def __init__(self, node_minus, node_plus, *args): else: self.values[0] = a self.value = a -======= - else: - for i, c in enumerate(a): - if c is None: - pass - elif type(c) is str: - self.labels[i] = c - else: - self.values[i] = c - - # Check its not too big, too small, or negative - # Note that values above max(min)_float would then - # be interpreted as infinity (or zero) - # if self.value>max_float: - # raise ValueError("Maximum allowed value is %.2e"%max_float) - # elif self.value<0: - # raise ValueError("Value should be a positive float") - # elif 0<=self.value>>>>>> master def __hash__(self, i): if self.labels[i] is None: @@ -2234,14 +2199,8 @@ def __hash__(self, i): else: return hash(str(self.values[i])+self.labels[i]+self.unit) -<<<<<<< HEAD - def _get_value(self, i, **kwargs): - -======= - def _get_value(self, i, **kwargs): ->>>>>>> master if self.values[i] is not None: return self.values[i] elif self.values[i] is None and kwargs is not None: @@ -2249,11 +2208,6 @@ def _get_value(self, i, **kwargs): return kwargs[self.labels[i]] return sp.Symbol(self.labels[i]) -<<<<<<< HEAD -======= - - ->>>>>>> master def _set_component_lists(self): for i, c in enumerate(self.labels): @@ -2661,11 +2615,7 @@ def _get_value(self, i, **kwargs): raise ValueError("Cannot set both use_E and use_I to True") def _get_Ej(self, i, **kwargs): -<<<<<<< HEAD return (hbar/2./e)**2/(self._get_value(0, **kwargs)*h)*((i+1)%2) #zero if i odd -======= - return (hbar/2./e)**2/(self._get_value(0, **kwargs)*h)*((i+1)%2) ->>>>>>> master def _set_component_lists(self): super(L, self)._set_component_lists() @@ -2737,139 +2687,6 @@ def _draw(self): return shift(x, self.x_plot_center), shift(y, self.y_plot_center), line_type if self.angle%180. == 90.: return shift(y, self.x_plot_center), shift(x, self.y_plot_center), line_type - -class D(L): - - - - def __init__(self, node_minus, node_plus, *args): - super(D, self).__init__(node_minus, node_plus, *args) - self.unit = 'Hz' - - - - - - def _get_value(self, i, **kwargs): - value = super(D, self)._get_value(0, **kwargs) - - L = (hbar/2./e)**2/(value*h) # E is assumed to be provided in Hz - return L - - - def _get_Ej(self, i, **kwargs): - if i%2 == 0: - return (-1)**(i//2) * super(D, self)._get_value(i, **kwargs) # to match the cosine developement of a Josephson junction in hamiltonian - else: - return super(D, self)._get_value(i, **kwargs) - - def _set_component_lists(self): - super(L, self)._set_component_lists() - self._circuit.junctions.append(self) - - - - @vectorize_kwargs(exclude = ['mode1', 'mode2', 'mode3']) - def three_term(self, mode1, mode2, mode3, **kwargs): - r'''Returns the contribution of this junction to the three waves-mixing coeeficient of a normal mode - - Returned in units of Hertz, not angular frequency. - - Parameters - ---------- - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - - mode: integer - where 0 designates - the lowest frequency mode, and the others - are arranged in order of increasing frequency - Returns - ------- - float - contribution of this junction to the anharmonicity of a given normal mode - - Notes - ----- - The quantity returned is the anharmonicity - of the mode ``m`` if this junction were the only junction - present in the circuit (i.e. if all the - others were replaced by linear inductors). - - The total anharmonicity of a mode (in first order perturbation theory) is obtained - by summing these contribution over all modes. - - For more details, see https://arxiv.org/pdf/1908.10342.pdf - ''' - return self._get_Ej(1, **kwargs)/6*np.absolute(self.zpf(mode1,quantity='flux',**kwargs) - *self.zpf(mode2,quantity='flux',**kwargs) - *self.zpf(mode3,quantity='flux',**kwargs)) - - @vectorize_kwargs(exclude = ['mode']) - def anharmonicity(self, mode, **kwargs): - r'''Returns the contribution of this junction to the anharmonicity of a given normal mode. - - Returned in units of Hertz, not angular frequency. - - Parameters - ---------- - kwargs: - Values for un-specified circuit components, - ex: ``L=1e-9``. - - mode: integer - where 0 designates - the lowest frequency mode, and the others - are arranged in order of increasing frequency - Returns - ------- - float - contribution of this junction to the anharmonicity of a given normal mode - - Notes - ----- - The quantity returned is the anharmonicity - of the mode ``m`` if this junction were the only junction - present in the circuit (i.e. if all the - others were replaced by linear inductors). - - The total anharmonicity of a mode (in first order perturbation theory) is obtained - by summing these contribution over all modes. - - For more details, see https://arxiv.org/pdf/1908.10342.pdf - ''' - return self._get_Ej(2, **kwargs)/2*np.absolute(self.zpf(mode,quantity='flux',**kwargs))**4 - - - def _draw(self): - pp = self._circuit._pp - - line_type = [] - x = [ - np.array([0., 1.]), - np.array([(1.-pp['D']['width'])/2., - (1.+pp['D']['width'])/2.]), - np.array([(1.-pp['D']['width'])/2., - (1.+pp['D']['width'])/2.]) - ] - y = [ - np.array([0., 0.]), - np.array([-1., 1.])*pp['D']['width']/2., - np.array([1., -1.])*pp['D']['width']/2. - ] - line_type.append('W') - line_type.append('D') - line_type.append('D') - - # center in x and y - x = shift(x, -1./2.) - - if self.angle%180. == 0.: - return shift(x, self.x_plot_center), shift(y, self.y_plot_center), line_type - if self.angle%180. == 90.: - return shift(y, self.x_plot_center), shift(x, self.y_plot_center), line_type - class D(L):