diff --git a/codes/hf.py b/codes/hf.py index 33ce562f395067809c5bdd81ad99f31dddb8e7ec..18e97357980efb00723977fa548369d72f0ba605 100644 --- a/codes/hf.py +++ b/codes/hf.py @@ -1,11 +1,8 @@ from scipy.ndimage import convolve import numpy as np import codes.utils as utils -from functools import partial -from scipy.optimize import anderson - -def mean_field_F(vals, vecs, E_F): +def density_matrix(vals, vecs, E_F): """ Returns the mean field F_ij(k) = <psi_i(k)|psi_j(k)> for all k-points and eigenvectors below the Fermi level. @@ -21,8 +18,8 @@ def mean_field_F(vals, vecs, E_F): Returns ------- - F : array_like - mean field F[kx, ky, ..., i, j] where i,j are cell indices. + rho : array_like + Density matrix rho=rho[kx, ky, ..., i, j] where i,j are cell indices. """ norbs = vals.shape[-1] dim = len(vals.shape) - 1 @@ -37,19 +34,19 @@ def mean_field_F(vals, vecs, E_F): occ_vecs_flat = np.transpose(occ_vecs_flat, axes=[0, 2, 1]) # inner products between eigenvectors - F_ij = np.einsum("kie,kje->kij", occ_vecs_flat, occ_vecs_flat.conj()) + rho_ij = np.einsum("kie,kje->kij", occ_vecs_flat, occ_vecs_flat.conj()) reshape_order = [nk for i in range(dim)] reshape_order.extend([norbs, norbs]) - F = F_ij.reshape(*reshape_order) + rho = rho_ij.reshape(*reshape_order) else: unocc_vals = vals > E_F occ_vecs = vecs occ_vecs[:, unocc_vals] = 0 # Outter products between eigenvectors - F = occ_vecs @ occ_vecs.T.conj() + rho = occ_vecs @ occ_vecs.T.conj() - return F + return rho def convolution(M1, M2): @@ -82,46 +79,62 @@ def convolution(M1, M2): return V_output -def compute_mf(vals, vecs, filling, H_int): +def compute_mf(rho, H_int): """ Compute mean-field correction at self-consistent loop. Parameters: ----------- - vals : nd-array - Eigenvalues of current loop vals[k_x, ..., k_n, j]. - vecs : nd_array - Eigenvectors of current loop vals[k_x, ..., k_n, i, j]. + rho : nd_array + Density matrix. H_int : nd-array Interaction matrix. - filling: int - Number of electrons per cell. Returns: -------- mf : nd-array Meanf-field correction with same format as `H_int`. """ - dim = len(vals.shape) - 1 - - nk = vals.shape[0] - - E_F = utils.get_fermi_energy(vals, filling) - F = mean_field_F(vals=vals, vecs=vecs, E_F=E_F) + + nk = rho.shape[0] + dim = len(rho.shape) - 2 if dim > 0: - H0_int = H_int[*[0 for i in range(dim)]] - rho = np.diag(np.average(F, axis=tuple([i for i in range(dim)]))) - exchange_mf = convolution(F, H_int) * nk ** (-dim) - direct_mf = np.diag(np.einsum("i,ij->j", rho, H0_int)) + H0_int = H_int[*([0]*dim)] + local_density = np.diag(np.average(rho, axis=tuple([i for i in range(dim)]))) + exchange_mf = convolution(rho, H_int) * nk ** (-dim) + direct_mf = np.diag(np.einsum("i,ij->j", local_density, H0_int)) + dc_direct = local_density.T @ H0_int @ local_density + dc_exchange = np.einsum('kij, kji', exchange_mf, rho) * nk ** (-dim) + dc_energy = 0.5*(-dc_exchange + dc_direct) * np.eye(direct_mf.shape[-1]) else: - rho = np.diag(F) - exchange_mf = F * H_int - direct_mf = np.diag(np.einsum("i,ij->j", rho, H_int)) - return direct_mf - exchange_mf + local_density = np.diag(rho) + exchange_mf = rho * H_int + direct_mf = np.diag(np.einsum("i,ij->j", local_density, H_int)) + dc_energy_direct = np.diag(np.einsum("ij, i, j->", H_int, local_density, local_density)) + dc_energy_cross = np.diag(np.einsum("ij, ij, ji->", H_int, rho, rho)) + dc_energy = 2 * dc_energy_direct - dc_energy_cross + return direct_mf - exchange_mf# - dc_energy * np.eye(direct_mf.shape[-1]) + +def total_energy(h, rho): + """ + Compute total energy. + Paramters: + ---------- + h : nd-array + Hamiltonian. + rho : nd-array + Density matrix. -def scf_loop(mf, H_int, filling, hamiltonians_0): + Returns: + -------- + total_energy : float + System total energy computed as tr[h@rho]. + """ + return np.sum(np.trace(h @ rho, axis1=-1, axis2=-2)).real / np.prod(rho.shape[:-2]) + +def updated_matrices(mf_k, model): """ Self-consistent loop. @@ -138,75 +151,16 @@ def scf_loop(mf, H_int, filling, hamiltonians_0): Returns: -------- - diff : nd-array - Difference of mean-field matrix. + mf_new : nd-array + Updated mean-field solution. """ # Generate the Hamiltonian - hamiltonians = hamiltonians_0 + mf + hamiltonians = model.hamiltonians_0 + mf_k vals, vecs = np.linalg.eigh(hamiltonians) vecs = np.linalg.qr(vecs)[0] + E_F = utils.get_fermi_energy(vals, model.filling) + rho = density_matrix(vals=vals, vecs=vecs, E_F=E_F) + return rho, compute_mf( + rho=rho, + H_int=model.H_int) - E_F * np.eye(model.hamiltonians_0.shape[-1]) - mf_new = compute_mf(vals=vals, vecs=vecs, filling=filling, H_int=H_int) - - diff = mf_new - mf - - return diff - - -def find_groundstate_ham( - tb_model, - int_model, - filling, - nk=10, - tol=1e-5, - guess=None, - mixing=0.01, - order=10, - verbose=False, - return_mf=False, -): - """ - Self-consistent loop to find groundstate Hamiltonian. - - Parameters: - ----------- - tb_model : dict - Tight-binding model. Must have the following structure: - - Keys are tuples for each hopping vector (in units of lattice vectors). - - Values are hopping matrices. - int_model : dict - Interaction matrix model. Must have same structure as `tb_model` - filling: int - Number of electrons per cell. - tol : float - Tolerance of meanf-field self-consistent loop. - guess : nd-array - Initial guess. Same format as `H_int`. - mixing : float - Regularization parameter in Anderson optimization. Default: 0.5. - order : int - Number of previous solutions to retain. Default: 1. - verbose : bool - Verbose of Anderson optimization. Default: False. - return_mf : bool - Returns mean-field result. Useful if wanted to reuse as guess in upcoming run. - - Returns: - -------- - scf_model : dict - Tight-binding model of Hartree-Fock solution. - """ - hamiltonians_0, ks = utils.kgrid_hamiltonian(nk, tb_model, return_ks=True) - if guess is None: - guess = utils.generate_guess(nk, tb_model, int_model, scale=np.max(np.abs(np.array([*int_model.values()])))) - fun = partial( - scf_loop, - hamiltonians_0=hamiltonians_0, - H_int=utils.kgrid_hamiltonian(nk, int_model), - filling=filling, - ) - mf = anderson(fun, guess, f_tol=tol, w0=mixing, M=order, verbose=verbose) - if return_mf: - return utils.hk2tb_model(hamiltonians_0 + mf, tb_model, int_model, ks), mf - else: - return utils.hk2tb_model(hamiltonians_0 + mf, tb_model, int_model, ks) diff --git a/codes/interface.py b/codes/interface.py new file mode 100644 index 0000000000000000000000000000000000000000..21c6edc6bb3c7c2b09c6a819c10c4cab784795b7 --- /dev/null +++ b/codes/interface.py @@ -0,0 +1,66 @@ +from scipy import optimize +from . import utils, solvers +import numpy as np + +def find_groundstate_ham( + model, + filling, + nk=10, + cutoff_Vk=0, + solver=solvers.kspace_solver, + cost_function=solvers.kspace_cost, + optimizer=optimize.anderson, + optimizer_kwargs={}, + return_mf=False, + return_kspace=False +): + """ + Self-consistent loop to find groundstate Hamiltonian. + + Parameters: + ----------- + tb_model : dict + Tight-binding model. Must have the following structure: + - Keys are tuples for each hopping vector (in units of lattice vectors). + - Values are hopping matrices. + filling: int + Number of electrons per cell. + guess : nd-array + Initial guess. Same format as `H_int`. + return_mf : bool + Returns mean-field result. Useful if wanted to reuse as guess in upcoming run. + + Returns: + -------- + scf_model : dict + Tight-binding model of Hartree-Fock solution. + """ + model.nk=nk + model.filling=filling + if model.int_model is not None: + model.vectors=[*model.int_model.keys()] + else: + model.vectors = utils.generate_vectors(cutoff_Vk, model.dim) + if model.guess is None: + model.random_guess(model.vectors) + solver(model, optimizer, cost_function, optimizer_kwargs) + model.vectors=[*model.vectors, *model.tb_model.keys()] + assert np.allclose(model.mf_k - np.moveaxis(model.mf_k, -1, -2).conj(), 0, atol=1e-15) + vals, _ = np.linalg.eigh(model.hamiltonians_0 + model.mf_k) + EF = utils.get_fermi_energy(vals, filling) + model.mf_k -= EF * np.eye(model.hamiltonians_0.shape[-1]) + if return_kspace: + return model.hamiltonians_0 + model.mf_k + else: + if model.dim > 0: + scf_tb = utils.hk2tb_model(model.hamiltonians_0 + model.mf_k, model.vectors, model.ks) + if return_mf: + mf_tb = utils.hk2tb_model(model.mf_k, model.vectors, model.ks) + return scf_tb, mf_tb + else: + return scf_tb + else: + if return_mf: + return {() : model.hamiltonians_0 + model.mf_k}, {() : model.mf_k} + else: + return {() : model.hamiltonians_0 + model.mf_k} diff --git a/codes/kwant_examples.py b/codes/kwant_examples.py index fffc827701123c73c57777a9eb1e3779e991d941..a867e7456ad342ff809f3f5814495806632264e3 100644 --- a/codes/kwant_examples.py +++ b/codes/kwant_examples.py @@ -27,7 +27,7 @@ def graphene_extended_hubbard(): return V * np.ones((2, 2)) syst_V = utils.build_interacting_syst( - syst=bulk_graphene, + builder=bulk_graphene, lattice = graphene, func_onsite = onsite_int, func_hop = nn_int, diff --git a/codes/model.py b/codes/model.py new file mode 100644 index 0000000000000000000000000000000000000000..4141bf6ceea9db2569bfdfc755f3050d02af970b --- /dev/null +++ b/codes/model.py @@ -0,0 +1,86 @@ +from . import utils +import numpy as np + +class Model: + """ + A period tight-binding model class. + + Attributes + ---------- + tb_model : dict + Non-interacting tight-binding model. + int_model : dict + Interacting tight-binding model. + Vk : function + Interaction potential V(k). Used if `int_model = None`. + guess : dict + Initial guess for self-consistent calculation. + dim : int + Number of translationally invariant real-space dimensions. + ndof : int + Number of internal degrees of freedom (orbitals). + hamiltonians_0 : nd-array + Non-interacting amiltonian evaluated on a k-point grid. + H_int : nd-array + Interacting amiltonian evaluated on a k-point grid. + """ + + def __init__(self, tb_model, int_model=None, Vk=None, guess=None): + self.tb_model = tb_model + self.dim = len([*tb_model.keys()][0]) + if self.dim > 0: + self.hk = utils.model2hk(tb_model=tb_model) + self.int_model = int_model + if self.int_model is not None: + self.int_model = int_model + if self.dim > 0: + self.Vk = utils.model2hk(tb_model=int_model) + else: + if self.dim > 0: + self.Vk = Vk + self.ndof = len([*tb_model.values()][0]) + self.guess = guess + if self.dim == 0: + self.hamiltonians_0 = tb_model[()] + self.H_int = int_model[()] + + def random_guess(self, vectors): + """ + Generate random guess. + + Parameters: + ----------- + vectors : list of tuples + Hopping vectors for the mean-field corrections. + """ + if self.int_model is None: + scale = 0.1 + else: + scale = 0.1*(1+np.max(np.abs([*self.int_model.values()]))) + self.guess = utils.generate_guess( + vectors=vectors, + ndof=self.ndof, + scale=scale + ) + + def kgrid_evaluation(self, nk): + """ + Evaluates hamiltonians on a k-grid. + + Parameters: + ----------- + nk : int + Number of k-points along each direction. + """ + self.hamiltonians_0, self.ks = utils.kgrid_hamiltonian( + nk=nk, + hk=self.hk, + dim=self.dim, + return_ks=True + ) + self.H_int = utils.kgrid_hamiltonian(nk=nk, hk=self.Vk, dim=self.dim) + self.mf_k = utils.kgrid_hamiltonian( + nk=nk, + hk=utils.model2hk(self.guess), + dim=self.dim, + ) diff --git a/codes/solvers.py b/codes/solvers.py new file mode 100644 index 0000000000000000000000000000000000000000..ef2b49d1cd6e26ecfad4ed3ba883f134e55ea80c --- /dev/null +++ b/codes/solvers.py @@ -0,0 +1,106 @@ +import numpy as np +from . import utils +from .hf import updated_matrices, total_energy +from functools import partial + +def optimize(mf, cost_function, optimizer, optimizer_kwargs): + _ = optimizer( + cost_function, + mf, + **optimizer_kwargs + ) + +def finite_system_cost(mf, model): + shape = mf.shape + mf = utils.flat_to_matrix(utils.real_to_complex(mf), shape) + model.rho, model.mf_k = updated_matrices(mf_k=mf, model=model) + delta_mf = model.mf_k - mf + return utils.complex_to_real(utils.matrix_to_flat(delta_mf)) + +def finite_system_solver(model, optimizer, cost_function, optimizer_kwargs): + """ + Real-space solver for finite systems. + + Parameters: + ----------- + model : model.Model + Physical model containting interacting and non-interacting Hamiltonian. + optimizer : function + Optimization function. + optimizer_kwargs : dict + Extra arguments passed to optimizer. + """ + model.mf_k = model.guess[()] + initial_mf = utils.complex_to_real(utils.matrix_to_flat(model.mf_k)) + partial_cost = partial(cost_function, model=model) + optimize(initial_mf, partial_cost, optimizer, optimizer_kwargs) + +def real_space_cost(mf, model, shape): + mf = utils.flat_to_matrix(utils.real_to_complex(mf), shape) + mf_dict = {} + for i, key in enumerate(model.guess.keys()): + mf_dict[key] = mf[i] + mf = utils.kgrid_hamiltonian( + nk=model.nk, + hk=utils.model2hk(mf_dict), + dim=model.dim, + hermitian=False + ) + model.rho, model.mf_k = updated_matrices(mf_k=mf, model=model) + delta_mf = model.mf_k - mf + delta_mf = utils.hk2tb_model(delta_mf, model.vectors, model.ks) + delta_mf = np.array([*delta_mf.values()]) + return utils.complex_to_real(utils.matrix_to_flat(delta_mf)) + +def rspace_solver(model, optimizer, cost_function, optimizer_kwargs): + """ + Real-space solver for infinite systems. + + Parameters: + ----------- + model : model.Model + Physical model containting interacting and non-interacting Hamiltonian. + optimizer : function + Optimization function. + optimizer_kwargs : dict + Extra arguments passed to optimizer. + """ + model.kgrid_evaluation(nk=model.nk) + initial_mf = np.array([*model.guess.values()]) + shape = initial_mf.shape + initial_mf = utils.complex_to_real(utils.matrix_to_flat(initial_mf)) + partial_cost = partial(cost_function, model=model, shape=shape) + optimize(initial_mf, partial_cost, optimizer, optimizer_kwargs) + +def kspace_cost(mf, model): + mf = utils.flat_to_matrix(utils.real_to_complex(mf), model.mf_k.shape) + model.rho, model.mf_k = updated_matrices(mf_k=mf, model=model) + delta_mf = model.mf_k - mf + return utils.complex_to_real(utils.matrix_to_flat(delta_mf)) + +def kspace_totalenergy_cost(mf, model): + mf = utils.flat_to_matrix(utils.real_to_complex(mf), model.mf_k.shape) + model.rho, model.mf_k = updated_matrices(mf_k=mf, model=model) + return total_energy( + model.hamiltonians_0 + model.mf_k, + model.rho, + ) + +def kspace_solver(model, optimizer, cost_function, optimizer_kwargs): + """ + k-space solver. + + Parameters: + ----------- + model : model.Model + Physical model containting interacting and non-interacting Hamiltonian. + optimizer : function + Optimization function. + optimizer_kwargs : dict + Extra arguments passed to optimizer. + """ + model.kgrid_evaluation(nk=model.nk) + initial_mf = model.mf_k + initial_mf = utils.complex_to_real(utils.matrix_to_flat(initial_mf)) + partial_cost = partial(cost_function, model=model) + optimize(initial_mf, partial_cost, optimizer, optimizer_kwargs) diff --git a/codes/utils.py b/codes/utils.py index 3c9f44da2d8d59358a9a398654e3e2e42d82db1f..442437d3f29c2b54abd2a9071d27a3f6bac69dc8 100644 --- a/codes/utils.py +++ b/codes/utils.py @@ -1,7 +1,7 @@ import numpy as np import kwant -from itertools import product from scipy.sparse import coo_array +from itertools import product import inspect from copy import copy @@ -113,6 +113,11 @@ def builder2tb_model(builder, params={}, return_data=False): .toarray() .T.conj() ) + else: + # Hopping vector in the opposite direction + tb_model[tuple(-b_dom)] += coo_array( + (data, (row, col)), shape=(norbs_tot, norbs_tot) + ).toarray().T.conj() else: tb_model[tuple(b_dom)] = coo_array( (data, (row, col)), shape=(norbs_tot, norbs_tot) @@ -123,6 +128,10 @@ def builder2tb_model(builder, params={}, return_data=False): .toarray() .T.conj() ) + else: + tb_model[tuple(-b_dom)] = coo_array( + (data, (row, col)), shape=(norbs_tot, norbs_tot) + ).toarray().T.conj() if return_data: data = {} @@ -133,32 +142,53 @@ def builder2tb_model(builder, params={}, return_data=False): return tb_model -def dict2hk(tb_dict): +def model2hk(tb_model): """ Build Bloch Hamiltonian. + Paramters: + ---------- + nk : int + Number of k-points along each direction. + tb_model : dictionary + Must have the following structure: + - Keys are tuples for each hopping vector (in units of lattice vectors). + - Values are hopping matrices. + return_ks : bool + Return k-points. + + Returns: + -------- + ham : nd.array + Hamiltonian evaluated on a k-point grid from k-points + along each direction evaluated from zero to 2*pi. + The indices are ordered as [k_1, ... , k_n, i, j], where + `k_m` corresponding to the k-point element along each + direction and `i` and `j` are the internal degrees of freedom. + ks : 1D-array + List of k-points over all directions. Only returned if `return_ks=True`. + Returns: -------- bloch_ham : function Evaluates the Hamiltonian at a given k-point. """ + assert ( + len(next(iter(tb_model))) > 0 + ), "Zero-dimensional system. The Hamiltonian is simply tb_model[()]." def bloch_ham(k): ham = 0 - for vector in tb_dict.keys(): - ham += tb_dict[vector] * np.exp( - 1j * np.dot(k, np.array(vector, dtype=float)) + for vector in tb_model.keys(): + ham += tb_model[vector] * np.exp( + -1j * np.dot(k, np.array(vector, dtype=float)) ) - if np.linalg.norm(np.array(vector)) > 0: - ham += tb_dict[vector].T.conj() * np.exp( - -1j * np.dot(k, np.array(vector)) - ) return ham return bloch_ham -def kgrid_hamiltonian(nk, tb_model, return_ks=False): +def kgrid_hamiltonian(nk, hk, dim, return_ks=False, hermitian=True): """ Evaluates Hamiltonian on a k-point grid. @@ -166,12 +196,10 @@ def kgrid_hamiltonian(nk, tb_model, return_ks=False): ---------- nk : int Number of k-points along each direction. - tb_model : dictionary - Must have the following structure: - - Keys are tuples for each hopping vector (in units of lattice vectors). - - Values are hopping matrices. + hk : function + Calculates the Hamiltonian at a given k-point. return_ks : bool - Return k-points. + If `True`, returns k-points. Returns: -------- @@ -184,15 +212,6 @@ def kgrid_hamiltonian(nk, tb_model, return_ks=False): ks : 1D-array List of k-points over all directions. Only returned if `return_ks=True`. """ - dim = len(next(iter(tb_model))) - if dim == 0: - if return_ks: - return syst[next(iter(tb_model))], None - else: - return syst[next(iter(tb_model))] - else: - hk = dict2hk(tb_model) - ks = 2 * np.pi * np.linspace(0, 1, nk, endpoint=False) k_pts = np.tile(ks, dim).reshape(dim, nk) @@ -201,6 +220,10 @@ def kgrid_hamiltonian(nk, tb_model, return_ks=False): for k in product(*k_pts): ham.append(hk(k)) ham = np.array(ham) + if hermitian: + assert np.allclose( + ham, np.transpose(ham, (0, 2, 1)).conj() + ), "Tight-binding provided is non-Hermitian. Not supported yet" shape = (*[nk] * dim, ham.shape[-1], ham.shape[-1]) if return_ks: return ham.reshape(*shape), ks @@ -237,14 +260,12 @@ def build_interacting_syst(builder, lattice, func_onsite, func_hop, max_neighbor return int_builder -def generate_guess(nk, tb_model, int_model, scale=0.1): +def generate_guess(vectors, ndof, scale=0.1): """ - nk : int - Number of k-points along each direction. - tb_model : dict - Tight-binding model of non-interacting systems. - int_model : dict - Tight-binding model for interacting Hamiltonian. + vectors : list + List of hopping vectors. + ndof : int + Number internal degrees of freedom (orbitals), scale : float The scale of the guess. Maximum absolute value of each element of the guess. @@ -253,22 +274,42 @@ def generate_guess(nk, tb_model, int_model, scale=0.1): guess : nd-array Guess evaluated on a k-point grid. """ - ndof = tb_model[next(iter(tb_model))].shape[-1] guess = {} - vectors = [*tb_model.keys(), *int_model.keys()] for vector in vectors: - amplitude = np.random.rand(ndof, ndof) - phase = 2 * np.pi * np.random.rand(ndof, ndof) - rand_hermitian = amplitude * np.exp(1j * phase) - if np.linalg.norm(np.array(vector)): - rand_hermitian += rand_hermitian.T.conj() - rand_hermitian /= 2 - guess[vector] = rand_hermitian + if vector not in guess.keys(): + amplitude = scale * np.random.rand(ndof, ndof) + phase = 2 * np.pi * np.random.rand(ndof, ndof) + rand_hermitian = amplitude * np.exp(1j * phase) + if np.linalg.norm(np.array(vector)) == 0: + rand_hermitian += rand_hermitian.T.conj() + rand_hermitian /= 2 + guess[vector] = rand_hermitian + else: + guess[vector] = rand_hermitian + guess[tuple(-np.array(vector))] = rand_hermitian.T.conj() + + return guess + + +def generate_vectors(cutoff, dim): + """ + Generates hopping vectors up to a cutoff. - return kgrid_hamiltonian(nk, guess) * scale + Parameters: + ----------- + cutoff : int + Maximum distance along each direction. + dim : int + Dimension of the vectors. + Returns: + -------- + List of hopping vectors. + """ + return [*product(*([[*range(-cutoff, cutoff + 1)]] * dim))] -def hk2tb_model(hk, tb_model, int_model, ks=None): + +def hk2tb_model(hk, hopping_vecs, ks=None): """ Extract hopping matrices from Bloch Hamiltonian. @@ -289,9 +330,6 @@ def hk2tb_model(hk, tb_model, int_model, ks=None): TIght-binding model of Hartree-Fock solution. """ if ks is not None: - hopping_vecs = np.unique( - np.array([*tb_model.keys(), *int_model.keys()]), axis=0 - ) ndim = len(hk.shape) - 2 dk = np.diff(ks)[0] nk = len(ks) @@ -337,3 +375,50 @@ def calc_gap(vals, E_F): emax = np.max(vals[vals <= E_F]) emin = np.min(vals[vals > E_F]) return np.abs(emin - emax) + + +def matrix_to_flat(matrix): + """ + Flatten the upper triangle of a collection of matrices. + + Parameters: + ----------- + matrix : nd-array + Array with shape (..., n, n) + """ + return matrix[..., *np.triu_indices(matrix.shape[-1])].flatten() + +def flat_to_matrix(flat, shape): + """ + Undo `matrix_to_flat`. + + Parameters: + ----------- + flat : 1d-array + Output from `matrix_to_flat`. + shape : 1d-array + Shape of the input from `matrix_to_flat`. + """ + matrix = np.zeros(shape, dtype=complex) + matrix[..., *np.triu_indices(shape[-1])] = flat.reshape(*shape[:-2], -1) + indices = np.arange(shape[-1]) + diagonal = matrix[..., indices, indices] + matrix += np.moveaxis(matrix, -1, -2).conj() + matrix[..., indices, indices] -= diagonal + return matrix + +def complex_to_real(z): + """ + Split real and imaginary parts of a complex array. + + Parameters: + ----------- + z : array + """ + return np.concatenate((np.real(z), np.imag(z))) + +def real_to_complex(z): + """ + Undo `complex_to_real`. + """ + return z[:len(z)//2] + 1j * z[len(z)//2:] \ No newline at end of file diff --git a/examples/1d_hubbard.ipynb b/examples/1d_hubbard.ipynb index 79ef0d60d10db5b7ec5377a14ddc702e40e44c31..19c2de176a5ef12105cf59784f6edaa0c94d9c93 100644 --- a/examples/1d_hubbard.ipynb +++ b/examples/1d_hubbard.ipynb @@ -9,10 +9,9 @@ }, "outputs": [], "source": [ - "import kwant\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from codes import utils, hf, kwant_examples\n", + "from codes import utils, model, interface, solvers\n", "from tqdm import tqdm" ] }, @@ -40,10 +39,7 @@ "outputs": [], "source": [ "hopp = np.kron(np.array([[0, 1], [0, 0]]), np.eye(2))\n", - "tb_model = {\n", - " (0,) : hopp + hopp.T.conj(),\n", - " (1,) : hopp,\n", - "}" + "tb_model = {(0,): hopp + hopp.T.conj(), (1,): hopp, (-1,): hopp.T.conj()}" ] }, { @@ -74,8 +70,9 @@ "source": [ "# Set number of k-points\n", "nk = 100\n", + "hk = utils.model2hk(tb_model=tb_model)\n", "# Compute Hamiltonian on the corresponding k-point grid\n", - "hamiltonians_0, ks = utils.kgrid_hamiltonian(nk, tb_model, return_ks=True)\n", + "hamiltonians_0, ks = utils.kgrid_hamiltonian(nk=nk, hk=hk, dim=1, return_ks=True)\n", "# Perform diagonalization\n", "vals, vecs = np.linalg.eigh(hamiltonians_0)\n", "# Plot data\n", @@ -97,38 +94,32 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 4, "id": "41bd9f60-8f29-4e7c-a0c4-a0bbf66445b2", "metadata": {}, "outputs": [], "source": [ - "def compute_gap(\n", - " tb_model,\n", - " int_model,\n", - " nk,\n", - " nk_dense,\n", - " filling=2\n", - "):\n", - " # Generate guess on the same k-point grid\n", - " guess = utils.generate_guess(nk, tb_model, int_model, scale=1)\n", - "\n", + "from scipy import optimize\n", + "def compute_gap(model, nk, nk_dense, filling=2):\n", " # Find groundstate Hamiltonian on the same grid\n", - " mf_model = hf.find_groundstate_ham(\n", - " int_model=int_model,\n", + " mf_model = interface.find_groundstate_ham(\n", + " model,\n", " filling=filling,\n", - " tb_model=tb_model,\n", - " guess=guess,\n", " nk=nk,\n", - " tol=1e-8\n", + " solver=solvers.rspace_solver,\n", + " cost_function=solvers.real_space_cost,\n", + " optimizer_kwargs={'M':0, 'w0':0.1}\n", " )\n", " # Generate Hamiltonian on a denser k-point grid\n", - " hk = utils.kgrid_hamiltonian(nk_dense, mf_model)\n", + " mf_k = utils.kgrid_hamiltonian(\n", + " nk=nk_dense, hk=utils.model2hk(tb_model=mf_model), dim=model.dim\n", + " )\n", " # Diagonalize groundstate Hamiltonian\n", - " vals, vecs = np.linalg.eigh(hk)\n", + " vals, _ = np.linalg.eigh(mf_k)\n", " # Extract dense-grid Fermi energy\n", " E_F = utils.get_fermi_energy(vals, filling)\n", " gap = utils.calc_gap(vals, E_F)\n", - " return gap, vals - E_F" + " return gap, vals# - E_F" ] }, { @@ -150,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 5, "id": "32b9e7c5-db12-44f9-930c-21e5494404b8", "metadata": { "tags": [] @@ -167,11 +158,11 @@ " for U in tqdm(Us):\n", " # onsite interactions\n", " int_model = {\n", - " (0,) : U * np.kron(np.ones((2, 2)), np.eye(2))\n", - " }\n", + " (0,): U * np.kron(np.eye(2), np.ones((2, 2))),\n", + " }\n", + " full_model = model.Model(tb_model=tb_model, int_model=int_model)\n", " _gap, _vals = compute_gap(\n", - " tb_model=tb_model,\n", - " int_model=int_model,\n", + " model=full_model,\n", " nk=nk,\n", " nk_dense=nk_dense,\n", " )\n", @@ -182,7 +173,7 @@ }, { "cell_type": "code", - "execution_count": 126, + "execution_count": 6, "id": "6a8c08a9-7e31-420b-b6b4-709abfb26793", "metadata": { "tags": [] @@ -192,20 +183,27 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 20/20 [00:31<00:00, 1.60s/it]\n" + " 0%| | 0/20 [00:00<?, ?it/s]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [00:14<00:00, 1.42it/s]\n" ] } ], "source": [ "# Interaction strengths\n", - "Us = np.linspace(0, 20, 20, endpoint=True)\n", - "nk, nk_dense = 20, 100\n", + "Us = np.linspace(0.01, 10, 20, endpoint=True)\n", + "nk, nk_dense = 40, 100\n", "gap, vals = compute_phase_diagram(Us=Us, nk=nk, nk_dense=nk_dense)" ] }, { "cell_type": "code", - "execution_count": 127, + "execution_count": 7, "id": "e17fc96c-c463-4e1f-8250-c254d761b92a", "metadata": {}, "outputs": [], @@ -213,11 +211,12 @@ "import xarray as xr\n", "\n", "ds = xr.Dataset(\n", - " data_vars=dict(\n", - " vals=([\"Us\", \"ks\", \"n\"], vals),\n", - " gap=([\"Us\"], gap)\n", + " data_vars=dict(vals=([\"Us\", \"ks\", \"n\"], vals), gap=([\"Us\"], gap)),\n", + " coords=dict(\n", + " Us=Us,\n", + " ks=np.linspace(0, 2 * np.pi, nk_dense),\n", + " n=np.arange(vals.shape[-1])\n", " ),\n", - " coords=dict(Us=Us, ks=np.linspace(0, 2 * np.pi, nk_dense), n=np.arange(vals.shape[-1])),\n", ")" ] }, @@ -226,18 +225,19 @@ "id": "5a87dcc1-208b-4602-abad-a870037ec95f", "metadata": {}, "source": [ + "\n", "We observe that as the interaction strength increases, a gap opens due to the antiferromagnetic ordering." ] }, { "cell_type": "code", - "execution_count": 128, + "execution_count": 8, "id": "868cf368-45a0-465e-b042-6182ff8b6998", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 640x480 with 2 Axes>" ] @@ -247,12 +247,12 @@ } ], "source": [ - "ds.vals.plot.scatter(x='ks', hue='Us', ec=None, s=5)\n", - "plt.axhline(0, ls='--', c='k')\n", - "plt.xticks([0, np.pi, 2 * np.pi], ['$0$', '$\\pi$', '$2\\pi$'])\n", + "ds.vals.plot.scatter(x=\"ks\", hue=\"Us\", ec=None, s=5)\n", + "plt.axhline(0, ls=\"--\", c=\"k\")\n", + "plt.xticks([0, np.pi, 2 * np.pi], [\"$0$\", \"$\\pi$\", \"$2\\pi$\"])\n", "plt.xlim(0, 2 * np.pi)\n", - "plt.ylabel('$E - E_F$')\n", - "plt.xlabel('$k / a$')\n", + "plt.ylabel(\"$E - E_F$\")\n", + "plt.xlabel(\"$k / a$\")\n", "plt.show()" ] }, @@ -270,13 +270,13 @@ }, { "cell_type": "code", - "execution_count": 129, + "execution_count": 18, "id": "ac2eb725-f3bd-4d5b-a509-85d0d0071958", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 640x480 with 1 Axes>" ] @@ -301,33 +301,33 @@ }, { "cell_type": "code", - "execution_count": 131, + "execution_count": 10, "id": "5499ea62-cf1b-4a13-8191-ebb73ea38704", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array(1.00352528)" + "array(1.00497633)" ] }, - "execution_count": 131, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ds.gap.polyfit(dim='Us', deg=1).polyfit_coefficients[0].data" + "ds.gap.polyfit(dim=\"Us\", deg=1).polyfit_coefficients[0].data" ] }, { "cell_type": "code", - "execution_count": 132, + "execution_count": 11, "id": "0cb395cd-84d1-49b4-89dd-da7a2d09c8d0", "metadata": {}, "outputs": [], "source": [ - "ds.to_netcdf('./data/1d_hubbard_example.nc')" + "ds.to_netcdf(\"./data/1d_hubbard_example.nc\")" ] } ], @@ -347,7 +347,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.11.6" }, "widgets": { "application/vnd.jupyter.widget-state+json": { diff --git a/examples/1d_hubbard_totalenergy.ipynb b/examples/1d_hubbard_totalenergy.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f31dd4d85516b08db2eef97c8e70b27213a06485 --- /dev/null +++ b/examples/1d_hubbard_totalenergy.ipynb @@ -0,0 +1,355 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "cb509096-42c6-4a45-8dc4-a8eed3116e67", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from codes import utils, model, interface, solvers\n", + "from tqdm import tqdm" + ] + }, + { + "cell_type": "markdown", + "id": "396d935c-146e-438c-878b-04ed70aa6d63", + "metadata": {}, + "source": [ + "To simulate infinite systems, we provide the corresponding tight-binding model.\n", + "\n", + "We exemplify this construction by computing the ground state of an infinite spinful chain with onsite interactions.\n", + "\n", + "Because the ground state is an antiferromagnet, so we must build a two-atom cell. We name the two sublattices, $A$ and $B$. The Hamiltonian in is:\n", + "$$\n", + "H_0 = \\sum_i c_{i, B}^{\\dagger}c_{i, A} + c_{i, A}^{\\dagger}c_{i+1, B} + h.c.\n", + "$$\n", + "We write down the spinful by simply taking $H_0(k) \\otimes \\mathbb{1}$." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5529408c-fb7f-4732-9a17-97b0718dab29", + "metadata": {}, + "outputs": [], + "source": [ + "hopp = np.kron(np.array([[0, 1], [0, 0]]), np.eye(2))\n", + "tb_model = {(0,): hopp + hopp.T.conj(), (1,): hopp, (-1,): hopp.T.conj()}" + ] + }, + { + "cell_type": "markdown", + "id": "050f5435-6699-44bb-b31c-8ef3fa2264d4", + "metadata": {}, + "source": [ + "To build the tight-binding model, we need to generate a Hamiltonian on a k-point and the corresponding hopping vectors to generate a guess. We then verify the spectrum and see that the bands indeed consistent of two bands due to the Brillouin zone folding." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b39a2976-7c35-4670-83ef-12157bd3fc0e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set number of k-points\n", + "nk = 100\n", + "hk = utils.model2hk(tb_model=tb_model)\n", + "# Compute Hamiltonian on the corresponding k-point grid\n", + "hamiltonians_0, ks = utils.kgrid_hamiltonian(nk=nk, hk=hk, dim=1, return_ks=True)\n", + "# Perform diagonalization\n", + "vals, vecs = np.linalg.eigh(hamiltonians_0)\n", + "# Plot data\n", + "plt.plot(ks, vals, c=\"k\")\n", + "plt.xticks([0, np.pi, 2 * np.pi], [\"$0$\", \"$\\pi$\", \"$2\\pi$\"])\n", + "plt.xlim(0, 2 * np.pi)\n", + "plt.ylabel(\"$E - E_F$\")\n", + "plt.xlabel(\"$k / a$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6ec53b08-053b-4aad-87a6-525dd7f61687", + "metadata": {}, + "source": [ + "Here, in the workflow to find the ground state, we use a helper function to build the initial guess. because we don't need a dense k-point grid in the self-consistent loop, we compute the spectrum later on a denser k-point grid." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "41bd9f60-8f29-4e7c-a0c4-a0bbf66445b2", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy import optimize\n", + "def compute_gap(model, nk, nk_dense, filling=2):\n", + " # Find groundstate Hamiltonian on the same grid\n", + " mf_model = interface.find_groundstate_ham(\n", + " model,\n", + " filling=filling,\n", + " nk=nk,\n", + " solver=solvers.rspace_solver,\n", + " cost_function=solvers.real_space_cost,\n", + " optimizer_kwargs={'M':0, 'w0':0.1}\n", + " )\n", + " # Generate Hamiltonian on a denser k-point grid\n", + " mf_k = utils.kgrid_hamiltonian(\n", + " nk=nk_dense, hk=utils.model2hk(tb_model=mf_model), dim=model.dim\n", + " )\n", + " # Diagonalize groundstate Hamiltonian\n", + " vals, _ = np.linalg.eigh(mf_k)\n", + " # Extract dense-grid Fermi energy\n", + " E_F = utils.get_fermi_energy(vals, filling)\n", + " gap = utils.calc_gap(vals, E_F)\n", + " return gap, vals - E_F" + ] + }, + { + "cell_type": "markdown", + "id": "dc59e440-1289-4735-9ae8-b04d0d13c94a", + "metadata": {}, + "source": [ + "Finally, we compute the eigen0alues for a set of Ualues of $U$. For this case, since the interaction is onsite only, the interaction matrix is simply\n", + "$$\n", + "H_{int} =\n", + "\\left(\\begin{array}{cccc}\n", + " U & U & 0 & 0\\\\\n", + " U & U & 0 & 0\\\\\n", + " 0 & 0 & U & U\\\\\n", + " 0 & 0 & U & U\n", + "\\end{array}\\right)~.\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "32b9e7c5-db12-44f9-930c-21e5494404b8", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def compute_phase_diagram(\n", + " Us,\n", + " nk,\n", + " nk_dense,\n", + "):\n", + " gap = []\n", + " vals = []\n", + " for U in tqdm(Us):\n", + " # onsite interactions\n", + " int_model = {\n", + " (0,): U * np.kron(np.ones((2, 2)), np.eye(2)),\n", + " }\n", + " full_model = model.Model(tb_model=tb_model, int_model=int_model)\n", + " _gap, _vals = compute_gap(\n", + " model=full_model,\n", + " nk=nk,\n", + " nk_dense=nk_dense,\n", + " )\n", + " gap.append(_gap)\n", + " vals.append(_vals)\n", + " return np.asarray(gap, dtype=float), np.asarray(vals)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "6a8c08a9-7e31-420b-b6b4-709abfb26793", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [00:32<00:00, 1.63s/it]\n" + ] + } + ], + "source": [ + "# Interaction strengths\n", + "Us = np.linspace(0.5, 10, 20, endpoint=True)\n", + "nk, nk_dense = 40, 100\n", + "gap, vals = compute_phase_diagram(Us=Us, nk=nk, nk_dense=nk_dense)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "e17fc96c-c463-4e1f-8250-c254d761b92a", + "metadata": {}, + "outputs": [], + "source": [ + "import xarray as xr\n", + "\n", + "ds = xr.Dataset(\n", + " data_vars=dict(vals=([\"Us\", \"ks\", \"n\"], vals), gap=([\"Us\"], gap)),\n", + " coords=dict(\n", + " Us=Us,\n", + " ks=np.linspace(0, 2 * np.pi, nk_dense),\n", + " n=np.arange(vals.shape[-1])\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "5a87dcc1-208b-4602-abad-a870037ec95f", + "metadata": {}, + "source": [ + "\n", + "We observe that as the interaction strength increases, a gap opens due to the antiferromagnetic ordering." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "868cf368-45a0-465e-b042-6182ff8b6998", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds.vals.plot.scatter(x=\"ks\", hue=\"Us\", ec=None, s=5)\n", + "plt.axhline(0, ls=\"--\", c=\"k\")\n", + "plt.xticks([0, np.pi, 2 * np.pi], [\"$0$\", \"$\\pi$\", \"$2\\pi$\"])\n", + "plt.xlim(0, 2 * np.pi)\n", + "plt.ylabel(\"$E - E_F$\")\n", + "plt.xlabel(\"$k / a$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0761ed33-c1bb-4f12-be65-cb68629f58b9", + "metadata": {}, + "source": [ + "The Hartree-Fock dispersion should follow (see [these notes](https://www.cond-mat.de/events/correl11/manuscript/Lechermann.pdf))\n", + "$$\n", + "\\epsilon_{HF}^{\\sigma}(\\mathbf{k}) = \\epsilon(\\mathbf{k}) + U \\left(\\frac{n}{2} + \\sigma m\\right)\n", + "$$\n", + "where $m=(\\langle n_{i\\uparrow} \\rangle - \\langle n_{i\\downarrow} \\rangle) / 2$ is the magnetization per atom and $n = \\sum_i \\langle n_i \\rangle$ is the total number of atoms per cell. Thus, for the antiferromagnetic groundstate, $m=1/2$ and $n=2$. The gap thus should be $\\Delta=U$. And we can confirm it indeed follows the expected trend." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "ac2eb725-f3bd-4d5b-a509-85d0d0071958", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds.gap.plot()\n", + "plt.plot(ds.Us, ds.Us)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "06e0d356-558e-40e3-8287-d7d2e0bee8cd", + "metadata": {}, + "source": [ + "We can also fit " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5499ea62-cf1b-4a13-8191-ebb73ea38704", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(1.00497633)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds.gap.polyfit(dim=\"Us\", deg=1).polyfit_coefficients[0].data" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0cb395cd-84d1-49b4-89dd-da7a2d09c8d0", + "metadata": {}, + "outputs": [], + "source": [ + "ds.to_netcdf(\"./data/1d_hubbard_example.nc\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/data/1d_hubbard_example.nc b/examples/data/1d_hubbard_example.nc index 7ea1d4f36266ed22a7b8a12472c15f3f9b41c02b..8da6096aced9004ef097743899b4b26c42ee0f94 100644 Binary files a/examples/data/1d_hubbard_example.nc and b/examples/data/1d_hubbard_example.nc differ diff --git a/examples/data/diatomic_molecule_example.nc b/examples/data/diatomic_molecule_example.nc index 72606ebef5db3c368507c337ae52eae4c014103b..be8b9027fa9ae7dba394759737bb95416249b977 100644 Binary files a/examples/data/diatomic_molecule_example.nc and b/examples/data/diatomic_molecule_example.nc differ diff --git a/examples/data/graphene_example.nc b/examples/data/graphene_example.nc index b779aefd53d518d3e385e9c75483c7a6251c1663..d17cd9d99826246714652acd845e60284a563ea3 100644 Binary files a/examples/data/graphene_example.nc and b/examples/data/graphene_example.nc differ diff --git a/examples/data/kspace_potential.nc b/examples/data/kspace_potential.nc new file mode 100644 index 0000000000000000000000000000000000000000..dd52d824f5eb726aedf030a600f2b288dd9e4037 Binary files /dev/null and b/examples/data/kspace_potential.nc differ diff --git a/examples/diatomic_molecule.ipynb b/examples/diatomic_molecule.ipynb index 4b6a18f515a72166e1e4361160db4829ccfff1f1..3f893c25048a8a03069a4502acf4b697666a15d2 100644 --- a/examples/diatomic_molecule.ipynb +++ b/examples/diatomic_molecule.ipynb @@ -9,10 +9,9 @@ }, "outputs": [], "source": [ - "import kwant\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from codes import utils, hf, kwant_examples\n", + "from codes import utils, model, interface, solvers\n", "from tqdm import tqdm\n", "from itertools import product" ] @@ -98,27 +97,25 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "id": "41bd9f60-8f29-4e7c-a0c4-a0bbf66445b2", "metadata": {}, "outputs": [], "source": [ "def compute_vals(\n", - " tb_model,\n", - " int_model,\n", + " model,\n", " filling=2,\n", "):\n", "\n", " # Run SCF loop to find groundstate Hamiltonian.\n", - " scf_model = hf.find_groundstate_ham(\n", - " tb_model=tb_model,\n", - " int_model=int_model,\n", + " scf_model = interface.find_groundstate_ham(\n", + " model,\n", " filling=filling,\n", - " tol=1e-4,\n", - " nk=2,\n", + " solver=solvers.finite_system_solver,\n", + " optimizer_kwargs={'w0':1e-3}\n", " )\n", " # Diagonalize groundstate Hamiltonian.\n", - " vals, vecs = np.linalg.eigh(scf_model[next(iter(scf_model))])\n", + " vals, _ = np.linalg.eigh(scf_model[()])\n", " # Extract Fermi energy.\n", " E_F = utils.get_fermi_energy(vals, filling)\n", " return vals - E_F" @@ -154,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "id": "32b9e7c5-db12-44f9-930c-21e5494404b8", "metadata": { "tags": [] @@ -176,14 +173,11 @@ "\n", " vals = []\n", " for U in tqdm(Us):\n", - " gap_U = []\n", " vals_U = []\n", " for V in Vs:\n", " int_model = {(): U * onsite_int + V * nn_int}\n", - " _vals = compute_vals(\n", - " tb_model=tb_model,\n", - " int_model=int_model,\n", - " )\n", + " full_model = model.Model(tb_model=tb_model, int_model=int_model)\n", + " _vals = compute_vals(full_model)\n", " vals_U.append(_vals)\n", " vals.append(vals_U)\n", " return np.asarray(vals)" @@ -191,7 +185,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "id": "6a8c08a9-7e31-420b-b6b4-709abfb26793", "metadata": { "tags": [] @@ -201,7 +195,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 20/20 [00:17<00:00, 1.13it/s]\n" + " 0%| | 0/20 [00:00<?, ?it/s]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [00:15<00:00, 1.28it/s]\n" ] } ], @@ -214,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "id": "e17fc96c-c463-4e1f-8250-c254d761b92a", "metadata": {}, "outputs": [], @@ -239,13 +240,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 14, "id": "868cf368-45a0-465e-b042-6182ff8b6998", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 1300x300 with 5 Axes>" ] @@ -256,13 +257,13 @@ ], "source": [ "# New result 0D\n", - "ds.vals.plot(col='n')\n", + "ds.vals.plot(x='Us', y='Vs', col='n')\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 15, "id": "0cb395cd-84d1-49b4-89dd-da7a2d09c8d0", "metadata": {}, "outputs": [], @@ -287,7 +288,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.11.6" }, "widgets": { "application/vnd.jupyter.widget-state+json": { diff --git a/examples/graphene_extended_hubbard.ipynb b/examples/graphene_extended_hubbard.ipynb index e5aa8f630161a2ce014a9f7e080a08846bbf0b5a..9627e7f2c4adada5a272754a88b8e38887804147 100644 --- a/examples/graphene_extended_hubbard.ipynb +++ b/examples/graphene_extended_hubbard.ipynb @@ -12,7 +12,7 @@ "import kwant\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from codes import utils, hf, kwant_examples\n", + "from codes import utils, hf, kwant_examples, model, interface, solvers\n", "from tqdm import tqdm" ] }, @@ -67,45 +67,55 @@ { "cell_type": "code", "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "params = dict(U=1, V=1)\n", + "int_model = utils.builder2tb_model(int_builder, params)\n", + "mf_model = model.Model(tb_model, int_model=int_model)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, "id": "41bd9f60-8f29-4e7c-a0c4-a0bbf66445b2", "metadata": {}, "outputs": [], "source": [ + "from scipy import optimize\n", + "\n", "def compute_gap(\n", - " tb_model,\n", - " int_model,\n", + " model,\n", " nk,\n", " nk_dense,\n", - " U,\n", " filling=2,\n", " guess=None,\n", "):\n", - " scale = np.max(np.array([*tb_model.values()]))\n", - " # Generate guess on the same grid\n", - " if guess is None:\n", - " guess = utils.generate_guess(nk, tb_model, int_model, scale=scale)\n", - " else:\n", - " guess += utils.generate_guess(\n", - " nk, tb_model, int_model, scale=scale\n", - " )\n", + "\n", + " model.guess = guess\n", "\n", " # Find groundstate Hamiltonian on the same grid\n", - " mf_model, mf = hf.find_groundstate_ham(\n", - " tb_model=tb_model,\n", - " int_model=int_model,\n", + " mf_model, guess = interface.find_groundstate_ham(\n", + " model,\n", " filling=filling,\n", " nk=nk,\n", - " guess=guess,\n", " return_mf=True,\n", + " optimizer_kwargs={}\n", + " )\n", + "\n", + " mf_k = utils.kgrid_hamiltonian( # only used for diagonalization to get gap\n", + " nk=nk_dense,\n", + " hk=utils.model2hk(tb_model=mf_model),\n", + " dim=2\n", " )\n", - " # Compute groundstate Hamiltonian on a dense grid\n", - " scf_ham = utils.kgrid_hamiltonian(nk_dense, mf_model)\n", " # Diagonalize groundstate Hamiltonian\n", - " vals, vecs = np.linalg.eigh(scf_ham)\n", + " vals, _ = np.linalg.eigh(mf_k)\n", " # Extract dense-grid Fermi energy\n", " E_F = utils.get_fermi_energy(vals, filling)\n", " gap = utils.calc_gap(vals, E_F)\n", - " return gap, mf" + "\n", + " # the guess was kind of unclear\n", + " return gap, guess" ] }, { @@ -118,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 12, "id": "32b9e7c5-db12-44f9-930c-21e5494404b8", "metadata": { "tags": [] @@ -132,12 +142,13 @@ " gap_U = []\n", " for V in Vs:\n", " params = dict(U=U, V=V)\n", + " int_model = utils.builder2tb_model(int_builder, params)\n", + " mf_model = model.Model(tb_model, int_model=int_model)\n", " _gap, guess = compute_gap(\n", - " tb_model=tb_model,\n", - " int_model=utils.builder2tb_model(int_builder, params),\n", + " model=mf_model,\n", " nk=nk,\n", " nk_dense=nk_dense,\n", - " guess=guess, U=U\n", + " guess=guess,\n", " )\n", " gap_U.append(_gap)\n", " gap.append(gap_U)\n", @@ -154,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "id": "6a8c08a9-7e31-420b-b6b4-709abfb26793", "metadata": { "tags": [] @@ -164,28 +175,29 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 20/20 [53:16<00:00, 159.83s/it]\n" + "100%|██████████| 10/10 [00:15<00:00, 1.59s/it]\n" ] } ], "source": [ "# Generate dense-grid k-points\n", "# Interaction strengths\n", - "nk=15\n", - "nk_dense=30\n", - "Us = np.linspace(0, 3, 20, endpoint=True)\n", - "Vs = np.linspace(0, 1.5, 20, endpoint=True)\n", + "nk = 9\n", + "nk_dense = 30\n", + "Us = np.linspace(0, 3, 10, endpoint=True)\n", + "Vs = np.linspace(0, 1.5, 10, endpoint=True)\n", "gap = compute_phase_diagram(Us, Vs, nk=nk, nk_dense=nk_dense)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 14, "id": "e17fc96c-c463-4e1f-8250-c254d761b92a", "metadata": {}, "outputs": [], "source": [ "import xarray as xr\n", + "\n", "gap_da = xr.DataArray(data=gap, coords=dict(Us=Us, Vs=Vs))" ] }, @@ -199,23 +211,52 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "101d04f3-f811-446d-a313-5a004eba2690", + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "<matplotlib.collections.QuadMesh at 0x7f946ef9d290>" + "<matplotlib.collections.QuadMesh at 0x130c85390>" ] }, - "execution_count": 8, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.log10(gap_da).plot(x=\"Us\", y=\"Vs\", vmin=-3, vmax=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4f71f6f2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.collections.QuadMesh at 0x13158f150>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "<Figure size 640x480 with 2 Axes>" ] @@ -225,17 +266,17 @@ } ], "source": [ - "gap_da.plot(x='Us', y='Vs')" + "np.log10(gap_da).plot(x=\"Us\", y=\"Vs\", vmin=-3, vmax=1)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "0cb395cd-84d1-49b4-89dd-da7a2d09c8d0", "metadata": {}, "outputs": [], "source": [ - "gap_da.to_netcdf('./data/graphene_example.nc')" + "gap_da.to_netcdf(\"./data/graphene_example.nc\")" ] } ], @@ -255,7 +296,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.11.6" }, "widgets": { "application/vnd.jupyter.widget-state+json": { diff --git a/examples/kspace_potential.ipynb b/examples/kspace_potential.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..09c120461b37efee204d99d10d712e3ae3fe364c --- /dev/null +++ b/examples/kspace_potential.ipynb @@ -0,0 +1,242 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "cb509096-42c6-4a45-8dc4-a8eed3116e67", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from codes import utils, hf, model\n", + "from tqdm import tqdm\n", + "from functools import partial" + ] + }, + { + "cell_type": "markdown", + "id": "396d935c-146e-438c-878b-04ed70aa6d63", + "metadata": {}, + "source": [ + "When the potential is infinite-range, it is more convenient to write it as $V=V(\\mathbf{k})$ than in tight-binding representation.\n", + "To exemplify this usage, we again use a 1D tight-binding model with two sublattices:\n", + "$$\n", + "H_0 = \\sum_{i,\\sigma} c_{i, B, \\sigma}^{\\dagger}c_{i, A, \\sigma} + c_{i, A, \\sigma}^{\\dagger}c_{i+1, B, \\sigma} + h.c.\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5529408c-fb7f-4732-9a17-97b0718dab29", + "metadata": {}, + "outputs": [], + "source": [ + "hopp = np.kron(np.array([[0, 1], [0, 0]]), np.eye(2))\n", + "tb_model = {(0,): hopp + hopp.T.conj(), (1,): hopp, (-1,): hopp.T.conj()}" + ] + }, + { + "cell_type": "markdown", + "id": "6ec53b08-053b-4aad-87a6-525dd7f61687", + "metadata": {}, + "source": [ + "And use the same worflow as before, except that now we increase the real-space cutoff of $V(\\mathbf{k})$ to second neighbors." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "41bd9f60-8f29-4e7c-a0c4-a0bbf66445b2", + "metadata": {}, + "outputs": [], + "source": [ + "def compute_gap(model, nk, nk_dense, filling=2):\n", + " # Find groundstate Hamiltonian on the same grid\n", + " mf_model = hf.find_groundstate_ham(\n", + " model,\n", + " filling=filling,\n", + " nk=nk,\n", + " cutoff_Vk=2,\n", + " )\n", + " # Generate Hamiltonian on a denser k-point grid\n", + " mf_k = utils.kgrid_hamiltonian(\n", + " nk=nk_dense, hk=utils.model2hk(tb_model=mf_model), dim=1\n", + " )\n", + " # Diagonalize groundstate Hamiltonian\n", + " vals, _ = np.linalg.eigh(mf_k)\n", + " # Extract dense-grid Fermi energy\n", + " E_F = utils.get_fermi_energy(vals, filling)\n", + " gap = utils.calc_gap(vals, E_F)\n", + " return gap, vals - E_F" + ] + }, + { + "cell_type": "markdown", + "id": "dc59e440-1289-4735-9ae8-b04d0d13c94a", + "metadata": {}, + "source": [ + "Finally, we define a potential\n", + "$$\n", + "V(\\mathbf{k}) = U \\frac{e^{-k}}{\\sqrt{1 + k^2}}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "73b6fb18", + "metadata": {}, + "outputs": [], + "source": [ + "def Vk(k, U):\n", + " return U * np.exp(-k[0]) / np.sqrt(1 + k[0]**2) * np.ones((4, 4))" + ] + }, + { + "cell_type": "markdown", + "id": "828b09a2", + "metadata": {}, + "source": [ + "And compute the spectrum as a function of the interaction strength $U$:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "32b9e7c5-db12-44f9-930c-21e5494404b8", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def compute_phase_diagram(\n", + " Us,\n", + " nk,\n", + " nk_dense,\n", + "):\n", + " gap = []\n", + " vals = []\n", + " for U in tqdm(Us):\n", + " # onsite interactions\n", + " full_model = model.Model(tb_model=tb_model, Vk=partial(Vk, U=U))\n", + " _gap, _vals = compute_gap(\n", + " model=full_model,\n", + " nk=nk,\n", + " nk_dense=nk_dense,\n", + " )\n", + " gap.append(_gap)\n", + " vals.append(_vals)\n", + " return np.asarray(gap, dtype=float), np.asarray(vals)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "6a8c08a9-7e31-420b-b6b4-709abfb26793", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 20/20 [00:15<00:00, 1.25it/s]\n" + ] + } + ], + "source": [ + "# Interaction strengths\n", + "Us = np.linspace(0.5, 20, 20, endpoint=True)\n", + "nk, nk_dense = 50, 100\n", + "gap, vals = compute_phase_diagram(Us=Us, nk=nk, nk_dense=nk_dense)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "e17fc96c-c463-4e1f-8250-c254d761b92a", + "metadata": {}, + "outputs": [], + "source": [ + "import xarray as xr\n", + "\n", + "ds = xr.Dataset(\n", + " data_vars=dict(vals=([\"Us\", \"ks\", \"n\"], vals), gap=([\"Us\"], gap)),\n", + " coords=dict(\n", + " Us=Us, ks=np.linspace(0, 2 * np.pi, nk_dense), n=np.arange(vals.shape[-1])\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "868cf368-45a0-465e-b042-6182ff8b6998", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds.vals.plot.scatter(x=\"ks\", hue=\"Us\", ec=None, s=5)\n", + "plt.axhline(0, ls=\"--\", c=\"k\")\n", + "plt.xticks([0, np.pi, 2 * np.pi], [\"$0$\", \"$\\pi$\", \"$2\\pi$\"])\n", + "plt.xlim(0, 2 * np.pi)\n", + "plt.ylabel(\"$E - E_F$\")\n", + "plt.xlabel(\"$k / a$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "0cb395cd-84d1-49b4-89dd-da7a2d09c8d0", + "metadata": {}, + "outputs": [], + "source": [ + "ds.to_netcdf(\"./data/kspace_potential.nc\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/tEnergyTest.ipynb b/examples/tEnergyTest.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..3eb8e471ec3fdc41dd72b0e739c313d78d243a4c --- /dev/null +++ b/examples/tEnergyTest.ipynb @@ -0,0 +1,161 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from codes import utils, model, interface, solvers, hf" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "U0 = 1\n", + "nk = 1001\n", + "filling = 2\n", + "\n", + "hopp = np.kron(np.array([[0, 1], [0, 0]]), np.eye(2))\n", + "tb_model = {(0,): hopp + hopp.T.conj(), (1,): hopp, (-1,): hopp.T.conj()}\n", + "\n", + "\n", + "def model_U(U):\n", + " int_model = {\n", + " (0,): U * np.kron(np.eye(2), np.ones((2, 2))),\n", + " }\n", + " return model.Model(tb_model=tb_model, int_model=int_model)\n", + "\n", + "\n", + "model0 = model_U(U0)\n", + "model0.vectors = [*model0.int_model.keys()]\n", + "model0.random_guess(model0.vectors)\n", + "model0.kgrid_evaluation(nk=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hamiltonians_0 = utils.kgrid_hamiltonian(\n", + " nk=nk, hk=utils.model2hk(tb_model=tb_model), dim=1\n", + ")\n", + "\n", + "\n", + "def groundstate(U):\n", + " _model=model_U(U)\n", + " tb_mf_k = interface.find_groundstate_ham(\n", + " _model,\n", + " filling=filling,\n", + " nk=nk,\n", + " solver=solvers.rspace_solver,\n", + " cost_function=solvers.real_space_cost,\n", + " return_kspace=True,\n", + " optimizer_kwargs={},\n", + " )\n", + " vals, vecs = np.linalg.eigh(tb_mf_k)\n", + " EF = utils.get_fermi_energy(vals, filling)\n", + " densityMatrix = hf.density_matrix(vals, vecs, EF)\n", + "\n", + " return tb_mf_k, densityMatrix, _model.H_int\n", + "\n", + "tb_mf0, densityMatrix0, H_int0 = groundstate(U0)\n", + "mf0 = tb_mf0 - hamiltonians_0\n", + "\n", + "\n", + "@np.vectorize\n", + "def mfRescaled(alpha, mf0=mf0, H_int0=H_int0):\n", + " hamiltonian = hamiltonians_0 + mf0 * alpha\n", + " vals, vecs = np.linalg.eigh(hamiltonian)\n", + " EF = utils.get_fermi_energy(vals, filling)\n", + " densityMatrix = hf.density_matrix(vals, vecs, EF)\n", + " return hf.total_energy(\n", + " hamiltonians_0 + np.sign(alpha) * mf0,\n", + " densityMatrix,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "alphas = np.linspace(-5, 5, 201)\n", + "plt.plot(alphas, mfRescaled(alphas), 'o')\n", + "plt.plot(-alphas, mfRescaled(alphas), 'o')\n", + "plt.axvline(x=1, c=\"k\", ls=\"--\")\n", + "plt.axvline(x=-1, c=\"k\", ls=\"--\")\n", + "plt.ylabel(\"Total Energy\")\n", + "plt.xlabel(r\"$\\alpha$\")\n", + "# plt.ylim(-4.6, -4.5)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAGdCAYAAADZiZ2PAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAABdl0lEQVR4nO3deViUVfsH8O/MMDPs44KAKIKairgLruVSuaVmm7lGamaZe7ZYVq/W733VrNfeytRWMzW1NLPMTNtIExUQF9wXFBQQUBzW2c/vD2QSBRxwhmdm+H6ua67GZ+55npuTzNyec55zZEIIASIiIiKqMrnUCRARERG5KhZSRERERNXEQoqIiIiomlhIEREREVUTCykiIiKiamIhRURERFRNLKSIiIiIqomFFBEREVE1eUidgLuzWCxIT0+Hn58fZDKZ1OkQERGRDYQQyM/PR0hICOTyivudWEg5WHp6OkJDQ6VOg4iIiKohLS0NjRs3rvB1FlIO5ufnB6Dkf4S/v7/E2RA5r8LCQoSEhAAo+QeIj4+PxBm5J7YzkW3y8vIQGhpq/R6vCAspBysdzvP392chRVQJhUJhfe7v788veAdhOxNVze2m5XCyOREREVE1sUeKiJyCh4cHxo0bZ31OjsF2JrIvmRBCSJ2EO8vLy4NGo4FWq+XQHhERkYuw9fubQ3tERERE1cR+XSJyCkIIFBUVAQC8vb257pqDsJ2J7Is9UkTkFIqKiuDr6wtfX1/rFz3ZH9uZyL5YSBERERFVEwspIiIiompiIUVERERUTSykiIiIiKqJhRQRERFRNbGQIiIiIqomriNFRE5BoVBg+PDh1ufkGGxncicnM/Mx/4ejeH90RwT6eUqSA7eIcTBuEUNERGRfQgh8vT8Vb/14DHqTBQ91DMH7ozrZ9Rq2fn+zR4qIiIhchrbYiFc2HcbPyZkAgL6tGuCNoZGS5ePwOVLLli1D06ZN4enpiaioKOzatavS+NjYWERFRcHT0xPNmjXDihUrbonZtGkTIiMjoVarERkZic2bN1f5ut999x0GDhyIgIAAyGQyHDx48JZz6PV6TJ8+HQEBAfDx8cGwYcNw8eLFqjUAERER2UXihVwMfn8Xfk7OhIdchtcGt8YX47ogwFctWU4OLaQ2bNiAWbNm4bXXXkNSUhJ69eqFBx54AKmpqeXGp6SkYPDgwejVqxeSkpIwd+5czJgxA5s2bbLGxMXFYeTIkYiJicGhQ4cQExODESNGYN++fVW6bmFhIe6++24sWrSowvxnzZqFzZs3Y/369di9ezcKCgowdOhQmM1mO7QOEd2osLAQMpkMMpkMhYWFUqfjttjO5IosFoGP/jiDER/H4dK1YjSp541Nz/XEpN7NIJdLvF+kcKCuXbuKyZMnlzkWEREhXnnllXLjX375ZREREVHm2LPPPiu6d+9u/fOIESPEoEGDysQMHDhQjBo1qlrXTUlJEQBEUlJSmePXrl0TSqVSrF+/3nrs0qVLQi6Xi+3bt5ebf3m0Wq0AILRarc3vIaqNCgoKBAABQBQUFEidjttiO5OruZxXLMZ+uleEzdkqwuZsFdO+PiDyig0Ov66t398O65EyGAxITEzEgAEDyhwfMGAA9uzZU+574uLibokfOHAgEhISYDQaK40pPWd1rluexMREGI3GMucJCQlB27ZtKz2PXq9HXl5emQcRERFV3d9ncjD4/d3YfSYHXkoFFj/WHh+M6gg/T6XUqVk5rJDKycmB2WxGUFBQmeNBQUHIzMws9z2ZmZnlxptMJuTk5FQaU3rO6ly3olxUKhXq1q1bpfMsXLgQGo3G+ggNDbX5mkRERASYLQJLdp7CE5/vQ06BHq2C/PDj9LsxoksoZDKJh/Ju4vDJ5jf/wEKIShuhvPibj9tyzqpe11a3O8+rr74KrVZrfaSlpd3xNYmIiGqLrDwdnvhsHz747TSEAEZ1CcX3U+/GXYF+UqdWLoctfxAQEACFQnFL701WVtYtvUWlgoODy4338PBA/fr1K40pPWd1rltRLgaDAbm5uWV6pbKystCzZ88K36dWq6FWS3f3ABERkavafToHszYkIafAAG+VAv95pC0e6dRY6rQq5bAeKZVKhaioKOzcubPM8Z07d1ZYiPTo0eOW+B07diA6OhpKpbLSmNJzVue65YmKioJSqSxznoyMDCQnJ1fpPERERFQ5s0VgyY6TiPliH3IKDIgI9sMP0+5x+iIKcPCCnLNnz0ZMTAyio6PRo0cPfPLJJ0hNTcXkyZMBlAyDXbp0CV999RUAYPLkyVi6dClmz56NSZMmIS4uDp9//jnWrVtnPefMmTPRu3dvvP3223jooYewZcsW/Prrr9i9e7fN1wWAq1evIjU1Fenp6QCAkydPAijpiQoODoZGo8HEiRPxwgsvoH79+qhXrx5efPFFtGvXDv369XNksxHVSgqFAoMHD7Y+J8dgO5OzuZynw4x1SdiXchUAMLprKOY92AaeShf5++no2wc/+ugjERYWJlQqlejcubOIjY21vjZu3DjRp0+fMvF//vmn6NSpk1CpVCI8PFwsX778lnN+++23olWrVkKpVIqIiAixadOmKl1XCCFWrlxpvQX4xse8efOsMcXFxWLatGmiXr16wsvLSwwdOlSkpqZW6efn8gdERETliz2ZJTq/tUOEzdkqIt/4WXyfdFHqlKxs/f7mXnsOxr32iIiIyjKZLfjfr6fx0Z9nIATQuqE/PhrTCc0a+EqdmhX32iMiIiKnczlPh+nrkrD/+lDemG5N8K+hka4zlHcTFlJE5BQKCwsRGBgIoOTuWB8fH4kzck9sZ5LSX6ey8fyGg7hSaICPSoGFj7XHsA4hUqd1R1hIEZHTKCoqkjqFWoHtTDXNbBF4/7fT+PD309ahvGVjO6NpgOsX8iykiIiIyGGuFOgxa8NB7DpdskOJqw/l3YyFFBERETlE4oVcTPv6ADK0OngpFVjwqPMvsFlVLKSIiIjIroQQ+HLPefznp+MwWQSaNfDB8rFRaBXsnNu83AkWUkRERGQ3BXoT5mw6jJ8OZwAAhrRriLeHt4ev2j1LDvf8qYiIiKjGnbqcj8lrEnEuuxAechnmDm6NCXeHQyaTSZ2aw7CQIiKnIJfL0adPH+tzcgy2MznK90mX8Op3R1BsNCPY3xMfje2MqLC6UqflcFzZ3MG4sjkREbkzvcmM/9t6DGv2pgIA7rkrAO+P6oj6vmqJM7szXNmciIiIHOpibhGmrj2AQxe1AIAZ992Fmf1aQiF336G8m7GQIiIioir740QWZm04CG2xEXW8lXhvZEfc2ypQ6rRqHAspInIKhYWFCA8PBwCcP3+eW5c4CNuZ7pTFIvC/307jg99OAwA6NNbgo7Gd0biut8SZSYOFFBE5jZycHKlTqBXYzlRd2iIjZm1Iwh8nswEAMd3D8PrQ1lB7uMcq5dXBQoqIiIhu60RmHp5dnYgLV4qg9pBj4aPt8Ghn91qlvDpYSBEREVGlfjiUjjkbD6PYaEbjul5Y8UQU2jbSSJ2WU2AhRUREROUymS14e/sJfLorBQDQq0UAPhjVCXV9VBJn5jxYSBEREdEtrhToMe3rJMSduwIAeK5vc7w4oFWtWtrAFiykiIiIqIxDadfw3JpEpGt18FEp8O7jHfBAu4ZSp+WUWEgRkVOQy+WIjo62PifHYDvT7XwTn4bXtyTDYLKgWYAPPo6JQosgP6nTclrcIsbBuEUMERG5Ar3JjDd/PIav95Vs9dKvdRCWjOwAf0+lxJlJg1vEEBERkU0ytTo8tzYRSanXIJMBs/u1xNR774Kc86Fui4UUERFRLbY/5SqmrD2AnAI9/D098P6oTrg3ovZt9VJdHCAnIqdQVFSE8PBwhIeHo6ioSOp03BbbmW60eu8FjPl0L3IK9IgI9sOP0+9hEVVF7JEiIqcghMCFCxesz8kx2M4EAAaTBfN/PGqdD/VghxC8/Vg7eKtYFlQVW4yIiKgWyc7XY8raRMSfz4VMBrw8MAKT+zSDTMb5UNXBQoqIiKiWSL6kxTNfJSBdq4Of2gMfjOZ8qDvFQoqIiKgW+OFQOl7eeAg6Y8n6UJ+Oi0bzBr5Sp+XyWEgRERG5MbNF4N0dJ7H8z7MAgL6tGuD9UZ2g8aqd60PZGwspIiIiN5WnM2LmuiT8cTIbADC5T3O8NJD75dkTCykicgoymQyRkZHW5+QYbOfa42x2ASZ9lYBz2YVQe8ixeHh7PNSxkdRpuR0WUkTkFLy9vXH06FGp03B7bOfa4Y+TWZixLgn5OhMaajzxSUw02jXWSJ2WW2IhRURE5CaEEPh01zks/PkEhACiw+pi+RNRaOCnljo1t8VCioiIyA0YTBa8tvkIvk28CAAY3TUUbw5rC5UHNzFxJBZSROQUioqK0KVLFwBAfHw8vL29Jc7IPbGd3dPVQgMmr07E/vNXIZcBbwyNxPie4ZwHVwNYSBGRUxBC4NixY9bn5BhsZ/dz+nI+nloVj7SrxfBTe+DDMZ3QtxUX2awpLKSIiIhc1B8nszDj6yTk601oUs8bn4+LRosgP6nTqlVYSBEREbkYIQS++Ps8/vPTMVgE0LVpPax4Igr1fFRSp1brsJAiIiJyIQaTBfN+SMa6/WkAgBHRjfHvh9txUrlEWEgRERG5iNxCA55bm4i9565CJgNeG9waE+9pyknlEmIhRURE5ALOZBXg6VXxOH+lCD4qBT4Y3Qn3tw6SOq1aj4UUETkFmUyGsLAw63NyDLaza9p1OhtT1h5Avs6ExnW98Pm4LmgVzEnlzoCFFBE5BW9vb5w/f17qNNwe29n1rNufite/T4bZIhAdVhcrYqIQ4MuVyp0FCykiIiInZLEIvP3LCXwcew4A8EinRlj0WDuoPRQSZ0Y3YiFFRETkZHRGM57fcBA/J2cCAGb1a4GZ97fgcKwTYiFFRE6huLgYvXv3BgD89ddf8PLykjgj98R2dn45BXo8vSoBB9OuQamQYfHw9nikU2Op06IKsJAiIqdgsViQkJBgfU6OwXZ2bqcv52PCl/G4mFuMOt5KfPxEFLo1qy91WlQJFlJEREROYM+ZHDy7JhH5OhPC63vji/Fd0KyBr9Rp0W2wkCIiIpLYNwlpmPvdEZiu35n3yZPR3O7FRbCQIiIikogQAv/dcQpL/zgDABjWIQSLh7eHp5J35rkKFlJEREQS0BnNeHnjYfxwKB0AMP2+uzC7f0vemediWEgRERHVsNxCAyZ9lYCEC7nwkMuw8NF2eDw6VOq0qBpYSBGR0wgICJA6hVqB7SyttKtFGLdyP85lF8Lf0wMrnohCz7v4/8RVsZAiIqfg4+OD7OxsqdNwe2xnaSVf0mL8ynjkFOjRqI4XvpzQBS2CuGeeK2MhRUREVANiT2VjyppEFBrMaN3QH19O6IIgf0+p06I7xEKKiIjIwb5NSMMr3x2B2SJwz10BWP5EZ/h5KqVOi+xALnUCRERAydYlffv2Rd++fVFcXCx1Om6L7VyzhBD44LfTeGnjYZgtAo90aoQvxndhEeVG2CNFRE7BYrEgNjbW+pwcg+1cc0xmC97Ykox1+9MAAM/1bY6XB7bi8gZuhoUUERGRnRUZTJj2dRJ+P5EFuQx4c1gbxPQIlzotcgAWUkRERHaUU6DHxC/jceiiFmoPOT4Y3QkD2wRLnRY5CAspIqJqSL6kRaC/GoF+vOuK/nE+pxDjVu7HhStFqOOtxOfjohEVVk/qtMiBONmciKiKzmTlY9jS3Zi0KkHqVMiJHEq7hkeX78GFK0UIreeFTc/1ZBFVC7BHioioin45ehkWAVzO00udCjmJXaez8ezqRBQZzGjbyB9fjO/C3spagoUUETkNb29vqVOwSezJkpXBTRYhcSbV4yrt7Cq2Hk7H8xsOwmguWSNqRUwUfNX8eq0t+H+aiJyCj48PCgsLpU7jtrTFRiSm5gIALML1CilXaWdXsTruPP71w1EIAQxp3xBLRnSA2kMhdVpUg1hIERFVwd9ncmC+3hNldtEeKbpzQgj879fTeP+30wCAJ7o3wZvD2kIh5xpRtQ0LKSKiKvjzZJb1uYWFVK1ktgjM/+EoVu+9AACYeX8LzOrXggtt1lK8a4+InIJOp8OQIUMwZMgQ6HQ6qdMplxACsaeyrX82u+DQniu0szMzmCyYuT4Jq/degEwGvPVQGzzfvyWLqFqMPVJE5BTMZjO2bdtmfe6Mjmfkl7lTzxWH9lyhnZ1Vod6EyWsSset0DpQKGZaM6IgHO4RInRZJjD1SREQ2+ut0SW9URLAfANecbE7Vc7XQgDGf7sWu0znwVinw+bguLKIIQA0UUsuWLUPTpk3h6emJqKgo7Nq1q9L42NhYREVFwdPTE82aNcOKFStuidm0aRMiIyOhVqsRGRmJzZs3V/m6QgjMnz8fISEh8PLyQt++fXH06NEyMX379oVMJivzGDVqVDVagYjcwZ6zVwAAfVsFAnDNHimqukvXijF8xR4cuqhFXW8lvp7UHb1bNpA6LXISDi2kNmzYgFmzZuG1115DUlISevXqhQceeACpqanlxqekpGDw4MHo1asXkpKSMHfuXMyYMQObNm2yxsTFxWHkyJGIiYnBoUOHEBMTgxEjRmDfvn1Vuu7ixYuxZMkSLF26FPHx8QgODkb//v2Rn59fJqdJkyYhIyPD+vj444/t3EpE5AqMZgsSzl8FANx9V30AgEWU/KOM3NeZrHwMX74H57ILEaLxxLeTe6BjaB2p0yJnIhyoa9euYvLkyWWORUREiFdeeaXc+JdffllERESUOfbss8+K7t27W/88YsQIMWjQoDIxAwcOFKNGjbL5uhaLRQQHB4tFixZZX9fpdEKj0YgVK1ZYj/Xp00fMnDnThp+0YlqtVgAQWq32js5D5O4KCgoEAAFAFBQUSJ3OLRLOXxFhc7aKjm/+IrLzdSJszlYRNmerMJktUqdWJc7ezs7kcNo10fHNX0TYnK3i/v/+KS7lFkmdEtUgW7+/HdYjZTAYkJiYiAEDBpQ5PmDAAOzZs6fc98TFxd0SP3DgQCQkJMBoNFYaU3pOW66bkpKCzMzMMjFqtRp9+vS5Jbe1a9ciICAAbdq0wYsvvnhLj9XN9Ho98vLyyjyIyPXtPVfSG9WtaX0o5f98dHJ4zz3tT7mK0Z/uRW6RER0aa/Dtsz0QUsdL6rTICTnsrr2cnByYzWYEBQWVOR4UFITMzMxy35OZmVluvMlkQk5ODho2bFhhTOk5bblu6X/Li7lw4YL1z2PHjkXTpk0RHByM5ORkvPrqqzh06BB27txZ4c+9cOFCvPnmmxW+TkSuKe76/KgezevjhjqKE87d0J8nszB5TSJ0Rgu6N6uHz8Z14ZYvVCGH/824eW0NIUSl622UF3/zcVvOaY+YSZMmWZ+3bdsWLVq0QHR0NA4cOIDOnTuXm/+rr76K2bNnW/+cl5eH0NDQcmOJ6B8+Pj5OO99IbzIj4UJJj1SP5vXhcUMl5Wr77TlzOzuDn49kYMb6JBjNAve2aoDlT0TBU8ktX6hiDhvaCwgIgEKhuKX3KSsr65aeoFLBwcHlxnt4eKB+/fqVxpSe05brBgcHA0CVcgOAzp07Q6lU4vTp0xXGqNVq+Pv7l3kQkWs7lKaFzmhBfR8VWgT6lumR4tCe+9iYeBFTvz4Ao1lgSLuG+DgmmkUU3ZbDCimVSoWoqKhbhsF27tyJnj17lvueHj163BK/Y8cOREdHQ6lUVhpTek5brls6XHdjjMFgQGxsbIW5AcDRo0dhNBrRsGHDyn50InIzpcN63ZvVh0wmg+KGnmtuE+MeVu05jxe/PQSLAEZEN8YHoztB5cGlFun2HDq0N3v2bMTExCA6Oho9evTAJ598gtTUVEyePBlAyTDYpUuX8NVXXwEAJk+ejKVLl2L27NmYNGkS4uLi8Pnnn2PdunXWc86cORO9e/fG22+/jYceeghbtmzBr7/+it27d9t8XZlMhlmzZmHBggVo0aIFWrRogQULFsDb2xtjxowBAJw9exZr167F4MGDERAQgGPHjuGFF15Ap06dcPfddzuy2YhqJZ1Oh5iYGADA6tWr4enpKXFG/9hzNgcA0L15Sc/4jRvTuto2Mc7czlL56I8zeOeXkwCACXeH440hkZBz82GylaNvH/zoo49EWFiYUKlUonPnziI2Ntb62rhx40SfPn3KxP/555+iU6dOQqVSifDwcLF8+fJbzvntt9+KVq1aCaVSKSIiIsSmTZuqdF0hSpZAmDdvnggODhZqtVr07t1bHDlyxPp6amqq6N27t6hXr55QqVSiefPmYsaMGeLKlStV+vm5/AGRbZz1tvwCnVHcNfcnETZnq0jJ/iev8FdKlj+4rC2WMLuqc9Z2loLFYhELtx23LmXx3x0nhcXiWstZkOPY+v0tE8LF/jnlYvLy8qDRaKDVajlfiqgShYWF8PX1BQAUFBTAx8dH4oxK/Hb8MiauSkBoPS/89dK91htS7pq7DSaLQNyr96GhxnVui3fWdq5pFovAvB+OYvXekju15w6OwDO9m0ucFTkTW7+/eT8nEVEldp0uGdbr3aJBmbt65XIZYBGcbO6CzBaBud8dwYaENMhkwH8ebocx3ZpInRa5KBZSRESVKN2ouFeLsnurlU44t1hqPCW6A2aLwEvfHsJ3SZcglwHvPt4Bj3ZuLHVa5MJYSBERVeBibhHOZRdCIZeh5/X99UqVTjh3tcnmtZnRbMHsbw7hx0PpUMhl+N/IjniwQ4jUaZGLYyFFRFSB3deH9TqF1oG/p7LMa6U3dXFozzUYTBbMWJeE7UczoVTI8OHoThjUlkvZ0J1jIUVEVIGKhvUAwENRssYQt4hxfnqTGVPXHsCvx7OgUsix/InOuL91xYsvE1UFCykicgre3t4oKCiwPpeayWyx9kj1ahlwy+vy63OkTGbXKqScrZ0dTWc045nVifjrVDbUHnJ88mQ0+rS8tTAmqi4WUkTkFGQymVPdir8/5SrydCbU81GhQ+M6t7x+vUPK5XqknK2dHanIYMLTqxKw5+wVeCkV+HxcNHredWtRTHQnWEgREZVj+9GSvTj7tw4qs5J5qdK79jhHyjkV6E146st47E+5Ch+VAisndEXXpvWkTovcEDcSIiKnoNfrMX78eIwfPx56vV7SXCwWgR1HLwMABrYtfy6N3EXv2nOmdnaUAr0J477Yj/0pV+Gn9sBXE7uxiCKHYSFFRE7BZDJh1apVWLVqFUwmk6S5HLp4DZl5OviqPdCzeflDQaW9VK62abEztbMjlBZRiRdy4e/pgbWTuiEqrK7UaZEb49AeEdFNSof17o0IhKdSUW4Mh/acT4HehPE3FFFfT+qOto00UqdFbo49UkRENxBC4JfkkkJqYJuKb5F31aE9d1WoN+GplfFIKO2JeppFFNUMFlJERDc4eTkf568UQeUhR99WgRXGcYsY51GoN2HCl/HYf/4q/Dw9sObpbmjXmEUU1QwWUkREN9h84BIAoE/LBvBVVzz7gT1SzqHI8M/deX5qD6yZ2A3ty1mugshRWEgREV1nMluwOamkkHrsNhvZWteR4hwpyZQWUfuuF1Grn+6GDqF1pE6LahkWUkRE1+0+k4OsfD3qeitxX0TFw3oAoJCXfHxysrk0ig1mTPwyAXvPXYWv2gNfTeyKjiyiSAK8a4+InIK3tzeysrKsz6Ww6fqw3rAOIVB5VP7vTEXppsUuNrTnDO18p4oNZkxcFY+4c1fgq/bAqqe6olMTLnFA0mAhRUROQSaToUED6fZAy9MZseP6sgePRVU+rAf8s46Uq/VISd3Od0pnNGPSVyXbvvioFFj1VBeuE0WS4tAeERGAnw5nQG+yoEWgL9rZcNu8nOtI1TiDyYIpaw9g95mc60VUV0SFccVykhYLKSJyCnq9HlOnTsXUqVNrfOsSIQRWx10AADwe3Rgy2a17693MurK5iw3tSdnOd8JktmDm+iT8fiILnko5vhjfBdHhLKJIeiykiMgpmEwmLFu2DMuWLavxrUsOpObiWEYe1B5yPB4VatN7XHVoT8p2ri6LReCljYfxc3ImVAo5PomJRrdm9aVOiwgACykiIqzaU9Ib9VDHENT1Udn0Hg7t1QwhBF77/gg2J12Ch1yGj8Z2Ru+WrjvHi9wPCykiqtWy8nTYdiQDAPBkj3Cb3+eqQ3uuRAiBt7Yew7r9aZDLgPdGdkT/yIq37SGSAgspIqrV1u1Pg8kiEBVWt0p7s/3TI+WozOjdHSex8u/zAIC3H2uPBzuESJsQUTlYSBFRraUzmrF6b8mw3pM9wqr03tKVzV1tHSlXsfT30/joj7MAgP97qA0ej7Zt7hpRTWMhRUS11qYDF5FToEejOl4Y3K5hld5rHdrjHCm7+2zXOby74xQA4LXBrRFThSFXoprGQoqIaiWzReCTv84BACbe0xRKRdU+DrlFjGOs3XcB//7pOADg+X4tMal3M4kzIqocVzYnIqfg5eWFlJQU63NH+zk5AxeuFKGOtxKjulZ92Kh0ixhXm2xe0+1cFVsOXsLr3ycDAJ7t0wwz7r9L4oyIbo+FFBE5BblcjvDw8Bq5lhACK2JL5t+M6xEOb1XVPwrl14f2TC7WI1WT7VwVf57MwgvfHIIQQEz3MLwyKMKmhVGJpMahPSKqdf48mY3kS3nwVMoxrmd4tc6h4DpSdpN44Somr0mEySIwrEMI3hzWhkUUuQwWUkTkFAwGA1566SW89NJLMBgMDruOEALv/VoykfnJHuGoZ+MCnDdz1cnmNdXOtjqRmYcJK+OhM1rQp2UDvPt4B2tvH5ErYCFFRE7BaDTi3Xffxbvvvguj0eiw6/xxMguHL2rhpVTgmTuYyFz6Ze9qyx/UVDvbIvVKEZ78fD/ydCZ0blIHy5/oDJUHv5bItfBvLBHVGkII/O/X0wBK1o0K8FVX+1ylQ3uu1iPlLLLydYj5Yh+y8vVoFeSHL8Z3qdZcNSKpsZAiolrj1+MlvVHeqjvrjQJu2LTYxXqknIG22IhxX8TjwpUihNbzwlcTu6KOd/WGWImkxkKKiGoFs0XgnV9OAADG9QxH/TvojQK4RUx1FRvMeHpVPI5n5CHAV43VT3VDkL+n1GkRVRsLKSKqFb47cBGnLhdA46XE5D7N7/h8pet3uto6UlIymi2Y9vUBxJ/PhZ+nB756qivCA3ykTovojrCQIiK3pzOa8d7Okjv1pvRtDo2X8o7PaZ1szjlSNrFYBOZsPIzfTmRB7SHH5+O6IDLEX+q0iO4YCykicntr9l5AulaHhhrPaq8bdTMPFlJV8vYvJ/Bd0iUo5DIsG9sZXZvWkzolIrvgLRJE5BS8vLyQnJxsfW4vVwr0eP+3kjv1ZvVrAU+lwi7ntd6152JDe45q58p8+XcKPo4t2dfw7cfa4/7WQTVyXaKawEKKiJyCXC5HmzZt7H7eJTtPIV9nQmRDfwyPqvqeehVx5S1iHNHOFfn5SAbe3HoMAPDigJYYHtW4xq5NVBM4tEdEbut4Rh7W7U8FAMx7MNK6ZIE9cB2p24s/fxUzNxyEEMDYbk0w9V5uQkzuhz1SROQUDAYDFixYAACYO3cuVKo7W1dICIH/23oMFgEMbheMbs3q2yNNK1edbG7vdq7Imax8PL0qAQaTBf1aB+Gth9py/zxySyykiMgpGI1GvPnmmwCAl1566Y6/4Hccu4w9Z69A5SHHqw+0tkeKZbjqgpz2bufyXM7TYdwX8dAWG9GpSR18OLqTXXsDiZwJh/aIyO3oTWYs2HYcADCpV1OE1vO2+zU4tFe+fJ0R41fG49K1YjQN8MHn47rAS2WfCf5EzoiFFBG5nZV/n8eFK0UI9FNjSl/HzMv5Z9Nih5zeJRnNFkxZe+D6quUqrJrQFfV8uPULuTcWUkTkVrLydFj6+xkAwMuDIuCjdswMBsX1kSr2SJUQQuD1zcnYdToH3ioFVo7viib17d8TSORsWEgRkVt5c+sxFOhN6BBaB492auSw6yhcdLK5o6yIPYcNCWmQy4APR3dCu8YaqVMiqhEspIjIbfx5Mgs/Hc6AXAb85+G21uE3R1DISz4+XW2yuSNsO5KBt7eXbAj9xtBILrhJtQoLKSJyCzqjGf/achQAMOHupmjbyLE9ItZNi2t5j1RSai6e33AQADC+Zzgm3N1U2oSIahiXPyAip+Dp6Yn9+/dbn1fV0t/PIPVqERpqPPF8/5b2Tu8WcplrLn9wp+18o7SrRZj0VQL0JgvuiwjEG0Mj7ZEikUthIUVETkGhUKBLly7Veu+ZrHx8/NdZAMC8B9vA10ETzG/kqnOk7qSdb6QtNuKpL+ORU2BA64b++IBrRVEtxaE9InJpQgjM3ZwMo1ng/ohADGxTM/NzXLWQsgej2YKpaw/gdFYBgvzV+GJ8dI0Ur0TOiH/zicgpGAwGvP/++wCAmTNn2rzi9reJF7E/5Sq8lAq8+VCbGtuGxDq052KFVHXbuZQQAv/achS7z5Qsc/D5uC5oqPFyRKpELoGFFBE5BaPRiJdffhkAMGXKFJu+4LPydPj31mMAgJn9WqBx3Zpbt6i0R8riYnOkqtPON/oq7gLW7U+FTAZ8MKqTwyf1Ezk7Du0RkUsSQuC175ORpzOhXSMNnr6nZu8Wc9UeqTvx95kcvHW9cH1lUAT6RXKZAyIWUkTkkrYezsDOY5ehVMiweHh7eChq9uNMUcu2iDmfU4gpaw/AbBF4tFMjPNO7mdQpETkFFlJE5HKuFOgx74eSNaOm3nsXWjf0r/EcatM6Uvk6I57+KgHaYiM6htbBgkfb1dhcNCJnx0KKiFzOvB+O4mqhARHBfg7blPh2asvQntkiMHP9QZy5fofeJzFR8FQqpE6LyGmwkCIil7I9ORNbD2dAIZfhneEdoPKQ5mPM4/oWMa422byq3vnlJH4/kQW1hxyfPhmNQP87W8STyN2wkCIil5FbaMDr3ycDAJ7t3UzSjXGv11Fu3SO1OekiVsSWLHS6eHh7tG9cR9qEiJwQlz8gIqfg6emJP/74w/r8ZkIIvP59MnIK9GjewAcz7m9R0ymWoXDhLWIqa+dSh9KuYc6mIwCAqfc2x0MdG9VIfkSuhoUUETkFhUKBvn37Vvj6loPp+OlIBjzkMrw3sqPk83Ss60i5WI/U7doZAHIK9Ji8JhEGkwX9Wgfhhf6taiY5IhfEoT0icnrp14rxxpaSIb0Z97dwiiEm+fVCyuRihdTtmMwWTPv6ADK0OjRv4IP3Rnaw/qxEdCv2SBGRUzAajfjkk08AAM888wyUSiWAkh6fF789hHydCR1D62BK3+ZSpmlVOrTnaj1SFbVzqcW/nMTec1fho1Lg45go+HkqyzsNEV3HQoqInILBYMC0adMAAOPHj7d+wa/ccx57zl6Bl1KBJSM61PjCmxX5Z0FO1yqkKmpnAPjpcAY++escAOCdxzvgrkA/SXIkciXO8YlERFSO05fz8fb2EwCAuUNao1kDX4kz+sc/60hJnIidnL6cj5c2HgJQckfk4HYNJc6IyDWwkCIip6Q3mTFz/UEYTBb0adkAT3RrInVKZbjqpsXlydMZ8ezqRBQZzOjRrD5eGsjJ5US2YiFFRE7p7Z9P4lhGHup6K7F4eHun25JE4SbrSFksAi9+cwjncgrRUOOJD8d0cprhUyJXwN8WInI6sSez8MXfKQCAdx/vgCAnXE1b7qKTzW+2PPYsdhy7DJVCjuVPRCHAVy11SkQuhYUUETmduZtLFoIc3zMc97cOkjib8pVuEeNqk81vFHc2B+/uOAkAePOhNugYWkfahIhckMMLqWXLlqFp06bw9PREVFQUdu3aVWl8bGwsoqKi4OnpiWbNmmHFihW3xGzatAmRkZFQq9WIjIzE5s2bq3xdIQTmz5+PkJAQeHl5oW/fvjh69GiZGL1ej+nTpyMgIAA+Pj4YNmwYLl68WI1WIKKquFpoRESwH155IELqVCrkDlvEvLTxMIQARkQ3xuiuzjUHjchVOLSQ2rBhA2bNmoXXXnsNSUlJ6NWrFx544AGkpqaWG5+SkoLBgwejV69eSEpKwty5czFjxgxs2rTJGhMXF4eRI0ciJiYGhw4dQkxMDEaMGIF9+/ZV6bqLFy/GkiVLsHTpUsTHxyM4OBj9+/dHfn6+NWbWrFnYvHkz1q9fj927d6OgoABDhw6F2Wx2QGsR1W5qtRrTFn2KBsPnwctLjQ9Hd5J89fLKuOpkc7VajS0//Ije097FVZ1AqyA/vDmsrdRpEbksmRCO+xTo1q0bOnfujOXLl1uPtW7dGg8//DAWLlx4S/ycOXPwww8/4Pjx49ZjkydPxqFDhxAXFwcAGDlyJPLy8vDzzz9bYwYNGoS6deti3bp1Nl1XCIGQkBDMmjULc+bMAVDS+xQUFIS3334bzz77LLRaLRo0aIDVq1dj5MiRAID09HSEhoZi27ZtGDhwoE1tkJeXB41Gg/T0dPj7+9/yukKhKLPfVWFhYYXnksvl8PLyqlZsUVERKvpfLZPJ4O3tXa3Y4uJiWCwV3//t4+NTrVidTldpwVqVWG9vb+tEZb1eD5PJZJdYLy8vyK93SxgMBhiNRrvEenp6QqFQVDnWaDTCYDBUGKtWq+Hh4VHlWJPJBL1eX2GsSqWyrkVUlViz2QydTmd97fDFaxj76T6YLALzh7XBEz2bQaVSlRt7M6VSaY21WCwoLi62S6yHhwfU6pI5Q0IIFBUVWV/LytOhzzt/Qi4Djr41qNLYm1Xl994RnxEf/X4GS/88Cx9vb/w4/W7cFejHzwh+Rjj9Z8TNbvxddsRnROn3t1arLff720o4iF6vFwqFQnz33Xdljs+YMUP07t273Pf06tVLzJgxo8yx7777Tnh4eAiDwSCEECI0NFQsWbKkTMySJUtEkyZNbL7u2bNnBQBx4MCBMjHDhg0TTz75pBBCiN9++00AEFevXi0T0759e/Gvf/2rwp9bp9MJrVZrfaSlpQkAFT4GDx5c5v3e3t4Vxvbp06dMbEBAQIWx0dHRZWLDwsIqjI2MjCwTGxkZWWFsWFhYmdjo6OgKYwMCAsrE9unTp8JYb2/vMrGDBw+utN1uNHz48EpjCwoKrLHjxo2rNDYrK8saO2XKlEpjU1JSrLEvvvhipbHJycnW2Hnz5lUau3//fmvs4sWLK439448/rLFLly6tNHbr1q3W2JUrV1Ya+80331hjv/nmm0pjV65caY3dunVrpbFLly61xv7xxx+Vxi5evNgau3///kpj582bZ41NTk6uNPbFF1+0xqakpFQaO2XKFGtsVlZWpbHjxo2zxhYUFFQaO3z48DJ/hyuLddRnhCq4hdiYkGaN5WdECX5GlOBnhBBarVYAEFqtVlTGYUN7OTk5MJvNCAoqO1E0KCgImZmZ5b4nMzOz3HiTyYScnJxKY0rPact1S/97uxiVSoW6devanD8ALFy4EBqNxvoIDQ2tMJaISCqe5kIMa++cE/mJXInDhvbS09PRqFEj7NmzBz169LAe/89//oPVq1fjxIkTt7ynZcuWmDBhAl599VXrsb///hv33HMPMjIyEBwcDJVKhVWrVmH06NHWmLVr12LixInQ6XQ2XXfPnj24++67kZ6ejoYN/1m9d9KkSUhLS8P27dvx9ddfY8KECbd0Qfbv3x/NmzcvdxI8UNLVe+N78vLyEBoayqG9Ksay2772dNt/tusc/rvjFDwsBqS8PwYAcPnyZdSpU8eph/a0xUZ0X/AbAODgvP7w8VQ79dCexSLwzOoE7Dp+CZeWPgEAKCgosP4u8TOCnxHO+hlREWcZ2nPYXnsBAQFQKBS39N5kZWXd0hNUKjg4uNx4Dw8P1K9fv9KY0nPact3g4GAAJb1ONxZSN8cYDAbk5uaW6ZXKyspCz549K/y51ep/Pkxv5OPjU+YXuyK2xFQn9sYPNnvG3vihbc/YG7847Blb0f+fO41VqVTWX1KpYpVK5S0b0Noj1sPDw/qBac9YhUKBo1l6fPBXGuQqT7w+qA0mvl/ymo+PT5mfW6FQ2Pz3XS6XOyRWJpOViRUeJshVJX/3vLx8oFYpKoy9nZqI/eiPM4hLLazw95ufESX4GVH1WEd+Rtj6991RnxE2nc9uZ7qJSqVCVFQUdu7cWeb4zp07KyxEevTocUv8jh07EB0dbf0fWlFM6TltuW7Tpk0RHBxcJsZgMCA2NtYaExUVBaVSWSYmIyMDycnJlRZSRGSbnAI9pq87ALNF4OGOIRgR3VjqlKpEccNK686+llT8+atYsvMUAOC1Ia0lzobIzVQ6g+oOrV+/XiiVSvH555+LY8eOiVmzZgkfHx9x/vx5IYQQr7zyioiJibHGnzt3Tnh7e4vnn39eHDt2THz++edCqVSKjRs3WmP+/vtvoVAoxKJFi8Tx48fFokWLhIeHh9i7d6/N1xVCiEWLFgmNRiO+++47ceTIETF69GjRsGFDkZeXZ42ZPHmyaNy4sfj111/FgQMHxH333Sc6dOggTCaTzW1g62Q1otrEZLaIsZ/uFWFztor7//unKNAZy0zQvnHyr7PSGU0ibM5WETZnq7hWZJA6nQpdLdCL7gt+FWFztoqZ6w6I/Px8l2pnIqnY+v3tsKE9oGSpgitXruCtt95CRkYG2rZti23btiEsLAxASQ/PjWs7NW3aFNu2bcPzzz+Pjz76CCEhIfjggw/w2GOPWWN69uyJ9evX4/XXX8cbb7yB5s2bY8OGDejWrZvN1wWAl19+GcXFxZgyZQpyc3PRrVs37NixA35+ftaY9957Dx4eHhgxYgSKi4tx//3348svv7SONxNR9Xz4+2nsPpMDL6UCy8d2ho/aA4WmiudNOKMbe6ScdZsYIQTmbj6CDK0OzQJ88O9H2kHmYu1M5Owcuo4UwfZ1KIhqiV2ns/HkF/shBPDeyA54pFPJkF5hYSF8fX0BlJ0E7ayEEGj66jYAQMLr/Zxyj7pvEtLw8sbD8JDLsHnK3WjXWONy7UwkFVu/v7nXHhHVmPRrxZi1/iCEAEZ3DbUWUa5IJpPh+uLmTtkjdT6nEG/+ULLt1ewBLdGusUbijIjck0OH9oiISumMZkxek4grhQa0CfHHvAfblHldrVbjm2++sT53BQq5DBazcLrJ5kazBbM2HEShwYyuTevh2d7Nra+5YjsTOTMWUkTkcEIIvLY5GYcvalHXW4kVT0Tdso+eh4cHHn/8cYkyrB65TAZAON3GxR/+fgYH067Bz9MD743saN0XEHDNdiZyZhzaIyKH+yruAjYduAi5DFg6pjNC69m+DpEzs25cXPEakjUu8cJVLP39NADgP4+0Q6M6tq/NRERVxx4pInKofeeu4P+2HgMAvPpAa9x9V0C5cSaTCZs3bwYAPPLIIzYv2iel0jv3TE5SSRUZTJj9zSFYBPBIp0YY1iHklhhXbGciZ8bfICJymPRrxZj69QGYLALDOoTg6V5NK4zV6/UYMWIEgJK7yVzhC15e2iPlJHOkFv18AheuFCFE44k3H2pTbowrtjORM+PQHhE5hM5oxnNrEpFTYEDrhv54+7H21j3K3EXp0J7ZCTqk/j6Tg6/iLgAA3h7eHv6etm3vQUR3hoUUEdmdEAJvfJ+MQxe1qOOtxCcxUfBSud9CtnJZaSElbY9Uvs6IlzceBgCM7dYEvVo0kDQfotqEhRQR2d2avRfwbWLJ5PIPR3dym8nlN1Nc/wSVemjvPz8dx6VrxQit54W5g7mXHlFNYiFFRHa150wO5v9YMrl8zqAIt+4d8ZCXfIRK2SP1x8ksrI9PAwC8M7wDfNSc80RUk1hIEZHdpOQU4rm1B2C2CDzUMQTP9G4mdUoOdb2OkmxBTm2xEa9sKhnSm3B3OLo3qy9JHkS1GQspIrILbZERE7+Mh7bYiI6hddxycvnNSpc/kGqLmEU/H8flPD2aBvjg5YERkuRAVNuxD5iI7pjJbMHUrw/gXE4hQjSe+OTJW1cuvx2VSoWVK1dan7sCuVy6yeZ7z13Buv0lQ3qLHm1n82R+V2xnImfGQoqI7tj/bT2G3Wdy4KVU4NNx0Qj086zyOZRKJcaPH2//5ByotEeqpof2dEYz5n53BAAwumsTdKvCkJ4rtjORM+PQHhHdkdVx57Hq+vpF/xvVEW1CNBJnVHOk2iJm6e9ncC6nEIF+arzyAIf0iKTEHikiqrbdp/+5Q++lga0wsE1wtc9lMpnwyy+/AAAGDhzoEituyyXYIuZ4Rh5WxJ4FALz1UFtovKq28KYrtjORM+NvEBFVy7nsAkxZmwizReCRTo0wpW/zOzqfXq/H0KFDAbjO1iWKGt4ixmwReGXTYZgsAgPbBGFQ26oXrq7YzkTOjEN7RFRlVwr0mPBlPPJ0JnRuUgcLH23n9nfolUdew1vErNpzHocuauGn9sBbD7WtmYsSUaVYSBFRleiMZjyzOhEXrhShcV0vfBwTXeU79NyF4nrtWBN37WXl6bBk5ykAwCuDIxDkX/UJ/URkfyykiMhmFovAC98eQuKFXPh7euDLCV3QwE8tdVqSqcmhvQXbjqNAb0LH0DoY3aWJw69HRLZhIUVENlv8y0n8dDgDSoUMH8dE465AP6lTkpSihtaR2nvuCr4/mA6ZDHjroTbWIUUikh4LKSKyydp9F6x3iy0e3h49mnM7kprokTKaLZi35SiAkjWj2jeu47BrEVHVsZAiotv642QW/nX9y3x2/5Z4pFNjiTNyDqXLHziyR+qruAs4eTkfdbyVeGlAK4ddh4iqh/e9ElGljqZrMe36RsTDoxpj+n13OeQ6KpUKS5cutT53BY4e2svK1+F/1yeYzxkUgbo+d94urtjORM6MhRQRVShDW4ynvoxHocGMu++qjwWPOG6ZA6VSialTpzrk3I5i3bTYQUN7i7adQL7ehA6NNRgZHWqXc7piOxM5Mw7tEVG5tEVGjPtiPy7n6dEyyBfLxkZB5cGPjBs5ch2pxAu5+C7p0vUJ5m05wZzISbFHiohuoTOaMemrBJy6XIAgfzVWTuha5a1IqspsNmPXrl0AgF69ekGhcP61qRy1abEQAgu2HQcAPB7VGB1C69jt3K7YzkTOjIUUEZVhtgjMXJ+E/eevws/TA6ue6opGdbwcfl2dTod7770XQMnWJT4+Pg6/5p2yzpGyc5fUL0cvI/FCLjyVcrxg5wnmrtjORM6M/fREZCWEwL+2JOOXo5eh8pDj0yejERHsL3VaTss6tGfHDimj2YK3t58AAEzq1YwrmBM5ORZSRGS19PczWLsvFTIZ8P7IjujejGtFVaZ0ixiLHe/aW78/FSk5hajvo8IzvZvZ7bxE5BgspIgIQMkX+H+v32o//8E2eKBdQ4kzcn7/9EjZp5Aq0Jvwv19PAwBm9WsBP0/HzksjojvHQoqI8Ouxy5i7+QgAYOq9zTGuZ7i0CbkIDzuvI/Vx7FlcKTSgaYAPRnXlfnpEroCFFFEtl3D+KqatOwCLAIZHNcaLXD3bZtYtYuxQSF3O0+HTXecAAHMGtYJSwY9nIlfA31SiWuxYeh4mfBkPndGCe1s1wMJHHbfgpjuS23H5g/d2noLOaEHnJnUwsE3wHZ+PiGoGlz8gqqVScgrx5Bf7kK8zoUt4XSwbGyVpL4hSqcTixYutz12BvXqkLlwpxLeJFwEAcwe3dmgx64rtTOTMWEgR1UIZ2mI88dk+5BQYENnQH5+N6wIvlbQLM6pUKrz00kuS5lBV9uqR+vD3MzBbBHq3bIDo8Hr2SK1CrtjORM6MQ3tEtczVQgOe+GwfLl0rRrMAH3w10fGrlrsrhR22iDmfU4jNSZcAAM/3a2GPtIioBrFHiqgWydeV7J93NrsQDTWeWP10NwT4qqVOC0DJ1iUHDhwAAHTu3Nklti6xDu3dQY9UaW9U31YN0KlJXXulViFXbGciZ8ZCiqiW0BnNeHpVAo5c0qKejwqrJ3arka1fbKXT6dC1a1cArrN1SenQnqmaS5unXinC9wdLeqNm9Wtpt7wq44rtTOTMOLRHVAsYzRZM+/oA9qVcha/aA6smdMVdgb5Sp+XySufmV7dH6tNd56xzozracWNiIqo5LKSI3JzFIvDyxsP49XgW1B5yfDYuGu0aa6ROyy0oZNVfkDOnQI9vEtIAAM/1aW7XvIio5rCQInJjQgi8+eNRbE66BIVchmVjO3P/PDtSyEs+Qqtz196Xf5+H3mRBh9A66N7MsXfqEZHjsJAiclNCCCz+5SRWxV2ATAb89/EOuL91kNRpuRXr0F4Ve6QK9CZ8FXceAPBcn2ZcBJXIhbGQInJTH/x2Bsv/PAsAeGtYGzzcqZHEGbkfeTX32tuYkIY8nQnNAnzQP5KrmBO5MhZSRG5o+Z9n8d6vpwAArw9pjZge4dIm5KYU1ViQ02IR+CruAgBgwt3h1iUUiMg1cfkDIjfzxe4UvL39BADgpYGt8HSvZhJnZBulUol58+ZZn7uC6mwR8/fZHJzLKYSv2gOPdG7sqNQq5IrtTOTMWEgRuZG1+y7gra3HAAAz7rsLU++9S+KMbKdSqTB//nyp06iSf7aIsf09q/aU9EYNj2oMX3XNfwS7YjsTOTMO7RG5iY2JF/Ha5mQAwLO9m+H5/jWzwGNtVtUeqbSrRfjtxGUAwBPdwxyWFxHVHPZIEbmBLQcv4eWNhwAA43uG45UHIlzuTjCLxYLjx48DAFq3bg253Pn/nVfVyeZr96VCCKBXiwDJFkR1xXYmcmYspIhc3PbkDMz+5hAsAhjdtQnmPRjpckUUABQXF6Nt27YAXGfrktLJ5iYbCimT2YLvDlwEAIzt1sSheVXGFduZyJnxnyJELuz3E5cxfV0SzBaBxzo3xn8ebuuSRZSrqsoWMbvP5CArX4+63krcF8H1vIjcBQspIhcVeyobk9ccgNEs8GCHECwe3t461EQ1Q16FLWI2HSjZnHhYhxCoPPjRS+Qu+NtM5IJiT2Vj0lcJMJgsGNgmCEtGdOB6RBLwUFyfbH6bHqk8nRE7jmYCAB6LqvklD4jIcThHisjF/HkyC8+sToTBZMGAyCB8OLozlAr+m0gKtvZI/XQ4A3qTBS0CfdGuETeMJnIn/PQlciE3FlED2wRh6ZjOHCaSkMLGu/ZKJ5k/FtWYc9iI3Aw/gYlcxM1F1IejWURJrfSuvcqG9rLydIg/nwsAeKhjSI3kRUQ1h0N7RC7gj5NZeParRBjM//REudtwnlKpxIsvvmh97gpsWUfql2MlC3B2alIHDTVeNZJXZVyxnYmcGQspIidXG4oooGTrknfeeUfqNKpEYcMWMaWTzAe2Ca6JlG7LFduZyJmxkCJyYn+cyMKzq0uKqEFtgvHhmE5uWUS5qtttEXOtyIC4s1cAOE8hRUT2xUKKyEnVtiLKYrEgNTUVANCkSROX2LrkdkN7vx3Pgski0CrID00DnGMFcVdsZyJnxkKKyAn9dvwynltzAAazBQ+0DcYHo927iAJKti5p2rQpANfZuuR2k823lw7rtXWe3ihXbGciZ8ZCisjJ/HwkA9PXJcFkEbWmiHJVpZ055e21V2Qw4a9T2QCAQRzWI3JbLKSInMiWg5cw+5tDMFsEhnUIwZIRHeDBIsppWXukyimk9p67Ar3JgkZ1vNC6oV9Np0ZENYSFFJGT+CY+DXO+OwwhgMejGmPRY+257YuTK90ixlzO0N5fp3IAAL1bNuAinERujIUUkRNYHXceb2w5CgB4onsTvDWsLTcgdgGVbRGz63TJsF6flgE1mhMR1SwWUkQS+2zXOfz7p+MAgIn3NMXrQ1qzB8NFVLT8waVrxTibXQi5DOjRnIUUkTtjIUUkoaW/n8a7O04BAKbe2xwvDmjFIsqFWHukbhra23V9knnH0DrQeHH1cCJ3xkKKSAJCCCzZeQof/n4GAPBC/5aYfn8LibOSloeHB6ZMmWJ97gr+2bS47PFdp0vmR/Vq0aCmU7otV2xnImfG3yKiGiaEwIJtx/HprhQAwNzBEXimd3OJs5KeWq3GRx99JHUaVWId2ruhR8psEdh95p+J5s7GFduZyJmxkCKqQRaLwL9+SMaavSUrS785rA3G9QyXNimqtvImmx+5pIW22Ag/Tw90aKyRKjUiqiEOXaAmNzcXMTEx0Gg00Gg0iImJwbVr1yp9jxAC8+fPR0hICLy8vNC3b18cPXq0TIxer8f06dMREBAAHx8fDBs2DBcvXqzytVNTU/Hggw/Cx8cHAQEBmDFjBgwGg/X18+fPQyaT3fLYvn37HbUL1U5GswXPf3MQa/amQiYDFj3ajkXUDYQQyM7ORnZ2NkQFK4U7m/Imm+++frdez+b1nXINMFdsZyJn5tDf8jFjxuDgwYPYvn07tm/fjoMHDyImJqbS9yxevBhLlizB0qVLER8fj+DgYPTv3x/5+fnWmFmzZmHz5s1Yv349du/ejYKCAgwdOhRms9nma5vNZgwZMgSFhYXYvXs31q9fj02bNuGFF164Jadff/0VGRkZ1sd9991nh9ah2kRnNGPy6kRsOZgOD7kMH4zqhFFdm0idllMpKipCYGAgAgMDUVRUJHU6NlGUM9k87lzJJsU9nfRuPVdsZyKnJhzk2LFjAoDYu3ev9VhcXJwAIE6cOFHueywWiwgODhaLFi2yHtPpdEKj0YgVK1YIIYS4du2aUCqVYv369daYS5cuCblcLrZv327ztbdt2ybkcrm4dOmSNWbdunVCrVYLrVYrhBAiJSVFABBJSUnVbgetVisAWM9JtU9esUGMWLFHhM3ZKlq9vk38fuKy1Ck5pYKCAgFAABAFBQVSp2OTtKuFImzOVtHitW1CCCF0RpNo+do2ETZnqziZmSdxduVzxXYmkoKt398O65GKi4uDRqNBt27drMe6d+8OjUaDPXv2lPuelJQUZGZmYsCAAdZjarUaffr0sb4nMTERRqOxTExISAjatm1rjbHl2nFxcWjbti1CQkKsMQMHDoRer0diYmKZvIYNG4bAwEDcfffd2LhxY6U/t16vR15eXpkH1V5XCw0Y8+k+7Eu5Cj+1B756qhvubRUodVpkJzcP7R1MvQa9yYIAXxVaBPpKmRoR1RCHFVKZmZkIDLz1CyMwMBCZmZkVvgcAgoKCyhwPCgqyvpaZmQmVSoW6detWGnO7a2dmZt5ynbp160KlUlljfH19sWTJEmzcuBHbtm3D/fffj5EjR2LNmjUV/twLFy60zsvSaDQIDQ2tMJbcW4a2GCM+jsORS1rU81Fh3TPd0bVpPanTIjuyLn9wfWhv77mrAIBuzepzPTCiWqLKhdT8+fPLnYB94yMhIQEAyv0gEULc9gPm5tdtec/NMbZc+3YxAQEBeP7559G1a1dER0fjrbfewpQpU7B48eIK83j11Veh1Wqtj7S0tErzJvd0PqcQw5fH4UxWARpqPPHNsz3QthHv4HI3pXOkhCj57Ig7V7LsQY9m9aVMi4hqUJWXP5g2bRpGjRpVaUx4eDgOHz6My5cv3/Jadnb2LT1BpYKDgwGU9BY1bNjQejwrK8v6nuDgYBgMBuTm5pbplcrKykLPnj2tMbe7dnBwMPbt21fm9dzcXBiNxgrzA0qGCD/77LMKX1er1VCr1RW+Tu7veEYeYj7fj5wCPZoG+GD1xK5oXNdb6rTIAW7cVLrIYMaB1GsAgB7NWUgR1RZV7pEKCAhAREREpQ9PT0/06NEDWq0W+/fvt75337590Gq11oLnZk2bNkVwcDB27txpPWYwGBAbG2t9T1RUFJRKZZmYjIwMJCcnW2NsuXaPHj2QnJyMjIwMa8yOHTugVqsRFRVV4c+flJRUpsgjulHihVyM/DgOOQV6tG7oj2+e7cEiyo3duLF0woVcGEwWNPBTo1mAj4RZEVFNctiCnK1bt8agQYMwadIkfPzxxwCAZ555BkOHDkWrVq2scREREVi4cCEeeeQRyGQyzJo1CwsWLECLFi3QokULLFiwAN7e3hgzZgwAQKPRYOLEiXjhhRdQv3591KtXDy+++CLatWuHfv362XztAQMGIDIyEjExMXjnnXdw9epVvPjii5g0aRL8/f0BAKtWrYJSqUSnTp0gl8vx448/4oMPPsDbb7/tqGYjF7brdDae+SoRxUYzosLq4ovxXbjPWhV4eHhg3Lhx1ueuQHHD9IC/z/wzrOfM86NcsZ2JnJojbx28cuWKGDt2rPDz8xN+fn5i7NixIjc3t0wMALFy5Urrny0Wi5g3b54IDg4WarVa9O7dWxw5cqTMe4qLi8W0adNEvXr1hJeXlxg6dKhITU2t8rUvXLgghgwZIry8vES9evXEtGnThE6ns77+5ZdfitatWwtvb2/h5+cnoqKixOrVq6vUBlz+oHb4+Ui6aDG35Lb3Jz7bKwr1RqlTohpQbDCJsDlbRdicrWLAklgRNmer+HrfBanTIiI7sPX7WyYEl7Z1pLy8PGg0Gmi1WmtPF7mXNXsv4F9bkmERwOB2wXhvZEeoPRRSp0U1wGCyoOXrP5c5tueV+xBSx0uijIjIXmz9/ma/LlE1CSHwv19P4/3fTgMARncNxb8fbldmAjLZTghhXWnb29vbqYfHSt38/7pVkJ/TF1Gu2M5EzoyFFFE1mC0Cr3+fjHX7SzYfnnF/CzzfrwW/lO5AUVERfH1LFrEsKCiAj4/zT9i+uWbu26qBNIlUgSu2M5EzYyFFVEU6oxkz1yfhl6OXIZMBbz3UFjHdw6ROiyQgk8kglwGlexb3cYFCiojsi4UUURVoi42YtCoB+89fhUohx/ujOuKBdlwOozbzkMthMFvgo1IgOowr1xPVNiykiGyUqdVh/Mr9OJGZDz+1Bz4dF43uXMG61pPLAZiBu+8KgMrDYbtuEZGTYiFFZIMzWQUY98V+XLpWjAZ+aqya0BWRIbwLk/5ZS6ovN6MmqpVYSBHdRlJqLp76Mh65RUY0C/DBqqe6IrQeVyunEiF1vJCWW4T7IlhIEdVGLKSIKvHHiSxMWXsAxUYzOoTWwRfjolHfl3sp0j/WP9MdBXoTgjWeUqdCRBJgIUVUgY2JFzFn02GYLQK9WzbA8rGd4aPmr4yjKBQKDB8+3PrcVdT3VbtUce2q7UzkrLiyuYNxZXPXI4TAR3+cwbs7TgEAHu3UCG8Pbw+lghOJiYhqC65sTlQNRrMFb3yfjPXxaQCAZ3s3w5xBEZBztXIiIioHCymi6wr0JkxdewCxp7IhlwHzh7XBkz3CpU6LiIicGMcqiABcztNhxIo4xJ7KhqdSjo9jollE1bDCwkLIZDLIZDIUFhZKnY7bYjsT2Rd7pKjWO3U5HxNWxuPStWIE+Krw+bgu6BBaR+q0iIjIBbCQolptz9kcPLs6Efk6E5o18MGX47uiSX2uEUVERLZhIUW11vdJl/DSxkMwmgW6hNfFJzHRqOujkjotIiJyISykqNYRQmDZn2fxzi8nAQBD2jfEfx/vAE8l19QhIqKqYSFFtYrJbMEbW5Kxbj+XNyAiojvHQopqjUK9CVO/PoA/T3J5AyIisg8WUlQrpF8rxsRVCTiekQdPpRwfju6M/pFBUqdFN1AoFBg8eLD1OTkG25nIvrhFjINxixjpHbmoxcRV8cjK1yPAV43PxkWjI5c3ICKiSnCLGCIA25MzMWtDEnRGCyKC/fDZuGg0rsvlDYiIyD5YSJFbEkLgk7/OYdH2ExAC6NuqAT4c3Ql+nkqpUyMiIjfCLWLI7RhMFryy6QgW/lxSRI3rEYbPnoxmEeXkCgsL4ePjAx8fH25d4kBsZyL7Yo8UuRVtkRGT1yQi7twVyGXAv4ZGYvzdTaVOi2xUVFQkdQq1AtuZyH5YSJHbOJ9TiKdWxeNcdiF8VAosHdMZ90YESp0WERG5MRZS5Bb2p1zFs6sTkFtkRIjGE5+P74LWDXmXJBERORYLKXJ5m5MuYs7GIzCYLejQWINPn4xGoL+n1GkREVEtwEKKXJbFIvDer6fw4e9nAAAPtA3GkhEd4aXiIoNERFQzWEiRSyrUmzD7m4P45ehlAMCUvs3x4oBW3DOPiIhqFAspcjkXc4vw9KoEnMjMh0ohx4JH22F4VGOp06I7JJfL0adPH+tzcgy2M5F9cYsYB+MWMfaVcP4qnl2diCuFBgT4qvBxTDSiwupKnRYREbkZbhFDbuebhDS8tvkIjGaByIb++HRcNBrV8ZI6LSIiqsVYSJHTM1sEFm47js92pwAomVT+3xEd4K3iX18iIpIWB8jJqeXpjHjqy3hrETXz/hb4aExnFlFuqLCwEA0aNECDBg24dYkDsZ2J7IvfRuS0UnIK8fSqeJzNLoSnUo7/Pt4RQ9o3lDotcqCcnBypU6gV2M5E9sNCipzS32dyMGXtAWiLjQj298Rn46LRtpFG6rSIiIjKYCFFTkUIgdV7L+DNH4/BbBHoGFoHn8REcaVyIiJySiykyGnoTWb86/uj2JCQBgB4pFMjLHy0HTyVXKmciIicEwspcgqX83SYvCYRSanXIJMBLw+MwOQ+zSCTcaVyIiJyXiykSHKJF3IxeU0isvP18Pf0wIdjOqNPywZSp0VERHRbLKRIUuv2p+JfW5JhNAu0DPLFJzHRCA/wkTotkoBcLkd0dLT1OTkG25nIvrhFjINxi5jyGUwWvPnjUazdlwoAGNSmZJFNHzVreyIikh63iCGnlZWvw5Q1B5BwIRcyGfBC/5aYeu9dnA9FREQuh4UU1aiDadcweXUiMvN08PP0wPujOuK+iCCp0yIiIqoWDpBTjfkmIQ0jVsQhM0+HuwJ9sWXq3SyiyKqoqAjh4eEIDw9HUVGR1Om4LbYzkX2xR4oczmi24N9bj2FV3AUAQP/IICwZ0QF+nkqJMyNnIoTAhQsXrM/JMdjORPbFQoocKqdAjylrD2B/ylUAwKx+LTDjvhaQyzkfioiIXB8LKXKYIxe1eHZ1AtK1OviqPfDeyI7oH8mhPCIich8spMghNsSn4o0tR2EwWdAswAefPBmNuwJ9pU6LiIjIrlhIkV3pjGbM2/LPfnn9WgdiyciO8Od8KCIickMspMhu0q4WYcraAzhySQu5DHhhQCs816c550MREZHbYiFFdhF7Khsz1yfhWpERdb2V+GB0J/Rqwf3yyHYymQyRkZHW5+QYbGci+2IhRXfEYhFY+scZvPfrKQgBdGiswbInotCojpfUqZGL8fb2xtGjR6VOw+2xnYnsi4UUVZu2yIjnvzmI309kAQDGdGuCeQ9GQu2hkDgzIiKimsFCiqrlaLoWz605gNSrRVB7yPHvh9vi8ehQqdMiIiKqUSykqMo2JV7E3M1HoDdZEFrPC8vHRqFtI43UaZGLKyoqQpcuXQAA8fHx8Pb2ljgj98R2JrIvFlJkM73JjP/begxr9qYCAO5t1QDvjeyIOt4qiTMjdyCEwLFjx6zPyTHYzkT2xUKKbJJ+rRjPrT2AQ2nXIJMBs+5vien33cWlDYiIqFZjIUW3tet0NmauP4irhQZovJT436iOuLdVoNRpERERSY6FFFXIbBF4/7fT+PD30xACaBPijxVPRCG0HudUEBERASykqALZ+XrM2pCEv89cAVCytMG/hkbCU8mlDYiIiEqxkKJb7Dt3BdPXJSErXw9vlQILHmmHhzs1kjotIiIip8NCiqwsFoEVf53Fu7+chEUALYN8sWxsZ9wV6Cd1alQLyGQyhIWFWZ+TY7CdieyLhRQBAHILDZj9zUH8cTIbAPBo50b498Nt4a3iXxGqGd7e3jh//rzUabg9tjORffFbknAgNRfT1h5AulYHtYccbz3UBiOiQ/mvVSIiottgIVWLCSHwxd/nsXDbcZgsAk0DfPDRmM6IDPGXOjUiIiKXwEKqltIWG/HyxkP45ehlAMCQdg2x6LF28PNUSpwZ1VbFxcXo3bs3AOCvv/6Cl5eXxBm5J7YzkX2xkKqFki9pMWVtyYbDSoUMbwyNREz3MA7lkaQsFgsSEhKsz8kx2M5E9sVCqhYRQmDNvlT834/HYDBb0LiuFz4a0xkdQutInRoREZFLkjvy5Lm5uYiJiYFGo4FGo0FMTAyuXbtW6XuEEJg/fz5CQkLg5eWFvn374ujRo2Vi9Ho9pk+fjoCAAPj4+GDYsGG4ePFila89c+ZMREVFQa1Wo2PHjuXmc+TIEfTp0wdeXl5o1KgR3nrrLZfc6FNbbMTUrw/gje+TYTBb0K91EH6a3otFFBER0R1waCE1ZswYHDx4ENu3b8f27dtx8OBBxMTEVPqexYsXY8mSJVi6dCni4+MRHByM/v37Iz8/3xoza9YsbN68GevXr8fu3btRUFCAoUOHwmw2V+naQgg89dRTGDlyZLm55OXloX///ggJCUF8fDw+/PBDvPvuu1iyZMkdtErNS0rNxZAPdmHbkUx4yGV4bXBrfPpkFDTenA9FRER0R4SDHDt2TAAQe/futR6Li4sTAMSJEyfKfY/FYhHBwcFi0aJF1mM6nU5oNBqxYsUKIYQQ165dE0qlUqxfv94ac+nSJSGXy8X27durde158+aJDh063HJ82bJlQqPRCJ1OZz22cOFCERISIiwWi03toNVqBQCh1Wptircns9kiPo49I5q/+pMIm7NV3PP2byIpNbfG8yCyRUFBgQAgAIiCggKp03FbbGci29j6/e2wHqm4uDhoNBp069bNeqx79+7QaDTYs2dPue9JSUlBZmYmBgwYYD2mVqvRp08f63sSExNhNBrLxISEhKBt27bWmOpcu6KfoU+fPlCr1dZjAwcORHp6eoUL2un1euTl5ZV5SOFKgR5PrYrHgm0nYLIIDGnXED/N6IWOHMojIiKyG4cVUpmZmQgMDLzleGBgIDIzMyt8DwAEBQWVOR4UFGR9LTMzEyqVCnXr1q00pqrXriif8nK5MdebLVy40DovS6PRIDQ01Obr2Uvc2SsY/MEu/HkyG2oPORY80g5Lx3SCP5c2ICcXEBCAgIAAqdNwe2xnIvupciE1f/58yGSySh+lt9aWdzu9EOK2t9nf/Lot77k5prrXtiWXis4PAK+++iq0Wq31kZaWVqXr3QmzReC9nacw9rO9uJynx12Bvtgy7W6M6daESxuQ0/Px8UF2djays7Ph4+MjdTpui+1MZF9VXv5g2rRpGDVqVKUx4eHhOHz4MC5fvnzLa9nZ2bf08pQKDg4GUNLb07BhQ+vxrKws63uCg4NhMBiQm5tbplcqKysLPXv2tMZU9doV5XNzz1NWVhaAW3vNSqnV6jJDgTUlU6vDzPVJ2JdyFQAwIrox5g9rw73yiIiIHKjKPVIBAQGIiIio9OHp6YkePXpAq9Vi//791vfu27cPWq3WWvDcrGnTpggODsbOnTutxwwGA2JjY63viYqKglKpLBOTkZGB5ORka0x1rl2eHj164K+//oLBYLAe27FjB0JCQhAeHm7zeRztjxNZGPzBLuxLuQoflQLvj+qIxcM7sIgiIiJyMIfNkWrdujUGDRqESZMmYe/evdi7dy8mTZqEoUOHolWrVta4iIgIbN68GUDJcNmsWbOwYMECbN68GcnJyRg/fjy8vb0xZswYAIBGo8HEiRPxwgsv4LfffkNSUhKeeOIJtGvXDv369avStc+cOYODBw8iMzMTxcXFOHjwIA4ePGgtnMaMGQO1Wo3x48cjOTkZmzdvxoIFCzB79mynGCozmCz4z0/HMOHLeFwtNKBNiD+2zuiFhzo2kjo1oiorLi5G37590bdvXxQXF0udjttiOxPZmSNvHbxy5YoYO3as8PPzE35+fmLs2LEiNze3TAwAsXLlSuufLRaLmDdvnggODhZqtVr07t1bHDlypMx7iouLxbRp00S9evWEl5eXGDp0qEhNTa3ytfv06WO9DfjGR0pKijXm8OHDolevXkKtVovg4GAxf/58m5c+EMJxyx9cyCkUw5buFmFztoqwOVvFvC3JQmc02fUaRDWJt+XXDLYzkW1s/f6WCeGCy3S7kLy8PGg0Gmi1Wvj7+9vtvE+vSsCvxy9D46XEO8PbY0CbYLudm0gKhYWF8PX1BQAUFBRwIrSDsJ2JbGPr9zcn0biofz/cFgDw5kNt0KgOd28nIiKSAgspFxWs8cRn46KlToOIiKhWc+hee0RERETujIUUERERUTVxaI+InIa3t7fUKdQKbGci+2EhRUROwcfHB4WFhVKn4fbYzkT2xaE9IiIiompiIUVERERUTSykiMgp6HQ6DBkyBEOGDIFOp5M6HbfFdiayL86RIiKnYDabsW3bNutzcgy2M5F9sUeKiIiIqJpYSBERERFVEwspIiIiompiIUVERERUTSykiIiIiKqJd+05mBACAJCXlydxJkTO7cbVtvPy8nhHmYOwnYlsU/q9Xfo9XhGZuF0E3ZGLFy8iNDRU6jSIiIioGtLS0tC4ceMKX2ch5WAWiwXp6enw8/ODTCaTOh3J5eXlITQ0FGlpafD395c6HbfFdq45bOuaw7auGWznEkII5OfnIyQkBHJ5xTOhOLTnYHK5vNJKtrby9/ev1b+gNYXtXHPY1jWHbV0z2M6ARqO5bQwnmxMRERFVEwspIiIiompiIUU1Sq1WY968eVCr1VKn4tbYzjWHbV1z2NY1g+1cNZxsTkRERFRN7JEiIiIiqiYWUkRERETVxEKKiIiIqJpYSBERERFVEwspkpxer0fHjh0hk8lw8OBBqdNxO+fPn8fEiRPRtGlTeHl5oXnz5pg3bx4MBoPUqbmFZcuWoWnTpvD09ERUVBR27doldUpuZeHChejSpQv8/PwQGBiIhx9+GCdPnpQ6rVph4cKFkMlkmDVrltSpODUWUiS5l19+GSEhIVKn4bZOnDgBi8WCjz/+GEePHsV7772HFStWYO7cuVKn5vI2bNiAWbNm4bXXXkNSUhJ69eqFBx54AKmpqVKn5jZiY2MxdepU7N27Fzt37oTJZMKAAQPKbL5M9hcfH49PPvkE7du3lzoVp8flD0hSP//8M2bPno1NmzahTZs2SEpKQseOHaVOy+298847WL58Oc6dOyd1Ki6tW7du6Ny5M5YvX2491rp1azz88MNYuHChhJm5r+zsbAQGBiI2Nha9e/eWOh23VFBQgM6dO2PZsmX497//jY4dO+J///uf1Gk5LfZIkWQuX76MSZMmYfXq1fD29pY6nVpFq9WiXr16Uqfh0gwGAxITEzFgwIAyxwcMGIA9e/ZIlJX702q1AMC/vw40depUDBkyBP369ZM6FZfATYtJEkIIjB8/HpMnT0Z0dDTOnz8vdUq1xtmzZ/Hhhx/iv//9r9SpuLScnByYzWYEBQWVOR4UFITMzEyJsnJvQgjMnj0b99xzD9q2bSt1Om5p/fr1OHDgAOLj46VOxWWwR4rsav78+ZDJZJU+EhIS8OGHHyIvLw+vvvqq1Cm7LFvb+kbp6ekYNGgQHn/8cTz99NMSZe5eZDJZmT8LIW45RvYxbdo0HD58GOvWrZM6FbeUlpaGmTNnYs2aNfD09JQ6HZfBOVJkVzk5OcjJyak0Jjw8HKNGjcKPP/5Y5gvHbDZDoVBg7NixWLVqlaNTdXm2tnXpB2J6ejruvfdedOvWDV9++SXkcv476k4YDAZ4e3vj22+/xSOPPGI9PnPmTBw8eBCxsbESZud+pk+fju+//x5//fUXmjZtKnU6bun777/HI488AoVCYT1mNpshk8kgl8uh1+vLvEYlWEiRJFJTU5GXl2f9c3p6OgYOHIiNGzeiW7duaNy4sYTZuZ9Lly7h3nvvRVRUFNasWcMPQzvp1q0boqKisGzZMuuxyMhIPPTQQ5xsbidCCEyfPh2bN2/Gn3/+iRYtWkidktvKz8/HhQsXyhybMGECIiIiMGfOHA6nVoBzpEgSTZo0KfNnX19fAEDz5s1ZRNlZeno6+vbtiyZNmuDdd99Fdna29bXg4GAJM3N9s2fPRkxMDKKjo9GjRw988sknSE1NxeTJk6VOzW1MnToVX3/9NbZs2QI/Pz/r/DONRgMvLy+Js3Mvfn5+txRLPj4+qF+/PouoSrCQInJzO3bswJkzZ3DmzJlbilR2SN+ZkSNH4sqVK3jrrbeQkZGBtm3bYtu2bQgLC5M6NbdRurRE3759yxxfuXIlxo8fX/MJEd2EQ3tERERE1cTZpkRERETVxEKKiIiIqJpYSBERERFVEwspIiIiompiIUVERERUTSykiIiIiKqJhRQRERFRNbGQIiIiIqomFlJERERE1cRCioiIiKiaWEgRERERVRMLKSIiIqJq+n/5ds3UwPg58wAAAABJRU5ErkJggg==", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(alphas[:-1], np.diff(mfRescaled(alphas)))\n", + "# plt.plot(-alphas[:-1], -np.diff(mfRescaled(alphas)))\n", + "plt.axhline(0, ls='--', c='k')\n", + "plt.axvline(x=1, c=\"k\", ls=\"--\")\n", + "plt.axvline(x=-1, c=\"k\", ls=\"--\")\n", + "# plt.ylim(-4, -2)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}