From 520750a8364952abf4bf9d9b2a87040e8a52da6c Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Fri, 31 Mar 2023 02:23:08 +0530 Subject: [PATCH 001/129] Added Dockerfile --- Dockerfile | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 Dockerfile diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000000..1dfacca889 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,27 @@ +# Base Image +FROM python:3.8-slim-buster + +# Set the working directory +WORKDIR /app + +# Install the necessary dependencies +RUN apt-get update \ + && apt-get install -y build-essential \ + && apt-get install -y libgmp3-dev libmpfr-dev libmpc-dev \ + && apt-get install -y libffi-dev libssl-dev + +# Copy necessary files into the container +COPY setup.py . +COPY CMakeBuild.py . +COPY README.md . +COPY pybamm/version.py ./pybamm/version.py + +# Install PyBaMM +RUN pip install -e ".[dev]" + + +# Expose the default Jupyter notebook port +EXPOSE 8888 + +# Start Jupyter notebook on container start +CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"] From 94b3358d53d697ce5ed7a5dd656724ac6f6d00fd Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Wed, 2 Aug 2023 14:34:13 +0530 Subject: [PATCH 002/129] Update Dockerfile --- Dockerfile | 28 +++++++++------------------- 1 file changed, 9 insertions(+), 19 deletions(-) diff --git a/Dockerfile b/Dockerfile index 1dfacca889..df9427c41f 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,27 +1,17 @@ -# Base Image -FROM python:3.8-slim-buster +FROM python:3.11-slim # Set the working directory -WORKDIR /app +WORKDIR /PyBaMM # Install the necessary dependencies -RUN apt-get update \ - && apt-get install -y build-essential \ - && apt-get install -y libgmp3-dev libmpfr-dev libmpc-dev \ - && apt-get install -y libffi-dev libssl-dev +RUN apt-get update && apt-get -y upgrade +RUN apt-get install -y build-essential -# Copy necessary files into the container -COPY setup.py . -COPY CMakeBuild.py . -COPY README.md . -COPY pybamm/version.py ./pybamm/version.py +# Copy project files into the container +COPY . . # Install PyBaMM -RUN pip install -e ".[dev]" +RUN python -m pip install --upgrade pip +RUN pip install -e ".[all]" - -# Expose the default Jupyter notebook port -EXPOSE 8888 - -# Start Jupyter notebook on container start -CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"] +CMD ["/bin/bash"] \ No newline at end of file From b31499b64f5addcbf9603f1fe2f186da25f00985 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Wed, 2 Aug 2023 11:22:23 +0100 Subject: [PATCH 003/129] #3321 allow T(y,z,t) --- examples/scripts/pouch_cell_cooling.py | 41 +++++++++++++++++++ pybamm/discretisations/discretisation.py | 7 ++-- .../lithium_ion/electrode_soh.py | 4 +- .../equivalent_circuit_elements/thermal.py | 1 + .../models/submodels/thermal/base_thermal.py | 16 ++++++-- pybamm/models/submodels/thermal/isothermal.py | 7 +++- pybamm/models/submodels/thermal/lumped.py | 2 +- pybamm/parameters/thermal_parameters.py | 11 ++++- .../spatial_methods/scikit_finite_element.py | 11 ++--- 9 files changed, 80 insertions(+), 20 deletions(-) create mode 100644 examples/scripts/pouch_cell_cooling.py diff --git a/examples/scripts/pouch_cell_cooling.py b/examples/scripts/pouch_cell_cooling.py new file mode 100644 index 0000000000..da7165cdce --- /dev/null +++ b/examples/scripts/pouch_cell_cooling.py @@ -0,0 +1,41 @@ +# +# Example showing how to customize thermal boundary conditions in a pouch cell model +# +import numpy as np +import pybamm + +pybamm.set_logging_level("INFO") + +# load model +model = pybamm.lithium_ion.SPM( + {"current collector": "potential pair", "dimensionality": 2}, name="2+1D SPM" +) + +# update parameter values, to use: +# 1) a spatially-varying ambient temperature +param = model.param +L_y = param.L_y +L_z = param.L_z +parameter_values = model.default_parameter_values + + +def T_amb(y, z, t): + return 300 + 20 * pybamm.sin(np.pi * y / L_y) * pybamm.sin(np.pi * z / L_z) + + +parameter_values.update({"Ambient temperature [K]": T_amb}) + +# create and solve simulation +var_pts = {"x_n": 4, "x_s": 4, "x_p": 4, "r_n": 4, "r_p": 4, "y": 16, "z": 16} +sim = pybamm.Simulation(model, parameter_values=parameter_values, var_pts=var_pts) +sim.build() +sim.solve([0, 3600]) + +# plot +output_variables = [ + "Negative current collector potential [V]", + "Positive current collector potential [V]", + "X-averaged cell temperature [K]", + "Voltage [V]", +] +sim.plot(output_variables) diff --git a/pybamm/discretisations/discretisation.py b/pybamm/discretisations/discretisation.py index 5dfd2405cc..deaed42657 100644 --- a/pybamm/discretisations/discretisation.py +++ b/pybamm/discretisations/discretisation.py @@ -99,8 +99,8 @@ def process_model( check_model=True, remove_independent_variables_from_rhs=True, ): - """Discretise a model. - Currently inplace, could be changed to return a new model. + """ + Discretise a model. Currently inplace, could be changed to return a new model. Parameters ---------- @@ -688,7 +688,8 @@ def process_dict(self, var_eqn_dict, ics=False): pybamm.logger.debug("Discretise {!r}".format(eqn_key)) processed_eqn = self.process_symbol(eqn) - + if eqn_key == "X-averaged cell temperature [K]": + print("hi") # Calculate scale if the key has a scale scale = getattr(eqn_key, "scale", 1) if ics: diff --git a/pybamm/models/full_battery_models/lithium_ion/electrode_soh.py b/pybamm/models/full_battery_models/lithium_ion/electrode_soh.py index e90b8d9649..92996675d4 100644 --- a/pybamm/models/full_battery_models/lithium_ion/electrode_soh.py +++ b/pybamm/models/full_battery_models/lithium_ion/electrode_soh.py @@ -623,7 +623,9 @@ def theoretical_energy_integral(parameter_values, inputs, points=100): y_vals = np.linspace(y_100, y_0, num=points) # Calculate OCV at each stoichiometry param = pybamm.LithiumIonParameters() - T = param.T_amb(0) + y = pybamm.standard_spatial_vars.y + z = pybamm.standard_spatial_vars.z + T = pybamm.yz_average(param.T_amb(y, z, 0)) Vs = np.empty(x_vals.shape) for i in range(x_vals.size): Vs[i] = ( diff --git a/pybamm/models/submodels/equivalent_circuit_elements/thermal.py b/pybamm/models/submodels/equivalent_circuit_elements/thermal.py index 5768d5dd18..a5003ef615 100644 --- a/pybamm/models/submodels/equivalent_circuit_elements/thermal.py +++ b/pybamm/models/submodels/equivalent_circuit_elements/thermal.py @@ -22,6 +22,7 @@ def get_fundamental_variables(self): T_cell = pybamm.Variable("Cell temperature [degC]") T_jig = pybamm.Variable("Jig temperature [degC]") + # Note this is defined in deg C T_amb = self.param.T_amb(pybamm.t) Q_cell_cool = -self.param.k_cell_jig * (T_cell - T_jig) diff --git a/pybamm/models/submodels/thermal/base_thermal.py b/pybamm/models/submodels/thermal/base_thermal.py index 54c4a1b467..9763639b06 100644 --- a/pybamm/models/submodels/thermal/base_thermal.py +++ b/pybamm/models/submodels/thermal/base_thermal.py @@ -37,10 +37,18 @@ def _get_standard_fundamental_variables(self, T_dict): T_mid = [T_dict[k] for k in self.options.whole_cell_domains] T = pybamm.concatenation(*T_mid) - # Get the ambient temperature, which can be specified as a function of time - T_amb = param.T_amb(pybamm.t) - - variables = {"Ambient temperature [K]": T_amb, "Cell temperature [K]": T} + # Get the ambient temperature, which can be specified as a function of space + # (y, z) only and time + y = pybamm.standard_spatial_vars.y + z = pybamm.standard_spatial_vars.z + T_amb = param.T_amb(y, z, pybamm.t) + T_amb_av = self._yz_average(T_amb) + + variables = { + "Ambient temperature [K]": T_amb, + "Volume-averaged ambient temperature [K]": T_amb_av, + "Cell temperature [K]": T, + } for name, var in T_dict.items(): Name = name.capitalize() variables[f"{Name} temperature [K]"] = var diff --git a/pybamm/models/submodels/thermal/isothermal.py b/pybamm/models/submodels/thermal/isothermal.py index 3573c1634a..d8070f6eba 100644 --- a/pybamm/models/submodels/thermal/isothermal.py +++ b/pybamm/models/submodels/thermal/isothermal.py @@ -22,8 +22,11 @@ def __init__(self, param, options=None): super().__init__(param, options=options) def get_fundamental_variables(self): - T_amb = self.param.T_amb(pybamm.t) - T_x_av = pybamm.PrimaryBroadcast(T_amb, "current collector") + # Set the x-averaged temperature to the ambient temperature, which can be + # specified as a function of space (y, z) only and time + y = pybamm.standard_spatial_vars.y + z = pybamm.standard_spatial_vars.z + T_x_av = self.param.T_amb(y, z, pybamm.t) T_dict = { "negative current collector": T_x_av, diff --git a/pybamm/models/submodels/thermal/lumped.py b/pybamm/models/submodels/thermal/lumped.py index 0b7387390f..09aa7dde6a 100644 --- a/pybamm/models/submodels/thermal/lumped.py +++ b/pybamm/models/submodels/thermal/lumped.py @@ -51,7 +51,7 @@ def get_coupled_variables(self, variables): def set_rhs(self, variables): T_vol_av = variables["Volume-averaged cell temperature [K]"] Q_vol_av = variables["Volume-averaged total heating [W.m-3]"] - T_amb = variables["Ambient temperature [K]"] + T_amb = variables["Volume-averaged ambient temperature [K]"] # Account for surface area to volume ratio in cooling coefficient # The factor 1/delta^2 comes from the choice of non-dimensionalisation. diff --git a/pybamm/parameters/thermal_parameters.py b/pybamm/parameters/thermal_parameters.py index 152530c55c..6bd239f657 100644 --- a/pybamm/parameters/thermal_parameters.py +++ b/pybamm/parameters/thermal_parameters.py @@ -41,9 +41,16 @@ def _set_parameters(self): # Initial temperature self.T_init = pybamm.Parameter("Initial temperature [K]") - def T_amb(self, t): + def T_amb(self, y, z, t): """Dimensional ambient temperature""" - return pybamm.FunctionParameter("Ambient temperature [K]", {"Time [s]": t}) + return pybamm.FunctionParameter( + "Ambient temperature [K]", + { + "Distance across electrode width [m]": y, + "Distance across electrode height [m]": z, + "Time [s]": t, + }, + ) def rho_c_p_eff(self, T): """Effective volumetric heat capacity [J.m-3.K-1]""" diff --git a/pybamm/spatial_methods/scikit_finite_element.py b/pybamm/spatial_methods/scikit_finite_element.py index e610c08c6e..0f0a42bbcb 100644 --- a/pybamm/spatial_methods/scikit_finite_element.py +++ b/pybamm/spatial_methods/scikit_finite_element.py @@ -52,18 +52,15 @@ def spatial_variable(self, symbol): """ symbol_mesh = self.mesh if symbol.name == "y": - vector = pybamm.Vector( - symbol_mesh["current collector"].coordinates[0, :][:, np.newaxis] - ) + entries = symbol_mesh["current collector"].coordinates[0, :][:, np.newaxis] + elif symbol.name == "z": - vector = pybamm.Vector( - symbol_mesh["current collector"].coordinates[1, :][:, np.newaxis] - ) + entries = symbol_mesh["current collector"].coordinates[1, :][:, np.newaxis] else: raise pybamm.GeometryError( "Spatial variable must be 'y' or 'z' not {}".format(symbol.name) ) - return vector + return pybamm.Vector(entries, domains=symbol.domains) def gradient(self, symbol, discretised_symbol, boundary_conditions): """Matrix-vector multiplication to implement the gradient operator. The From ce86eb4f863405d3b374730bf3d1996c3fc0e502 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Wed, 2 Aug 2023 16:17:03 +0530 Subject: [PATCH 004/129] Install git only --- Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Dockerfile b/Dockerfile index df9427c41f..814102299c 100644 --- a/Dockerfile +++ b/Dockerfile @@ -5,7 +5,7 @@ WORKDIR /PyBaMM # Install the necessary dependencies RUN apt-get update && apt-get -y upgrade -RUN apt-get install -y build-essential +RUN apt-get install -y git # Copy project files into the container COPY . . From 8428308dd7eafb7a13e1bf1645048468a860f685 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Wed, 2 Aug 2023 16:56:17 +0530 Subject: [PATCH 005/129] Install build tools --- Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Dockerfile b/Dockerfile index 814102299c..a1f41e8ea5 100644 --- a/Dockerfile +++ b/Dockerfile @@ -5,7 +5,7 @@ WORKDIR /PyBaMM # Install the necessary dependencies RUN apt-get update && apt-get -y upgrade -RUN apt-get install -y git +RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git # Copy project files into the container COPY . . From 11abbce5999aa9fda4a22e4738aea59e62bde7f5 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Wed, 2 Aug 2023 17:33:54 +0100 Subject: [PATCH 006/129] #3321 add h_cc(y,z) --- examples/scripts/thermal_lithium_ion.py | 74 +++++++++---------- .../full_battery_models/base_battery_model.py | 7 +- pybamm/models/submodels/thermal/lumped.py | 5 +- .../pouch_cell_1D_current_collectors.py | 9 ++- .../pouch_cell_2D_current_collectors.py | 16 ++-- pybamm/models/submodels/thermal/x_full.py | 6 +- pybamm/parameters/thermal_parameters.py | 18 ++++- 7 files changed, 75 insertions(+), 60 deletions(-) diff --git a/examples/scripts/thermal_lithium_ion.py b/examples/scripts/thermal_lithium_ion.py index 9240c6e895..81c46b1b76 100644 --- a/examples/scripts/thermal_lithium_ion.py +++ b/examples/scripts/thermal_lithium_ion.py @@ -1,27 +1,25 @@ # # Compares the full and lumped thermal models for a single layer Li-ion cell # - import pybamm -import numpy as np -# load model pybamm.set_logging_level("INFO") -options = {"thermal": "x-full"} -full_thermal_model = pybamm.lithium_ion.SPMe(options) - -options = {"thermal": "x-lumped"} -lumped_thermal_model = pybamm.lithium_ion.SPMe(options) - +# load models +full_thermal_model = pybamm.lithium_ion.SPMe( + {"thermal": "x-full"}, name="full thermal model" +) +lumped_thermal_model = pybamm.lithium_ion.SPMe( + {"thermal": "lumped"}, name="lumped thermal model" +) models = [full_thermal_model, lumped_thermal_model] -# load parameter values and process models and geometry -param = models[0].default_parameter_values - -# for x-full, cooling is only implemented on the surfaces -# so set other forms of cooling to zero for comparison. -param.update( +# load parameter values, we will use the Marquis2019 parameter set +parameter_values = pybamm.ParameterValues("Marquis2019") +# for the "full" model we use a heat transfer coefficient of 5 W.m-2.K-1 on the large +# surfaces of the pouch and zero heat transfer coefficient on the tabs and edges +full_params = parameter_values.copy() +full_params.update( { "Negative current collector" + " surface heat transfer coefficient [W.m-2.K-1]": 5, @@ -32,29 +30,27 @@ "Edge heat transfer coefficient [W.m-2.K-1]": 0, } ) +# for the lumped model we set the "Total heat transfer coefficient [W.m-2.K-1]" +# parameter as well as the "Cell cooling surface area [m2]" parameter. Since the "full" +# model only accounts for cooling from the large surfaces of the pouch, we set the +# "Surface area for cooling" parameter to the area of the large surfaces of the pouch, +# and the total heat transfer coefficient to 5 W.m-2.K-1 +A = parameter_values["Electrode width [m]"] * parameter_values["Electrode height [m]"] +lumped_params = parameter_values.copy() +lumped_params.update( + { + "Total heat transfer coefficient [W.m-2.K-1]": 5, + "Cell cooling surface area [m2]": 2 * A, + } +) +params = [full_params, lumped_params] +# loop over the models and solve +sols = [] +for model, param in zip(models, params): + sim = pybamm.Simulation(model, parameter_values=param) + sim.solve([0, 3600]) + sols.append(sim.solution) -for model in models: - param.process_model(model) - -# set mesh -var_pts = {"x_n": 10, "x_s": 10, "x_p": 10, "r_n": 10, "r_p": 10} - -# discretise models -for model in models: - # create geometry - geometry = model.default_geometry - param.process_geometry(geometry) - mesh = pybamm.Mesh(geometry, models[-1].default_submesh_types, var_pts) - disc = pybamm.Discretisation(mesh, model.default_spatial_methods) - disc.process_model(model) - -# solve model -solutions = [None] * len(models) -t_eval = np.linspace(0, 3600, 100) -for i, model in enumerate(models): - solver = pybamm.ScipySolver(atol=1e-8, rtol=1e-8) - solution = solver.solve(model, t_eval) - solutions[i] = solution # plot output_variables = [ @@ -62,6 +58,4 @@ "X-averaged cell temperature [K]", "Cell temperature [K]", ] -labels = ["Full thermal model", "Lumped thermal model"] -plot = pybamm.QuickPlot(solutions, output_variables, labels) -plot.dynamic_plot() +pybamm.dynamic_plot(sols, output_variables) diff --git a/pybamm/models/full_battery_models/base_battery_model.py b/pybamm/models/full_battery_models/base_battery_model.py index 7a39874108..34afebf092 100644 --- a/pybamm/models/full_battery_models/base_battery_model.py +++ b/pybamm/models/full_battery_models/base_battery_model.py @@ -284,11 +284,12 @@ def __init__(self, extra_options): name: options[0] for name, options in self.possible_options.items() } - # Change the default for cell geometry based on which thermal option is provided + # Change the default for cell geometry based on the current collector + # dimensionality extra_options = extra_options or {} # return "none" if option not given - thermal_option = extra_options.get("thermal", "none") - if thermal_option in ["none", "isothermal", "lumped"]: + current_collector_option = extra_options.get("current collector", "none") + if current_collector_option == 0: default_options["cell geometry"] = "arbitrary" else: default_options["cell geometry"] = "pouch" diff --git a/pybamm/models/submodels/thermal/lumped.py b/pybamm/models/submodels/thermal/lumped.py index 09aa7dde6a..a239e4b994 100644 --- a/pybamm/models/submodels/thermal/lumped.py +++ b/pybamm/models/submodels/thermal/lumped.py @@ -54,13 +54,14 @@ def set_rhs(self, variables): T_amb = variables["Volume-averaged ambient temperature [K]"] # Account for surface area to volume ratio in cooling coefficient - # The factor 1/delta^2 comes from the choice of non-dimensionalisation. if self.options["cell geometry"] == "pouch": + y = pybamm.standard_spatial_vars.y + z = pybamm.standard_spatial_vars.z cell_volume = self.param.L * self.param.L_y * self.param.L_z yz_cell_surface_area = self.param.L_y * self.param.L_z yz_surface_cooling_coefficient = -( - self.param.n.h_cc + self.param.p.h_cc + self._yz_average(self.param.n.h_cc(y, z) + self.param.p.h_cc(y, z)) ) * (yz_cell_surface_area / cell_volume) negative_tab_area = self.param.n.L_tab * self.param.n.L_cc diff --git a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py index 558ba3441e..a96621e3b6 100644 --- a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py +++ b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py @@ -55,15 +55,18 @@ def set_rhs(self, variables): T_av = variables["X-averaged cell temperature [K]"] Q_av = variables["X-averaged total heating [W.m-3]"] T_amb = variables["Ambient temperature [K]"] + y = pybamm.standard_spatial_vars.y + z = pybamm.standard_spatial_vars.z # Account for surface area to volume ratio of pouch cell in cooling - # coefficient. Note: the factor 1/delta^2 comes from the choice of - # non-dimensionalisation + # coefficient. cell_volume = self.param.L * self.param.L_y * self.param.L_z yz_surface_area = self.param.L_y * self.param.L_z yz_surface_cooling_coefficient = ( - -(self.param.n.h_cc + self.param.p.h_cc) * yz_surface_area / cell_volume + -(self.param.n.h_cc(y, z) + self.param.p.h_cc(y, z)) + * yz_surface_area + / cell_volume ) side_edge_area = 2 * self.param.L_z * self.param.L diff --git a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py index 35d226d6e3..8327711aee 100644 --- a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py +++ b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py @@ -55,17 +55,21 @@ def set_rhs(self, variables): T_av = variables["X-averaged cell temperature [K]"] Q_av = variables["X-averaged total heating [W.m-3]"] T_amb = variables["Ambient temperature [K]"] + y = pybamm.standard_spatial_vars.y + z = pybamm.standard_spatial_vars.z # Account for surface area to volume ratio of pouch cell in cooling - # coefficient. Note: the factor 1/delta^2 comes from the choice of - # non-dimensionalisation - yz_surface_area = self.param.L_y * self.param.L_z + # coefficient cell_volume = self.param.L * self.param.L_y * self.param.L_z + + yz_surface_area = self.param.L_y * self.param.L_z yz_surface_cooling_coefficient = ( - -(self.param.n.h_cc + self.param.p.h_cc) * yz_surface_area / cell_volume + -(self.param.n.h_cc(y, z) + self.param.p.h_cc(y, z)) + * yz_surface_area + / cell_volume ) - edge_cooling_coefficient = self.param.h_edge + edge_cooling_coefficient = -self.param.h_edge # Governing equations contain: # - source term for y-z surface cooling @@ -77,7 +81,7 @@ def set_rhs(self, variables): pybamm.laplacian(T_av) + pybamm.source(Q_av, T_av) + yz_surface_cooling_coefficient * pybamm.source(T_av - T_amb, T_av) - - edge_cooling_coefficient + + edge_cooling_coefficient * pybamm.source(T_av - T_amb, T_av, boundary=True) ) / self.param.rho_c_p_eff(T_av) diff --git a/pybamm/models/submodels/thermal/x_full.py b/pybamm/models/submodels/thermal/x_full.py index 49d83a6f2e..e5e7828d46 100644 --- a/pybamm/models/submodels/thermal/x_full.py +++ b/pybamm/models/submodels/thermal/x_full.py @@ -97,16 +97,18 @@ def set_boundary_conditions(self, variables): # N.B only y-z surface cooling is implemented for this thermal model. # Tab and edge cooling is not accounted for. + y = pybamm.standard_spatial_vars.y + z = pybamm.standard_spatial_vars.z self.boundary_conditions = { T: { "left": ( - self.param.n.h_cc + self.param.n.h_cc(y, z) * (T_n_left - T_amb) / self.param.n.lambda_(T_n_left), "Neumann", ), "right": ( - -self.param.p.h_cc + -self.param.p.h_cc(y, z) * (T_p_right - T_amb) / self.param.p.lambda_(T_p_right), "Neumann", diff --git a/pybamm/parameters/thermal_parameters.py b/pybamm/parameters/thermal_parameters.py index 6bd239f657..5fd86eb525 100644 --- a/pybamm/parameters/thermal_parameters.py +++ b/pybamm/parameters/thermal_parameters.py @@ -70,14 +70,24 @@ def __init__(self, domain, main_param): def _set_parameters(self): Domain = self.domain.capitalize() - self.h_cc = pybamm.Parameter( - f"{Domain} current collector surface heat transfer coefficient " - "[W.m-2.K-1]" - ) + self.h_tab = pybamm.Parameter( f"{Domain} tab heat transfer coefficient [W.m-2.K-1]" ) + def h_cc(self, y, z): + """Current collector surface heat transfer coefficient [W.m-2.K-1]""" + inputs = { + "Distance across electrode width [m]": y, + "Distance across electrode height [m]": z, + } + Domain = self.domain.capitalize() + return pybamm.FunctionParameter( + f"{Domain} current collector surface heat transfer coefficient " + "[W.m-2.K-1]", + inputs, + ) + def c_p(self, T): """Electrode specific heat capacity [J.kg-1.K-1]""" inputs = {"Temperature [K]": T} From a41cbec9474a18701f0dbf7842a030abdffc434d Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Thu, 3 Aug 2023 11:18:44 +0100 Subject: [PATCH 007/129] Add volume-averaged diffusivity --- pybamm/models/submodels/particle/base_particle.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pybamm/models/submodels/particle/base_particle.py b/pybamm/models/submodels/particle/base_particle.py index 94e9fb5c40..01188206c7 100644 --- a/pybamm/models/submodels/particle/base_particle.py +++ b/pybamm/models/submodels/particle/base_particle.py @@ -400,6 +400,8 @@ def _get_standard_diffusivity_variables(self, D_eff): f"{Domain} {phase_name}particle effective diffusivity [m2.s-1]": D_eff, f"X-averaged {domain} {phase_name}particle effective " "diffusivity [m2.s-1]": pybamm.x_average(D_eff), + f"Volume-averaged {domain} {phase_name}particle effective " + "diffusivity [m2.s-1]": pybamm.r_average(pybamm.x_average(D_eff)), } return variables From 751b92084b7b5af3fd79c252d71b7b8b2f1ede72 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Fri, 4 Aug 2023 11:56:36 +0100 Subject: [PATCH 008/129] #3321 add h_egde(y,z) --- examples/scripts/pouch_cell_cooling.py | 24 +++++++++-- examples/scripts/pouch_cell_isothermal.py | 41 ++++++++++++++++++ .../pouch_cell_2D_current_collectors.py | 43 ++++++++++++------- pybamm/parameters/thermal_parameters.py | 14 +++++- pybamm/plotting/quick_plot.py | 8 +++- 5 files changed, 106 insertions(+), 24 deletions(-) create mode 100644 examples/scripts/pouch_cell_isothermal.py diff --git a/examples/scripts/pouch_cell_cooling.py b/examples/scripts/pouch_cell_cooling.py index da7165cdce..d2093aed07 100644 --- a/examples/scripts/pouch_cell_cooling.py +++ b/examples/scripts/pouch_cell_cooling.py @@ -8,11 +8,13 @@ # load model model = pybamm.lithium_ion.SPM( - {"current collector": "potential pair", "dimensionality": 2}, name="2+1D SPM" + {"current collector": "potential pair", "dimensionality": 2, "thermal": "x-lumped"} ) # update parameter values, to use: # 1) a spatially-varying ambient temperature +# 2) a spatially-varying surface heat transfer coefficient +# 3) a spatially-varying edge heat transfer coefficient param = model.param L_y = param.L_y L_z = param.L_z @@ -23,13 +25,27 @@ def T_amb(y, z, t): return 300 + 20 * pybamm.sin(np.pi * y / L_y) * pybamm.sin(np.pi * z / L_z) -parameter_values.update({"Ambient temperature [K]": T_amb}) +def h_edge(y, z): + return pybamm.InputParameter("h_right") * (y >= L_y) + + +parameter_values.update( + { + "Current function [A]": 2 * 0.680616, + "Ambient temperature [K]": 298, + "Negative current collector surface heat transfer coefficient [W.m-2.K-1]": 0, + "Positive current collector surface heat transfer coefficient [W.m-2.K-1]": 0, + "Negative tab heat transfer coefficient [W.m-2.K-1]": 10000, + "Positive tab heat transfer coefficient [W.m-2.K-1]": 0, + "Edge heat transfer coefficient [W.m-2.K-1]": h_edge, + } +) # create and solve simulation var_pts = {"x_n": 4, "x_s": 4, "x_p": 4, "r_n": 4, "r_p": 4, "y": 16, "z": 16} sim = pybamm.Simulation(model, parameter_values=parameter_values, var_pts=var_pts) sim.build() -sim.solve([0, 3600]) +sim.solve([0, 600], inputs={"h_right": 5}) # plot output_variables = [ @@ -38,4 +54,4 @@ def T_amb(y, z, t): "X-averaged cell temperature [K]", "Voltage [V]", ] -sim.plot(output_variables) +sim.plot(output_variables, variable_limits="tight", shading="gouraud") diff --git a/examples/scripts/pouch_cell_isothermal.py b/examples/scripts/pouch_cell_isothermal.py new file mode 100644 index 0000000000..fce55a99dc --- /dev/null +++ b/examples/scripts/pouch_cell_isothermal.py @@ -0,0 +1,41 @@ +# +# Example showing how to customize thermal boundary conditions in a pouch cell model +# +import numpy as np +import pybamm + +pybamm.set_logging_level("INFO") + +# load model +model = pybamm.lithium_ion.SPM( + {"current collector": "potential pair", "dimensionality": 2} +) + +# update parameter values, to use: +# 1) a spatially-varying ambient temperature +param = model.param +L_y = param.L_y +L_z = param.L_z +parameter_values = model.default_parameter_values + + +def T_amb(y, z, t): + return 300 + 20 * pybamm.sin(np.pi * y / L_y) * pybamm.sin(np.pi * z / L_z) + + +parameter_values.update({"Ambient temperature [K]": T_amb}) + +# create and solve simulation +var_pts = {"x_n": 4, "x_s": 4, "x_p": 4, "r_n": 4, "r_p": 4, "y": 16, "z": 16} +sim = pybamm.Simulation(model, parameter_values=parameter_values, var_pts=var_pts) +sim.build() +sim.solve([0, 3600]) + +# plot +output_variables = [ + "Negative current collector potential [V]", + "Positive current collector potential [V]", + "X-averaged cell temperature [K]", + "Voltage [V]", +] +sim.plot(output_variables, variable_limits="tight", shading="gouraud") diff --git a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py index 8327711aee..adaf5d25a0 100644 --- a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py +++ b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py @@ -58,8 +58,8 @@ def set_rhs(self, variables): y = pybamm.standard_spatial_vars.y z = pybamm.standard_spatial_vars.z - # Account for surface area to volume ratio of pouch cell in cooling - # coefficient + # Account for surface area to volume ratio of pouch cell in surface cooling + # term cell_volume = self.param.L * self.param.L_y * self.param.L_z yz_surface_area = self.param.L_y * self.param.L_z @@ -69,48 +69,59 @@ def set_rhs(self, variables): / cell_volume ) - edge_cooling_coefficient = -self.param.h_edge + # Edge cooling appears as a boundary term, so no need to account for surface + # area to volume ratio + edge_cooling_coefficient = -self.param.h_edge(y, z) # Governing equations contain: # - source term for y-z surface cooling # - boundary source term of edge cooling # Boundary conditions contain: # - Neumann condition for tab cooling + # Note: pybamm.source() is used to ensure the source term is multiplied by the + # correct mass matrix when discretised. The first argument is the source term + # and the second argument is the variable governed by the equation that the + # source term appears in. self.rhs = { T_av: ( pybamm.laplacian(T_av) + pybamm.source(Q_av, T_av) - + yz_surface_cooling_coefficient * pybamm.source(T_av - T_amb, T_av) - + edge_cooling_coefficient - * pybamm.source(T_av - T_amb, T_av, boundary=True) + + pybamm.source(yz_surface_cooling_coefficient * (T_av - T_amb), T_av) + + pybamm.source( + edge_cooling_coefficient * (T_av - T_amb), T_av, boundary=True + ) ) / self.param.rho_c_p_eff(T_av) } - # TODO: Make h_edge a function of position to have bottom/top/side cooled cells. - def set_boundary_conditions(self, variables): T_av = variables["X-averaged cell temperature [K]"] T_amb = variables["Ambient temperature [K]"] + y = pybamm.standard_spatial_vars.y + z = pybamm.standard_spatial_vars.z # Subtract the edge cooling from the tab portion so as to not double count # Note: tab cooling is also only applied on the current collector hence - # the (l_cn / l) and (l_cp / l) prefactors. - # We also still have edge cooling on the region: x in (0, 1) + # the (l_cn / l) and (l_cp / l) prefactors. We also still have edge cooling + # in the region: x in (0, 1) h_tab_n_corrected = (self.param.n.L_cc / self.param.L) * ( - self.param.n.h_tab - self.param.h_edge + self.param.n.h_tab - self.param.h_edge(y, z) ) h_tab_p_corrected = (self.param.p.L_cc / self.param.L) * ( - self.param.p.h_tab - self.param.h_edge + self.param.p.h_tab - self.param.h_edge(y, z) ) - T_av_n = pybamm.boundary_value(T_av, "negative tab") - T_av_p = pybamm.boundary_value(T_av, "positive tab") + negative_tab_bc = pybamm.boundary_value( + -h_tab_n_corrected * (T_av - T_amb), "negative tab" + ) + positive_tab_bc = pybamm.boundary_value( + -h_tab_p_corrected * (T_av - T_amb), "positive tab" + ) self.boundary_conditions = { T_av: { - "negative tab": (-h_tab_n_corrected * (T_av_n - T_amb), "Neumann"), - "positive tab": (-h_tab_p_corrected * (T_av_p - T_amb), "Neumann"), + "negative tab": (negative_tab_bc, "Neumann"), + "positive tab": (positive_tab_bc, "Neumann"), } } diff --git a/pybamm/parameters/thermal_parameters.py b/pybamm/parameters/thermal_parameters.py index 5fd86eb525..9cfd09691f 100644 --- a/pybamm/parameters/thermal_parameters.py +++ b/pybamm/parameters/thermal_parameters.py @@ -35,14 +35,13 @@ def _set_parameters(self): self.T_ref = pybamm.Parameter("Reference temperature [K]") # Cooling coefficient - self.h_edge = pybamm.Parameter("Edge heat transfer coefficient [W.m-2.K-1]") self.h_total = pybamm.Parameter("Total heat transfer coefficient [W.m-2.K-1]") # Initial temperature self.T_init = pybamm.Parameter("Initial temperature [K]") def T_amb(self, y, z, t): - """Dimensional ambient temperature""" + """Ambient temperature [K]""" return pybamm.FunctionParameter( "Ambient temperature [K]", { @@ -52,6 +51,17 @@ def T_amb(self, y, z, t): }, ) + def h_edge(self, y, z): + """Cell edge heat transfer coefficient [W.m-2.K-1]""" + inputs = { + "Distance along electrode width [m]": y, + "Distance along electrode height [m]": z, + } + return pybamm.FunctionParameter( + "Edge heat transfer coefficient [W.m-2.K-1]", + inputs, + ) + def rho_c_p_eff(self, T): """Effective volumetric heat capacity [J.m-3.K-1]""" return ( diff --git a/pybamm/plotting/quick_plot.py b/pybamm/plotting/quick_plot.py index 7a76a19c69..03bfeeccd4 100644 --- a/pybamm/plotting/quick_plot.py +++ b/pybamm/plotting/quick_plot.py @@ -70,6 +70,8 @@ class QuickPlot(object): default color loop defined by matplotlib style sheet or rcParams is used. linestyles : list of str, optional The linestyles to loop over when plotting. Defaults to ["-", ":", "--", "-."] + shading : str, optional + The shading to use for 2D plots. Defaults to "auto". figsize : tuple of floats, optional The size of the figure to make n_rows : int, optional @@ -97,6 +99,7 @@ def __init__( labels=None, colors=None, linestyles=None, + shading="auto", figsize=None, n_rows=None, time_unit=None, @@ -140,6 +143,7 @@ def __init__( else: self.colors = LoopList(colors) self.linestyles = LoopList(linestyles or ["-", ":", "--", "-."]) + self.shading = shading # Default output variables for lead-acid and lithium-ion if output_variables is None: @@ -572,7 +576,7 @@ def plot(self, t, dynamic=False): var, vmin=vmin, vmax=vmax, - shading="auto", + shading=self.shading, ) else: self.plots[key][0][0] = ax.contourf( @@ -725,7 +729,7 @@ def slider_update(self, t): var, vmin=vmin, vmax=vmax, - shading="auto", + shading=self.shading, ) else: self.plots[key][0][0] = ax.contourf( From c8965d240f18ad2f75c971e1b142929b937ee968 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Fri, 4 Aug 2023 16:39:12 +0530 Subject: [PATCH 009/129] Use repo to copy pybamm --- Dockerfile | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Dockerfile b/Dockerfile index a1f41e8ea5..0d1eaf62bc 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,14 +1,16 @@ FROM python:3.11-slim # Set the working directory -WORKDIR /PyBaMM +WORKDIR / # Install the necessary dependencies RUN apt-get update && apt-get -y upgrade RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git # Copy project files into the container -COPY . . +RUN git clone https://github.com/pybamm-team/PyBaMM.git + +WORKDIR /PyBaMM/ # Install PyBaMM RUN python -m pip install --upgrade pip From 90ae2a937915d9fbc8dfa3fc7c67c71c806547d9 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Fri, 4 Aug 2023 16:51:36 +0530 Subject: [PATCH 010/129] install odes if args passed --- Dockerfile | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Dockerfile b/Dockerfile index 0d1eaf62bc..8e57f47bd9 100644 --- a/Dockerfile +++ b/Dockerfile @@ -16,4 +16,10 @@ WORKDIR /PyBaMM/ RUN python -m pip install --upgrade pip RUN pip install -e ".[all]" +ARG ODES + +RUN if [ "$ODES" = "true" ]; then \ + pybamm_install_odes; \ + fi + CMD ["/bin/bash"] \ No newline at end of file From ed1fb10611da470331d31c91972e91fc79d1e5c3 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Fri, 4 Aug 2023 17:30:04 +0530 Subject: [PATCH 011/129] install odes if `ODES = true` --- Dockerfile | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Dockerfile b/Dockerfile index 8e57f47bd9..3b00219321 100644 --- a/Dockerfile +++ b/Dockerfile @@ -7,6 +7,9 @@ WORKDIR / RUN apt-get update && apt-get -y upgrade RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git +ENV CMAKE_C_COMPILER=/usr/bin/gcc +ENV CMAKE_MAKE_PROGRAM=/usr/bin/make + # Copy project files into the container RUN git clone https://github.com/pybamm-team/PyBaMM.git @@ -18,7 +21,10 @@ RUN pip install -e ".[all]" ARG ODES + RUN if [ "$ODES" = "true" ]; then \ + apt-get install -y cmake && \ + pip install wget && \ pybamm_install_odes; \ fi From f9d15d36f262e6cf5b4882492c0b30a6312bfc11 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Fri, 4 Aug 2023 19:12:42 +0530 Subject: [PATCH 012/129] Install jax if `JAX=true` --- Dockerfile | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Dockerfile b/Dockerfile index 3b00219321..dbfde65455 100644 --- a/Dockerfile +++ b/Dockerfile @@ -20,6 +20,7 @@ RUN python -m pip install --upgrade pip RUN pip install -e ".[all]" ARG ODES +ARG JAX RUN if [ "$ODES" = "true" ]; then \ @@ -28,4 +29,8 @@ RUN if [ "$ODES" = "true" ]; then \ pybamm_install_odes; \ fi +RUN if [ "$JAX" = "true" ]; then \ + pip install -e ".[jax,all]";\ + fi + CMD ["/bin/bash"] \ No newline at end of file From f463546d397a6b91c0bbba73d9288dcc052ee54a Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Fri, 4 Aug 2023 19:45:45 +0530 Subject: [PATCH 013/129] Change Headings --- docs/source/user_guide/installation/install-from-source.rst | 2 +- docs/source/user_guide/installation/windows-wsl.rst | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/source/user_guide/installation/install-from-source.rst b/docs/source/user_guide/installation/install-from-source.rst index 82a7976852..81b50d84ad 100644 --- a/docs/source/user_guide/installation/install-from-source.rst +++ b/docs/source/user_guide/installation/install-from-source.rst @@ -1,4 +1,4 @@ -Install from source (developer install) +Install from source (GNU Linux and macOS) ========================================= .. contents:: diff --git a/docs/source/user_guide/installation/windows-wsl.rst b/docs/source/user_guide/installation/windows-wsl.rst index 15f479cbaf..fc9a783b21 100644 --- a/docs/source/user_guide/installation/windows-wsl.rst +++ b/docs/source/user_guide/installation/windows-wsl.rst @@ -1,5 +1,5 @@ -Windows Subsystem for Linux (WSL) -====================================== +Install from source (Windows) +============================= We recommend the use of Windows Subsystem for Linux (WSL) to install PyBaMM, see the instructions below to get PyBaMM working using Windows, From 605fed6e994b3afb75e68491266e48ac85f949ee Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Fri, 4 Aug 2023 19:59:13 +0530 Subject: [PATCH 014/129] Remove developer install section --- .../user_guide/installation/GNU-linux.rst | 52 ------------------- 1 file changed, 52 deletions(-) diff --git a/docs/source/user_guide/installation/GNU-linux.rst b/docs/source/user_guide/installation/GNU-linux.rst index 8f1ee50dbc..c4ca23c247 100644 --- a/docs/source/user_guide/installation/GNU-linux.rst +++ b/docs/source/user_guide/installation/GNU-linux.rst @@ -145,58 +145,6 @@ GNU/Linux and macOS The ``pip install "pybamm[jax]"`` command automatically downloads and installs ``pybamm`` and the compatible versions of ``jax`` and ``jaxlib`` on your system. (``pybamm_install_jax`` is deprecated.) -Developer install ------------------ - -If you wish to contribute to PyBaMM, you should get the latest version -from the GitHub repository. To do so, you must have ``Git`` and ``graphviz`` -installed. For instance, run - - .. tab:: Debian-based distributions (Debian, Ubuntu, Linux Mint) - - In a terminal, run the following command: - - .. code:: bash - - sudo apt install git graphviz - - .. tab:: macOS - - In a terminal, run the following command: - - .. code:: bash - - brew install git graphviz - -To install PyBaMM, the first step is to get the code by cloning this -repository - -.. code:: bash - - git clone https://github.com/pybamm-team/PyBaMM.git - cd PyBaMM - -Then, to install PyBaMM as a `developer `__, type - -.. code:: bash - - pip install -e .[dev,docs] - -or on ``zsh`` shells, type - -.. code:: bash - - pip install -e .'[dev,docs]' - -To check whether PyBaMM has installed properly, you can run the tests: - -.. code:: bash - - python3 run-tests.py --unit - -Before you start contributing to PyBaMM, please read the `contributing -guidelines `__. - Uninstall PyBaMM ================ From ab00e8d111e047e42fd486f0b35a4fa5f0d93e0a Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Fri, 4 Aug 2023 20:20:18 +0530 Subject: [PATCH 015/129] Move troubleshoot section to install from source --- .../user_guide/installation/GNU-linux.rst | 37 ----------------- .../installation/install-from-source.rst | 40 +++++++++++++++++++ 2 files changed, 40 insertions(+), 37 deletions(-) diff --git a/docs/source/user_guide/installation/GNU-linux.rst b/docs/source/user_guide/installation/GNU-linux.rst index c4ca23c247..1baab24e38 100644 --- a/docs/source/user_guide/installation/GNU-linux.rst +++ b/docs/source/user_guide/installation/GNU-linux.rst @@ -155,40 +155,3 @@ PyBaMM can be uninstalled by running pip uninstall pybamm in your virtual environment. - -Troubleshooting -=============== - -**Problem:** I’ve made edits to source files in PyBaMM, but these are -not being used when I run my Python script. - -**Solution:** Make sure you have installed PyBaMM using the ``-e`` flag, -i.e. ``pip install -e .``. This sets the installed location of the -source files to your current directory. - -**Problem:** Errors when solving model -``ValueError: Integrator name ida does not exsist``, or -``ValueError: Integrator name cvode does not exsist``. - -**Solution:** This could mean that you have not installed -``scikits.odes`` correctly, check the instructions given above and make -sure each command was successful. - -One possibility is that you have not set your ``LD_LIBRARY_PATH`` to -point to the sundials library, type ``echo $LD_LIBRARY_PATH`` and make -sure one of the directories printed out corresponds to where the -sundials libraries are located. - -Another common reason is that you forget to install a BLAS library such -as OpenBLAS before installing sundials. Check the cmake output when you -configured Sundials, it might say: - -:: - - -- A library with BLAS API not found. Please specify library location. - -- LAPACK requires BLAS - -If this is the case, on a Debian or Ubuntu system you can install -OpenBLAS using ``sudo apt-get install libopenblas-dev`` (or -``brew install openblas`` for Mac OS) and then re-install sundials using -the instructions above. diff --git a/docs/source/user_guide/installation/install-from-source.rst b/docs/source/user_guide/installation/install-from-source.rst index 81b50d84ad..e18621617a 100644 --- a/docs/source/user_guide/installation/install-from-source.rst +++ b/docs/source/user_guide/installation/install-from-source.rst @@ -158,6 +158,9 @@ If you are using ``zsh``, you would need to use different pattern matching: pip install -e '.[all,dev,docs]' +Before you start contributing to PyBaMM, please read the `contributing +guidelines `__. + Running the tests ----------------- @@ -252,3 +255,40 @@ Here are some additional useful commands you can run with ``Nox``: - ``--install-only``: Skips the test execution and only performs the installation step defined in the Nox sessions. - ``--nocolor``: Disables the color output in the console during the execution of Nox sessions. - ``--report output.json``: Generates a JSON report of the Nox session execution and saves it to the specified file, in this case, "output.json". + +Troubleshooting +=============== + +**Problem:** I’ve made edits to source files in PyBaMM, but these are +not being used when I run my Python script. + +**Solution:** Make sure you have installed PyBaMM using the ``-e`` flag, +i.e. ``pip install -e .``. This sets the installed location of the +source files to your current directory. + +**Problem:** Errors when solving model +``ValueError: Integrator name ida does not exsist``, or +``ValueError: Integrator name cvode does not exsist``. + +**Solution:** This could mean that you have not installed +``scikits.odes`` correctly, check the instructions given above and make +sure each command was successful. + +One possibility is that you have not set your ``LD_LIBRARY_PATH`` to +point to the sundials library, type ``echo $LD_LIBRARY_PATH`` and make +sure one of the directories printed out corresponds to where the +sundials libraries are located. + +Another common reason is that you forget to install a BLAS library such +as OpenBLAS before installing sundials. Check the cmake output when you +configured Sundials, it might say: + +:: + + -- A library with BLAS API not found. Please specify library location. + -- LAPACK requires BLAS + +If this is the case, on a Debian or Ubuntu system you can install +OpenBLAS using ``sudo apt-get install libopenblas-dev`` (or +``brew install openblas`` for Mac OS) and then re-install sundials using +the instructions above. From cd9b68022fd72d091b65a7ed99b33436409db944 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Fri, 4 Aug 2023 15:55:01 +0100 Subject: [PATCH 016/129] #3321 update notebook --- .../notebooks/models/thermal-models.ipynb | 297 ++++++------------ examples/scripts/DFN_ambient_temperature.py | 2 +- examples/scripts/pouch_cell_isothermal.py | 7 +- pybamm/discretisations/discretisation.py | 2 - .../full_battery_models/base_battery_model.py | 20 +- pybamm/models/submodels/thermal/lumped.py | 51 +-- .../pouch_cell_1D_current_collectors.py | 18 +- .../base_lithium_ion_tests.py | 2 +- 8 files changed, 137 insertions(+), 262 deletions(-) diff --git a/docs/source/examples/notebooks/models/thermal-models.ipynb b/docs/source/examples/notebooks/models/thermal-models.ipynb index 788a02a88f..4d046ac993 100644 --- a/docs/source/examples/notebooks/models/thermal-models.ipynb +++ b/docs/source/examples/notebooks/models/thermal-models.ipynb @@ -14,13 +14,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "zsh:1: no matches found: pybamm[plot,cite]\n", "Note: you may need to restart the kernel to use updated packages.\n" ] } @@ -35,7 +36,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Lumped models\n", + "## Lumped model\n", "\n", "The lumped thermal model solves the following ordinary differential equation for the average temperature, given here in dimensional terms,\n", "\n", @@ -69,50 +70,13 @@ "Here $i_k$ is the current, $\\phi_k$ the potential, $a_k$ the surface area to volume ratio, $j_k$ the interfacial current density, $\\eta_k$ the overpotential, and $U$ the open-circuit potential. The averaged heat source term $\\bar{Q}$ is computed by taking the volume-average of $Q$.\n" ] }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "There are two lumped thermal options in PyBaMM: \"lumped\" and \"x-lumped\". Both models solve the same equation, but the term corresponding to heat loss is computed differently." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### \"x-lumped\" option\n", - "The \"x-lumped\" model assumes a pouch cell geometry in order to compute the overall heat transfer coefficient $h$, surface area $A$, and volume $V$. This model allows the user to select a different heat transfer coefficient on different surfaces of the cell. PyBaMM then automatically computes the overall heat transfer coefficient (see [[1]](#references), [[2]](#references) for details). The parameters used to set the heat transfer coefficients are:\n", - "\n", - "\"Negative current collector surface heat transfer coefficient [W.m-2.K-1]\" \n", - "\"Positive current collector surface heat transfer coefficient [W.m-2.K-1]\" \n", - "\"Negative tab heat transfer coefficient [W.m-2.K-1]\" \n", - "\"Positive tab heat transfer coefficient [W.m-2.K-1]\" \n", - "\"Edge heat transfer coefficient [W.m-2.K-1]\" \n", - "\n", - "and correspond to heat transfer at the large surface of the pouch on the side of the negative current collector, heat transfer at the large surface of the pouch on the side of the positive current collector, heat transfer at the negative tab, heat transfer at the positive tab, and heat transfer at the remaining surfaces.\n", - "\n", - "The \"x-lumped\" option can be selected as follows\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "options = {\"thermal\": \"x-lumped\"}\n", - "model = pybamm.lithium_ion.DFN(options)" - ] - }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### \"lumped\" option\n", - "The behaviour of the \"lumped\" option changes depending on the \"cell geometry\" option. By default the \"lumped\" option sets the \"cell geometry\" option \"arbitrary\". This option allows a 1D electrochmical model to be solved, coupled to a lumped thermal model that can be used to model any aribitrary geometry. The user may specify the total heat transfer coefficient $h$, surface area for cooling $A$, and cell volume $V$. The relevant parameters are: \n", + "This option allows any electrochmical model to be solved, coupled to a lumped thermal model that can be used to model any aribitrary geometry. The user may specify the total heat transfer coefficient $h$, surface area for cooling $A$, and cell volume $V$. The relevant parameters are: \n", "\n", "\"Total heat transfer coefficient [W.m-2.K-1]\" \n", "\"Cell cooling surface area [m2]\" \n", @@ -120,9 +84,7 @@ "\n", "which correspond directly to the parameters $h$, $A$ and $V$ in the governing equation.\n", "\n", - "However, if the \"cell geometry\" is set to \"pouch\" the heat transfer coefficient, cell cooling surface are and cell volume are automatically computed to correspond to a pouch. In this instance the \"lumped\" is equivalent to the \"x-lumped\" option.\n", - "\n", - "The lumped thermal option with an arbitrary geometry can be selected as follows\n" + "The lumped thermal option can be selected as follows\n" ] }, { @@ -131,33 +93,7 @@ "metadata": {}, "outputs": [], "source": [ - "# lumped with no geometry option defaults to an arbitrary geometry\n", "options = {\"thermal\": \"lumped\"}\n", - "model = pybamm.lithium_ion.DFN(options)\n", - "\n", - "# OR \n", - "\n", - "# lumped with arbitrary geometry specified \n", - "options = {\"cell geometry\": \"arbitrary\", \"thermal\": \"lumped\"}\n", - "model = pybamm.lithium_ion.DFN(options)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The lumped thermal option with a pouch cell geometry can be selected as follows" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# lumped with pouch cell geometry (equivalent to choosing \"x-lumped\" thermal option)\n", - "options = {\"cell geometry\": \"pouch\", \"thermal\": \"lumped\"}\n", "model = pybamm.lithium_ion.DFN(options)" ] }, @@ -249,7 +185,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Model comparison" + "# Model usage" ] }, { @@ -257,21 +193,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Here we compare the \"lumped\" thermal model for a pouch cell geometry and an arbitrary geometry. We first set up our models, passing the relevant options" + "Here we compare the \"full\" one-dimensional model with the lumped model for a pouch cell. We first set up our models, passing the relevant options, and then show how to adjust the parameters to so that the lumped and full models give the same behaviour" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "pouch_model = pybamm.lithium_ion.DFN(\n", - " options={\"cell geometry\": \"pouch\", \"thermal\": \"lumped\"}\n", + "full_thermal_model = pybamm.lithium_ion.SPMe(\n", + " {\"thermal\": \"x-full\"}, name=\"full thermal model\"\n", ")\n", - "arbitrary_model = pybamm.lithium_ion.DFN(\n", - " options={\"cell geometry\": \"arbitrary\", \"thermal\": \"lumped\"}\n", - ")" + "lumped_thermal_model = pybamm.lithium_ion.SPMe(\n", + " {\"thermal\": \"lumped\"}, name=\"lumped thermal model\"\n", + ")\n", + "models = [full_thermal_model, lumped_thermal_model]" ] }, { @@ -284,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -296,39 +233,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "and look at the various parameters related to heat transfer" + "For the \"full\" model we use a heat transfer coefficient of $5\\, \\text{Wm}^{-2}\\text{K}^{-1}$ on the large surfaces of the pouch and zero heat transfer coefficient on the tabs and edges" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 15, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Negative current collector surface heat transfer coefficient [W.m-2.K-1]: 0.0\n", - "Positive current collector surface heat transfer coefficient [W.m-2.K-1]: 0.0\n", - "Negative tab heat transfer coefficient [W.m-2.K-1]: 10.0\n", - "Positive tab heat transfer coefficient [W.m-2.K-1]: 10.0\n", - "Edge heat transfer coefficient [W.m-2.K-1]: 0.3\n", - "Total heat transfer coefficient [W.m-2.K-1]: 10.0\n" - ] - } - ], + "outputs": [], "source": [ - "params = [\n", - " \"Negative current collector surface heat transfer coefficient [W.m-2.K-1]\", \n", - " \"Positive current collector surface heat transfer coefficient [W.m-2.K-1]\", \n", - " \"Negative tab heat transfer coefficient [W.m-2.K-1]\", \n", - " \"Positive tab heat transfer coefficient [W.m-2.K-1]\", \n", - " \"Edge heat transfer coefficient [W.m-2.K-1]\",\n", - " \"Total heat transfer coefficient [W.m-2.K-1]\",\n", - "]\n", - "\n", - "for param in params:\n", - " print(param + \": {}\".format(parameter_values[param]))" + "full_params = parameter_values.copy()\n", + "full_params.update(\n", + " {\n", + " \"Negative current collector\"\n", + " + \" surface heat transfer coefficient [W.m-2.K-1]\": 5,\n", + " \"Positive current collector\"\n", + " + \" surface heat transfer coefficient [W.m-2.K-1]\": 5,\n", + " \"Negative tab heat transfer coefficient [W.m-2.K-1]\": 0,\n", + " \"Positive tab heat transfer coefficient [W.m-2.K-1]\": 0,\n", + " \"Edge heat transfer coefficient [W.m-2.K-1]\": 0,\n", + " }\n", + ")" ] }, { @@ -336,44 +261,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We see that the default parameters used for the pouch cell geometry assume that the large surfaces of the pouch are insulated (no heat transfer) and that most of the cooling is via the tabs.\n", - "\n", - "We can also look at the parameters related to the geometry of the pouch" + "For the lumped model we set the \"Total heat transfer coefficient [W.m-2.K-1]\"\n", + "parameter as well as the \"Cell cooling surface area [m2]\" parameter. Since the \"full\"\n", + "model only accounts for cooling from the large surfaces of the pouch, we set the\n", + "\"Surface area for cooling\" parameter to the area of the large surfaces of the pouch,\n", + "and the total heat transfer coefficient to $5\\, \\text{Wm}^{-2}\\text{K}^{-1}$ " ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 16, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Surface area [m2]: 0.056907200000000005\n", - "Volume [m3]: 7.798725e-06\n" - ] - } - ], + "outputs": [], "source": [ - "L_cn = parameter_values[\"Negative current collector thickness [m]\"]\n", - "L_n = parameter_values[\"Negative electrode thickness [m]\"]\n", - "L_s = parameter_values[\"Separator thickness [m]\"]\n", - "L_p = parameter_values[\"Positive electrode thickness [m]\"]\n", - "L_cp = parameter_values[\"Positive current collector thickness [m]\"]\n", - "L_y = parameter_values[\"Electrode width [m]\"]\n", - "L_z = parameter_values[\"Electrode height [m]\"]\n", - "\n", - "# total thickness\n", - "L = L_cn + L_n + L_s + L_p + L_cp\n", - "\n", - "# compute surface area\n", - "A = 2 * (L_y * L_z + L * L_y + L * L_z)\n", - "print(\"Surface area [m2]: {}\".format(A))\n", - "\n", - "# compute volume \n", - "V = L * L_y *L_z\n", - "print(\"Volume [m3]: {}\".format(V))" + "A = parameter_values[\"Electrode width [m]\"] * parameter_values[\"Electrode height [m]\"]\n", + "lumped_params = parameter_values.copy()\n", + "lumped_params.update(\n", + " {\n", + " \"Total heat transfer coefficient [W.m-2.K-1]\": 5,\n", + " \"Cell cooling surface area [m2]\": 2 * A,\n", + " }\n", + ")" ] }, { @@ -381,54 +289,45 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "and the parameters related to the surface are for cooling and cell volume for the arbitrary geometry " + "Let's run simulations with both options and compare the results. For demonstration purposes we'll increase the current to amplify the thermal effects" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Cell cooling surface area [m2]: 0.0569\n", - "Cell volume [m3]: 7.8e-06\n" + "hi\n", + "hi\n" ] - } - ], - "source": [ - "params = [\"Cell cooling surface area [m2]\", \"Cell volume [m3]\"]\n", - "\n", - "for param in params:\n", - " print(param + \": {}\".format(parameter_values[param]))" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We see that both models assume the same cell volume, and the arbitrary model assumes that cooling occurs uniformly from all surfaces of the pouch.\n", - "\n", - "Let's run simulations with both options and compare the results. For demonstration purposes we'll increase the current to amplify the thermal effects" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1169e50029dc4054a65d583321a6a919", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.0, description='t', max=1154.8765298002877, step=11.548765298002877)…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ee873b57af934694abc47b15f91f7d87", + "model_id": "45569a0e5cca46fcb25956cd0ca8673d", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=1000.0, step=10.0), Output()), _dom_classes=…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=1154.8765298002877, step=11.548765298002877)…" ] }, "metadata": {}, @@ -437,50 +336,43 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# update current to correspond to a C-rate of 3 (i.e. 3 times the nominal cell capacity)\n", - "parameter_values[\"Current function [A]\"] = 3 * parameter_values[\"Nominal cell capacity [A.h]\"]\n", - "\n", - "# pick solver \n", - "solver = pybamm.CasadiSolver(mode=\"fast\", atol=1e-3)\n", - "\n", - "# create simulations in a list\n", - "sims = [\n", - " pybamm.Simulation(pouch_model, parameter_values=parameter_values, solver=solver),\n", - " pybamm.Simulation(arbitrary_model, parameter_values=parameter_values, solver=solver)\n", + "params = [full_params, lumped_params]\n", + "# loop over the models and solve\n", + "sols = []\n", + "for model, param in zip(models, params):\n", + " param[\"Current function [A]\"] = 3 * 0.68\n", + " sim = pybamm.Simulation(model, parameter_values=param)\n", + " sim.solve([0, 3600])\n", + " sols.append(sim.solution)\n", + "\n", + "\n", + "# plot\n", + "output_variables = [\n", + " \"Voltage [V]\",\n", + " \"X-averaged cell temperature [K]\",\n", + " \"Cell temperature [K]\",\n", "]\n", + "pybamm.dynamic_plot(sols, output_variables)\n", "\n", - "# loop over the list to solve\n", - "for sim in sims:\n", - " sim.solve([0, 1000])\n", - " \n", "# plot the results\n", "pybamm.dynamic_plot(\n", - " sims, \n", + " sols,\n", " [\n", - " \"Volume-averaged cell temperature [K]\", \n", - " \"Volume-averaged total heating [W.m-3]\", \n", - " \"Current [A]\", \n", - " \"Voltage [V]\"\n", + " \"Volume-averaged cell temperature [K]\",\n", + " \"Volume-averaged total heating [W.m-3]\",\n", + " \"Current [A]\",\n", + " \"Voltage [V]\",\n", " ],\n", - " labels=[\"pouch\", \"arbitrary\"],\n", - ") " - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We see that the lumped model with an arbitrary geometry is cooled much more (it is cooled uniformly from all surfaces, compared to the pouch that is only cooled via the tabs and outside edges), which results in the temperature barely changing throughout the simulation. In comparison, the model with the pouch cell geometry is only cooled from a small portion of the overall cell surface, leading to an increase in temperature of around 20 degrees." + ")" ] }, { @@ -519,7 +411,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "dev", "language": "python", "name": "python3" }, @@ -533,7 +425,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.0" + "version": "3.9.16" }, "toc": { "base_numbering": 1, @@ -547,6 +439,11 @@ "toc_position": {}, "toc_section_display": true, "toc_window_display": true + }, + "vscode": { + "interpreter": { + "hash": "bca2b99bfac80e18288b793d52fa0653ab9b5fe5d22e7b211c44eb982a41c00c" + } } }, "nbformat": 4, diff --git a/examples/scripts/DFN_ambient_temperature.py b/examples/scripts/DFN_ambient_temperature.py index 7fa2cb31f3..4d724aaa0e 100644 --- a/examples/scripts/DFN_ambient_temperature.py +++ b/examples/scripts/DFN_ambient_temperature.py @@ -18,7 +18,7 @@ # load parameter values and process model and geometry -def ambient_temperature(t): +def ambient_temperature(y, z, t): return 300 + t * 100 / 3600 diff --git a/examples/scripts/pouch_cell_isothermal.py b/examples/scripts/pouch_cell_isothermal.py index fce55a99dc..7f7186edec 100644 --- a/examples/scripts/pouch_cell_isothermal.py +++ b/examples/scripts/pouch_cell_isothermal.py @@ -1,7 +1,6 @@ # # Example showing how to customize thermal boundary conditions in a pouch cell model # -import numpy as np import pybamm pybamm.set_logging_level("INFO") @@ -20,7 +19,11 @@ def T_amb(y, z, t): - return 300 + 20 * pybamm.sin(np.pi * y / L_y) * pybamm.sin(np.pi * z / L_z) + return ( + 300 + + pybamm.InputParameter("T_top") * (z >= L_z) + + pybamm.InputParameter("T_right") * (y >= L_y) + ) parameter_values.update({"Ambient temperature [K]": T_amb}) diff --git a/pybamm/discretisations/discretisation.py b/pybamm/discretisations/discretisation.py index deaed42657..efa6e88a13 100644 --- a/pybamm/discretisations/discretisation.py +++ b/pybamm/discretisations/discretisation.py @@ -688,8 +688,6 @@ def process_dict(self, var_eqn_dict, ics=False): pybamm.logger.debug("Discretise {!r}".format(eqn_key)) processed_eqn = self.process_symbol(eqn) - if eqn_key == "X-averaged cell temperature [K]": - print("hi") # Calculate scale if the key has a scale scale = getattr(eqn_key, "scale", 1) if ics: diff --git a/pybamm/models/full_battery_models/base_battery_model.py b/pybamm/models/full_battery_models/base_battery_model.py index 34afebf092..52c730f079 100644 --- a/pybamm/models/full_battery_models/base_battery_model.py +++ b/pybamm/models/full_battery_models/base_battery_model.py @@ -26,8 +26,8 @@ class BatteryModelOptions(pybamm.FuzzyDict): "true" or "false". "false" is the default, since calculating discharge energy can be computationally expensive for simple models like SPM. * "cell geometry" : str - Sets the geometry of the cell. Can be "pouch" (default) or - "arbitrary". The arbitrary geometry option solves a 1D electrochemical + Sets the geometry of the cell. Can be "arbitrary" (default) or + "pouch". The arbitrary geometry option solves a 1D electrochemical model with prescribed cell volume and cross-sectional area, and (if thermal effects are included) solves a lumped thermal model with prescribed surface area for cooling. @@ -283,15 +283,21 @@ def __init__(self, extra_options): default_options = { name: options[0] for name, options in self.possible_options.items() } + extra_options = extra_options or {} # Change the default for cell geometry based on the current collector # dimensionality - extra_options = extra_options or {} # return "none" if option not given - current_collector_option = extra_options.get("current collector", "none") - if current_collector_option == 0: - default_options["cell geometry"] = "arbitrary" - else: + dimensionality_option = extra_options.get("dimensionality", "none") + if dimensionality_option in [1, 2]: + default_options["cell geometry"] = "pouch" + # The "cell geometry" option will still be overridden by extra_options if + # provided + + # Change the default for cell geometry based on the thermal model + # return "none" if option not given + thermal_option = extra_options.get("thermal", "none") + if thermal_option == "x-full": default_options["cell geometry"] = "pouch" # The "cell geometry" option will still be overridden by extra_options if # provided diff --git a/pybamm/models/submodels/thermal/lumped.py b/pybamm/models/submodels/thermal/lumped.py index a239e4b994..62c147755b 100644 --- a/pybamm/models/submodels/thermal/lumped.py +++ b/pybamm/models/submodels/thermal/lumped.py @@ -53,51 +53,16 @@ def set_rhs(self, variables): Q_vol_av = variables["Volume-averaged total heating [W.m-3]"] T_amb = variables["Volume-averaged ambient temperature [K]"] - # Account for surface area to volume ratio in cooling coefficient - if self.options["cell geometry"] == "pouch": - y = pybamm.standard_spatial_vars.y - z = pybamm.standard_spatial_vars.z - cell_volume = self.param.L * self.param.L_y * self.param.L_z - - yz_cell_surface_area = self.param.L_y * self.param.L_z - yz_surface_cooling_coefficient = -( - self._yz_average(self.param.n.h_cc(y, z) + self.param.p.h_cc(y, z)) - ) * (yz_cell_surface_area / cell_volume) - - negative_tab_area = self.param.n.L_tab * self.param.n.L_cc - negative_tab_cooling_coefficient = ( - -self.param.n.h_tab * negative_tab_area / cell_volume - ) - - positive_tab_area = self.param.p.L_tab * self.param.p.L_cc - positive_tab_cooling_coefficient = ( - -self.param.p.h_tab * positive_tab_area / cell_volume - ) - - edge_area = ( - 2 * self.param.L_y * self.param.L - + 2 * self.param.L_z * self.param.L - - negative_tab_area - - positive_tab_area - ) - edge_cooling_coefficient = -self.param.h_edge * edge_area / cell_volume - - total_cooling_coefficient = ( - yz_surface_cooling_coefficient - + negative_tab_cooling_coefficient - + positive_tab_cooling_coefficient - + edge_cooling_coefficient - ) - elif self.options["cell geometry"] == "arbitrary": - cell_surface_area = self.param.A_cooling - cell_volume = self.param.V_cell - total_cooling_coefficient = ( - -self.param.h_total * cell_surface_area / cell_volume - ) + # Newton cooling, accounting for surface area to volume ratio + cell_surface_area = self.param.A_cooling + cell_volume = self.param.V_cell + total_cooling_coefficient = ( + -self.param.h_total * cell_surface_area / cell_volume + ) + Q_cool_vol_av = total_cooling_coefficient * (T_vol_av - T_amb) self.rhs = { - T_vol_av: (Q_vol_av + total_cooling_coefficient * (T_vol_av - T_amb)) - / self.param.rho_c_p_eff(T_vol_av) + T_vol_av: (Q_vol_av + Q_cool_vol_av) / self.param.rho_c_p_eff(T_vol_av) } def set_initial_conditions(self, variables): diff --git a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py index a96621e3b6..cac043e85f 100644 --- a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py +++ b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py @@ -58,8 +58,8 @@ def set_rhs(self, variables): y = pybamm.standard_spatial_vars.y z = pybamm.standard_spatial_vars.z - # Account for surface area to volume ratio of pouch cell in cooling - # coefficient. + # Account for surface area to volume ratio of pouch cell in surface and side + # cooling terms cell_volume = self.param.L * self.param.L_y * self.param.L_z yz_surface_area = self.param.L_y * self.param.L_z @@ -69,9 +69,11 @@ def set_rhs(self, variables): / cell_volume ) - side_edge_area = 2 * self.param.L_z * self.param.L + side_edge_area = self.param.L_z * self.param.L side_edge_cooling_coefficient = ( - -self.param.h_edge * side_edge_area / cell_volume + -(self.param.h_edge(0, z) + self.param.h_edge(self.param.L_y, z)) + * side_edge_area + / cell_volume ) total_cooling_coefficient = ( @@ -93,8 +95,10 @@ def set_boundary_conditions(self, variables): T_av = variables["X-averaged cell temperature [K]"] T_av_top = pybamm.boundary_value(T_av, "right") T_av_bottom = pybamm.boundary_value(T_av, "left") + z = pybamm.standard_spatial_vars.z # find tab locations (top vs bottom) + L_y = param.L_y L_z = param.L_z neg_tab_z = param.n.centre_z_tab pos_tab_z = param.p.centre_z_tab @@ -120,15 +124,17 @@ def set_boundary_conditions(self, variables): ) # calculate effective cooling coefficients + # Note: can't do y-average of h_edge here since y isn't meshed. Evaluate at + # midpoint. top_cooling_coefficient = ( param.n.h_tab * neg_tab_area * neg_tab_top_bool + param.p.h_tab * pos_tab_area * pos_tab_top_bool - + param.h_edge * non_tab_top_area + + param.h_edge(L_y / 2, z) * non_tab_top_area ) / total_area bottom_cooling_coefficient = ( param.n.h_tab * neg_tab_area * neg_tab_bottom_bool + param.p.h_tab * pos_tab_area * pos_tab_bottom_bool - + param.h_edge * non_tab_bottom_area + + param.h_edge(L_y / 2, z) * non_tab_bottom_area ) / total_area # just use left and right for clarity diff --git a/tests/unit/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py b/tests/unit/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py index d60dcda8b6..c6e4da19c6 100644 --- a/tests/unit/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py +++ b/tests/unit/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py @@ -28,7 +28,7 @@ def test_well_posed_2plus1D(self): self.check_well_posedness(options) def test_well_posed_lumped_thermal_model_1D(self): - options = {"thermal": "x-lumped"} + options = {"thermal": "lumped"} self.check_well_posedness(options) def test_well_posed_x_full_thermal_model(self): From be918c89498f1211a07f264e86aaf5eafaa451f4 Mon Sep 17 00:00:00 2001 From: Arjun Date: Mon, 7 Aug 2023 19:30:02 +0530 Subject: [PATCH 017/129] Update Dockerfile Co-authored-by: Saransh Chopra --- Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Dockerfile b/Dockerfile index dbfde65455..68386e271b 100644 --- a/Dockerfile +++ b/Dockerfile @@ -33,4 +33,4 @@ RUN if [ "$JAX" = "true" ]; then \ pip install -e ".[jax,all]";\ fi -CMD ["/bin/bash"] \ No newline at end of file +CMD ["/bin/bash"] From d97a57bfa33b41c7ae92ca497d9e094202b87e33 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Mon, 7 Aug 2023 20:18:33 +0530 Subject: [PATCH 018/129] Define `IDAKLU` arg --- Dockerfile | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Dockerfile b/Dockerfile index dbfde65455..a7298c040c 100644 --- a/Dockerfile +++ b/Dockerfile @@ -21,6 +21,7 @@ RUN pip install -e ".[all]" ARG ODES ARG JAX +ARG IDAKLU RUN if [ "$ODES" = "true" ]; then \ @@ -33,4 +34,9 @@ RUN if [ "$JAX" = "true" ]; then \ pip install -e ".[jax,all]";\ fi +RUN if [ "$IDAKLU" = "true" ]; then \ + python scripts/install_KLU_Sundials.py;\ + git clone https://github.com/pybind/pybind11.git pybind11/ \ + fi + CMD ["/bin/bash"] \ No newline at end of file From 3ce9673b1d548d5a1747f9b1414bfa892949272b Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Tue, 8 Aug 2023 19:39:14 +0530 Subject: [PATCH 019/129] Modify for IDAKLU --- Dockerfile | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/Dockerfile b/Dockerfile index ab2c03a761..9b82bbc9fd 100644 --- a/Dockerfile +++ b/Dockerfile @@ -5,9 +5,10 @@ WORKDIR / # Install the necessary dependencies RUN apt-get update && apt-get -y upgrade -RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git +RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git make g++ build-essential ENV CMAKE_C_COMPILER=/usr/bin/gcc +ENV CMAKE_CXX_COMPILER=/usr/bin/g++ ENV CMAKE_MAKE_PROGRAM=/usr/bin/make # Copy project files into the container @@ -17,7 +18,7 @@ WORKDIR /PyBaMM/ # Install PyBaMM RUN python -m pip install --upgrade pip -RUN pip install -e ".[all]" +# RUN pip install -e ".[all]" ARG ODES ARG JAX @@ -26,7 +27,8 @@ ARG IDAKLU RUN if [ "$ODES" = "true" ]; then \ apt-get install -y cmake && \ - pip install wget && \ + pip install wget \ + pip install -e ".[all]" \ pybamm_install_odes; \ fi @@ -35,8 +37,10 @@ RUN if [ "$JAX" = "true" ]; then \ fi RUN if [ "$IDAKLU" = "true" ]; then \ - python scripts/install_KLU_Sundials.py;\ - git clone https://github.com/pybind/pybind11.git pybind11/ \ + pip install wget \ + python scripts/install_KLU_Sundials.py \ + git clone https://github.com/pybind/pybind11.git pybind11/; \ + pip install -e ".[all]"; \ fi CMD ["/bin/bash"] From 8fe9a5309d0f91593e24232763b086f297b032d1 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Tue, 8 Aug 2023 22:25:06 +0100 Subject: [PATCH 020/129] #3321 debug 1+1D --- .../notebooks/models/pouch-cell-model.ipynb | 50 ++++++++----------- examples/scripts/pouch_cell_cooling.py | 9 ++-- examples/scripts/pouch_cell_isothermal.py | 44 ---------------- .../pouch_cell_1D_current_collectors.py | 16 +++--- 4 files changed, 35 insertions(+), 84 deletions(-) delete mode 100644 examples/scripts/pouch_cell_isothermal.py diff --git a/docs/source/examples/notebooks/models/pouch-cell-model.ipynb b/docs/source/examples/notebooks/models/pouch-cell-model.ipynb index 4abae879fb..fc60373fab 100644 --- a/docs/source/examples/notebooks/models/pouch-cell-model.ipynb +++ b/docs/source/examples/notebooks/models/pouch-cell-model.ipynb @@ -49,6 +49,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "zsh:1: no matches found: pybamm[plot,cite]\n", "Note: you may need to restart the kernel to use updated packages.\n" ] } @@ -79,7 +80,7 @@ "outputs": [], "source": [ "cc_model = pybamm.current_collector.EffectiveResistance({\"dimensionality\": 1})\n", - "dfn_av = pybamm.lithium_ion.DFN({\"thermal\": \"x-lumped\"}, name=\"Average DFN\")\n", + "dfn_av = pybamm.lithium_ion.DFN({\"thermal\": \"lumped\"}, name=\"Average DFN\")\n", "dfn = pybamm.lithium_ion.DFN(\n", " {\"current collector\": \"potential pair\", \"dimensionality\": 1, \"thermal\": \"x-lumped\"},\n", " name=\"1+1D DFN\",\n", @@ -129,6 +130,7 @@ " \"Negative tab heat transfer coefficient [W.m-2.K-1]\": 10,\n", " \"Positive tab heat transfer coefficient [W.m-2.K-1]\": 10,\n", " \"Edge heat transfer coefficient [W.m-2.K-1]\": 10,\n", + " \"Total heat transfer coefficient [W.m-2.K-1]\": 10,\n", " }\n", ")" ] @@ -245,7 +247,7 @@ "mesh = simulations[\"1+1D DFN\"].mesh\n", "L_z = param.evaluate(dfn.param.L_z)\n", "pybamm_z = mesh[\"current collector\"].nodes\n", - "z_interp = pybamm_z * L_z\n", + "z_interp = pybamm_z\n", "\n", "\n", "def get_interp_fun_curr_coll(variable_name):\n", @@ -457,12 +459,12 @@ " error_bar = np.abs(comsol_var - dfncc_var)\n", "\n", " # plot time averaged error\n", - " ax[1, 0].plot(z_plot * 1e3, np.mean(error, axis=1), \"k-\", label=r\"$1+1$D\")\n", - " ax[1, 0].plot(z_plot * 1e3, np.mean(error_bar, axis=1), \"k:\", label=\"DFNCC\")\n", + " ax[1, 0].plot(z_plot * 1e3, np.nanmean(error, axis=1), \"k-\", label=r\"$1+1$D\")\n", + " ax[1, 0].plot(z_plot * 1e3, np.nanmean(error_bar, axis=1), \"k:\", label=\"DFNCC\")\n", "\n", " # plot z averaged error\n", - " ax[1, 1].plot(t_plot, np.mean(error, axis=0), \"k-\", label=r\"$1+1$D\")\n", - " ax[1, 1].plot(t_plot, np.mean(error_bar, axis=0), \"k:\", label=\"DFNCC\")\n", + " ax[1, 1].plot(t_plot, np.nanmean(error, axis=0), \"k-\", label=r\"$1+1$D\")\n", + " ax[1, 1].plot(t_plot, np.nanmean(error_bar, axis=0), \"k:\", label=\"DFNCC\")\n", "\n", " # set ticks\n", " ax[0, 0].tick_params(which=\"both\")\n", @@ -563,14 +565,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -609,14 +609,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -675,14 +673,12 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzoAAAHbCAYAAAADNu+6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOyddXwcx/XAv+/uxJJlS5ZkmTHG2IntMDNjw2kaaANN0oap/aXhNgwNk9MkDTbMzOAktmM7ZmaSjGLpbt/vj7073Z0O9qSTBZ7v53PW7ezMm7ezK3nevnlvRFUxGAwGg8FgMBgMhs6Eq60VMBgMBoPBYDAYDIZUYwwdg8FgMBgMBoPB0Okwho7BYDAYDAaDwWDodBhDx2AwGAwGg8FgMHQ6jKFjMBgMBoPBYDAYOh3G0DEYDAaDwWAwGAydDk9bK2AwGAwGg6H1mTx5crHH43kKGIV50WkwGDoHFjDD6/X+ady4cesiT3YIQ0dEsoCPgP1V1RflfDrwmf+8d2vrZzAYDAaDU0L+T7sZuExVj4xS5zPgRFXdmKp+PR7PUz169BheVFS00eVymU30DAZDh8eyLCkrKxuxZs2ap4CjI893lDc65wBvRDNyAFS1HvgcOHmramXYZhGRbiLSX0TOEpFuba1PKCKys4j8KCLfiMhLIpLW1joZDIYwzgHeAKL+n+bneeDCFPc7qqioaIsxcgwGQ2fB5XJpUVHRZmxPddPzW1mf5nI68LaI5IrI5yIyRUR+E5FjQuq85a9nMGwNxgF/AY4CTmhjXSJZju3d3BtYAhwTv7rBYNjKnA687f/eRUTeF5G5IvKYiAT+X34HODXF/bqMkWMwGDob/r9rUW2adm/o+JelDVTVJUAtcJyqjgX2A+4REfFXnQHs1DZaGgyxEREVkSoRuW1r9Keqq1W1xn9Yj71+NaDLFyJSKyLfbQ1dDAZDOBH/pwHsjP3SZAQwCDgewL9kLUNECttCT4PBYOgMtHtDB+gObPJ/F+CfIjIdOyanF1AC4F/WVi8ieW2hpGGbYzLwIPAu8JqD+mNU9e+RhSLylYhsFJGMKOd6isiK5iooIv2Ag/06AqCq+wMXNFemwWBoMaH/pwH8rKqL/P+HvQTsGXJuHdBzK+pmMBgMnYqOYOjUAJn+76cDRcA4Vd0BWBtyDiAD2+tjMLQYEckTkTtFZJ6I1InICv/SkgxV3aiqS1T1P80NFhaR/sBegBIlgA44HDtguTmyu2Cv8T9LVRuaI8NgMLQKof+ngf37T4zjTH/9TsOyZcs8Rx555MA+ffqMGjly5PB99tln8PTp0zMmTZqUueuuu27Xv3//Uf369Rt11VVXlVqW7Yz+97//XSgi4956663gi8znn3++q4iMe+aZZ7oBvPTSS/nDhw8fMXTo0BGDBg0aedddd3UP1L377ru7DxgwYOSAAQNGbr/99sM//vjj3MC5nXfeeeg333yTvRWHYJvkxBNP7F9QUDBmyJAhI1tLjtvtHjds2LARgwcPHjl06NARN9xwQ4nPFy8MztAc4o3ze++9l5eXl7fDsGHDRgwbNmzE7rvvvh3A5Zdf3jMrK2vHlStXBpOgZWdn7xj4HuvvAsD06dMz9tlnn8H9+vUbNWLEiOGHH374wOXLlztOptbuDR3/JNItIplAPrBOVRtEZD+gX6Ce371fbiZ1hhTyO+BR4A9AOnCYql6gqnUpkv8HYCLwH+DMKOcPBz4AEJElInKViEz3L4N7WkRKRORDEakQkc8CSRFExAO8DNykqnNTpKvBYEgBEf+nAewsIgP8sTknA98B+Jdl98COs+sUWJbF0UcfPXjvvfeuWL58+YyZM2fOvv3221euWrUq7bjjjht89dVXr1myZMmMGTNmzPrpp59y77jjjqJA2yFDhtS89NJLBYHjl19+uWDo0KE1AHV1dXLJJZf0e++99+bPnTt31owZM2YdfPDBFWAbQM8880zRDz/8MHfx4sUzH3300aVnnXXWgGXLlnWIrLOdhXPOOaf8nXfemZ+o3nvvvZf3u9/9rn9z5GRkZFhz5syZtWDBgplffPHFvE8//TT/yiuvNB7RFJNonMePH185Z86cWXPmzJn1ww8/zAuUd+3a1XvrrbeWRMqL93ehurpajjrqqCHnn39+2dKlS2fMmjVr9oUXXli2Zs2azmPo+PkE253/AjBeRH7DniTOCamzH/B+G+hm6KT4vTWLgT2A31T1txR38QfsZ/oF4BARCf4B8GdK2xv4NKT+74CDgO2wkyB8CPwN28vpAv7qr3cqsAtwvX9pnMlGaDC0LwL/pwH8AjwEzAYWA2/6y8cBE9tyy4THH3+8YMiQISPdbve4IUOGjHz88ccLEreKzXvvvZfn8Xj06quvLguU7bbbbjWzZ8/OHD9+fOXxxx+/BSAvL8969NFHlz3wwAOlgXq77LJL5a+//ppTV1cnmzdvdi1ZsiRj5MiR1QCbNm1yeb1eKSkp8QJkZWXpmDFj6gDuvvvuHv/6179WlJaWegH23HPP6pNOOmn9PffcU9ySazEkx2GHHVZZVFTU4mfZqZxevXp5n3rqqSXPPPNMccAzaEg9yYzzqaeeuv6dd94pWLt2rTu0PNbfhUMPPbTyiSeeKBg7dmzlaaedtjlw7sgjj6zYaaedHK/e6iiGzsPAmaparqq7qer2qnq2qg4PCeg8DXi87VQ0dGKOxc7qlzJEZE9sj+SrqjoZWIj9DAfYG5imqhUhZQ+q6lpVXQl8C/ykqr+qai325GhHAFV9XlULVXVf/+eVVOpuMBhaTOD/tK9UdW9VPUJVh/o9xoHZwhnAI22l4OOPP15wyy239Lr33nuXVVdXT7n33nuX3XLLLb1aYuxMnz49a8yYMdWR5TNnzswcO3ZsWPnIkSPrqqurXRs2bHABiAh77733ljfeeKPLiy++2PXQQw/dFKhbUlLiO+iggzb17dt39FFHHTXg0UcfLQgspVmwYEHWHnvsESZ7p512qp49e3ZWc6/D0DEYMWJEvc/nI3S5lCH1RI7zpEmTcgNL16655poegXq5ubm+U089tfz2228P8+rE+rsAMGPGjKzIvw3J0iFuvqpOEZEvRcQdZ8PQt1R1XpTmBkOzEZEiYHfgkhSLPhP4RFXL/ccv+svu8x8Hl62FsDbke02U41wMBkO7J9H/aX5mqOrnW1WxEO6+++7SRx99dMlRRx1VAeD/ueTyyy/ve/75529oC51OP/30Dffff39JRUWF+/77719+0003BT0+r7zyytKff/553Ycffpj373//u8dnn33W5fXXX1/SFnq2V84555w+M2bMSGk80qhRo6onTJiwvKVyRo8ePay+vt5VXV3t2rx5s2fYsGEjAG677bYVv/vd77a0XNPOyc477zz097//fflf//rX9XV1dbLXXnttd9ZZZ5VdeOGFGyoqKlwHHHDAkHPPPXfdueeeu3H9+vXuww47bPBFF1209swzz9y0evVqzzHHHDPo0ksvXXPaaadtXrZsmadv374t9rqNHz++8ssvv1wQ7dy11167bsyYMSP+8Y9/rGlpP07pEIYOgKpOiHOuHnhuK6pj2HY4ClihqlNSJdC/K/pJ2Ov0A7/sGUBXERmjqtOwDZ3jU9WnwWBoX8T7P81//smtpUs0Fi1alHnwwQdXhpYdfPDBlYsWLcqM1SYR22+/fc1bb73VZIPlESNG1H777bdhL2pmzZqVnp2dbRUUFATXw+y3337VF1xwQVZWVpY1evToJrGSO++8c83OO+9cc955520YPHjw9sCSwYMH13z//ffZRx99dNA7PmnSpOzhw4d3qiQPHZ3p06fPAXsZ0zPPPFOYCiN11qxZ6W63m169erXZ8s9tgdBxnjZtWty63bt39x133HEb7rrrruDS0Vh/FwBGjhxZ+80337ToJW6HMXQMhjbidOBrf/rnI7FTwbb07dWx2Duib4+9z02AV4E/iMhDQIaqzm5hPwaDwdAsBg4cWPvJJ5/kBjw6AJ988knuwIEDm53Z9Kijjqq4/vrr5e677+5+5ZVXlgP89NNPWSNGjKi99957S9966628Y489tqKyslIuuuiivn/5y1+avPW95ZZbVmRlZYVlqtu8ebPr22+/zTnyyCMrAjJ79uxZD3D55Zev+dvf/tZ75513ntejRw/fDz/8kPXKK68UTpw4cU6k7M5OKjwvHYVVq1Z5zj333H5nn332Opero0RpJM/PP/8cTDiUkZGhocd5eXlW6HFhYaEv9Li0tNQbetwcb05zxvnvf//72vHjxw/3+XwCsf8ubNy40X3uueeuv++++3q8/PLL+aeccspmgA8//DC3e/fuXqdxOsbQMRiiICKHARcB+wMV2Ps1/TMFRg7YS9SeUdVlEX0+BPwbOyA5ctmawWAwbDWuvPLK1X/+85/7A0sOPvjgyk8++ST3z3/+c//rr79+ZXNlulwu3nnnnYUXXnhhnwceeKBHRkaG9u7du+7BBx9c/sYbbyy4+OKL+1566aVplmVx4oknrr/uuuvWRco46aSTmixjsiyLu+66q+Tiiy/ul5mZaWVnZ1tPP/30YoDTTz9984oVK9J33XXX4SKiOTk51oQJExb369cvmKH1uOOOG+LxeBRg7NixlR9++OGi5l6jITpHHXXUgIkTJ+Zt3LjRU1JSMvraa69dddlll5UnbulcTl1dnWvYsGEjvF6vuN1uPfnkk9ffcMMNaxPJNCRHS8e5tLTUe9hhh218+umnSyD+34Xc3Fx9++23F/z1r3/tc8011/TxeDw6fPjwmkcffXRZon4CiGpkCn+DwZBKRKQWqAP+rarXO6j/AfCQqqbc2BGRT4FdsT1TB6RavsFgaL9MmzZtyZgxYxxPLh9//PGCu+++u3TRokWZAwcOrL3yyitXt1V8jsFgMMRj2rRp3ceMGdM/stx4dAyGVkZVk13T/hXwZSuogqoe1BpyDQZD5+P888/fYAwbg8HQkTGGjsHQzlDVO9taB4PBYDAYDIaOTueN0DIYDAaDwWAwGAzbLMbQMRgMBoNh28CyLEvaWgmDwWBIJf6/a1a0c8bQMRgMBoNh22BGWVlZvjF2DAZDZ8GyLCkrK8sHZkQ7b2J0DAaDwWDYBvB6vX9as2bNU2vWrBmFedFpMBg6BxYww+v1/inaSZNe2mAwGAwGg8FgMHQ6zBsdg8FgMBgMBoPB0Okwho7BYDAYDAaDwWDodBhDx2AwGAwGg8FgMHQ6jKFjMBgMBoPBYDAYOh3G0DEYDAaDwWAwGAydDmPopBARGSoiU0M+W0TkUhE5UURmioglIuPjtD9UROaKyAIRuTakfICI/OQvf0VE0ttSVxHpIyJfisgsf91LQs7dKCIrQ+Qe3lJdW6qvv/0SEfnN33ZSSHmBiHwqIvP9P7u1pa6x2vrPpXxs4+h6l4jMEZHpIvKmiHSN0b49PLMJdW1nz6zTsd1qz6zBYDAYDJ0Rk166lRARN7AS2AXIxs7z/ThwpapOilF/HnAQsAL4BThVVWeJyKvAG6r6sog8BkxT1UfbUNdSoFRVp4hIHjAZONav641AparenSr9Wqqvv80SYLyqlkeU3wlsUNXb/RP1bqp6TVvqGq2tqi5t7bGN0HUo8IWqekXkDoDIcWlHz6wTXdvTM5tQX3+bJbTBM2swGAwGQ2fBeHRajwOAhaq6VFVnq+rcBPV3Bhao6iJVrQdeBo4REQH2B17z13sWOLYtdVXV1ao6xf+9ApgN9EqxTvFIdmzjcQz2mEI7GNtYbVOsU8L+VPUTVfX6yycCvaPUby/PbEJd29kz62Rs49Haz6zBYDAYDJ0CY+i0HqcALyVRvxewPOR4hb+sENgUMjEKlKeSZHUNIiL9gR2Bn0KKL/Yvy5nQSstqmqOvAp+IyGQROS+kvERVV/u/rwFKUqFgCM0e2xhtW3NsY+l6DvBhlPL2+MzG0jVIO3tm4+nbVs+swWAwGAydAmPotAL+eISjgf+1tS6JaImuIpILvA5cqqpb/MWPAoOAHYDVwD2p0TTYZ3P13VNVxwKHAReJyN6RFdRex5mytZwtHNtobVttbGPpKiJ/B7zAC6nqq6W0RNf29Mw60HerP7MGg8FgMHQmjKHTOhwGTFHVtUm0WQn0CTnu7S9bD3QVEU9Eeapojq6ISBr2hPEFVX0jUK6qa1XVp6oW8CT28qZU0ix9VXWl/+c64M0Qvdb64zcCcRzr2lrXWG1beWyb9CciZwFHAqdr9GC+dvPMOtC1XT2zTvRto2fWYDAYDIZOgzF0WodTSX650i/AEH+2qnTspS7v+CdBXwIn+OudCbydMk2boas/BuNpYLaq3htxrjTk8DhgRos1DKc5+ub4A9ARkRzg4BC93sEeU2gHYxuvbSuPbVh/InIocDVwtKpWx2jTLp5ZJ7q2p2fWob5t9cwaDAaDwdB5UFXzSeEHyMF+o50fUnYcdpxCHbAW+Nhf3hP4IKTe4dhZrBYCfw8pHwj8DCzAXv6S0Za6AntiL5eZDkz1fw73n3se+M1/7h3sTFdtOrb+8Zvm/8yMGNtC4HNgPvAZUNAOnoMmbVtzbGPougA7/iZwfx9rx89sQl3b2TPrRN+t/syaj/mYj/mYj/l0to9JL20wGAwGg8FgMBg6HZ7EVQwGg8FgMHR0Jk+eXOzxeJ4CRmGWrhsMhs6BBczwer1/GjduXJOYVWPoGAwGg8GwDeDxeJ7q0aPH8KKioo0ul8ss5zAYDB0ey7KkrKxsxJo1a57CznAahnmjYzAYDAbDtsGooqKiLcbIMRgMnQWXy6VFRUWbsT3VTc9vZX0MBoPBYDC0DS5j5BgMhs6G/+9aVJvGGDoGg8FgMBhanQULFqTtsssu2w0aNGjk4MGDR95yyy3FgXNr165177777kP69es3avfddx9SVlbmBrAsi7POOqtP3759R2233XYjvvvuu+y2uwKDE8rLy92HHnrowAEDBowcOHDgyM8++ywHzD3uTJx44on9CwoKxgwZMmRkaHlz7vGDDz5Y2K9fv1H9+vUb9eCDDxamWldj6LQDROS8ttbBKUbX1qEj6QodS1+jq8HQPkhLS+Oee+5ZsXDhwpm//PLL7Keffrp48uTJmQA33HBD6b777luxdOnSGfvuu2/FP/7xjx4A//vf//IXLVqUuWTJkhmPPvro0gsvvLBv216FIRHnnXden4MPPnjL4sWLZ86aNWvWDjvsUAvmHncmzjnnnPJ33nlnfmR5svd47dq17jvuuKPnzz//PHvSpEmz77jjjp4B4yhVGEOnfdCRJjdG19ahI+kKHUtfo6vB0A7o169fw5577lkN0K1bN2vQoEE1y5YtSwf46KOPup5//vnrAc4///z1H374YTeAt99+u+vpp5++3uVyccABB1Rt2bLFs3Tp0rRQuVu2bHHtu+++g4cOHTpiyJAhI5988sluW/vaDDbr1693//TTT3mXXnppOUBmZqZ2797dB+YedyYOO+ywyqKiIm9kebL3+K233srfe++9t5SUlPiKiop8e++995Y33ngjP1LuhRde2GvQoEEjt9tuuxHnnXde72R0NVnXDAaDwWAwbFXmzp2bPmvWrOx99tmnEmD9+vWefv36NQD06dOnYf369R6A1atXp/Xv378+0K60tLR+6dKlaYG6AG+88UaXHj16NHz11VcL/LJS+kbY4Jy5c+emFxQUeE888cT+s2bNyh49enTVk08+ubxLly6Wucedn2Tv8cqVK9N69+4dLO/Vq1f9ypUrw4zcNWvWuD/44INuixYtmuFyuSgvL0/q3htDJw4e93aKVgMggCBh58X/rzQpI8oZ/zkNbwuQQQF50l/D6sWQ0/RceGksXRIfR0qKXj+P7vSQQRrtfNP2YRcbvX6UQgn+o+HtmshplN9EV4Hu7gIGZvQLH9fQmxBWFlvvsPImZU1lxi0Pa994rkdmF0bkl2rYuZC6Eq9cQs7F7Ktp23h6No5p03KAXnnZjCkp1Ghj0lgv1jhrRL0IEdL0fGi7aM9MWJuIdn0LMhjXP1fDxi1SroNriP7LEUvXKHUc/HL2LfUwbmSmOqkbehznj0eCesrUKfUfq+qhGLYpzjnn3D4zZsxIaSzEqFGjqidMeHJ5onqbN292HX/88YNuv/325QUFBVbkeZfLhUT9RY/O2LFja/7+97/3+fOf/9zrmGOO2XzooYdWJql6p+Tzvz3XZ/28lSm9x4Xb9ao+4J9/iHmPvV6vzJ49O/uBBx5Ytv/++1edffbZfa6//voeDzzwwKrQeuYepwZr4gV9dNOslN5j6Tqi2rXrYwl/jxOR7D2ORWFhoS8jI8M6+eST+x955JGbTj755M3JtDeGThxUq+mS/hfciP1RFy7/DMHlL3P5PwAuJXgcWi7BY3BpY3sJlBFa5pehjeZNoK2EytTI8sa69rlGAym0TqCeaKBttLqE1w2US5QywBViaAS+2z81okwRaZxkBo5dAiKNk9jG8kCZIq5AuUa0j1Y3Spn/E2gDIC7CyiPr2nKiywjoGq+eSES5K0pZcEway3DFaB/Ui7AyYtV1ETQAounU2A/h5VF0JeRaI2Xi7yusfdS6jX2GlofqEapXQI9QmfjvLRHXEFmXgD6R9VyB8Wrsi5By+7nwGz6h50LkRusrvJ7dVqOWB+TaRRrsi+AvlwZkukAlpNz/S6hhdf31XNJYH8Bl14tsr/5r0oBOLh9dMxZ3x2DYStTV1ckRRxwx6MQTT9xw5plnbgqUFxYWegNv8ZcuXZpWUFDgBSgtLW1YsmRJeqDe6tWr00Pf9AOMHj26bsqUKbNef/31/Ouvv77XZ599tuXuu+9evdUuyhCkf//+9SUlJfX7779/FcDJJ5+88fbbb+8B5h5vCyR7j3v16tXw9ddf5wXKV65cmb7PPvtUhMpMS0tj6tSps995550ur732WrdHH320eOLEifOc6mQMHYPBYDAYtjGceF5SjWVZnHLKKf2222672htvvHFt6LlDDjlk0+OPP174z3/+c83jjz9eeOihh24COProozc98sgjxeeee+6GL7/8MicvL88XOQlesmRJWnFxsffCCy/c0K1bN9/TTz9tjHcgnueltejbt6+3R48e9dOmTcsYM2ZM3SeffNJl6NChtWDucWuQCs9LKkn2Hh977LGbb7755l6BBARff/11l/vuu29FqMzNmze7KisrXSeffPLmAw88sHLQoEHbJ6OTMXQMBoPBYDC0Op9++mnuW2+9VThkyJCaYcOGjQC46aabVp588smbb7rpptXHHXfcoH79+nXv1atX/ZtvvrkQ4KSTTtr8/vvv5/fr129UVlaW9dRTTy2JlDt58uSs6667rrfL5cLj8egjjzyydCtfmiGEBx98cNnpp58+sL6+Xvr27Vv30ksvLQEw97jzcNRRRw2YOHFi3saNGz0lJSWjr7322lWXXXZZebL3uKSkxHfVVVetGjdu3HCAq6++elVJSYkvtK9Nmza5jzzyyMF1dXUCcMsttyRl3Imq2TssFm5XbzVL18zStWgyArqapWtm6VonWLo2WVXHY+j0TJs2bcmYMWPK21oPg8FgSDXTpk3rPmbMmP6R5Sa9tMFgMBgMBoPBYOh0GEPHYDAYDAaDwWAwdDqMoWMwGAwGg8FgMBg6HcbQMRgMBoPBYDAYDJ0OY+gYDAaDwWAwGAyGTocxdAwGg8FgMBgMBkOnwxg6BoPBYDAYthper5fhw4eP2G+//QYHyubMmZM+evToYX379h11xBFHDKytrRWAmpoaOeKIIwb27dt31OjRo4fNnTs3PbZkQ3vgpptuKh48ePDIIUOGjDzqqKMGVFdXC5h7bGgbjKFjMBgMBoNhq3HrrbeWDB48uCa07PLLL+998cUXr122bNmM/Px87wMPPNAd4IEHHuien5/vXbZs2YyLL7547eWXX967bbQ2OGHx4sVpTzzxRMnUqVNnzZ8/f6bP55OnnnqqAMw9NrQNxtAxGAwGg8GwVVi4cGHaxx9/nH/uuecGNy61LIsff/wx7+yzz94IcM4556x/9913uwK89957Xc8555z1AGefffbGH374Ic+yrDCZS5cuTRs/fvzQYcOGjRgyZMjIjz76KHfrXZEhEp/PJ1VVVa6GhgZqampcvXv3bjD32NBWGEPHYDAYDAbDVuGiiy7qc+edd65wuRqnH2vXrvXk5eX50tLSAOjfv3/92rVr0/3n0gcMGFAPkJaWRm5urm/t2rWeUJkTJkwoOOCAAzbPmTNn1uzZs2fusssu1VvvigyhDBgwoOGiiy5aM2DAgNHFxcVj8vLyfMcff/wWc48NbYUncRWDwWAwGAydibsueK7P4lmrslMpc8CIntVXPfaH5bHOv/TSS/ndu3f37rXXXtXvvfdeXqr63XXXXavOP//8/g0NDa4TTjhh4+67716TuFXnp+yhf/apX7Yopfc4ve/A6qKL/xbzHpeVlbnff//9rgsWLPitsLDQd8QRRwx85JFHCo477rgtLenX3GNDczGGThwsXfnxprpru7e1Hu0GTbLcYDB0BMoTVzEYWs53332X++mnn3bt1atXfl1dnauqqsp1zDHHDHjzzTcXV1RUuBsaGkhLS2PJkiXpJSUl9QAlJSX1ixcvTh80aFBDQ0MDlZWV7pKSEm+o3MMOO6zym2++mfv666/nn3POOQMuvvjitRdffPH6trnKbZt33323S9++fet69uzpBTj22GM3/fDDD7kXXHDBBnOPDW2BMXTioKqHtrUOBoPBYDCkmniel9bi4YcfXvnwww+vBHjvvffy7rnnnpK33357McCuu+5a8cwzz3Q777zzNk6YMKHwyCOP3ARwxBFHbJowYULhgQceWPXMM89022233SpCl70BzJs3L33gwIH1V1xxRXldXZ1MmTIlG9jmJ8HxPC+tRf/+/eunTJmSW1FR4crJybG++OKLvHHjxlW7XC5zjw1tgjF0DAaDwWAwtCn33HPPipNPPnnQrbfe2mvkyJHVl1xySTnAJZdcUv673/1uQN++fUfl5+f7XnnllYWRbT/++OO8f//73z08Ho9mZ2f7XnjhhcVb/woMAPvvv3/VUUcdtXH06NHDPR4PI0eOrL788svLwNxjQ9sgqmbdkcFgMBgMnZ1p06YtGTNmjFmqaDAYOh3Tpk3rPmbMmP6R5SbrmsFgMBgMBoPBYOh0GEPHYDAYDAaDwWAwdDqMoWMwGAwGg8FgMBg6HcbQMRgMBoNh28CyLEvaWgmDwWBIJf6/a1a0c8bQMRgMBoNh22BGWVlZvjF2DAZDZ8GyLCkrK8sHZkQ7b9JLGwwGg8GwDeD1ev+0Zs2ap9asWTMK86LTYDB0Dixghtfr/VO0kya9tMFgMBgMBoPBYOh0mDc6BoPBYDAYDAaDodNhDB2DwWAwGAwGg8HQ6TCGjsFgMBgMBoPBYOh0GEPHYDAYDAaDwWAwdDqMoWMwGAwGg8FgMBg6HcbQMRgMBoPBYDAYDJ0OY+gYDAaDwWAwGAyGTke7N3REZIKIrBORGSFld4nIHBGZLiJvikjXkHPXicgCEZkrIoeElB/qL1sgItdu5cswGAwGg8FgMBgMW5F2b+gA/wEOjSj7FBilqqOBecB1ACIyAjgFGOlv84iIuEXEDTwMHAaMAE711zUYDAaDwWAwGAydkHZv6KjqN8CGiLJPVNXrP5wI9PZ/PwZ4WVXrVHUxsADY2f9ZoKqLVLUeeNlf12AwGAwGg8FgMHRCPG2tQAo4B3jF/70XtuETYIW/DGB5RPku0YSJyHnAeQA5Ga5xw3pmpkxRtXtoTqNUKuCAJHRMpX5BeYn716T7jSOzOdeg4qxpErJVHY67w3rqcCyj6RhT7UR9a6Bvadp1DKEaqJhgrByPT6K66rBeM/tXK+LaNepXQBzdo6h1Ysp0rufi+mXlqlrkqLKhU9C9e3ft379/W6thMBgMKWfy5MlR/0/r0IaOiPwd8AIvpEqmqj4BPAEwfmCO/vTPYSEnHWkVW7alhDnR4skLnkswCbJiT4CaVnY4UfNFOPriynQlrKO+QD0HBoxFY70mMhvbWz5A3Y50DJcZWwerASCxTAsgcoyiXZuCzyuNYxQHSwGfO6acUHwNLkcyfZFjFEOm1wK8MfqOwOsTsBLLbPABvrSE8gC8DS6Cvxdx7nlDvQsn90cBb4MnTp1GI7Wh3h0cy3gvIiyf4PPZfTc1ssPb1NWlEfp7HtXwUPD5BJ8VqBf5eyxB1X0+8HobZQb614j6AA0NYGm4TI2oEzj3xzXnLW2qmKEz079/fyZNmtTWahgMBkPKEZGo/6d1WENHRM4CjgQOUA1OPVYCfUKq9faXEac8Ni5FMhsSK+PwzblYgEhig8npm3j8ho46kAlhk6d4fYtP7P4TvmHH0YSb0Al3k9fPUY4dyBQftnXg5LqD1xN/TMXhOLqINnmM7hYREfueJ0AsUFfE9QS+N2muIA4V9Wm4gDjGQaI6AKqups9RtPoqWFaM+xhR3/LZho4m0NPrc8d+jsJ0FLwNnpB7FLtufV0aIq7wakFDItSwFryRxmCE3ED92tpwQ6cRsQ1aPz5vo/EUVaTaz63PB3UN6U3Fqd1nqOFV39B03DWsvq2HOvz7YjAYDAZDR6ZDGjoicihwNbCPqlaHnHoHeFFE7gV6AkOAn7FnJ0NEZAC2gXMKcFrCjlwKWfEMnSQnCz4ce1WcyhZv4gl8qMyE82MF9SbwvvhlSMAgizDMIrsQH6jPyQzbLzPS0Il2fS5sX54D1BXiVYnjKVOrqT6xaXrdjYJCavlC6sSRLS5sHaPdoCbGjwsnior4vU9hhVF0hNhGSYQOaglYCQxmtcfSauL1iqjjV8bnDRg5cbyhgLdeiPyT1cS7ovbE3zZKiD6hD3kG6uvTaPQSSROZgWVjliV4va4mz09k/5YKtbXpaBRDR0PbKjR4BV/IGDU1SOzr8VlQ2xDi0YmUF6JDnRd8fgMp5vJO9du/BoPBYDC0A+a99wuTHvuQjQtX021QKeMvOIztjtwpJbLbvaEjIi8B+wLdRWQFcAN2lrUM4FOx35ZPVNULVHWmiLwKzMKeBl+kqj6/nIuBj7FnNRNUdWbCzl2K5vr8isSp12Q2GUFgUmHFkxNywvJ7FxLIVAAfiBOjKLB8K87kJ4jXlYTMiLfhhMzVQ65bvAkGKTCR1ihLvUINioCR5QXciVxOoXpGWfKkETKjeVOiydOAkyb2eNreLhC3+F15UeSGfHcpWBrnAQkdU5dFE49BDM+YxroYIfjcqjbqGzgZ8zFRQWMZOiEyvA0u1BtYOhXFiAnzbLiJ6WUI8bJ5ve6QZXPSqGekZ0WhviH0T1vjfQ7Gu/jb1NWloVa4oRN+/XaZZUF9feTyvkZjonE5mVBVHWqUxPYANTS4aPA1jk2koROQ6fNBlTfUo9M0Pizwvc5nv08JlEXWiWIbGQwGg8HQZsx77xcm3vc2+992BqXjBrN68gK++PvzACkxdtq9oaOqp0YpfjpO/duA26KUfwB8kFTfbvDlRbocolQMncPHm0loonfWIfWiyYkm04ryVjsalt8gijYhjjwOe3MdDQnKjDqB1Yi6PsCbwFMRqG1B1NibyNvQQPTX0jFlatj5aHETLsG/zC0KEW/5NeCpCbs/jW0D3yyfy+8qiqNjcPLdZPAan61QT4y4mt50aZzMgx0MH7pqLnQSHTyQwA/xG5iRBkz4pN721Nh1wybwTZ5B2xjyeqP9eZEm372Wm0ivnfqa1vc2ePCFxv2EeVfCDb+Gek9YEL/SeBtC731tbTo+K0RPfxuN6Dtg6GiYkSFBL2Do5VfUpIV5dIKyIg0dHzT4XOGPkN8YC71NPgsqwv48NH3IAyX1WDQEPXmNZm7oJ3jGWDsGg8FgaGMmPfYh+93ye6rKNvPmGfdw9NN/Zf/bzuCbW1/ZNgydtkTd4O3ipGLIlCje5MGBcwjwGyVEzEpidOx15HuxZVphs6WYIsXrI2YmrNDjSOMpVl2/oRNVz8i2FmjAsxFl3h84drlJvHQtYNT4JEw+hN6viCV30QydSMNNgYbGt/8xPXoK4gEiE0YEZYa+7VfEinLdkU0DM9QmS9ACs+2QCb9o2CQ8mh0V8ErYSS2ie0jCAustF2q5g/WiywSf5YpYDhey1CtCT8vrCTFCAjpJEwOioT4NK8Qo0RCPXKPXyC6rq0sLGl9W4P5EiS2qrklD1RM4DJMZOvg+C+oaAskIQrKlhRgmAX0r6t2AJ8wrE+1XpN6ChpDxi1w5aQV/+tiEFTRwQmU11re/1eKlPuQ48vaoPQxYkYNrMBgMBsNWRlXZsGAV7139BL6yalbUree+nfflouv+ysaFq1PShzF04qAu8OY5CLbXQGxJgnqW4nIyuYh8/RqzniDeKDKjtQvIS7TMzlJcXkHCAhVi1PXhzyQXpU7Isfj8cTqx9AqTKSGemjhL7RpA3P468eQBNLhiL90L1dPC7y1JoKOKPfMNTHZjJCHDAnG5bMFBGX4dApZsSLn4DZMmK70i+g/NbRC004Kr3kIru8LGPLDaLnISH3zUol1n2DkBy2Vnc4uoH5kCWX0SHqMTnMxHLuWyg/wtS8LqNY0xsT1EQY+OBgyT8H5tXVzU13tCDJJAeXhcjapQV58eYpBJ2FiEjomFi9p6lz+ZQNMla4QcV/lcYV6ZaEaOAg0otX71I700oW3qsdiMD/XXapSpYfUUqKGBBrGCtyu0TWg9y1g5BoPBYGgjVJXlP8zmp/vfAYVN6zYw/Nz9OeH3B3HInLnc+KerOaV0z5T0ZQydeLgUdZh1LVrwcRMaQCVx1igUfxB7RGEIwXmyK3EsT6NMB8aLCpYrJO4n1qRfAXdI+EkUeUGngw9oCPHoxOwbO1jFFUgcEKViaFGTdVkx9LX8chPtreJz+fNWE143cqaqgCdgEMUxtFzYuZsDcSbRrIlAPz71Gzjx3rRLiBGkgRJ7mMKtGNszZlm2SylSXqBaoGpIrFXgGjS0cnASr1iWouqOqBNyWX6viarbv8SNsHFrXPrl/2nZGc3CvCQh/YY+ApYlWL7G9pGPR8CQsSxo8Db+nmmYwRZuvHl9Yqdj1ogVqBGGjFeh1hue3rlJXf/11Gq4IRHN4LGABnzUBk2W8Lqhbevwslm8Ic6+xhqBJWqBdlXUUy8WKtGNooDhY6GNwTwGg8FgMGwlVk9ZyMT73mblz/PILe3GLFnLyPy+fP7D1/z+hr/wzcvvclqPvfhww1T+nIL+jKGTiHh2RLRXtYmIWjfCAAk5lBjVwirEC9KJfOOvIeUxdFE7aiN6vRjjITHlhTSMdj6yLHS2mUhm5Kww9LDJLFyiLPeKPJYQGyJ0oipNxiBgV2iTGX9ovZBlbdH6DPYjqEijkRM5xqHj4AovCxcbYsyFGj5h1x0iPNS7E7CWQm47NHUABu2/wBgEdZCw8qDokLEN67jJ/XGFO7H8z7RIwFgSXAKW2AZOuMNLmnhWQiUHAt4Ee4zt9tJ46RFLC4OiNPy7+PsKZojXiOELjI+G37JI2Y23OOEvjZ/Q5zLQLvCbGrrkTf3X2GjcBUxKjUhxnuD1iMFgMBgMKaVs9nIm3v8OS7/6jazCPPb6v5PJGFvC2aPGML7LIA4p24F/9TmVGY98xt5Xn8CFxz+Ukn6NoRMH8QnuLbGGKPRVs79+IoFekNBlTDENFxrnp3HnQQoNEu5LinwdHJBpOZUJ1Ie8349nnFg0iT+JOgZewCc4iudpCEiJ4VEKVG8A9QWydYXIiFa/ToiepSxC2wZ3SAauODoiaEMUD140mZY/VXfouSZ6StOxjDQQwsZNImTEfvIkZBIeZpkEbRt7yZy4Qt/9N3pbBCU4sxdwuWx/QLRx1hAryO324fFYIZaRhhgO4V4VVV9YrE+wjjbqgoLPEux0e439aZQ2Nt6mCRKQsLwQqn6Pji98eAO6aEhbrw88IuHeoRA5AWNYFXz1drrsUJnR8pXUq4uMiOcyTI9APcAdsqlp46fRSxM4V4uX+hDPbXhiQQ35KQ42EjMYDAaDoWVsXLSGnx98j/kfTCKjSza7XXEsWbv05l9338WLZ72MiDDgkB24+N/306NHDwC+/PIrhg8fnpL+jaETB/FCxrpoM7qI40RxLwF8RN87Mtrk3IlMldjppWPJdLLnTgM0mk9hM8ko8kKyRjWpE1iWBfhibAgZ+QbeL7NJvQi0QUAjHt+oMgVtiJDZBP+SpzoXUTO+RfatoA2J6vllNniIXBYWTWfLEtTritFlhIGo0viGPtKwDb2/EvFTw48DXjhxgfhTddueC9uqafTShWslPolxzwM6CZoGHn+2CI2yDFDDWlnBhAABHZpeBIjLhy/NajRCgrLCPUSq4HFbIUZSdH1VBbfbi1qeYJ9hIWcheluW0NCQ1miARMT7BO+3BRl1nmBmushEBaE0+KDe8jS9h0jYr3+Dz0PXpuo3MZ5sQyc9PL20htcJPfgZg8FgMBhahy0r1/PLw+8z580f8WSmM/6Cw8jZqx+333cPL//5VTIzM7n88ksZNGggD9/0Xy7d7z7Wr6igsHceMzf9wN/vvTYlehhDJw7SILjXORiiWG/WoxlEEmWyH1dm7HIFf5awCJkSvX7M5WORXXiFaOmXI2anjfvoJJLpEzTehpRNZm+JZVoN4jdKYhhuoePk88uM7CtSZr0bJ0aJnV463NCJebsaPHHveeDQ8ontTUo0lkowQ1q0c400en3imrai/jTUfp9I0CjSpgYSAXkhWfli6IiASPjGs029Nn554vNn2gvRPeKaFBCXC1/ofkyRYxnibUlLt8KNlSZGsG38eNI8WCH3MlhNw/WwLMHn8/jvtT3+0ZbLWQpZtWmoRhitUYwyr0/w+kKe4aDscJn1XqhrCMkMR4RuId00+MAb+F2LyCjY5NEyMToGg8FgSDFVZZuZ/PhHzHj5WwBGn7EfXfYbxB0P3s/LV7xCVlYWV1xxGVdeeTnFxcV88eovDEqfw9z6H5lV/Ssj6ndkUPp4StyDUqKPMXTiYQm6JcPR5NMJGkjHTPgEpLnyAHuyIokn8Y0zuKZLb6LKJMZkukm9QN04k30fIZ4SBzIjUz5Hk+kFxaFMb4I6gbf5XgimUItnEFnYG1fG8vg0kRk+4Y/axvIbMIkSJgR/JqhLuK0SV6aAS7TxmAh1Q+0OVRAruhfR317VDotxuX1BPcLERBgItkGkTTwzjTIluL+MKyTFYPTQNHt5mtvTmBUvljcHQFwNdnKFSHmhhgl2jgrVtLC2kaNr+fcT8njqAE8T/SKNJ58P1ArsCyRRjRG17Hr1DekRfRMWQxTA6w0kVwj9nQw3HIPttmAwGAwGQ7OY994vTHrsQzYuXE23QaWM+cP+bF5exvTnv8RX72X473Yn/8DB3PXog7z6f/8jOzubq6++kiuuuIyioqKgnBfu/JA//uN4fvtue77fsiP/+fYmVsxfy0NXvML+J5l9dFoV9QlalZ64YpD4Hh17staCMOAoEzttsmlnAvlOPDqhHpB4MmMsr4v25libLB2LJzPxGIUZJQlkaiJDJyCzwZlMVex4moiJa9Q5emRGs1g6KnY8j5PnQ4X4S/EiukvknSPEkxPTG+g/7VI79Xi0ZzHoybEn/S5Xgo1SAzIDm25GbhoaUd9Sml53DK+bz1KibYDaxJhRVxMhkXUChz5fIKNHU8MhVKTL5SbSXdIkDTX29Wogy1+TuKXGtj4fNDSEbgEarW/7Wm1jy9M0liiKnsbQMRgMBkNzmPfeL0y87232v+0Mug/vzfd3vM6X/3gBVBly5E50O2Qodz/1MK/d9jo5OTlcc81VXHHFZXTv3j0ow7IsJn40gyWzV3P/X18kOy+TI/+4F263i+13H8yyuWtSoqsxdOKhgtbHH6KkPDIRE2NnRInFCBXp0DAIW16XwNixgp6nGLqE9e2gfyuaoROjbczYpIi+g56SxKhDD5V9PbE2xYmoF+OtfnhF/8eJng5lht7GhAS9M34LJPS+R7ZPfLv9ovwXJU09MKEr9MQV5ktJQLj3pYkHyI/LAlGfs985S8KNgBgGkRXcqTSGaiHlbreGe1Sa2HGB5YIWsR7kyLTVlmWFnIuiJ36j0R17LK2QvwH25q+Nya2tWJvVtuB9i8FgMBi2bSY99iG6dw+uOftSRtUXk+fJwtOnC556eGrZp7x2yAXk5uZy3XXXcPnll1JYWBhsW1tdz6cvTuS1hz5nxfx1uD1uDj9rD/5087Hk5mcB8OvXc+k7tEdKdDWGTjxU7BiLZJokOtkSj040kUkbOgHixLZo45Kd2EQxmBIaY4n1bDRK4uvZ1FMSR6bDMYoZ+xJZL+h9SWHfwWfDYV2nM1UHMiW41i6ZZ9NvCsdoIgJNdrKN5dERWwlVf/RLtNggwO0SmhgQ0TxLYCc4oKlXKPL3z4p2f2J4q0TACm3vjl7f3lMrwRI7/z30+aJ4siLrWiBNsphEeJX8/agGvDqJvcsGg8FgMCRLfVUtG+avonreEnaTfvTacyhlg1xccccN3NbrJD6e+gn/939/47LLLqGgoCDYbsOazbz9xNe889Q3bFlfxdCx/fj7f87B8lr859Z32ef4sWy/+2B++2EB91z4POfccExK9G33ho6ITACOBNap6ih/WQHwCtAfWAKcpKobxZ4NPAAcDlQDZ6nqFH+bM4H/84u9VVWfddJ/3CD60HoxDyLL29LQcda3BuJ+Ek2GHE6WnHpUIBmjxFk9ICRts5NlfQ78EEFPTSgxDDL/mTaZVybTqcOhjGfchBJ1H9tYtrW9Ji3KZD5CphXngiKWZfnUQlSiZDkMr+h2S1PXTDTxCj4Et5NYr3jPZkj3lj85SVyjQ8HezzT636HItj6f4A771Y2x9NLQ5ojIUOz/xwIMBP4B9AKOws4svhA4W1U3RbTtAzwHlGDf7idU9YGtoLbBYNhGqa+sZfoLXzF1wqcAFPQvYfDZe/Hv/z3Dmze8xfbd+lNuVbJkyYIwA2fxzJW89uDnfP7KL3gbfOx2xGhO/OsBbL/74OD/+y63i4eueIVlc9fQd2gPzrnhmJTE50AHMHSA/wAPYf9RD3At8Lmq3i4i1/qPrwEOA4b4P7sAjwK7+A2jG4Dx2P8pTBaRd1R1Y9yeVVCfw1gIBzR5E5+KCYflxPuSXF8O5n0hMhNP/OJ5K6K9vY4tU6LUc+oBiUV4cHdy3pf48oL1ndyf4JgH15tFyIj84oCwRnGWwzm93wTEBNx+ca4rWC9JmXH0lHi70kY0c1nauGQvDnYYUWw9Q2NrXKEBOzEbBGKTHNxz8S/FS/Dc+bzgdnvj1okVV+SovqFNUNW5wA4AIuIGVgJvAkOB61TVKyJ3ANdh//8Wihe4QlWniEge9v9pn6rqrK12AQaDYZugvrKG6c9/ya//+Zy6TVX03WsEj775X/Z1b8+df7yA8vQabr3ganrOtnjk1ze5uaAAVWXy57P5378/Y9Lns8nISuOws3bndxcdQO/BxU362P+knVJm2ETS7g0dVf1GRPpHFB8D7Ov//izwFfZ/BMcAz6m9rfpEEekqIqX+up+q6gYAEfkUOBR4KW7fxPDoNHOSEDcLVowlOImFgpO3x40kWCYDIdnhEujh1EsUNMZSaJA1CTRPJDPxcjjH15PMEsTQOW88h0QyMpu1/DG6AQUQz35oUjf0WyI7x6mXKFgvwRK7kE1NE+krrmTqxYhjCdHNUv/vhINnxKXi7B6JHUOT4Krtf6PF2oB/uWVIbRd2qu4E120MnXbHAcBCVV0KLA0pnwicEFlZVVcDq/3fK0RkNrYnyBg6BoMhJdRV2AbO1P98Rt3mavruPZKa7fO47YUn+HnDr4inC+f0OoIcUWq/2kzlLgOoKcvio+d+4LUHP2fxrFUUlHThnBuP5shz9iK/MLdNrqPdGzoxKPH/oQdYg+2+B/sP/fKQeiv8ZbHK46OgvhQuNXPwpjXakqi4bZxMzpOd1FiS2AvRJPYhth7q/yfqhqEJ5ceQGW2ZmeMlg/ENnebco/j1m/MMJbIiHEqIt3QrrJ6zh6TRKIltODXWS0amE49OiMwEYyCBZW4JvDqB+KAwojSx7aZA4oL4nbtD1u3FMyjs/Ytinm2qZzSZEe9hxJ8NMFF2R2PotDtOIfqLt3MIX97WBP+LwB2Bn1KvlsFg2Nao21LNtOe+ZNqzn1O3pZq++4yifIBw7fOPM/up2QwcOJCTDjib1T/VUfK3fTnl3GN49oHXePm2r+iTuQd3/fl5BozsxdWP/4H9ThxPekZa4k5bkY5q6ARRVRVxOEtzgIicB5wH0KdrZkqXrgHN8AYlmLAkE6vikGTifuzLSVDXcljPXxcHdZO57lZJRuDwPqrDBAOtEb/VKrRCwFG4URTbMEnGeGqS2jqGTJdLsPNbRyGkq8YlbJLQKFS3OFLTCiYZkCb9hXcOKjE28Y1ARCOMmGS8vYa2QETSgaOxl6iFlv8de4naC3Ha5gKvA5eqatSE4aH/p/Xt2zdFWhsMhs5G3ZZqpj77OdOe/YL6ihr67jOSJcU1XPzcvSxfvpzRo7fnxRef58QTT+D8Xf/JMZcXcf/D93PH1Y/SM2073JqG2+XhzncvYux+wxLG3W4tOqqhs1ZESlV1tX9p2jp/+UqgT0i93v6ylTQudQuUfxVNsKo+ATwBMLZ3vqbUowPNfLvvbxqzMJklYYk9FsktXXNA0DBwIDNIYo9SqpfDOX3LndwyM2fVkqqb4sx9SdtXYfWjGyb23zdnsSrS5F1CFJkaKtMBrkih0WW6Yi1dI7xYsY2IRF4nVbA0fp0AbhdYduaP8I4icdkbljrBpfhTuceXaTw67YrDgCmqujZQICJnYSfhOcC/FLsJIpKGbeS8oKpvxBIe+n/a+PHjzZ03GLZxom30Wbl6A9Oe+4L6ylp67zOC2bkb+OPz/6S8vJw999yDxx57mMMOOxQRweezWDpnNd1KutB95Q6kZXs48NSdOfaC/fjzHv9k3P7D2/oSw+iohs47wJnA7f6fb4eUXywiL2MnI9jsN4Y+Bv4pIt389Q4m4u1ZVJQQj04yk/TQSpG1WzBJjTFhibXKv9n/o1n2G+TkBErsKlEMnbgiHcQWxYuTiX/dicbfgcykvS9bT2az2iYhyjZKoq1bjFzr1WxtwiWHrJATd7S+ozXC9ro0qRpl2Z4KTo2neC+nQvf+cTs0RFXBFbG/lAb/Ce83aha7GDI1dNBi6GloV5xKyLI1ETkUuBrYR1WrozXwZxh9GpitqvduFS0NBkOHJ3Sjz26DS8M2+uy593AmyXKue+kGKisrOeKIw7n22qvYc889AdiyoYoPn/2ed578BlVYNGMl59x4NEectSddi/JSuvdNKmn3ho6IvITtjekuIiuws6fdDrwqIn/EDtw8yV/9A+zU0guw00ufDaCqG0TkFuAXf72bA4kJ4qEqWF7/RKS588omk54UvI3XyK8JlnklKz7mhqHxiGKIhH5NMJFPznj0HzbLqxL/bbwjb0kCeTGiYGKWJj/3bOkzFNqjxChPtv/wthIMEHIgM2owkYbICS1KLM9SEHvX28S4nY2l5ahvCfmZWE/7edOmZZFSFX+K9sRoFCHBTUqdiTBsRUQkBzgIOD+k+CEgA/jUv/RjoqpeICI9gadU9XBgD+AM4DcRmepv9zdV/SCV+llLXkVn3glb5kKXocjIq3H1PylxQ4PB0C6Z9NiHWLsX84+zr2SEt4hMVzpWaRYNG2s49bm/4fV6Ofnkk7j22qsYPXo0AAunr+DNx77k81d+ob62gTF7DWGPI8fw/XtTGbHzQHK7ZvPr13NTuvdNKmn3ho6qnhrj1AFR6ipwUQw5E4AJSfdvuRNXSkpgisUl4QlwvDIq1TJDls2lRiDJxeg47N/xdSczPg7rOn4sYr+sb0LTJWHRBUoy98ehjdUYT+NUpoPFjA7ruaBxM89ETRSatRwurivS2ZJKK4qhEw2xkl0paXuzjPem/aOqVUBhRNngGHVXYb/IQ1W/o5WD+qwlr6LTbkJG/x8U7wmbZqK/XI4FzTJ2jNFkMLQtW5aXs2H+KrzzljPW1YuC3Qbw6uJvePfrT7lvyFmcc85ZXHXVFQwcOBBvg4+v35jMm499xW/fLyAjK42DTt2FY87fh0Hb9wZg2Pj+rbb3TSpp94ZOWxOZvjU6Dt9cJ708yYHIYKxKyiSSVOpmJxKTue6k4mmSlZk47qdZRkkcnZvndUqEw9gkh6KTihdMyihJxqPjoFrUZXNRSGIs7Sc9sUVoZ7Z2uuGQs/sjDj2IIgKuiFieGDg1ngyGROjMO5FdHka/OJLQXyr94Rx8U64BTx6k5YAnFzw5SFoeeBqPScsNfteNv8HS15BRV0HJPlC5GJ10tTGaDIatQPmcFUx58mPmfzgZRZG+eXzNYl57/mny8vI494hT2Di/hkcffYKN67bw3zs+4N2nvqV81SZK+xdy/j9/x2F/2I28bjlhcltz75tUYgydOKhK9H10ouLQE+B0Uul0wp+ESGdIkp4NB9VaycBrvswY7YJhHU4Moo5Bm6maMo9OY/tksq7Fr9co0+XQeFIL4mdbS/5ZtBJsVhqQ2WiMOfBmJbTFWtUJYOhMbJkL3XdFdnsSvFXQUIE2bIGZdyK9j4SGStRbCd5KqNuAVi0HbwU0VNk/o6y31MlXNR6IG/3xXHyz7oXMIiSzCDKKILMIMouRzGL/d7tcPFlAo6fJtesjULQ7lP2ANfHCZhtNBkNnRFVZNWkBU578mKVfzyAtOwPP+BJeeOc1DmoYi3dzHgfk/JHhA7oxqqyBF9Z+Tcaf/sNXr0+mod7L+AOGc8kDp7LLIaNwu1OcfXgrYwydRDjy6OAkbMFpiEHSOPYaRGubsCAFpMDQia5ny+KImrz4TmYJlxNUna85SkjzjC+HPhXnIpNauuaQuH9DmxHBpIl+J0LeTjvdLTXh3/lGGeLQo+Py104kszHNhwNvY1Q9mxOHZdjm6TIUWf8TMqBx9biu/Rprxbu4dn4wblNVBaveNoIaKrHeGYkc+Aniq0brNkBtGVq7FmbdAzl97OOKRVBXZhtVRHlSPbm20VOzBrqNQZf8D8omQk5fZNhF6G+3oX1/h7hSvNzcYOhAqGWx+IvpTHnqE9b8uoiMrjnU7JDP3V+/ytKpK+iVOZQlDdkcuX03atduhIwGJi6pIq1hPN+9O5UjztmTY87bp10mFWguxtCJh9o7l6eW9v1GVUnw4ro5MlNtQDiR2ZxraKZBFrsrifiZCpnJVkou6UHKbn0Sc2vHRlGIlyhxWgBnV9IkC3UMmq4Gi5dYw1nfGrieBNVtJ40zj070RBnGuDEkj4y8GmvihU08JzLmhsRtRcCdYX8yCiF/GKINSOmBjU/l2q+xVn6Ae5//hbVVbxXUlkNtGdSVobXr7O+B4yWvgLcCXfmeXRaC9WohZPexjZ/cfpDTz/6e0w9y+0FmjzBDyCyBM3QWfPVe5r33M1Oe+oSNC9eQWdyFlUPgoS+epvLnKg499BCevPxJHrvwQ36q+oneg05mxhIvm5ZV4HXVkpefxytz/kVOl6y2vpSUYwyduEisV6TtBtUk354nmnQGq6TWKGmJZyG2YEipns2U5sx3kKDvZAcnifrJ3M9EtZx22+iFcNx1YlwBYQmMg2T6cxp206ReHAUc54J2Vs0W52xPovAwImPgGJqPq/9JWIA16YpGQ2DMDc0yBJIxmsSTA7k5tmFC06fet3E6rnF3ISX7oN4aqF6OrngPnfMwMvB0qFqKVi5DV34EtfbWRMHfBFcaZPeF3L725lQbpyPbnQs97oOGzejka8wSOEOHor6qlln/+56pz3xG5ZqNZPTK59fiDfznuwmkZ2Zwxhmnc+mlf2XodkP56eMZbFpVTQ/Znm9fnsl633LcPSu5/IbzePbi7zulkQPG0ElIS5aFbQ1aGne8teKWUx6n00pL7FIlNiinxc9PSPuob+uTkhBFTnIqxqraonGL0Th6sW2OJjLuHT/XUffbiVItmfcdDhMCBBI2JKwa7NtpYof2/TfL0HFw9T8JUjDpb1WjqWY1Ov9pZOy/msgLGEJULkWrlkHVUv/3pbBhCqgPnXkXzLzLbpDeDf3pIqyyibYXKn8Y5A+344cMhjYkcpPP0b/fj6p1m5j+3y+p21yNq08eH3rm8MGX31NSUsKNN9/ABRech1Xr5sNnv+emZ5+nfNUm3B4X+50wnrP/cTQ9+tkJH+39bxa28RW2HsbQSUDKDZ0UTtADy8xSqaKq2jEGkTLb2cvhWJ6slhturbHMrBk3qNVipdqhyBjD0+xH0LGX0+/DS/VaTWfOl0aHl4QdNkGCwX0OPDqtFQhoMLSQtjCaxJMFXbaDLts19Qy9lIecsAqpWWNngdsyF900Cxb/F13yEjRsafxNyuhuGz5dhoUYQMPspXD+X2CzDM7QWoRu8plb2o0f7nqDr258ARTqe2fy3xXf8uvn89h++1E888xTnHTiiUz9aj73nf8qP38yE4CdDhrBX+49mdrKOv5z67usXlJO955d+e2HBe12/5tUYQydeCjOl7Y4FJdKsynwMjq1MiXlMlsj61qjXAf1HAsk+J9WS/oL7zmJ6+4Axk3y4lKngOORTOpRc36PnN1/TSrmSMMPG1WKqOc0k0nQS+RQBYOhI5ISo6nLUGTjVKRkH8gfivQ61I4b2jAZ1+G/QM0q2Dwb3TwHNs9Bt8xBl74GDZsaf7/SutoGjysdNv2GjLgc+h4PlUtszxBmGZyh5Ux67EN8O3TjzrP+xiDL9sKUZdbgrvBx8xdPc/jhh3HX8w8ycsgYPnz2B84aczPrV2+msEc+p199KIeftQclfRu363K5XR1i/5tUYQydONgrUFKcFjnl0hwsfUlSpkbOwJKVEKVtUnFEMWQ0len0DXdq+22snKiCXz+nF5/i1ONBmQ7islKdTS3ZcUzuNjmp7TQmyXnPzq/dufEkaNOxavGfnBSuwTQYOinx4oZEBLJ7QXYvpPTAYBtVteN+Ns+xDaAtc9DNs6Hse3sZ3NTrYer1kFkMOf3QyVehaXlQsCOS1XmyWBm2DpbPYvHn09gwfxXMhyGeYhbnbeaZqR9Q4avhviFnMeO3aWxa0sD7D3/Hvz55DYCdDx7JJfefyq6HjsLtaZqFsKPsf5MqjKETF2nnMTqtoVtYGHnKaLYxFqdds0QmapSMRdaeH41QHGeCSPVdTzxA4s/ELDh4RpIyBDX8MGbF1KfJSNaoT/gb10oeUYNhW6Y5cUMiAlk9IKsH0mPfYLnvpTzk2AVIxQJ000zYMAXdMAXqyrG+PsGulN0LCsYiBWORgh2hcCySURi9I8M2Td2Wama99j3T//slFSs34FOLWXUbmFnmIV26slfPP7DLrj3YPHkhNx37nO29Kc3n9GsO4/Azdw/z3hiMoZOYFO5sryQ/CUooM9msa05k0kGmVR1gqVerkewNSkVquCTq216i5ASn7DmWuIdhaKtl43D2B8FR75Kc56mjPMIGQ1uTqrghugxFKuYhJfsgJXsB2MvgfrkM184PoRsmw/op6IZf0RXvNv6O5vRHCsfaHp8C/8/0fBPvs42ycfFapj//BXPenEhDdR0VXZQ3yr+li6+Qg7uPYPDpA9jxgH35+P6P8ExaxszNaQzeu09c742hgxs6InIZ8Cfs/9t/A84GSoGXgUJgMnCGqtaLSAbwHDAOWA+crKpL4nagoEnuoxN3kpEiC6JJHy3NvBZxLC1budYucZq4oGMYjc1ZmuTAXZLUfjZO+kv1lbfCws82vt8Oo4OSkupcpsFgSAVxl8EV744U7x6sq/WbYcOvtsdnw6/o+imw7I3G38jMHtBQgQw8DcbfB1Yd+vMlJt6nk6KqrPhxDlOf/YKlX/0GbmGBaz2vL/2GjZ5aTj/9VGa9VMXm0u7kf72M2V//h+64qOjdnaXlK3jujYva+hLaPR3W0BGRXsBfgRGqWiMirwKnAIcD96nqyyLyGPBH4FH/z42qOlhETgHuAE5O1I9zQ8fZxEGbPflrKj+4P02KZ2tbK+V0y0gi6Btnb+7tFU/NG8t40pNKTeywL+datuXNTPkCyJRKC4xhKn99JPBLmXJaS67BYGgpSWWCS8+HHvuGLX3T2nK/8fMrOuse8GSh85+E+U+COxPytrPjfTKLoPsuiCd7612coVXw1tYz952fmPbcl2yYvwpfuvBN1Ww+XfMrvbfrz6U3XUevjKF888ZU0n1LmTilnO127s1plx5BQ84mzj33zwz07d/Wl9Eh6LCGjh8PkCUiDUA2sBrYHzjNf/5Z4EZsQ+cY/3eA14CHREQ0wQzYeYxOajcJdCo/5e/NtTXedLdCgA7JGo0OYzGadd0xNFHbbkqpV5DGuBZnBComktq+jZKATCcJKJKXmUJpgWVmKTdKkhxPYxQZDFuVliyDk8zu0PMgpOdB+H67BdcJK6CuHMonoeu+Q9d9Z8f7fHEkiAcKxyHFeyDFe0LRbkhalxRfjSEVRO59M/6Cw+i502B+e+FrZr7yLbWbqticXs87a35kWvUyjjrmaO7e6XxWTavkk39Nx9swh0Hb96ZbSRfGHt+bFz96miePv5Xhw4dz0R8uZdb7ZW19iR2CDmvoqOpKEbkbWAbUAJ9gL1XbpKpef7UVQC//917Acn9br4hsxl7eVh6zj3afjACIlrWpmYjfFkj9lFeaOe+K0io4b2+Ob8xBlrak5AVqx5GbtCXafJ9fbAXahmSyuTkXmrrx8ecsTKmOttGUjPGUbNa3DuFuNRgMzaXLUCj7wU573ecopM9R/nifS3GNvR1d971t/Mz+NzrrXnvJQNfRSPGetuFTvHtYkgMT79M2zHvvFz675QXeqpjCl/N+5jj2YcO1axCfYlnKAt86Plj1C9XdXJx+xlmcwAAmvjeLVz78lq7dcznmvH04+PRdGTymD1+8+gsTbnqb5x95he13H7xN7H2TSjqsoSMi3bC9NAOATcD/gENTIPc84DyAXrk5qK8Fs6DIpq0RtpDKt9GtNofSFk/PJMIxkbQB6jCuxHH8fJNZfJzcXimWmdyVR3sI24qW9q0pNZ4C2c5SvbQQsSJMeyf5vePRDK+TMYoMhg5J3HifnocgPQ8BQL3VUP6z3+PzPbrgKXTuQ7aQ/BFI8Z6ouGH5u7h2fyJMlon3aX0+v/0lXi3/kUvPv5A//XI466Yvod5bT716uXvZO+yw266cdsAVrJ5WxeRnVuBJW89uh2/Pwafvys4Hj8KT1phYIJAKelva+yaVdFhDBzgQWKyqZQAi8gawB9BVRDx+r05vYKW//kqgD7BCRDxAPnZSgjBU9QngCYDRRd21RR6daPOMpCa9DuQnEUPuhKB6bWiQSZSDSGMh2WxZznc1cbhsr0n3TRsl5zGI5kqL1dC54dgooSWei+ZMmO3+Ur7SLKa8CB0d9itxjYgY1+3IMHE4ZrHWPDaR56TfWHKNwWMwdBScxvuIJzss1kd9dbB+Mlrm9/gsfhG8lQBYP/8VKd4L6XkQMv5ue78fY+i0GpuXl+Etq+J32Tux4ukfqfTC7C3VTKyZxUU9x3HGgdcx8/slfDdpLkPH9uMv95zMfieOJ78wN6bMzr73TeW3n7LxtWdpWLmUtF796HbCmeTudVBKZHdkQ2cZsKuIZGMvXTsAmAR8CZyAnXntTOBtf/13/Mc/+s9/kSg+B0A1la97k5hwaJMvMeq13NKJ1kPL56ehUpNL4xZmWzpIFuZIpjoRlgrC+3B+e5xftB3vnkiqBvsPyo8pNpHHwGmcT7IkG3ei4ErxsylODEB//Rj1mhZbiCvOsstIHRJi35+WGU8Gg6Gj0Jx4H3Fn2MvWineHkVehlhfr5a7IDjejZT+iy15HFz5jx/ioF2vm3UjPg+xlbyl/I7Xt4WvwseTL6cx4+RuWfz8bFMor6vhw/RTolcfwQbux4/wcKr3Kyrnr+d3FB3DI6bvSf0TPtla9zan89lM2vPgERRdeS+bwMdTOnkbZI7cDpMTY6bCGjqr+JCKvAVMAL/ArtifmfeBlEbnVX/a0v8nTwPMisgDYgJ2hLUEnqY3Rad6eN601yYxPM9/hh7QMv1BJxh5zYJQ4tQMbFWiqU9Mq9qS3ZUv4Iq67WSOZIHGCo4F0mHwBkqgXo24sr0RzPRAxDQp16MF0qqNd19nvpDbRMXYzRVypNEqsxPIcG2EBjJfHYOjMiMsD+cOQwnG4RlyOWg1Q/hPW/Kdh+dvotBvQaTdAZolt8JQejJTuj6R3a2vVOxRbVq5n1v++57dXvqFuQyVbtJbv1s+iu2s4I7tlMLbP/ixYWoF34xZ2Khamrq/npVW3dYo9b5rrhVFVrIrNNKxdjXftSsonPEDG4OFsev05Gtauoue/Hqfowmspf+q+bdvQAVDVG4AbIooXATtHqVsLnJiUfECtZqsXhWZMexOuJbPfcrctEd6bBDWcyXI2nU1ZzHfA4dHciXTKiadFG09SnQ56MjfHqbGRrLwEcsVxjE58r04TmU6uR5zKdG44OV/iZgwdg6Gz0yTeR31Q/jOy62NIyV7o6s9g1Wfoivdh0X9RcUHhzkjPg5HSg6BgByTlQYwdH8tnsfTrGUx/8SuWfzsLRZlVuYKftiyhsM8oCnrsy8olFYgqo4qqGdVHSCvO4a2VP9JQ3Tk29kzkhbHq6vCWrca7dhUNa1f5f/qP161Ca6rD5NUtmE1acSkZ240EbwOZw8fQsHJpSnTt0IbO1iDZ1MAJSWFMTXCq4tQYa4VMUM4E20H+zpxjzkfHsc/CyZKfwJzTciozzqmQc0l5hxzHlXQQwizRZk6sIy7WsUc05J7HbxNpZMXWM0xOApni6P8xy5Eny9bRuefJuZ4Gg6EzkyjeRwaeAQPPQC0vrJ+Erv4UXfUJOv1mdPrNkNEdKT0QSg9CSg9E13yxTWdwq1y7kVn/+56pL3xJ/YYqKnw1/LhpAes92RTnj6Dbpr5YS6FwbAG+ahhybC+e/fQZZs+ezXDPcM7+/fmdJiX0hv/9h4LTzgOXi8pvPqZh3WrSSnpS9vC/WP+fB/FtDA+Bl/QMPCU9SSvpSeaoHUkrLvUf92LN3f9H0XlXkLX9uGD9mt8mk9arX0p0NYZOPLQZ2b0S0BoLilJpvwSC8ZOblqYokKYZMsXJJNXpPXQUGB6zYmOL0BCQqNVb+Da9iStr67+dd+L1Ssa70KxJfJx60Tw6sXyNjmVGebEZtWnMuJ8o98mRTNvrFF3PpokLbJmRD6HBYNgWcRLvIy4PFO2KFO0Ko69Ha9ehqz+H1Z/aXp8lL9s5L11p0O8EZOeHwFeL/nRRp8vgFrn3zbjzDiWzaw5TnvuMFd/NRhTmVK1iTnUFGflDqKsbQ2aNUtC7kBNu2Il9fzeOXoOK23VKaCdLzlQV36YNeNcFvDCr7e/rVgc9NOvuu7GxgQjuwmK0vo6sPQ8kraQnnuJS0nr0wlNcirtrQcxYsIKTzqbskdubeIcKTjsvJddrDJ0EtI99dOJNZJ0uh0ti8VjSsUSJ3FRq2xpJzccThdtHyzwWZ3mfox6jLYeLJrN5Gb6SkpkAZ3nXouw5E0tXCdxzB3KdegwkiefI0ZKwRMSe3MdVszkxOnHlJTKetPFnhDEYvZkFjlc6WPZSvPbwZ8tgMHRIJLMYGXAqDDgVtXywcSrWV8dDRnfb6Fn8ImT3goJxdqxP398hro6/HGvee7/w4f89x7crK6muSWdo5TLWXzUBASp9tUzbspbNngIaKnujPqUgt4j9zhrHfieMZ8DIXmGy2mtK6MCSs+5/vob0vgOp/ulryic8QNWk73Hn5NGwbhXetavxlq1G6+vD2rrzu+EpLiVjyAis6iry9j2UrB13tY2a7iXUzplO+VP3UXzx35LSKWBklT91X9D4KjjtvPaddU1EChxUs1R1U2v0n1qSmTEkzpaVeh1S7vdJzu0UEOskVjpJ11N8kc3dhDROr9rc/UoSyXUmyBaVuLKKONzvJ8rkPFY7afIltkwn1ZzWCZGZeOyTiKdJIkbHWYybc5mB7HBOZDozSgJZ15zJJKb3x2AwGJJDXG4oHAf1G3AdtwAatqArP0JXvAOrPgarDuutQUjvo5DeR9spr11pba12s/jwH88zc201e25fhHvVFkQ9bKy3SHcpn5dnYnn7U9SrG/ueOY79ThzPdjv2jZuxLpUpoZMN/FdVrC2b8JatoWHdGrxla/CuW03Flx/izu/K2jv/hlZXBetXffsprtw8PEWlpPXpT/a43fEU9yCtuCeeklI8xaW4MjLD9Nnw4hNkj98DT1GPFnthcvc6KGWGTSSt5dFZ5f/E++/WDfRtpf5TRLJZ10LrRp9ROjV2nC1TsftMbkPKxDJFW+4lija/dr4Zp5Mxd2IMxVEo6imnpkZIpVgJvqTxtNMJqgayIcTCf0o0yYxmrUHkdadAn7DnOKGXI6G0uGcb7TrnC0klCUOnJUvswkQF+nZsvIQYWY68SgaDweCALkOh7AekZB9k4Okw8HSslR+hP/8VKdoNXfIqumACpHVFeh+O9DkGehyAeLLaWvO4qCrlc1Yw6flPcVXWMbpLGlVLy5hfXU1ZbVeq6l0c0wuOPGcf9jthPKN2G4TLtXUTNEQL/F/38L/wVVaQMXA7vxGzhoay1cHv3rI1aF1tmBzJzkFrq0kftSOe4lI8JaWkFZXi7l7MqmvOpf9zHznWqbW9MKmktQyd2aq6Y7wKIvJrK/WdWpq9dC2OWyRpL0D8TGSO3946lKlojLcUUWa3scJimtZMeayK86xr8YOONPSbUxsizhKwxDnownttdl8pI5n7EH15WNS4kiRkOovncZ6dLZmA/KSX1yVcFteyuJ+o9Rzt9wOI1WQ5HE0PDQaDISmaZHAr+wGddAWy4624+p+E+mph9efo8rfRlR/Yy9s8OUjPQ6HP0UjPQ5C0vLa+jCBV6zbz6ytfMe3lr9DyGrxqoepiboXFgi0ZZOXls/cp4xg9rJBJD7zN3+87Nek+WrIJpjbU411fhrd8LeuffYisHXah8ttP2fTG83jXrcG3oYz1T94T1saVl4+nqAdpvfuRveMutjFT1MP+FPfAnZPH8kt+T/5RJzcN/O/dP+nra00vTCppLUNntxTVaVOU5iw3S/AmOelYFYg1TbEn+s6iNZzKBFvH6NcdpY3jN+JEue4YxpQTkdK8FXYtr5QAZ1ZOyEmHGSKiNW1HxDJsk1LVueWaWJBT70uyxpMjYyPJ5XAJZdpxN86eYad9GwwGg3MSZnBzZ0LvI5DeR9h79qz9Gl3+jr3EbdnrqCsDSg9E+hyD9D4cXfXpVs/g5q2tZ9b7P/HjhA+pX7AeQVhbV8eq6nRWVrsozoQditP43d+OYq+z96V8xlLe/sujzK5uSLqveOmXc/Y80F5WVr4Wb9na8J/+j2/ThrCJWOUX7wdjZNIHDCF7pz3Y/O4r9LjuTjzFtjHjyspOqFe3E85s1cD/9kirGDr+PWsQkROBj1S1QkSuB3YEblXVKYE67RqlGR6deEuPNMlAf4cz/qRwEAOiONwpWZMbnzaboLfRMh1HE/ckDJ72RnxHY8pltkP7LgrJecccG0+ONyB1ajwZDAZDcjjJ4AbYMTqlB9opqcffB+U/2p6e5e+gK99HxQ2uNGTIubDfO0jFfKyJF7ZKBjdVZflPc/jikTfZ9MtSPJZQ6fWxotrN8mrIKC5i/z/uzGVH78ibL71H/WffUvzJ3az84hYqvVlUVHVl2Cl7J9WnVVPNhpeepMshx+Jdt4ZNs6fhLVuLKyePdQ/ehjz8zyaB/pKegaeoBE/3ErLH7hb87inqQdmjd9L9T5eRPXbXYP2a3yZT/etPZI/fPSndOtKSs1TR2lnXrlfV/4nInsABwF3Ao8Aurdxvymh+AoFowuJ5S6KReLaikswSoYDMRJkDWmeW1BpTeadL15z4vQTniQNsmuGNiSfV4Zv4lDk+WkqCGJBklq4588A0I/YlgUzHm3s6XmYG4koiqYVTb5ITUYIxdAwGQ7tCXG4o3hMp3hMdeyesn4z19fHgykDnPAhzH0FLD0L6n4zOuN2RIRXJHSfdgnfycrq4hS0+xTOuD+fddR6f/Pt/LP9kBpn14LWUVTXCsmpw9+zOwX/cg8uO2oGBo3oFX+z2945g0er3efiXbiwqG8jAoo1ctNNmBv5ueLAvq7oK7/p19qd8Hb71Zf5je5mZb30ZVnUlABueeyTYzt21EE9RCXgb6HL0qY2GTPcSPEUluPLyY6dfPvVPlD95T8q8MB1lyVmqaG1Dx+f/eQTwhKq+LyK3tnKf7Rhp40lq4lfwdtIATWqa6rTflEgMCLGwJ57NzT4WTaY6XWuVjCujA3pqEpE4X0JK5bauzCSSETSrz0RJEZzG3iShszF0OgQiMhR4JaRoIPAPoBdwFFAPLATOjpahVEQOBR7ATuzzlKre3to6GwwtQUSg+3io34ictB7ZMhdd+iq65BV0lR0Ib028wE5tXbwX4uDt3x0n3ULvhTPYfqcKchsq2OzLZMHizbxw8A2oKlvqhJnVoH0LOeyifbjs2HGU9u/eRI6qsuGVCfQ/72Luu67INlzWr6Nu/mzKHr2Dja/9B2/5OrSmuklbd9cCPIXFpJX2IWvUWDyFxWz+4DXyjzmVnJ32wFNYjKSlU/PbZMqfuo/Csy5Oaty2RS9MKmltQ2eliDwOHATcISIZdLAV5Cn16JBcXIkjkrGcgm8L4msQPVNYS7SOpWD0LHJx0YjvjvR0OoPuhEZJaxDDzosczpYa9c7aOjAkWt5JkvWdx/04M0rUed9CzL+w4c3Ns97WqOpcYAcAEXEDK4E3gaHAdarqFZE7gOuAa0Lb+us/jP1/6wrgFxF5R1Vnbb0rMBiaSZehSPmPdga3btujY25C5zyEzrgdXfYWuuh5yO6F9D8Z6X8q0nVETFG9Fs5g+77l/LSqD9VrelOUU82onivwqfCFqz+H/fEgLj10BLnuenwby/EumcSmKeV4N5bj21COd0M5vg1leDeuB28D5Y/e0ShcBHfXArS2hrRe/cgavROewiI8hcV4uhfjLizG0607ktY0nbanqIQNLz5BRv/BeLr3oOa3ycYL00a0tqFzEnAocLeqbhKRUuCqVu4zxbRGAEIbEew+URoqoqgaI3GAU6Iu2YshU+LXaJEezoUaEpFUvFl8Un2fRRwaBy1IHCAQXb4rif1+otWLZoA73gQ0ibgfQ7MQkRxVrRKRXFWtTJHYA4CFqroUWBpSPhE4IUr9nYEFqrrIr9PLwDGAMXQM7R4ZeTXer85mw4whVM2pImdYDgWj5uPe5X6k95H+rG0vobMfQGfdC93GIANORfqdiGT1oLaqhtf/+V+WfDCJo3quZemaQvLqa0nPq8BT6MIq7cVYz1L26APer//Fpo9r2BSpQ3YOnm7dcRd0J3PEGNwFRVR8+QFdDj6G7B12wVNYhLtbd2pnT6P8qfvocfU/k7pG44VpP7Sqd0VVq1X1DVWd7z9eraqfpEq+iHQVkddEZI6IzBaR3USkQEQ+FZH5/p/d/HVFRP4tIgtEZLqIjE2VHk5RTfJD4g/Ye/04+uDs4x/dFH6S9Iwl8QLbHodE1xQxbnHGHIf3JuImJLqUToQionYcikv9MSHRPjTrIyn6OF2+lZQ9EKFjyoyJSP1p+nFGyPg7/OthaBbdRORiYM8UyjwFeClK+TnAh1HKewHLQ45X+MtahY33lvLDJfsDUFlWzsZ7S/n+UnvCtnb+PDbeW8q3lx0OwNJJv7Dx3lK+ufxoAOZ98Skb7y3l6ytte23W+2/Zx1fZ6Xqnvvo8G+8t5atr/wDAL/95zD7+v3MBmPjo3Xb9Gy8C4Pv7b7bl33Y5AN/d9Xc23lvKd3f9HYBvbrvc1u/+mwH4+saL2HhvKRMfvRuAr/7vXDbeW8ov/3nMPr72D2y8t5Sprz5v17/qVDbeW8qs99+yj688gY33ljLvi09t+ZcfzcZ7S1k66RcAvr3scDbeW8ra+fNs/S49iI33llJZVg7AD5fsz8Z7S4NjOfHSvVl/d8/g8c+X7kH5nY23btKlu7Lu9j7B418v24k1tzVuOTj18nGsuqV/8Hj6FTuw4uYBweOZV41m2Y2Dgsezrx7Fkn8MDh7Pu3YEi/5vu+Dx/OuGMf+6YcHjRf+3HfOubfSgLPnHYGZfPSp4vOzGQcy8anTweMXNA5h+xQ7B41W39Gfq5Y2pi9fc1pdfL2vcNHPd7X2Y++9/sWlmKQU7rKTvsb+S2+8XNs0spXp5NzbeP5gp991HQ69bqO33AnVbMqhZPhedci2+NwZR/0wXKu8exi5zJnDa4OkMOngWex46iWP+9CmnX/4Rx/3+Q3r2+gG3S6nvkk3hTr9R0Sed4ktvoO6IkyjYcyErBvVmwH8/Yf1eh5GV/z9mrV5A4Rl/pmK7oaSv+TvTJtyKu1t3pt59Hb7PD2ddhp04INlnb/Lnb5Hb73PWHXAMfR74L5M+ftU8ewmevdagVQwdEZmSijoOeAA7q9swYAwwG7gW+FxVhwCf+48BDgOG+D/nYSdFSIhjI8LBJ+lZnyb+JGdAOJzBN3vvoFg079rjj2cUg6OF87tmT/22xTlja1yzplKs/2bHNMRsgw2X33Bz8HFsQMTpM9ZHY3yCujrSk0bj0+XgY2guBwBnAQNFpLilwkQkHTga+F9E+d8BL/BCC+WfJyKTRGRSWVlZS0QZtnEqv/2UXE89PTIqWX7J76n89lNH7QSlYe0qaufNxC1KV3c1lBzJ5s3nUrW6C+tnl1KztoR1D9xMuttHX/d6Vl1zLmvvvh2t81A1u4jF74+kbEYp4rHoNqScPkfPostBPtzZ9WT22sT3q05kYeHL1GzJIrf3Jlx9a/AdeCo+dbEprZDcvQ9Ge/Tzv/yMPvWt7TEYnwpFFUtZfMp+dFkyGZ8KldlFqRxGw1ZGNNVBKICI1ADz41UB8lW1b5w6ifrIB6YCAzXkIkRkLrCvqq72L5X7SlWH+mOFvlLVlyLrxepjVEGx/u/Ak5urYhScj3UyKahTnyStmdmtEslLpm5CrMY36w5kxuw7rNzC2YbHCXRsrkzHrx0sXG5n9ZzJ9O/T4nTcAzLj1rcQt1NvRGyZ4Yc+x9eNW2Pq2ESmowW89vU4uiCXz+E99zmU6UM8xF4qF9a3RazNRSOLMs7/YbKqjneiqaERERkOpAF9VPX9FMg7BrhIVQ8OKTsLOB84QFWbRD+LyG7Ajap6iP/4OgBV/Ve8vsaPH6+TJk1qqcqGDkRLNq2MlBPYFyZjyAiqJ//A+mceJHefQ0jvMwDf5o34tmzCt3kj1uaN9rH/o/V1UWU2+Fw0+NxUNXioy8mjN+soG3YAM35eSs26enJIw+dLY0uDi/J0N733H8Hvb/wDed4Z6OKX0WVvQMNmvHUeZk/tz8xJQ6muSGO/3ebR74BK0k6a3dLhM3QgRCTq/2mtFaMzLHGVYEa25jIAKAOeEZExwGTgEqAkxHhZA5T4v8dy9cc0dCDgiUkdjiYrBJZ6tc1bV+eGk9OK7fjtcahqCS88UDlBiHvISUEcXr469s5JRB9xpSqOblPST3nKjevoMjX+6TiCYg9QUrc8Zkvn9ZwbxSmo5zfqWylDvAFQ1cDsaXqKRJ5KyLI1fza1q4F9ohk5fn4BhojIAOwkBqcAp6VIH0MnId6mlQFjx6qvw6rYgq9iM1bFZvvnFvunb8smrMot+LZspnbmFFw5eay54zq0uirYx+Y3/9vYoScNd5euuPO74c7vRlqvfsHvgXJXfjfmXPNXfl3YHe/Be7PHiQfx2tUTGLlmKTk9M/j+f+tId2VRZ2VQ1sXDyFN35Q+Xnkx6VkbIlfnTVY+/G+uV7kj+DozaaTLb77KAuooCpO9puDY+vDWG2NABaK0NQ5e2htwIPMBY4C+q+pOIPEDjMrWAHirBqGRniMh52EvbKM3OS1KlxF05tV/EqUXkGOfDkHobS+zlNw7rhk/44ygSfz7bpGrCwoSyAg3aseEWDYfGTmplJjFGjvd+UceJA8Im+nHkOvcK4lDHJGQmcd3icngLXZpE4gJDSxCRf6jqzRFlBaq6IQkZOdiZ084PKX4IyAA+9e+rMVFVLxCRnthppA/3Z2S7GPgYO730BFWd2cJLMrQTkvXCqCpaX4dVWYFVWYGvagtWZQXrn32InJ33ombmr1RN/Bpf5RZcuV1Y99A/2fDfx/BVbEZra2LKlaxs3Hn5uPPy0fp6Mnceizu/q12W3w1XXhfW3fMP+jz4Eu78bkh2TsLNxlcvKWfGkgLG9FnL2+/9yLMvT2X7wirG9lnJ3LUl1Jaks/1Z+7PfGUfgyWiazSxMP3cm5A8jbfzNkD8SXfwCGQuegY0PgbiwJl+FDD4HyR8eV46hc9PaWddakxXAClX9yX/8Grahs1ZESkOWrq3zn18J9Alp39tfFoaqPgE8ATCqW4kmF6/i0CPgYGKT+hWFyb0PT85Z40BZx+MYKStGO5GkJvBRNYwoFEnSq5LSiq3IVvK+tDucLmt0LM/hUk2XQ4NM8Mf+OOzbCWbD0K3J/v4l0G+oaoO/rFBEjlTV55wIUNUqoDCibHCMuquAw0OOPwA+aJbmhpTT0iVi6vVi1VRR+dVHbHr7JfKPOQVPUSl182dS/uS9VP7wJZ7CIqwqvzFTWYFVuQWryv6OtyGq3C0fvQmAKycPV14X3Hn50FBP5sgdcOfl4/IbMq4u+UGjxi7rgqSlB+Usv+T3dDnoKLK2b0w0UPPbZNJ69yetZ58m/QYoW7mRqV/P48dPpjHji5nk1daxQ9duLFwDxw9YQW5GHRVWFlXjDmXVfxfzt3n/djxmADLyaqyJF+La9RFk6IXQbQz6wzmQ2x+d/yQ69xEo2t02ePoeZxtHhm2KDmvoqOoaEVkuIkP9+xEcgJ1acxZwJnC7/+fb/ibvABf703DuAmyOF5/TDI1SJyopz0E7Xz7WmpPsVMpuBT1bY/lQqh19rTkfbvPbk8AQbnP7rxXiI50uU+xgPsn2ihf4J/CYiHyCvQfOB9j/7zgydAzNI5VxJy0yTlTRhnoqv/qQja89S7eTziGtZx9q5/xG+YQHbEOgVz+s6kqs6ir7U1OFBr6HlEfGsWx45sGw4+qfvraNldw8XDl5uHPz8BQMDDuOPL/2vhsp/MNFZI/fA3HbAY6BTSuL/3p9UmPV7YQzKXvk9ibL4CL3hdmwdgtTv5nLr1/N5adPp+FbV0GPLCjJtNg7ywVZ4FNlgaeI4X+5nP4HjMWdnsZTVz/GFl/yf5lc/U/CAqxJV8CWufYePWNvx9X/JLS2DF30X3TBM+iPf0InX22nqR78RyR/aNJ9GTomHdbQ8fMX4AV/1ppFwNnY71JfFZE/Yu9HcJK/7gfYb8MWANX+uimkNZY1dZSlUjH0bO2ZZCqWZKVYx9aKjWiR2MbQotTKTCDA8e1JsDqx2TgIyE/YQfB8/N/B1nWgqPPBVOJ6k1rjHcE2zFTsJWcV2HvY/AGYQMf/fzVIqgyKVMpyEncSifq8aF0dVl0tWl+H1tVS9dM3bPnoDboccSJpxT2pWzyP8qfuo+qX70jr0QurtgatrQn5WY3W2MdWTXXwHFZjuHG5X48AFZ+9a38RQbKycWXl4MrOwZWdiysvH09JT/+xvyw7h/UTHqD4ipttz0p2Dq6cPCQzm2V/PIr+z3+U1FgVnPIn1v/nQVzZOXGNEyfk7nUQbz73Ef2uuJKeOfWsqkpnab+xHD1iN755awpTv5nHpM9nsmZhGUUZtmEzLtMip8SDoviKMul7wA7sdurBTLh+AjJlBRO//JUBu4/ipf97mvLXp+AZF9szFA9X/5Og/0lNyiWzCBlxGTr8Elj7DbpgAjr/CXTuw1C8p+3l6XOM8fJ0clKeda2VNlNrE0Z1K9FXDzjFYe1klsA4rehMZvjkuuX3M5Cq1jmJDBxNLkNaE4Wi1Wth1rWok2CnWcqajk9sPZxmXbOiTlCjxxY1Q2aIoKYyWyPrms951jXxy4yroy3TWYY0RdyWA3nYGdKcZrBzO1265jDrmiSRdS3N6f3xNZlmx2qWfs5Ek3WtBYhICXCoqj4bUlYAvK+qu7WdZrFJJutaLIMi2U0PVZXKbz5mw0tP0f2Pl5IxaBi1s6ay/tmHyT/8BLJGj0MbGtCGev8n/vctH79lb/DYpasdl1JXi299GfXLFpHeZ0CIMVOHVV+L1tWCL8ncRyJIZhauzCxcmdn296wsf1k2rqzs4HnJzGLji0/Q/YKrceXk2m2yc5H0DFZedQ79n/8YycxCnP3RZvklv6f7ny5rskSs/Kn76PPAf+O0jE6qDMxbL/03s1+cym4DusLmGmo9bqavaWBljYtMl9Ijy6Iwo47SzAzSXC58biV7WAljj9+bEYfvQlZBeMzzHSfdgnfycrq4hS0+xTOuD9e8mpyXqTlo7bqgl4fKRZBRiAw4zTZ6umyHteRVdOadjd6hkVfbhpSh3RMr61prGDq9gWOxd21O7vVDOyM5QyeAk0wDyWqS4G2yOOzXIckbOv7+Y7ZpgaETx4BotqETK+ynHRk6cS+rmYZObJnty9CJ3SYJQ8cVfs9jGzpe52PpUQc6Au4k0ks7uh5/emkng+n2OX6O0v9oDJ2WIiIuVbUiyo5T1TfbSqd4JGPoLL/k9xT+8VK2fPQGeL2oz4dv8wYaVi4jvf9gu8zrtb0lPq+/jl2Gz4d6G4LlKUMEVHHl5CJp6UhGJpKegaRnUL9wDlk77opkZOAKKQ9+z8i0v2fY5evuvYEe199rGy3pGbYhk5bBsvOOY8Br3yYMqo8cq1QZJ6kyMFOBZVksn7eWmT8t4qUrn2V0NzeTypX1ddAvF0Z0sWiwINdj/9Gxcj303ms440/Yj147b4c7vf06N1UtWPsV1vwJsOJdUC90GQZ15cjuTyMl+0DZD1gTL0TG3GCMnQ7A1kwvHdhMbYKIFKvqugT12zkpXjaWXBI4ByQnL7VLq5wmV2gGbSCzOSvhUr1UrVUuu4Pcn46gZrtf8qWEPcjtfdFrRyfSyPGXtUsjJ1kaVi4la8QOrJ/wAOJ2I24PkpaO1tXiysiEHA/iSUPcHvB4gnXs7/5PmgfcHja99izdTj3XNk7S0uwgd7eb8of/Rck1/worj/cdt5sVl54R06govf4ex9e38dVnELebzKGjwuSk9e6flJEDzuNXnBAwZsqfui/ohdlaRk51RS1zJi1h5k+LmPXTImb9vIjKTXZWtgNKXCyoqqJrZjVjuuXSxZOJIriBHS86jGGH7UTB4NKkx66tEHFBj/1x99gfrVmDLnoenX4baAP6wx9h0JnIdufj2vURO/7HGDodltYwdH4GzsHeTK1jGzktyl4UfYqR6mByaJ2la8nomPjvWnMzQTW9lvC0wcntaxJWPZZXJ0kdY2nQ3FucanmtJbM1aN6eOXEkaeJkf2IJ6sj7Iog6HEsVaDL9jd5KrcjG0WTa6QMcOd9VEOIoajA4JK1XP2pnT6PP/c8Hy4IGxY0PJCWrauLXZA4dFTVjV87OeyUlK1VGRXs2TnL3Oihlhs0Xr/7CC3d+yLK5a+g7tAenX30Y+5+0E6rKqkVlzPppMTN/WsisnxazeOZKLMv+/zojzyJdN9Art4Y+WXl0Sctn+7RsyMijaOwARh+zBz/Mmkf1sz+wx1+PSYmubYVk9UBGXoVv2k3IPm+gC/+Dzr4Pnf0A9DkWNs9paxUNLSDlhk4rbKbWhihJbsOTUF6yODEiUv8CRZGosy+n8TPJVEtgzMRpJ47rxlAgSiyRY5osi4rVtmXPT9TLS1ZkhKsqJY9LQvdXEr2oRPVENJWQhAER5fc21hPt3F6O9xSHCLFIyniKdT81pB5W9N/ImLq0NyvW0OFIpSHQHo2K9mycpIovXv2Ff1/1Iks9k5lZPZkxa/di1UVlvPrAZ5St2MCmcjuMOi3TjbtLPe6c1eT7auiX1YV+md1xSSG4hW4je7N+ziomr6tln2v35ejzj+XlJ9/mg/u+Zu9+ye432I7JH4Z4MnHt/RJauQSd9xg6/2lA8X1yAK5hF0PvoxBna6gN7YSUx+iECRfpr6pLWq2DVmZUQbG+dlAq3ZWtMdZRDJ1Eb7ETyrQQV7xazZhpNydGJ059iWXgJfBuxdehmTE6CWQ6i9fwy3QYJ9NEZtR2VtCTFl9sMjE6sfaICR9rwXIeo4Nlb3mYAEkqGYHTZ9SpTCth4oDgqUCSAQd9O0tGYCFpTjfcjaVn0/HIvOB7E6OzjZFMjA60z6xrhsTUVNWx6LcVXHP8A+Ra6xnbNZ8sy6LCC3O3wIo6yOrlo2LTErLrqxiQXcDg7B6kiwcEugwuYcj+O9Jnt2H0GDsIT0Ya8977hQ//7zm+XVnJxqp0uuXUs1evXA679Q9sd+RObX3JKcFa8io67SZcu9p771D2A9aPF0DxHlA+ESoXQ05fZLsLkEFnIuld21plQwhbM0YnlDeAsRGK7KqqE1u535SReo+O8/eyTok7QQ2eS/I6UhxL1LwEB4lIQqaDeuLIKHAuL4lqyVd22n9rvNmPuqdrCzty9KshDh9jRS0nWQOwPZcOvUSJll8GVXMJ4kimy+GSTgWf0xvu3+O4SXXj4jEkTyq9FO3R49FeibXcLBoVG6tYMG0586cut39OW87yeWtRVXpnKSO75rEoI5M1sgVf+TL2yO/JQF8GmT4vOfmDAMju3Y1Be4+mzx7D6bXzdmR0yW7ST8CYKXrsQzYuXE23QQMYf8FhncbIgRh78uxwk70nj+WDlR9gzX0Y/fVv6G//RAaegQz9M5I3qK1VN8ShVQwdETkJ28DJE5HhwNyQoM0ngNGt0W9r0BqT8+QUSNwmaR0TGjHqMKDQeYxMi9JLR0PUofclXGb81VZO35pHNHPQb0ppL3PWlOkh9uaZTvbmcTSk/iVhDvafURHHMh0nVNQkZSYMTnIhqg5tvCiWent5XgwGQ0K+ePUXJtz0Nlc8cgbb7z6Y335YwD0X2nFSO+y9nW3QTF/O/KnLmD91OWuWrg+2LSjtQpce6ZSMS2P5+oUMrSplypaleCq9jMvtRbecgQBku5Xhx+5Nn92H03u3oeSWdHOk23ZH7tSpDJtoxNyTx+WGPkfh7nMUuuFXdM7D6IKn0HmPQa/D7WVtxXt1mGQM2xKt5dH5HsgE/gTcCwwVkU3AKqCmlfpMOSLYaWoT0jaRv/YcLvXr8Z17X5KJaWnmGMVdQef82iXmQdOKiUUm6DciHsa5QeZcZrsgihERFkDvIBmAXTNhcE4T6YkV89dP1MSJggFZEXFEMXu2xPHLhybJCGKs3FSfwxidwMPWbh4Sg8GQDC/c+SE7HN+Ts847kzWLNtC/eCgDug3n9nP/g8/b6CruObA7BX2zyR1ksXLTImbOm8zyVXUM2FjM4JxSxmaXkpHuZs/0gbiyM+i7y1BcJYW8/PxExnuqOejOs9vwKjs2UrAjsvtT6I63oPOeRBc8jfX5+9BtNDL0IqTfiYg7w+zJ005oFUNHVVcCz4nIQlX9HkBECoH+QCdMXxGYVTj1RiQjO7bMgJhm7XmTNC0x5mIlDogh06mR5dhL5IwWy3LcvjlevdYkVgfR9JToVST8MFjbwaUqOIpPcr7w0+kSt2TqxvbSNNUpyeVwMQj1Q4pDozFYKUJXY/cYDO2PhnovKxeWsXTOapbOWc2yOWtYMns19UtWcHKXHcgbABVemLluHT5vFjse15vVW5by28LJ/Dp3EQOWFDEgq4Qdu/blkK77I13t3/Rug0spHTuI2R/+zOdrF5IuI1n/wgwKe+exsX4WaT1HtvGVdw4kqxQZ8w905FXoklfQuQ+hE89Hp15vx/isn4xrt8cb430mXogFxtjZyrRqjE7AyPF/Xw+sj1O9E5Dw9XELZKbSayRJyGudBAqdjlR7wBzLbA3aSM8Io6ldy3QayxWXGNZhtC6Tcdy2RpY9g8EQl3hxNfW1DSyftzZo0Cydu4alc1azcsG6MC9Naf9Cemb72KHIQ/2OfZjr3sC6eXPYXgrIlComvf8qQ7v05oycHckaYMt2Z6bRY8xASscOonTHgZTsMIDM/BwAeu8yFLnlBd6qmMhX1T+zn+zMsb3GcsC1p279AerEiCcLGXwWOuhMWPMF1pyHYPlb4EpDF7+MZJYgJfuYPXnaCJMjL6WkegLfVkaGxPjeHFnRardcZqvE2Gtz4p1SVdlZtrnWIZn7GHIXEwb6J0lrXHcryEydF9E/lg6MJucxbgaDYWsTiKu58M4T6VqUx/fvTeP+S17k1Qc+o7qihtWLy+39aQCXS+g5qIh+w0oZd+BQNLOOjbVrWbxmPjNmfcZhuYP5ZY2bZe++QVFWOtt3HUQXdxY7doUd2Y3cngWU7jiQHjsOonTsILoP7YXLEz3NYyCeputjBRyjI+k2sLTTJRBoT4gIlB6Au/QAfC/mwsAz0MUvoYuehz5HI8MvtZexGbYqrZpeurURETcwCVipqkeKyADgZaAQmAycoar1IpIBPAeMw/Yqnewk7fWowmJ945ATUqxz6sY7+OK2FTKkOa/s0DBpZqB/dGFAYI+j5sToxKzgT7OcUFqUfmM0EpwmTXAa6Q7iOA12cvUcx2UlWGYmAZnJpJd2sHQNLFyO0jZrY2xdymT6x9LJBbl8DlOKW42pumM+PwC+JO6PP1W3g7rZl3xl0ktvYySbXrqzk0x2MwCf18e6FRtZtaiM1UvKWb24nNVLyvnxg99QLBpqfcG64hI8aW52P2I0fbYrIa2LUuFdz9K1C5kxawbTpk1n5YqVFKd3oU9Gd4Z07c2Qrr3oXpsZDGi3FGrcaWQPKkTnr+acr28nt4ezxAGGtsX3/nhc4++B/JHovEfRuY9Bwybw5ODa53Uo3tMkLkgxbZVeurW5BJgNdPEf3wHcp6ovi8hjwB+BR/0/N6rqYBE5xV/v5ITSlSSClZ2g9lacKY+paY6OsWWqOtXRceAAztf6xLnWJu2TDU53IrOZtMYSqQDt8W9hlOttsZopG8NWfHkTNVBI4x7GE+Zs7yT/3kVOxkVi122Pj5HB0FbEym5WU1XHkB36sHpxOav8hkzAoFm7bAOWr3GpmSfNTUm/QuprGyjMX88e/Xrirq7Dl+fhjeU/YlWM553ZTzHztVl46xooTe9Gv+wiRpUMZI+iA8nt4kG89h8Md7qHwu16UTZ/JZOqFnHC3/7Ificcyk+Tf+HGP13NKaV7GiOnAyEjr8aaeCGuXR9BRl0LhePRH84FfFifHwpFu+EacSX0PMQYPK1Mh/XoiEhv4FngNuBy4CigDOihql4R2Q24UVUPEZGP/d9/FBEPsAYo0gQXP6qgWN845MQUat28JUJxSWpJSxKpm+MKTfaZSZReuhnPoCSzwaZT+U49OvH6De8rGY+O4+xs4nQT0rbx6ACIfzNMxx4dB3oGNiENK4vagTZ6GlPp0XHoKRHxOZbpZKNU8OHfx89B5wHPU+JnPusv3xiPzjZGZ/HoJOuJCVBTVUf5qk2sX72Zf/3xGboPzmTy1ClUbayjW1YRWZKPt84X1qZr91xKB3SntH93/88iCnrmUUcF6zavYcGCBUy7Zwaju3l4s/IXJq+ey/Ds3pzWY2/KawVPSQMlri5kVKntogHS87LoPrw3RcP7UDSiL0Uj+tBtYA9cHjfz3vuFz255gbcqpvDl3J/Zb+jOHJs3lgOvP90sOetgRMu6Jr2PQhc9h866D6qXQ9ftkZFXIX2OtVNYG5pNZ/To3A9cDeT5jwuBTarq9R+vAHr5v/cClgP4jaDN/vrliTpxagc6mSQ695RASrwVTeql6q1BpBxnOsQey1B5yaXLdpyFKyA7Xi3HNyeenOaNTVK0h3cTTdKrpUCmIyPCiaCQZ8hBHFEqN51tFg6v25mh48wQNRi2Ns01TqLJifTE3P3n59iyvpLtxvVj/erNQWOmfPUm1q/aRPmazaxftYmqLbVhsspXQbesvgwdVkBGFxe/zppEF3pz08vnU9ynG/VSxbKVS5k3bx7z50/lq+/mM2/CfJYvX46qkuVKpyS9K+f2PIhNdR6OLN2d3/fcF1dFAwBdciE7u4ii4X3oPqLRqOnSu3vM/29MXE3nIeaePNudjw4+x87UNuse9Ps/oHmDkRGXI/1PRdzpbaBt56VDGjoiciSwTlUni8i+KZZ9HnAeQM/sXMftnBpEqTQ3ksPZZF+x50rJzaUTXZEtre29s0L7sBI6EQljdZKgFTOkbVXa/Dk3GFJDaxongU0wo8mrra5ny4ZKtqyvomJjFVs2NH5ee/BzhuzYl/898BmPXfc661dvZlPZFh688tUwGW6Pi8LSrhSW5tuB//sNo7C0K91Lu9K9Zz6XHnM7J564PbnLNlK5bB1kZ+AaXMi03zbxp6t+z8KFC/F6vQhCgSeHAd16MbJ0ILv22ZeCvjmkVyla1RDsLy9dqK12s7qqAcnPo3TXnug3czjnuzuTHq9tYWPObR1xpSEDf4/2PxVWvIs18070pwvR325Dhl+KDDoL8WS3tZqdgg5p6AB7AEeLyOHYG5N2AR4AuoqIx+/V6Q2s9NdfCfQBVviXruUTI9W1qj4BPAH20rVWvYqtTjKX4zT2xqmsJPp2UlWxlzslo0L4l6bnk8rh24a0Bx1TaeC0gczGYuceUXGqSDIeFQcep6QxHh1DCkjWOAmgqjTUe6mprKO2qo6aqnom3PQ2R5+3LzWVtXz28s9s2VDFiF0G8sBlL/PtO1PZsr4yzJipr22IKR9gzq+L2FS5gS01G8jqms7uh+/EtA+WcetrF1LYwzZkcrtlsXbtWpYvX87y5StYvnwFE5dNZPn3K1i+fDldJI3KL9OZsPZnplfNZmzuSE4oHk9NXjlFReMo6bk/OfUedFMd2uBfzlYLmVm5dBvYg24DS/w/e/DBdU/zyrofuPGpO9lzzz347rvvg3E1BkM8xOWGvsfi6nMMrP4Ua+bd6OSr0Bl3IMMuRoach6Tnm81HW0CHjdEJ4PfoXOnPuvY/4PWQZATTVfUREbkI2F5VL/AnIzheVRM+IaMKivX1g1MZo4PzmHzH8rSZnpLo991+AR4rz3Jzn5VYMTot3IQ0GZnRLkciD+1YkcTDmUy2N6dxMh0sRgeijF8ozYzRiSvTeTxNWMxPAj1THaOTTNY1ZzL9Y+loMC3Hr6+yLjIxOtsaycTo/HH8zVx454ksmbWKmqo6aqvqWTZvDdO+mce4A4bbhkx1PTWVtcHzNVV11FTWhQXsx0JcoBb0HdqDLgU5dCnIIa9bTvB7l8LA99zG4245nLb9tdTXz+DwftvjXVeFr4uHD5b9hs8aTPGBdSxbtozly1ewatUqvF5vsL80cdOrSzHblfanX7ceDCzLpj4rHVeth3TLItsdqpvQpU9325AZ0CNo2HQd0IOsgqYrPUxcjSGV6LrvsWbeDas/gbQuULw3bJzWZPNRGXODMXZC6IwxOtG4BnhZRG4FfgWe9pc/DTwvIguADcApbaRfG9N8QyW1tPEmpOZtd8tJZba1jibTYNgGWDZ3DbNXTGHCNd8iCIpFRnY69dVeFs9aRVZ2Bpm5GRT0yCcrN4OsnAwyszPIys0gMyedrJwMsnIyycxJ5/7L/svS+t+46paL2HPfXZk1dwZXXHA9I7L35JkpN9DQ0EB5eTllZWWUldk/F5ctoGyJ/b28fH3wXI/yfA4qGMYTUz5jetVsRucM56SSnflqwzwW/VTBwKLe7DZ0MIXbdyFPM0ivA2tzHQ1bauwLs7DXc7hgS20NPbYrodew/myWWia88RJHekZxwbR/405PczxWJq7GkEqkeA/cxXugG6baMTzL3gBXBrr8XSRviNl8NEk6vEenNem8Hp04qaWJ59FxLieynvMND1tJpqPg9BbsoxODTu3RIV6b5nl04uvQDI9Owt+3TubREaeZ3IxHZ1skGY/OCUOuYFbNd9zz6C3se8DeTPxpIhedcQ0jsvbktfn3BOupKnV1dVRUVFBRUUFlZaX/e2Xw+ParHmX3jB0ZWeQio8ZHpdti5nqLLzdPpDprHZs2bYqqg4jQq3sPehf0oLRrd4pzu9F7kQurKJ+q9Upag4+8TBc5HgFveLY0d0YaeT0LyOtVSF7PArr0LCCvZyF5veyf75z7IL49irnzxceZPXs2w4cP5+rTzsfzQxmnvfePZo+xwZBqfC/mwoBTYcmrIG5kyLkw/BL07aG4T61oa/XaDduKR8eQECeGRCd+992a+91sa0jsp6m5w6txkgc0d4WmxmjsOOamo9F2GU8MnYglDVPZJ2NXZvz9DRZc+TqVHotx3u35auUnjBw5JsywCV0iFo1xeQMZ2KWGb5f6qK7PpTjXyw5d3VRYXRi1137kp+WQ40onw/LgaQBqvPgq6qjbWIXl9dnP9Eb/Jw3Y5KW0MIe8Ht3I61nAZl815V/P5/AHzgsaM1kFeXEzae7058OZeN/bfPTUK5SOG8zqyQv44u/PM/6yY1I4igZDCsgfhmvg72H7v6MzbkfnPQrzn4T0bmjdeiSjsK01bNcYQ2ebIyKV87aKMXhaTqo3DY1ljLSmzI7yK5DMQJhn2pACZONKdhi2Ix8t2EhFbTbdc7zs2M3N6noP/fqNICcji9y0LLLTMsl0pZHpSiMdNx5147YEl1eRBgut97Fh3irScjI5PF9oqK4DMgA4qGAMzPQCm3FnppFW2IXswjyy+nUnqyCPrMI8+zj4vQuvnn0Pr677nhtubwz8v9Mf+D/40HGOry+wrOybW19h48LVdBtUyq6XHWOWmxnaHWGbj+78IJTshf58GdRtwHp7pJ20YNjFSHrXtla1XWIMnW2SRLO7WK+E2zi2JpUyO/JksL1MziXsR2uIbvcyo9LW98d4dAwp4KgeO9PzzHEc8vgPeGsbCBgnxxbtAgsDtRr8HxtfugdXTiaenEzScjNJy8kivSCDzfPWMK1iCfsetB+DRm3Hig1rePSZpznGM5o/fHYrWYV5pGVnONLrwL+fBrco/7roH8HA/5O7784B156a9DWaNM6GjoCr/0lYYMfkBLKu7fIQ0nUU1m+3oTP+hc59FBlxKbLdn5E051ujbAsYQ2eboqUzsNbwBrWmzDjyQk+ZSWGLiDbKzU4EKB1AZnunU16UYWtTINlcdveN3HrkhfQfMpAVa1fx/EsvcZBnGEc9+RfSczJIy8kkPTfT/pmTiTs9+pTixSNvZo/dx3Dbi48z+3F/PMwf7XiYLn26J6WXCfw3bIvE2nzUvdcL6IaptsEz7UZ0zkPIiMvstNRmHx7AGDqGZtMam2+mWqazTVIDp9t+Q9MORqqX/3UEN44Tb0myfRoPjKEdUjC4J//Y/VJuffFxZj8cbpz023tkUrLGX3BYSuNhjCfGYGhECnbAvc//0PJfsKbfgv76d3T2v5GRVyGDz0HczrylnRVj6GxTtIZx0oakcnLYkSaa7UXX1tjscivIak2ZrUOSv7fGcDKkgFQaJyYexmBofaT7Trj3f8feh2f6zejkK9HZ9yGjrkUGnoG4nKdM70wYQ2crooBoCkyN0ODvpOUl9nJoqlNgtxapmNB1iAttp0QZ/7CFiE6zlIfKixTS9DA5WkPmVkedP+ud6D2GoW1JtXFivDAGw9ZBivfAdcBHsPZLrGm3oD//BZ15D7L9tUj/U9Flb6Az72yM9xl5dafeeNQYOglJ5ZQoRbMQDf/qWEOJeRAhP3KfmE6UhCBAx5rptj+cGA7JjnFrGCOp3jC0vbuWxP+726ENu20DERkKvBJSNBD4B7ASuBEYDuysqlE3vhGRy4A/Yf/h+w04W1VrU6mjMU4Mho6JiECP/XGV7AerPraXtE28AJ16I6gX2eM/SPGeUPYD1sQLsaDTGjtOtyg0bJMoqTdI2oFMM+trOdr4SdlwBmKliCVTHX5ARJt8iPZx4fwTqpTE+bQlrZGi29AqqOpcVd1BVXcAxgHVwJvADOB44JtYbUWkF/BXYLyqjsLeJvaUVlfaYDB0KEQE6XUorkO/w7XXS1C/EerK0clXwapPoHhvXLs+Ynt4OinG0EmAauo+HWdZiYT8TPWMrg1lJuiiw9yedoBI4yelMlMnrvVItQfGgeEW1UiL9glRsT3YXQbHHAAsVNWlqjpbVec6aOMBskTEA2QDq1pVQ4PB0GEREaTP0WDVI7s9DVYD1jcnYX1+KOpKt5exdVKMoWPYajg2CFtNAZrMHw3No8l9o+XDGilnq9wmR4ZGwHWl4Ao3LKJ5jsTl/IPgwJukJLTlQ6waSaKuod1wCvCS08qquhK4G1gGrAY2q+onraSbwWDoLOQPQ7JLcR0xCdnpftgyF/30QPDkoBULEzbviBhDZ1vC+cofh3Ul4uNAbjPVNITQngbEP2lOyfw5SlxJ8+QlMUBWszqI31Nb3h9jwHQ4RCQdOBr4XxJtugHHAAOAnkCOiPw+Rt3zRGSSiEwqKytLhcoGg6GDIiOvxpp4IZT9gAw6C9nlUUjLB18d1vvjsCZdidZ2rr8THdbQEZE+IvKliMwSkZkicom/vEBEPhWR+f6f3fzlIiL/FpEFIjJdRMa27RWkCqevb5P5JJKbrC4tn/slb/g4qG0sqRYT/kQ0c0ADy+CI/ZQFy8XJRxI/qiFyW8pWeYwcK5qEh8rQXjgMmKKqa5NocyCwWFXLVLUBeAPYPVpFVX1CVcer6viioqIUqGswGDoqrv4nIWNuwJp0BdYrBejU65Gd7sd1zCxk4Bno/Mex3h2NNfMu1Fvd1uqmhA5r6ABe4ApVHQHsClwkIiOAa4HPVXUI8Ln/GOz/TIb4P+cBj259lZOI6aE9T1U6wtqXJH0MIYPqON7KwafzTSfDl2eFx4jQfLua+HW0tR65FMtsF/e7vf9qGiI5lSSWrflZBuwqItkiItgxPrNTrpnBYOh0uPqfhPuISbhPrcB9xCTb+MkqxbXzg7gO/wWK90Kn3Yj17hishc+ilq+tVW4RHdbQUdXVqjrF/70C+498L2x3/rP+as8Cx/q/HwM8pzYTga4iUpq4p9R5SlSTqO9kKZhToynqR2N+Uj9bS2bm5ezag8Zgi8YgwngxOMfBeCU93+4s98DphQs4TUYQNRYoanxQhGwHiQsMbYeI5AAHYXtkAmXHicgKYDfgfRH52F/eU0Q+AFDVn4DXgCnYqaVdwBNbWX2DwdDJkPxhuPd5FdeBH0N2T/SnC7E+3BVd+ZE9P+yAdIp9dESkP7Aj8BNQoqqr/afWACX+772A5SHNVvjLVoeUISLnYXt8KM3ObeMJsJMZUzIKJqjbqm+CnQoP6JiofgpvTAfwFGw12U7ZimPWvK7UmUxRh5njNLjELiEB75YTmWHKRBEVWs+RSG2aCtvQblHVKqAwouxN7DTTkXVXAYeHHN8A3NDaOhoMhm0PKd4T18FfwfK3sKb+A+vr30HJ3rh2uA0p7FiRHx3WoxNARHKB14FLVXVL6DnV5JM6h65nLsjISqGm7YEY63+aFEurLLFLuWelpbZOayyH6gir+lKBg7FP+vZENGhvt6e1bdd4q/piZz2I9ptmMBgMBkPLEBGk73G4jpiMjLsHNs3C+ngvrO/PQiuXYC15Fd/74/G9lIfv/fFYS15ta5Wj0qE9OiKShm3kvKCqAdf/WhEpVdXV/qVp6/zlK4E+Ic17+8u2Kqn2EDVvH5OIRhp5qA4ndUl6adqLAdBiPQSNGLSgyMj7K1HKYhD5bMRVMxmZIYJSdgta0aPT0RxszSc5b5Kji5CmddvntRsMBoOhIyDudGToBejA09BZ96FzHkSXvQnubGT3J5Ceh0LZD1gTL8TCjgFqT3RYj44/APNpYLaq3hty6h3gTP/3M4G3Q8r/4M++tiv2vgNhy9ai9IJqMp9E3orQqOrUxf2kRrdtJFYlzqxPHY87YceSKNbKsUxHaiZPEvPktmarGzlJhY81ek4k3sdpPE3Io5Qok1xUPaPF3biwZYfoE9XzY2J0DAaDwZAEktYF15gbcB01HTw54K1EfzwfnfMgdN8F166PoDPvbGs1m9CRPTp7AGcAv4nIVH/Z34DbgVdF5I/AUiBgWn6Avb55AVANnJ1adTrXxMHp1bTGxNSxsZWEtyQ4qWyF2xRLZEvGJtUyIz07LZaZMJQqiYEO8ULEUdOW6ejVTLgREfIjSt9JekUlqEns047lhV937C7tJAOOxEbx6BgMBoPBkCokuyd4K5BDv0On34xOvR6d/zSy4y2weU5bq9eEDmvoqOp3xP7v/IAo9RW4KLlOSGK+5mRmofYL/lTG0YtTw0AcT+jUaSx1kwVcsftGkniJ7GxGl2hWHEbMMYoIhHBqZMXrtnnLCZvfX5vJa6XJdOgtaF4XGv5V4si0nBpPkZqFEyazBcaGxOwjzoMZ2o/x1BgMBoOhtekyFGnYhGvf19E1X2BNvhr97gxwZ6ObZiBdR7W1hkE67NK1rUfzlh7FlJXU0rXExE9ZHVk31UvXxHk2gmSTDKRKVjJ9pUpkKywDDFMzWblRHocWD+dW8hg0T8cQN04UPcNkJvGrm2iFYnBlqmO5/v2IQpazRZcfqzxKP6n982IwGAwGQxNk5NVYEy9E134NxXshY++E9AIQwfpwN6xfLkNry9taTaADe3S2Bkoyk1VnHh2nNZ3ItF9Wx/OqRGuf4je+8dwXwVN29Itjb4nToXTqzZIEI5loeVMzaA2vTrNJ6Ply7MIjmecnlshYYxNbhWSfWQVX/DbBvlwktxzOyeMuDu9/MkZHrOtpYuj443QciDQYDAaDoTm4+p+EBViTroAtc20Pz/h7kNID0d/+ic5/Av3/9u47vqnye+D457SFsjeyN8iQJXuDCArKEEURB4gKqLjXl+HeqD8RByKigoKCiigiQxAUHCB7I3vvvenI+f2RNLalI2mTZvS8X69o780dJ2nJybnPc59nxzdI3WFItf5IRI6AxWqFTroy8pUh7X5S3l/pT30HFfG4m1niGNLf1sPt0not7ucE9fTLHx5+rXUdzLML58mOmHwn/e9/vvqCmHDKoCh4AtDvTVzFk0enlvSLiIRjev1++ryITePfovuU6fwFJ2718bCrmXOAAQ+OGeFNVzxjjDEmYyIq3gIpjLAmjd5Gq96NY/n/0GVPoZs/JaLhcKRUhwBEaYVOulQ9LCOS9ClKfR/x6At/8i8/aezghzv3PR1cGgL0Rd7rL6/Jvnqm8Da4yyaHZ0dUD75MJrRiefgn9N93Xk9aDXzE6+N5VORk8NiZO22y7dNvpRLAqwlD02klSnxMT1tpxKNCRz0uiGwwAmOMMYEmhWoRcdU02DsDx/LBOOZ3hzLXEXHl60iBqlkaixU66fD6npV0iglPBw5ItlfqW3pcafiyvSLRUbPy3ueE8F03VzgcnhZaqZduQTlwQLJflU+Ol8KBJPk2nve+TFFKf7XetTamd0xP/9hSKzRS6Drq8c37nhYleN6qop4VTxDvefEi1qJjjDEm8EQEyl5PRKkO6L+j0LXDccxohFQfhNT+H5KjQJbEYYVOWhTPL8e7pXU5PgP3GqRzzEsLjbS7zXl33vRlvFDw4r3wRzESjAVOsoP4LMS0ChzfHz5jB/AkRm9aKpL9W0t1N1HXH0N63c1cwxd4c++NR8f0YDsvj+nx/UHGGGOMn0lkNFLrMbRSb3TVi+iGkej2iUi9F5FKdyARkX49vxU66fBpi0XCJW4Pb6BP+m0k5Z3+2ywrm1b+k/Gec6l900rhi1qmazfnhKmJj5ty3OLh69Gk36M9vRfFs0O7j+kzrr87f3y3DZVjpi3RLzOtk3tcMHra+TNp4ZTm8ZL//pJv7L5HJ80DeXIyY4wxxuckd0mk2Udotf44lj2FLn4A3TSGiIZvoef2OCcbTRjY4IqnnfcA+YAVOlnKi28Xl3zhTnlflXQGBMgAT4c3SLRD+rzoOZe8KEn1pB6/bm9GFfOOr1uG/HE13qcxiqeDDHgxySUp1PUp8aibl/M43nQzEw9HXfO4tSTC85Yf8eJ+Ho940nXNihxjjDEBIkUbENFxLrrzW3TlMzjmdoTIvEizD5FyN8Dhv3AsegAH+KTYsUInHb6+B8XzIQFScumV5//qnPS+vWRgxCpP+aK3XPJDJmsx8cEhfXjM/wY3SO3vQxJv6+l9WeqasDS92LwMOPkxUzyMt8fM+K4pBHLpDfSp3WLj2d9wohEl0jumA6/uafFomBBJb4OE9R4OMiD8t126xSCeH9MYY4wJABFBKt6Clr0ex4+1IPYUuuh+OLkJqfUYEc1GOYeutkLHvxTxeNQ1T2+K96qrV1or9b8fPIzQtYsHAahk7obmhIASxZiR3f+LJ8UfnTF6eujkr0dTCFO8mOvHD4WYe+/0Wr8cGRjJ7dKzZJo/vyun/BZ43qKT0gtP8Zietr4AkkKrSirtrJ61EiV0M/OgS1ySrmtpxqt4POqbMcYYE0ASlRdijiFdVsGqF9F1byIVboLiLZzd2HzACp10eFLoiBdfkD08q8ffU7w/rQdH9qY7XEqHS+XLta/eIu9bplL7OppsK48Hnkj9no5Mt3SkcTx/HDOYvw8nLszTrPvTqoxT2zetJ1Ncl/JgBCn9TafYHS2lVh5JedS1S3ut6qVFVgoFEuAa8S3dZkZjjDEmOBSojpzbjbQaj57ZieSrgB78HQpU98nhs1WhIyKdgJFAJDBWVd9Icwf1rNBRTy+gBvyLRqaakzKxpWvCUA9Pn95mznt4vLtHx5Nzq8cFa6IN06gaFC+LYA9aXzSllZmQUEakO8llqvt6WkamwYO5X5ytMR7cf5JwSE+7ekk6rS/i5XbgjNE9iEwKBYp7O9eQ1Wn9cQqAAyIcqXeJS1zwiePSQsfTYs4YY4zJYnLF0zgWPUBEs1FQvAV68Hccix5A6j3vk+Nnm0JHRCKBD4GOwB5giYhMU9X1ae2nDs++EXjULczjpghxberZl0WP55Lx9PzpfOlMclRPGohEvGok8ow3x5T0vpU7n8pogGm9B94e05P7ULz9kppOVzhxb+QBcRUc6cbgxT1hEam0glxybk+HTk7aqpHmLpGeFU8SgbPYSG87ASLiUy+KkhU6RManHGOSFQ4kynHpa09pOdKR+h+yJ/cOGWOMMVkoouItOMB5T07CqGv1nrdR1zKgCbBFVbcBiMgkoDuQaqGjKjjiM3KzSrKuMwm3XigejvAEms63U/cxPf5CmfZ2iZ9SL2aL92Q7df/HEw6Prpx7WoBCstaftOIQQdP/LpskjtSO6b7/RzwfjEBcv/L0thf19JiefZ9VHJ5/7/XHDLGejuQW4WFRL+m36LhXR3j294YoEpnKH0dC8ZcgR6JjphWvxDsLrfQKEImDHKk9l2w5Mj71T/VE22qAhqM3xhhjkouoeItPBh5ISXYqdMoAuxMt7wGaprdTXFzGJjJK6QuZalqFQcrdTSSFdcn3y0xRIikdV1K4epyiVL4gp3B52vOvVRHOi/HpnF9Qj2/I14QiIsn+KWwnXg6snW5XK7h0ApTUD6YR6tFI2F59SZU07nFJenbPW0vEk4IjleOl9TecXpNapCNRl7A0jimKRMZ78qIhKh5J65+4u9BxuAsd97+ZlFpdBciZxjGTFDVxrk/gZEXZJa8nHqIVTV6QpdTyGhGf9D1KrXXW0+GqjTHGmBCWnQodj4jIAGCAa/FMi/mv+WbYB98qBhwJdBCZFOqvIdTjh9B/DaEePwT2NVQI0HlNgCxbtuyIiOxMtCrU/g2FWrwQejFbvP5l8fpPijktOxU6e4FyiZbLutYloapjgDFZFVRGiMhSVW0U6DgyI9RfQ6jHD6H/GkI9fgiP12BCh6oWT7wcan9/oRYvhF7MFq9/WbxZLzOzpYSaJUA1EakkIjmBW4FpAY7JGGOMMcYY4wfZpkVHVeNE5EFgNs5e7J+p6roAh2WMMcYYY4zxg2xT6ACo6gxgRqDj8IGg7lrnoVB/DaEeP4T+awj1+CE8XoMJXaH29xdq8ULoxWzx+pfFm8VE/TFcrDHGGGOMMcYEUHa6R8cYY4wxxhiTTVihE8REpJyIzBeR9SKyTkQeca0vIiJzRGSz6/+FAx1rekQkUkRWiMh013IlEVksIltEZLJrgIigJSKFROQ7EdkoIhtEpHko/R5E5DHX39BaEflaRHIF++9ARD4TkUMisjbRuhTfc3F6z/VaVotIg8BF7o41pfjfcv0NrRaRqSJSKNFzQ1zx/ysi1wYkaJNtiEgn19/aFhEZHOh4kgvV/BdKuS7U8loo5LFQy1vZIU9ZoRPc4oAnVLUW0AwYJCK1gMHAr6paDfjVtRzsHgE2JFoeDoxQ1arAceCegETluZHALFWtAdTD+VpC4vcgImWAh4FGqlob52ActxL8v4NxQKdk61J7zzsD1VyPAcBHWRRjWsZxafxzgNqqWhfYBAwBcP27vhW4wrXPKJE0pzI1JsNcf1sf4vx3Uwvo7fobDCahmv9CKdeFTF4LoTw2jtDKW+MI8zxlhU4QU9X9qrrc9fNpnB9CZYDuwHjXZuOBGwISoIdEpCxwPTDWtSxAe+A71yZB/RpEpCDQBvgUQFVjVPUEofV7iAJyi0gUkAfYT5D/DlR1AXAs2erU3vPuwBfqtAgoJCKlsiTQVKQUv6r+oqpxrsVFOOfzAmf8k1T1oqpuB7YATbIsWJPdNAG2qOo2VY0BJuH8GwwaoZj/QinXhWheC/o8Fmp5KzvkKSt0QoSIVASuBBYDJVR1v+upA0CJQMXloXeBpwGHa7kocCLRP6Q9OBNYsKoEHAY+d3VJGCsieQmR34Oq7gXeBnbhTAwngWWE1u8gQWrveRlgd6LtQuH13A3MdP0civGb0BVSf28hlP/eJXRyXUjltRDPY6Gct0I+T1mhEwJEJB8wBXhUVU8lfk6dw+YF7dB5ItIFOKSqywIdSyZEAQ2Aj1T1SuAsyZrzg/n34OoP3B1nYisN5OXSpuqQE8zveXpEZBjOrjkTAx2LMcEsVPJfCOa6kMpr4ZLHguk9TU+45CkrdIKciOTA+SE/UVW/d60+mNC86fr/oUDF54GWQDcR2YGze0R7nP2CC7man8HZLLo3MOF5ZA+wR1UXu5a/w5kgQuX30AHYrqqHVTUW+B7n7yWUfgcJUnvP9wLlEm0XtK9HRO4CugC363/j+4dM/CYshMTfW4jlv1DLdaGW10I5j4Vc3gqnPGWFThBz9e/9FNigqu8kemoa0Nf1c1/gx6yOzVOqOkRVy6pqRZw3sc1T1duB+UBP12bB/hoOALtFpLpr1dXAekLn97ALaCYieVx/Uwnxh8zvIJHU3vNpQB/XKDbNgJOJugoEDRHphLNrSzdVPZfoqWnArSISLSKVcN6c+k8gYjTZwhKgmmvEqpw4P5unBTimJEIt/4VargvBvBbKeSyk8lbY5SlVtUeQPoBWOJs4VwMrXY/rcPb7/RXYDMwFigQ6Vg9fTztguuvnyjj/gWwBvgWiAx1fOrHXB5a6fhc/AIVD6fcAvAhsBNYCXwLRwf47AL7G2Rc7FufVx3tSe88BwTmK1FZgDc6ReYIx/i04+zgn/HsenWj7Ya74/wU6Bzp+e4T3w5VLNrn+5oYFOp4U4gvZ/BcquS7U8loo5LFQy1vZIU+JK3BjjDHGGGOMCRvWdc0YY4wxxhgTdqzQMcYYY4wxxoQdK3SMMcYYY4wxYccKHWOMMcYYY0zYsULHGGOMMcYYE3as0DHGGGOMMcaEHSt0jDHGGGOMMWHHCh1jfExEaonIXSJSTkTyBzoeY4wxJqMsp5lQZoWOMb6XA3gI6AGcSf6kiFQUkfMistLXJxaR3CKyUkRiRKSYr49vjDEm27GcZkKWFTrG+F454HNgC5Da1a+tqlrf1ydW1fOu4+7z9bGNMcZkS5bTTMiyQseYDBKRea4rTStF5IKI3AKgqtOB71R1hqqe8uA4FUVko4iME5FNIjJRRDqIyJ8isllEmniznTHGGOMty2kmHFmhY0wGqWp715Wmj4FpwJREzx3w8nBVgf8DargetwGtgCeBoRnYzhhjjPGY5TQTjqICHYAxoUxE+gCdgZtUNT4Th9quqmtcx1wH/KqqKiJrgIoZ2M4YY4zxiuU0E26s0DEmg0TkZuB2oLuqxmbycBcT/exItOwg6b9TT7czxhhjPGY5zYQj+yMyJgNEpAvwANBFVS8EOh5jjDEmoyynmXBl9+gYkzHjgbLAn64bN+8JdEDGGGNMBllOM2FJVDXQMRiTrYhIRWC6qtb24zl2AI1U9Yi/zmGMMcZYTjPBzFp0jMl68UBBf06uhnOCN4evj2+MMcYkYznNBC1r0THGGGOMMcaEHWvRMcYYY4wxxoQdK3SMMcYYY4wxYccKHWOMMcYYY0zYsULHGGOMMcYYE3as0DHGGGOMMcaEHSt0jDHGGGOMMWHHCh1jjDHGGGNM2LFCxxhjjDHGGBN2rNAxxhhjjDHGhB0rdIwxxhhjjDFhxwodY4wxxhhjTNixQscYY4wxxhgTdqzQMcYYY4wxxoQdK3SMMcYYY4wxYccKHWOMMcYYY0zYsULHGGOMMcYYE3as0DHGGGOMMcaEHSt0jDHGGGOMMWHHCh1jjDHGGGNM2LFCxxhjjDHGGBN2rNAxxhhjjDHGhB0rdIwxxhhjjDFhxwodY4wxxhhjTNixQscYY4wxxhgTdqzQMcYYY4wxxoQdK3SMMcYYY4wxYccKHWOMMcYYY0zYsULHGGOMMcYYE3as0DHGGGOMMcaEHSt0jDHGGGOMMWHHCh1jjDHGGGNM2IkKdACeEJHcwCygvarGp/D828AMVZ2X5cEZ4wfLli27LCoqaixQG7sgYXzLAayNi4u7t2HDhocCHUx2lFpOE5FxwHRV/U5EJgHPqurmAIVpjM9YTjN+lGZOC4lCB7gb+D6lIsflfeATwAodExaioqLGlixZsmbx4sWPR0REaKDjMeHD4XDI4cOHax04cGAs0C3Q8WRT6eU0gI+Ap4H+WROSMf5jOc34S3o5LVSq6tuBHwFE5H8iskZEVonIGwCquhMoKiIlAxmkMT5Uu3jx4qcsIRhfi4iI0OLFi5/EeWXVBMbtwI/i9IGI/Csic4HLEm2zEOggIqFyQdKYtFhOM36RXk4L+kJHRHIClVV1h4h0BroDTVW1HvBmok2XAy0DEaMxfhBhCcH4i+tvK+g//8NR4pwG9ACqA7WAPkCLhO1U1QFsAeoFIExjfM1ymvGbtHJaKCS6YsAJ188dgM9V9RyAqh5LtN0hoHTWhmaMMcZ4JXFOawN8rarxqrqPS7tfW14zxphMCIVC5zyQy4Ptcrm2NcYYY4KVpzkNLK8ZY0ymBH2ho6rHgUgRyQXMAfqJSB4AESmSaNPLgbUBCNGYsHXzzTdXLFKkSL1q1apd4a/jREZGNqxRo0atqlWrXlG9evVazz//fIn4+LTu0Q4tab2+6dOn58+fP3/9GjVq1KpRo0atFi1aXA7w+OOPl86dO/eVe/fudd+fkSdPnisTft61a1dUly5dKpcrV672FVdcUbNt27ZVV69eHQ2wevXq6LZt21atUKFC7Vq1atW87rrrKu/evdvu8wgSyXLaAqCXiESKSCngqmSbW14zxocsp2VeqOW0oC90XH4BWqnqLGAasFREVgJPAohIDqAqsDRgERoThu6+++4j06ZNS3d42+nTp+e/6aabKmbkONHR0Y6NGzeu37Jly7p58+ZtmjNnTsEnn3wybLrrpPf6GjVqdGbjxo3rN27cuP6vv/7alLC+UKFCca+88kqJ5MdzOBx069ataps2bU7v3r177bp16za88cYbe/ft25fj3Llz0rVr12oDBw48vHPnzrXr16/f8MADDxw+cOCAFTrB5RegFTAV2AysB74A/k7YQERKAOdV9UBAIjQmDFlOy7xQy2mhUuh8CPQFUNU3VLWWqtZX1aGu57sA36lqXMAiNCYMde7c+Uzx4sUz/e/K0+OUKVMmbuzYsTs+//zzyxwOR2ZPG3S8eX29e/c+Om3atCIHDx6MTLx++vTp+aOiovTpp58+nLCuefPm5zt16nRmzJgxRRo0aHDmtttuO5nwXJcuXU43btz4gs9fjMmMD4G+6vSgqlZX1Y6qep2qfufa5jbg4wDGaEzYsZzmW6GQ00LiKp+qLheR+SISmcq8A1HA/2V1XMZkhbvvvrvc2rVr8/jymLVr1z732Wef7fblMX2lVq1aMfHx8ezduzeqXLlyPr140aRJk+p33HHHkYcffvjoxYsXpXXr1pffddddhx944IFjp0+fjrj66qur9e/f/1D//v2PHz16NLJz585VBw0adLBv374n9u/fH9W9e/cqjz766IHbbrvt5K5du6LKly/vdXyJXx/A0qVL89WoUaMWQPfu3Y8NHz78AEC+fPnie/fufeSNN94oMWLEiH0J+69evTp3vXr1zqV07LVr1+Zu0KBBis+Z4OFBTgPngAVfZmFYxmQJy2m+YzktfSFR6ACo6mdpPPdtVsZijHGqW7dujZiYmIhz585FnDx5Mirhw+3VV1/dc9NNN50KdHyhoFGjRmfmz5+/JaXnBg8efKhevXq1nnvuOeu+FGbSymmu5z/PqliMMU6W0zIv2HJayBQ6xmRXwXqVCmD16tUbwdn0/PnnnxedMmXKjswec/369TkjIyMpU6aMz7ui/vPPP/8m/BwdHa2Jl/Pnz+9IvFy0aNH4xMulSpWKS7yckStfkPT1rVq1Ks1tixUrFt+jR49jb731lnsiyTp16pz/4YcfCqe0/RVXXHFhwYIF+TISlzHGZAXLab5jOS19oXKPjjEmG9i3b19U//79K/Tr1+9QRET4fTxl5PUNGzbs4Pjx44vHx8cLQNeuXU/HxMTI22+/XSxhm8WLF+eeNWtWvv79+x9dtmxZvkmTJhVMeG7mzJn5lixZ4ulwxsYYY3zEctqlsjqnhd+7bozxma5du1Zq1apVje3bt0eXKFGi7ogRI4qlv5d3x7l48WJEwlCVV1111eVXX331qbfffntfWscLJZl9faVKlYrr3Lnz8ZiYGAGIiIhg2rRpW+fNm1egXLlytatWrXrF//73vzJlypSJzZcvn/74449bPvzww8sqVKhQu0qVKld8+OGHl5UsWdIGajHGZHuW0zIv1HKaqGpGXqcxxo9WrVq1o169ekcCHYcJX6tWrSpWr169ioGOwxgT/iynGX9LLadZi44xxhhjjDEm7FihY4wxxhhjjAk7VugYY4wxxhhjwo4VOsYEJ4fD4ZBAB2HCk+tvK/ym6TbGBCvLacZv0sppVugYE5zWHj58uKAlBuNrDodDDh8+XBBYG+hYjDHZhuU04xfp5TSbMNSYIBQXF3fvgQMHxh44cKA2dkHC+JYDWBsXF3dvoAMxxmQPltOMH6WZ02x4aWOMMcYYY0zYsaraGGOMMcYYE3as0DHGGGOMMcaEHSt0jDHGGGOMMWHHCh1jjDHGGGNM2LFCxxhjjDHGGBN2rNAxxhhjjDHGhB0rdIwxxhhjjDFhxwodY4wxxhhjTNixQscYY4wxxhgTdqzQMcYYY4wxxoSdqEAHEMyKFSumFStWDHQYxhjjc8uWLTuiqsUDHYfJOpbTjDHhKrWcZoVOCkSkK9C1atWqLF26NNDhGGOMz4nIzkDHYLKG5TRjTLhLLadZ17UUqOpPqjqgYMGCgQ7FGGOMyRTLacaY7MoKHWOMMSaMiUhXERlz8uTJQIdijDFZygodY4wJMUeOHGHv3r2BDsOECGvRMcb4y9KlS/nyyy+5ePFioENJkRU6xhgT5D755BMmTJjgXq5bty7PPPNMACMyocRadIwxvjR79mxiY2MBWLBgAX369MHhcAAwZ84cJkyY4H4+0KzQSYElBWNMVtq6dSt//vmne7lPnz706NHDvTx+/Hi+/vpr9/LIkSMZMGBAlsZoQpe16BhjfOXvv/+mU6dOfPfddwAMGDCATZs2kTt3bgA+//xzXnzxRUQkkGG6WaGTAksKxhhfS7jaBTBx4kQefPBB9/KwYcPo06ePe7lu3bo0aNDAvfzLL7/w888/u5dvvvlmmjdv7ueIjTHGmKSaNWvG+PHjufHGGwHIly8f1apVcz8/YcIEFi5cSFRUFLGxsVx33XXMnDkzUOFaoWOMMb529uxZFi1ahKoC8H//938UL16c+Ph4ADZv3syCBQvcxc/QoUP59ttv3fs/+eSTPPvss+7lPHnyZGH0JtxYLwVjTGY4HA6GDRvGzp07ERH69OlDdHR0ittGRERQsmRJAPbv38/evXsD2o3NL4WOiBTx4FHIH+c2xpistm3bNoYPH86JEycAGDduHM2bN2fPnj2As4WmX79+nD9/HoAXXniB1atXExER4X4+cQuOCS6hntOsl4IxJjO2b9/OqFGjmDp1qlf7lS9fnuXLl9O1a1cAxo4dy7Bhw7K08PHXhKH7XI+0OuhFAuX9dH5jjPEph8NBfHw8OXLkYMOGDTz11FO88sor1K9fny1btjB48GBatmxJq1at6NKlC+XKlaNIkSIAdOzYkY4dOwb4FZhMsJxmjMm2qlSpwtq1ayldurTX+0ZGRrp/Xr16NevXrycqyl/lx6X81XVtg6pWVtVKqT2Ao346tzHGZNrJkyc5etT5MbVt2zYKFSrk7l6WO3dudu3axbFjxwBo06YNR48epVWrVgBUqFCBbt26kTdv3sAEb3wtpHOadV0zxnjL4XBw3333MX78eADKlCmT6QEG3nvvPX7++WdEhOPHjzNkyBBOnz7ti3BT5a9Cx5O7ZIP2TtrMJAWHw8Gff/7Jvn37AIiPj2f79u3uX6SqcvHixSQ3JhtjAm/Pnj1s2bIFcN5jU7x4cd5//30AypUrR58+fahSpQoAFStWZPXq1bRv3x6AXLlyuVtvTFgK6ZxmXdeMMd6KjY1l27Zt7rzoKwn39vzyyy/83//9n8+Pn5xfCh1VveCLbQIlM0nh7NmztGrViq+++gqAEydOULlyZT7//HMADhw4QK5cufjkk08A2LVrF0WKFHEPHbtjxw5q167NjBkzANi5cyfdunXjr7/+AmDv3r0MGzaMjRs3AnD48GG+/vprDhw4AMDp06dZu3Yt586dA5yFV8IN0caY/6xfv949pLOq0qxZM/cAAHnz5mXkyJF069YNgBw5cvDBBx/QtGnTgMVrAifUc1pm7Nmzh3nz5gU6DGNMFtmzZw+nTp0iOjqan3/+mZdfftkv5+nVqxfbtm3jyiuvBOD7779395LwJZ8XOiLSUUQ+EZH6ruVsNdlDrly5mD17NjfddBPgHC1p3Lhx7v75efPm5bXXXqNJkybu52+//XYqV64MQFRUFNWrV6dAgQIAnD9/nt27d7tnnN2zZw/Dhw9nx44dgPPL2m233cb69esBWLx4MXXq1GHZsmUAzJo1i8jISP755x8Afv/9d1q3bu2uoFevXs2LL77I4cOHAecIGX/88QcXLjhztrU8mXCxfPlyJk2a5F5+8MEHefjhhwEQET755BOGDh3qfv7++++3AQJMts9p/fv35+GHH7YLZsZkA2fPnqVhw4bcd999gPMinz+VLVsWcF60v/3223nppZd8fxJV9ekD+BooBLwNtAdG+focWfVo2LChBiOHw6EOh0NVVc+dO6fr16/X06dPq6rqgQMH9JtvvtEjR46oquqGDRv02Wef1b1796qq6vz58/Wqq67SnTt3qqrq+PHjFdAdO3aoqurHH3+sgO7Zs0dVVT/44AONjo7WgwcPqqrqN998o9ddd52eOnVKVVVXrlyp33zzjcbGxqqqamxsrDs2YwJp8eLF+sorr7iX77//fi1QoIDGx8erquqKFSt0y5YtgQov4IClGgSfs8H+yO45bePGjbps2TJVVY2JidFz5855fQxjTHDbsGGD++cvv/xSN23alOUxrFixQo8dO5bh/VPLaf5ICmMS/fwGsMTX58iqR7AWOr6WuDjZu3evzp49Wy9evKiqqn/++ac+/fTT7uXx48drw4YNNS4uTlVVhw4dqpGRke4vj4MHD9ZChQq5j/fll1/qY4895j7X+vXrdcWKFVn10kw2cvz4cZ0wYYKeP39eVVXfffddzZEjhx46dEhVVffs2aOHDx8OZIhBxQqd7JPTgK7AmKpVq2pmvPnmm3rZZZe5/00ZY0LfxIkTFdClS5cGOpRMSS2n+eMeHff03ao6GPjCD+cwPhQVFeUeSaN06dJcc8015MyZE4AWLVowfPhw93KfPn1YunSpe7jAp59+mjVr1rjnA2nTpg2PPPKI+3hr167l119/dZ/rtddeo0ePHu7lQYMG0b17d/fywoULWbRokR9frQkniUc++/vvv7njjjv47bffALj33ns5ceIExYsXB5wjxhQrVixQoZrQFfI5TX00GEGLFi2499573f+mPvjgAyZMmOCLEI0xWeTQoUPcdNNN7nvBO3bsyDvvvEPNmjUDHJl/iLMI8tPBRRoBw4AKOOfsEUBVta7fTpp6LJVdsRRU1Z6e7NOoUSNdunSpfwPLZjZs2MDhw4dp06YNACNGjGDv3r28/fbbALRt2xaHw8HChQsB6NevH0WLFnU//9dff1GiRAn36Fcme1FVzp8/T548edi1axcVKlTg3Xff5ZFHHuHixYusWLGCJk2auAtvkzoRWaaqjQIdRygJppyWEb7MaarOATwqV67sHkzn3nvvpVWrVtx1112A857Pyy67LMk8GsaYrLd06VLOnDlDu3btiI2NpWHDhjz55JP06dMn0KH5TGo5zd8z9kwEngLWABm+q11EPgO6AIdUtXai9Z2AkTgnahurqm+kdgxV3QbcIyLfZTQOk3k1a9ZMctXgscceS/L8F198wZkzZ9zLefPmJU+ePO7lO+64g2bNmrlHtevVqxdt2rRh0KBBAGzdupUKFSpk6WRUJms4HA7q1KlDu3bt+PDDDylfvjxjxoyhQ4cOgHPIymbNmgU4ShPmfJLTwoGIsGjRIs6fPw84/32uXbuWihUrupcrVKjA448/zhtvvIHD4eDuu++md+/eXHvttTgcDtatW0flypVtvilj/ODChQvkypULgIEDB5IzZ07+/vtvcuTIwapVqzI9J06o8Pe3wcOqOs0HxxkHfECiLgMiEgl8CHQE9gBLRGQazqLn9WT7362qh3wQh/GzChUqJFn+4IMPkix/88037jHYVZXjx4+7E21sbCxXXHEFDz30EG+99RaqyhdffEHbtm3dydeElmHDhrF582a++eYbIiIiuPPOO5O05vXv3z+A0ZlsyFc5LSyIiPtCVERERJJux3Fxcbz//vvUq1cPcE61MH/+fJo3d043dOjQIerWrcsHH3zAoEGDOHToEH369OHpp5+mffv2nDt3jlWrVlG7dm3y58+f9S/OmBD21ltvMXLkSLZt20bOnDkZP368e4QzINsUOeC/CUMTPC8iY0Wkt4jcmPDw9iCqugBIPrh2E2CLqm5T1RhgEtBdVdeoapdkDytywkSjRo2oU6cO4PyH+ssvv/Dkk08CziuIn376KbfeeivgnIPorrvuYtasWQAcPXqU++67j9WrVwcmeJOuGTNm0KdPn4QbqMmfPz8FCxZ0Lw8ePJibb745kCGa7M0nOc0XRKSyiHwarL0UcubMycCBA92trEWKFGHnzp0MHDgQgHz58jF58mSuvfZaAE6dOsXRo0eJj48HYN26dbRo0YL58+e7lzt16sTKlSsBZ6E0d+5cv8+qnh0dPXqUGTNmuKeXmDp1Kl27duXs2bMAfPvtt3Tq1Mm9PGvWLB5//HH3tBQ7duxg+fLlNj1FFlJVpk2bxokTJwDnd6XevXu7LwTXrl2bQoUKBS7AAPJ3odMPqA90wjnqS1ecXdB8oQywO9HyHte6FIlIUREZDVwpIkPS2G6AiCwVkaUJc8uY0BAdHc3tt99Ow4YNAShfvjz//vsvPXs6b8navn07kyZN4siRIwD8888/NGzY0J04z58/7/6gNlnn7NmzxMbGAs4E+8cff7gnwB08eDCffPJJtrr6ZIKaT3KaiHwmIodEZG2y9Z1E5F8R2SIig9M6husi3z3enjtY5MuXj1tuuYWqVasCULVqVZYsWeKec65atWr8/PPP7hag06dPc/ToUXe35D/++IOOHTuydetWwDnZ4GWXXcamTZvcz/fv39/9eb9hwwYmTJjgnkz7+PHj7Ny5076MA7t37+bNN990f0meOnUq119/vXu+vtjYWPbu3ev+nL548SLHjx93/y7WrVvHZ5995h60aPTo0Um6EY8cOZKuXbu6L1itXLnSPQm68Y1Vq1bRvXt3PvvsMwCuuuoq3nrrLTI7AElYSGkoNl89gH99eKyKwNpEyz1x3peTsHwn8IGPzuWToThN8ImPj3cPjf3XX39phw4ddPfu3arqHDo7KipKN2/erKqqx44dszkj/Gzr1q1atGhRHTdunKqqxsXF2TxMWYRsOLw00CCthwf7+ySnAW1c50yc0yKBrUBlICewCqgF1AGmJ3tclmi/7zw9bzhNmXD06FH9/fff9ezZs6rqnDdr4MCBevToUVV1DplbunRp9xxw7777rgLu599++20F3HPCvfbaaxodHa0XLlxQVdX3339f69at6546Ydy4cdqzZ0/3+b/++mt96KGH3MtTp05NMm/XrFmz9OOPP3Yvz58/X7/55hv38t9//62zZ892L69YsUIXLVrkXv7333+TzG1y9uxZn302Hj9+XD/88EP3XCm//fabAvrLL7+oqur+/ft1wYIF7qH6vbV582adOXOme3nEiBHarVs39/Jtt92mFStWdC8//vjj2qtXL/fyvHnz9Pfff8/QubOTM2fOJHmff/vtN/echtlRajnN30nlc6CWj46VvNBpDsxOtDwEGOLL+MMpKZj0rVixQocNG+YuhIYMGaIFCxZ0J1L7Au4bu3fv1vnz56uq8z19+OGHdcmSJYENKhvKpoXOfNfjbyAWWAosc/38twf7B11Oy66FjrdOnz6tmzZtchcua9eu1U8//dT9eT9v3jx9+umn3Z/zX331ld50003u/UeMGKFNmjRxLz/33HNas2ZN9/KDDz6oZcuWdS/369dPy5Ur516+7bbbNPHF0549e2qtWrXcy127dtX69eu7lzt16pTkfB06dNBWrVq5l5955hl988033csrV67UXbt2pfjaY2NjdcyYMbpw4UJVVd23b58C+v7776uqcyLYffv2pbivP2zfvl0XL17sXn711VeTFI1t2rTR1q1bu5fvuOMOffTRR93La9eudU+Snp09+OCDmjt37kxNshlOUstpqQ4vnV6/Y1X9Pq3nXcfYAFQBtgMXycRQnCJSEZiurlHXRCQK2ARcDewFlgC3qeo6b4+dwrm6Al2rVq3af/PmzZk9nAlRf/31F4sXL3aPDHf77beTI0cOxo0bF9jAQty1117Lxo0b2bZtmw07G0DZeXhpEfkeeF5V17iWawMvaDpTD/g5p/UEOqnqva7lO4GmqvpgKvsXBV7FOSDPWFVNPghPwnYDgAEA5cuXb7hz505vQzUZcPHiRWJiYtwDKRw7dowLFy5QunRpwDkH2IULF7j88ssBWL9+PRcuXKBBgwYALF68mJiYGFq3bg3AV199RXx8PHfeeScAN954I0WLFuWTTz4BoEaNGtSpU4dvv/0WcM6NcuWVV/Lmm2+iqhQqVIi+ffvy3nvvAc57WMuXLx+U3YL37dvHmTNn3O/No48+SpEiRXjuuecAqFSpEk2aNGHy5MkATJs2jcaNG1OqVKmAxZxVHA4H58+fJ2/evBw+fJg1a9bQvn37QIcVFFLLaWkVOp+7frwMaAHMcy1fBfylqun2SxaRCimtV1WvPmlF5GugHVAMOIgzQX0qItcB7+Js8v9MVV/15rjpsXl0TGLPP/88kZGR7g/bu+++m+uuu859D5BJ2caNG3n55Zf58MMPKVSoEOvWrSNv3rw2El6AZfNCZ52qXpHeuhT280lOcx2rIpkodLw8l128C3O///47uXPnpkmTJoBzRMpmzZpxzz3O27j27NlDmTJlgrKw8dbMmTMpVKgQzZs35+zZsxQoUIDBgwfz6quv4nA4+OOPP2jZsmXYXUhTVW688UYcDgc//PBDWPwufcnreXRUtZ9rx19wNtXvdy2Xwjncc1onaw4sysiHfyqx9E5l/Qxghi/OkViipODrQ5sQ9uKLL7p/PnPmDMuWLXOPABcTE8Pbb7/N7bfffskQ2dmRqhITE0N0dDTnzp1j5syZrF69mjZt2nDFFWl+lzQmK6wWkbHABNfy7UCqwzH6OqelYi9QLtFyWdc6Y9LVtm3bJMsJLT0JEg8tHOo6d+7s/jl37twsW7aMwoULA86b8tu2bcu4cePo27evs+tSmBQEIuIerMN4LtUWHfcGIhtUtWai5QhgXeJ1KezzEdAUZ9eyWcAsVT3gm5CzjrXomPQ4HA4iIiL466+/aNmyJdOnT+f666/n8OHDbNu2jcaNGxMR4e/BDYNLbGwsrVu3plWrVrz99tuAc0S73LlzBzgyk1g2b9HJBdyPc1AAgAXAR6qa4rCL/shpWdkdO4HlNBPuzp07x/Tp0+nYsSOFCxfm22+/5b333uPbb7+lZMmSgQ7PaxcvXmTIkCF07979kmLWJOV1i04iv4rIbOBr13IvYG5aO6jq/a6T1gA6A+NEpCDOm0BnAX+qarwX8Wcpa9ExnkooYlq0aMG+ffsoUqQIAJMmTeLhhx/m33//dfczDmcXL15k0aJFtG3blhw5cnD11VdTs+Z/10KsyDHBRFUvuKYbmKGq/3qwvU9zWuLu2CKyh/+6Yz8IzOa/7tg+KXIsp5nsIk+ePNxyyy1J1kVHR1O8eHHAOZR2mTJlQuYCZGxsLD///DOFChWyQieD0m3RARCRHiS68qWqU70+kUhunPf3dAaah8KVRLv6ZTLq+PHjzJ8/nxtvdI7p8c4773D55ZfTpYuvppEKLkOHDuWtt95i586d7pttTXDL5i063YC3gJyqWklE6gMvqWo3L45hOc2YEBITE0PNmjVp1qwZEydODHQ4qVJVpk6dSrdu3YiKiuL06dPuQS1M6lLLaZ6WtMuBn1X1MWC2iHj9jqvqeeA0EBEKCcGYzChcuLC7yImNjWXChAlMmTIlwFH5zwMPPMCMGTOyxag3Jiw8DzQBTgCo6kqgkjcHCKWcJiJdRWTMyZMnAx2KMQETGRnJ888/z8CBAwGIj4/nzJkzAY7qUr///js33XSTuxizIidz0i10RKQ/8B3wsWtVGeAHT08gIleKyFsisgN4CdjgfZhZy5KC8aUcOXLw999/u4f13LFjBz///HOAo8q8BQsWcN1113Hy5EnKli1Lx44dw+amTxP2YlU1+Qd8+t0bCM2cpqo/qeoAmyXdZGeRkZH06dOHNm2cHZSGDx9OgwYNOHLkSIAjczp//jwA7dq146effnIPJW4yx5MWnUFAS+AUgKpuxjnkdKpE5HIReV5ENgLvA7twdpO7SlU/yGTMfmdJwfhadHS0+6rMG2+8Qe/evTl69GiAo8qc/fv3s3fvXuLi4gIdijHeWicitwGRIlJNRN4H/kpt41DPaXbxzphLtWrViuuvv56iRYsGOhSmTJlC1apV2bVrFwBdunQJmfuIgp0n7+JFVY1JWHCNDJPela+NQHugi6q2UtX3gaAdfMCYrDRy5Eh+/fVX94frypUrAxuQlxLu6+vVqxfLli0LiiRhjJceAq7AOenn1zgv5D2axvYhndPs4p0xl2rTpg0jRoxARNi/fz/Dhg0jNjY2ILHUrVuXFi1a2MA9fuBJofO7iAwFcotIR+Bb4Kd09rkR2A/MF5FPRORqnDNIhwS7+mX8KTo6msaNGwMwd+5crrzySr7//vsAR+WZo0eP0rx5c+bPnw9AVJQnAzcaE1xU9ZyqDlPVxqrayPVzikNLu4R0TjPGpO2HH37g/fff599/0x2E0WeOHDnCmDFjAKhWrRrffvute3Q44zueFDqDgcPAGmAgzgk6n0lrB1X9QVVvBWrgHH7zUeAyEflIRK7JVMRZwK5+mazSunVrRowY4R6N7fTp0wGOKG0XLlwgLi7OmtRNSBORn0RkWrLHlyLyiGuOnSRCPafZxTtj0nb//fezefNmateuDfzXc8GfPvjgAx5++GG2b9/u93NlZx4NL+2TE4kUBm4Geqnq1Vly0kyyoThNVrp48SKNGjWic+fOvPnmm4EOJ4n4+HgiIiIQEfckqSa0ZfPhpUcCxUk6P9wpnN2yC6hquncBW04zJjxNnjyZmTNn8vnnn/t1gJ24uDg2bNhAnTp1/HaO7CTDw0uLyBoRWZ3ssVBERoiIx53zVfW4qo4JlYRgTFYTEW644QbatWsHZM0VJU+oKgMHDuShhx5CVa3IMeGghare5mq9/0lV7wAaq+ogoIEnB7CcZkx42rJlCzt27ODcuXM+P/bq1avp1KkTx48fJyoqyoqcLODJN5aZwM/A7a7HT8BS4AAwLqUdRGR5egf1ZJtAsWZ+Ewg5c+bk5Zdf5rrrrgNg9OjR3HXXXe4hJwNFVSlcuDCFCxe24aNNuMgnIuUTFlw/53MtxiTf2HKaMdnH0KFDmTNnDnnz5vX5sXft2sX27ds5duyYz49tUpZu1zURWa6qDVJaJyJrVPWSclREzgOb0zosUFBVy6exTcBZM78JpNdff50//viD6dOnB6zAiI2NJUeOHICz4LFCJ3xk865r1wGjga0481El4AHgN6C/qr6bbHvLacZkMydPnmTIkCE899xzlCxZMlPHSpw/4+PjiYyM9EWIJpHUcponQyZFikgTVf3HdaDGQMJvKLUJNGp4cNyQGZrTmEAYMmQIDocDEeH48eO88MILvPDCCxQuXDhLzv/9998zbNgw5syZQ9myZa3IMWFDVWeISDX+y1X/Jhp17d0UdrGcZkw2s2/fPiZOnEjz5s0zNXlnfHw8PXr04N5776Vbt25W5GQxTwqde4HPRCQfzqtWp4B7RSQv8HpKO6jqTt+FaEz2lXA/zPz58xkzZgx33XVXlhU6JUuWpEqVKhQpUiRLzmdMFqsGVAdyAfVEBFX9IqUNLacZk/3UrFmTXbt2kdkReE+cOMGhQ4dCfpLwUOXxqGsiUhBAVbNNJ19r5jfB5NChQ1x22WUAPPvssxQrVoxHHnnE5+c5f/68TVqWDWTzrmvPA+2AWjinTOgM/KGqPQMZl79ZTjMmY1atWkW1atXIkydPhvaPi4sjMjLSekb4UYZHXXPtfD3OOXQeEZHnROQ5D/YRESnnfajGmJQkFDkOh4OVK1eyceNG93MxMZfcP50hu3fvpkaNGnz11Vc+OZ4xQaoncDVwQFX7AfWANC/bhnJOs8EIjMm4bdu20aBBA0aPHu3VfnFxcbz11lucPn2aqKgoK3ICxJPhpUfjnGPgIZxd124GKqS3nzqbimZkNsBAsKRggllERAQ//fQT7733HgAbN26kXLlyzJ8/P9PHLly4MM2bN7chL024O6+qDiBORAoAh4A0i5hQzmk2CbYxGVe5cmVGjx5Nnz59vNpvzpw5PP3008yZM8dPkRlPeNKi00JV+wDHVfVFoDlwuYfHX+4avCCkWFIwoSBhNDSAli1bumd03rVrF94W6efPnyc2NpZ8+fIxadIkK3RMuFsqIoWAT4BlwHLgbw/2C8mcZozJnP79+1OsWDGv9uncuTObNm2iR48eforKeMKTQidhJJpzIlIaiAVKeXj8psDfIrLVNdHoGhFZnZFAjTEpq1GjBt9//z3FixcHYNCgQTRs2BCHw+HR/qpKr169uOGGG4JmklJj/EWc/UdeV9UTqjoa6Aj0dXVhS4/lNGOyqaVLlzJw4EDi49MfYDGhO3m1atWsy1qAeTLq2k+uK19v4bzqpTivgnni2gzGZYzJoBdffJFt27YRERGBqjJ27FhuvvlmChUqlOL2IkK3bt2Ii4uzD2QT9lRVRWQGUMe1vMOL3YMmp4nIDcD1QAHgU1X9JbARGRPeduzYwZQpU3jssceoUSP1EecvXLhAjRo1GDJkCAMHDszCCE1K0ix0RCQC+FVVTwBTRGQ6kMvTkddUdaeI1ANau1YtVNVVmQnYGJO2Bg0a0KCBc47ftWvXMmDAAGJiYhg0aNAl2x45coRixYpx7733ZnWYxgTSchFprKpLvNnJVzlNRD4DugCHVLV2ovWdgJE456obq6pvpBHLD8APIlIYeBuwQscYP7rhhhvo0qULuXLlSnO7M2fOcM0113D55Z7e5WH8Kc2ua66bNT9MtHzRm+GlReQRYCJwmesxQUQeymCsxhgv1alTh5UrV3LPPfcAMGPGDIYNG8a5c+f49NNPqV69Ov/++2+AozQmy2WoC5oPc9o4oFOyY0fizLedcQ573VtEaolIHRGZnuxxWaJdnyFRnjbG+EdUVJS7yEmrm3exYsUYM2YMV111VVaFZtLgyT06v4rITZKxPi33AE1V9TlVfQ5oBvTPwHEyTURuEJFPRGSyiFwTiBiMCYR69eq5P5z//vtvvvvuO3LmzMlVV13FbbfdRpUqVQIcoTFZ7lqgCtAe6IqzdaWrB/v5JKep6gLgWLLVTYAtqrpNVWOASUB3VV2jql2SPQ65hrseDsxU1eXexmCM8d7Bgwdp0qRJqlMwHD16lG3btmVxVCYtnhQ6A4FvgRgROSUip0XklIfHFyDxXVvxrnVeEZHPROSQiKxNtr6TiPwrIltEZHBax1DVH1S1P3AfzuGyjcl2Xn75ZVasWEFUVBSVK1fm/fffJyrKk1v1jAkfqroT53DS7V0/n8OzfOiTnJaKMsDuRMt7XOtS8xDQAegpIveltpGIDBCRpSKy9PDhw76J1Jhsqnjx4pQoUSLVSbW/+OILqlSpwq5du7I4MpOadL/hqGr+TBz/c2CxiEx1Ld8AfJqB44wDPgC+SFiRqJm/I86EsEREpuHs2/x6sv3vVtVDrp+tmd9kaxmd2dmYcCEizwONgOo481QOYALQMp1dfZXTMk1V3wPe82C7McAYgEaNGtmwisZkQsI8dqnp2bMnhQoVonz58lkYlUlLuoWOq8va7UAlVX3ZNTN0KVX9x4P9vgV+A1q5VvdT1RXeBqmqC0SkYrLV7mZ+1/kSmvlfx9kNIaV43sCa+Y0xJrvrAVyJcyRRVHWfiKR5Uc+XOS0Ve0k6aWlZ17pME5GuQNeqVav64nDGZHvx8fHExMRc0rJTrlw5+vXzZKT60HXo0CG2bdtGo0aNQqJHiCdN9aNwThJ6m2v5DB60iCTMIq2qy1X1PdfDVwkBrJnfGGNMxsS4cpQCiEje9HbIgpy2BKgmIpVEJCdwKzDNh8c3xvjAiRMnKF68OB9//HGS9Rs3bmTGjBnuOXTC0fTp06lUqRLNmzenRYsWnDrl6Z0sgeNJodNUVQfhmjhUVY8DOT08ftDMIu1KSg1V9T7XJHGpbTdGVRupaqOECRiNMcaElW9E5GOgkIj0B+bi2fxwPslpIvI18DdQXUT2iMg9qhoHPAjMBjYA36jqusyeC0BVf1LVAQULFvR63127djFtmtVbxiQoVKgQ9957L1deeWWS9V988QXdu3cnNjY2QJH515IlS+jRowc1a9bkvffeY+nSpbz88suBDitdkt5M6CKyGGgBLFHVBiJSHPhFVa9Mc0fnvhuBqsBO4CzOmzZVVet6Haiz69r0hDkHRKQ58IKqXutaHoLz4Mnvz/Faomb+/ps3b87s4YwxJuiIyDJVbRToOAJFRDoC1+DMS7NVdY4H+/gsp2WlzOS0WrVqsWHDBs6dO5fqDdjGGDh37hzr1q2jceOguL7vU6dOnaJBgwbExsaycuVKChcuzB133MGPP/7Ivn37yJ8/M7fz+0ZqOc2TFp33gKnAZSLyKvAH8JoHJxRgABkbwtMTfmvmz8zVL2OMMcFNRB4H1qvqU6r6pIdFjr9zWlDat28fgM23ZUwyBw4cSNJNLU+ePGFZ5KgqgwYNYvv27Xz11VcULlwYgPvvv58zZ84EfYtvuoWOqk4EnsY5ktl+4AZV/daD/RT4UFV3Jn94G2RWN/OLSFcRGXPypMdzoxpjjAkd+YFfRGShiDwoIiXS28GXOS2rZebiXenSpQFYv369r8MyJmT9/PPPlCpVimXLlgFw+PBh3n33XXbv3p3OnqFn3LhxTJgwgeeff56WLf8bmLJ58+aULFky9AsdEXkPKKKqH6rqB6q6wYvj+6Q/s6r2VtVSqppDVcuq6qeu9TNU9XJVraKqr2b2PInOZy06xhgTplT1RVW9AhgElAJ+F5G5HuwaNPedZpWEe1Wt0DHmP02aNGHkyJGUKeMcA2vFihU89thj7NixI7CB+di6desYNGgQ7du3Z9iwYUmei4iIoEOHDvz222+kdxtMIHnSdW0Z8IyIbBWRt0XEmz7dTYFFrn1Xi8gaEVmdsVCzjrXoGGNMtnAIOAAcBS7zYPtsl9POnTsHWKFjTGLFixfn4Ycfds+X07FjRw4ePEiTJk0CHJnvnD17lltuuYUCBQowceJEIiMjL9mmdevWHDp0iC1btgQgQs94MmHoeGC8iBQBbgKGi0h5Va3mwfGvzWyAgaCqPwE/NWrUqH+gYzHGGONbIvIAcAtQHOfcOP1V1ZNv8tkup504cQJwXtk1xvzn+PHjHDlyhGrVqiEiXHaZJ9dKQkNMTAw33XQTGzduZPbs2ZQsWTLF7RLuSVqxYgXVql1aFjgcDkaMGEGuXLno27cv+fLl82vcKfGkRSdBVaAGUAHY6OE+u4DWQF9XP2YF0u0LHWjWomOMMWGtHPCoql6hqi94WORANsxpCYXO5s2bOXbsmI8jMyZ03XXXXdx4440AvPvuu0F/r4qn4uLiuPPOO5k9ezaffPIJHTp0SHXbWrVqERUVxapVqy55LjY2lr59+/Lkk0/y4IMPUqpUKZ5//nmy+ru1J/fovCkim4GXgLVAI1X1dJSZhMlGe7uWT+PBZKOBZvfoGGNM+FLVIaq6UkQuE5HyCQ8Pds1WOU1VOXHiBK1bt0ZVWbBggZ8iNCb0PPHEEwwfPhyADz/8kClTpgQ4osw7efIkXbp04ZtvvuGtt97i7rvvTnP76Ohoqlevzpo1a5Ksj42NpXv37kyYMIE+ffpw1VVXUadOHV566SWaNm2apV3d0u26BmwFmqvqkQwcv6lr7p0V4Jxs1DUUtDHGGBMQrnll3gFK47xPpwLO0TuvSGfXbJXT4uPj6d+/P1dffTVLly7lt99+44Ybbgh0WMYEhTZt2rh/3rRpExcvXgxgNJm3cuVKbr/9djZt2sQnn3zCvffe69F+l19+ORs2JB2n7Mcff2TmzJmMHDmShx9+2L1+wYIF3HjjjTRt2pSpU6cmeQ/9xZPhpT8G4kWkiYi0SXh4ePxYEYnE2byPa7JRR8bDzRrWdc0YY8LaK0AzYJOqVgKuBhZ5sF9I5rSMioqKYtSoUdx00020bNmSX3/9NdAhGRM0zp49y/Llyzlz5gwiQq5cuQIdUoYcOXKEJ554gsaNG3P06FFmz57tcZEDUK1aNbZt20Z8fLx73WeffUbZsmUZNGhQkm3btGnD4sWLKV68ONdee22WfKZ40nXtXmABzvlqXnT9/wUPj5+hyUYDzbquGWNMWItV1aNAhIhEqOp8wJMRRUMyp/ni4l3nzp1Zu3YtW7du9WFkxoSuv/76i4YNG/Ldd9/x5JNPhtS/jWPHjjFu3Di6dOlCmTJlePfdd+nbty/r16+nffv2Xh2rWrVqxMTEuOcQ2rdvH7Nnz6ZPnz4pjtRWpUoV/vzzT6pWrUq3bt1YuHChT15TajwZjOARoDGwU1WvAq4ETnhy8IxONmqMMcb40QkRyYfzIt5EERkJnE1vp1DNab64eHfTTTcBhMV9CMb4QoMGDZg6dSrR0dGMGjWKo0ePBjqkNB0/fpyxY8fSqVMnSpQoQb9+/Vi7di0PPfQQa9euZezYsRQpUsTr4yYMsZ1Q6Hz99dc4HA769u2b6j5FixZl7ty5lCtXjuuvv57Fixdn7EV5QNKb5EdElqhqYxFZibN/8kURWeeabC0sufpvd61atWr/zZs3BzocY4zxORFZpqrezIsWNkQkL3Ae58W+24GCwERXK0/YatSokS5dujTD+zdp0oS4uDiWL1/uw6hMKNi2bRv3338/O3bs4O677+app54iIsKbgXvDn6oiIoEO4xIbN27krbfe4quvvuLChQtUrlyZm2++mZ49e9KwYcNMx7xu3Tpq167N119/za233krXrl3ZsmXLJfftpGTv3r20adOGo0ePsmrVKipUqJDhOFLLaZ78le4RkULAD8AcEfkR2JnhSEKAdV0zxpjwpapnVdWhqnHAUVV9L9yLHF/o27cvK1asIDPFkgk9O3bsoGXLlvzzzz+ULl2awYMH8+yzzwY6rIBTVRYvXsy2bdsAgq7IOXnyJA899BC1a9dm8uTJ9O3bl6VLl7JlyxbeeOMNGjVq5JOYy5QpAziLFoBly5bRqJFn19DKlCnDL7/8wpkzZ3j66aeT3OfjK54MRtBDVU+o6gvAs8CnwA0+j8QYY4zJei8FOoBQceedd5I3b14++uijQIdisoiq0r9/f86cOcMff/zBvHnz6NevH2+88UZI3ZPiDyJCu3bt6NChA0899VSgw0lix44dtGjRglGjRjFgwAC2bdvG6NGjfdKCk1zBggXJkycPe/fu5ciRI+zfv58rr7zS4/2rVKnCgw8+yDfffMNrr/n+lkdv2x2rq+o0VY3xeSTGGGNM1guuy7B+4KuRRAsUKMDtt9/OV199ZZOHZhM//PADc+fO5c033+SKK65ARHjllVeIiori7bffDnR4ATdt2jQaN24cVPeu7dy5k1atWrFv3z7mzp3LqFGjuOyyy/x2PhGhZMmSHDhwwD0/zuWXX+7VMUaMGMEdd9zBCy+84POusd4WOvd5s7E43SEiz7mWy4tIEy/PmeVseGljTLC6ePEia9asYfLkyTz//PNs3Lgx0CGFuoGebhiqOc2X3bEffPBBLly4wDvvvOODyEwwU1VefvllqlatSv/+/d3rS5cuTZ8+ffj88885depUACMMvI4dOzJ58mR397VAS5io8+zZs/z+++9cddVVWXLeokWLcvz4cXehU7VqVa/2FxE++ugj3n//ferXr+/T2LwtdLy98pWtZpE2xhhfOX/+PCtXruSrr77imWeeoUePHlSvXp28efNSt25dbr31Vl555RVWrlwZ6FBDjojkEZFnReQTVf1HRKqJSBcPdg3JnOZLderUoVevXrz77rscPHgw0OEYP/rtt99YsWIFgwcPJioq6fzyffv25eLFi/z8888Bii44rF27lkWLPJmCK2u8+eabrFq1inHjxlG3bt0sO2+RIkU4duwYW7duRUSoVKmS18fIly8fDzzwgM8HuYhKf5Mkunq5fbaaRdoYY7x15swZNm7cyPr165M8tm3bRsKomJGRkVSrVo3atWvTq1cvatWqRa1atbj88stDdpK6APscWIazaAHYC3wLTE9nP8tpwMsvv8x3333H888/z+jRowMdjvGTMWPGUKhQIW677bZLnmvRogWlSpViypQp9O7dO4W9s4dnnnmGH3/8kU8//ZS77747oLFs2LCBl156iVtuuYXu3btn6bmLFCnC1q1b2b9/P8WKFSM6OjpLz5+WdAsdESmBc0K00qraWURqAc1V9VMPjp+tZpE2xpjUXLx4kfXr17Ny5UrWr1/PunXrWL9+PTt3/jeIZY4cOahevToNGzbkzjvvdBc01apVI2fObPd92p+qqGovEekNoKrnxLM7dIMmp4lITZzz3BUDflXVLBshoFq1ajz88MOMGDGCm266iY4dO2bVqU0WOXr0KN9//z333XcfuXPnvuT5iIgIbrjhBsaPH09sbCw5cuQIQJSB9/LLLzNnzhzWrVsX0DhUlQceeIC8efPy3nvvZfn5E1p0Dh48SIkSJbL8/GnxpEVnHM6rX8Ncy5uAyThHX0tP8lmke+Icuc0YY8LWsWPHWLVqFStXrnQ/1q9fT1xcHAC5cuWiRo0atGzZkv79+7sLmipVqlzSRcT4RYyI5Oa/gqUKcNGD/XyS00TkM6ALcEhVayda3wkYCUQCY1X1jdSOoaobgPtEJAL4AsjSodBeffVVZs2aRb9+/dzDDmfE2rVrmTNnDkWLFqVnz57kyZPHx5GajPjxxx+JiYmhT58+qW5z1VVX8dFHH7FixQqaNAn6W9X8ok6dOpw9m+5cw373/fff89tvvzFq1KiAFBoJ9+js378/JAudYqr6jYgMAVDVOBHxaKBrVZ0oIsuAq3He33OD68PZGGNCnqqyc+dOVq5cyYoVK9xFza5du9zblCpVivr169OlSxfq169PvXr1qFKlCpGRkQGMPNt7HpgFlBORiUBL4K70dvJhThsHfICzQAHA1VL0IdAR2AMsEZFpOIue15Ptf7eqHhKRbsD9wJcZiCFTcufOzVdffUXr1q259tpr+f33372aVf3kyZM8/vjjfPbZZ+51b731FgsXLqRQoUJ+iNh449tvv6VSpUo0aNAg1W1at24NwMKFC4Oi0HE4HPz999/s2LGDKlWq0LhxY79/zh4+fJiFCxfSrl07r/7+fenixYs89dRT1K5dO8mgEVmpSJEiqCqbNm2ic+fOAYkhVaqa5gP4DSgKLHctNwN+T28/17bDPVkXbA+c9yKNqVq1qhpjjKrqxYsXdcWKFfr555/rI488om3bttWCBQsqzlYBjYiI0Jo1a2rv3r11+PDhOnv2bD1w4ECgw04VsFSD4PM2UA9XXrseZ8tKMQ/38VlOAyoCaxMtNwdmJ1oeAgzx8Fg/e7Jdw4YNU/hLyJxff/1Vc+bMqVWrVtXVq1d7tM/vv/+uFSpU0IiICP3f//6ne/fu1R9//FGjoqK0a9eu6nA4fB6n8dyxY8c0KipKn3rqqXS3rVq1qnbv3t3/QaVj8+bN2rhxY/fnMaBFihTRO++8U6dOnapnz571y3knTZqkgH733Xd+Ob4nxowZo4DOnDkzYDF89tln7vf9scceC0gMqeU0T1p0HgemAVVE5E+gOM7mek90BP6XbF3nFNYFFVX9CfipUaNGgSmNjTEBt3v3bv7880/++OMP/vrrL9auXUtsbCwAefLkoV69etx2223Ur1+f+vXrU7t2bet2EyJEpAcwT1V/di0XEpEbVPWHdHb1Z04rA+xOtLwHaJraxiLSDrgRiAZmpLHdAGAAQPny5X0QZlLt27dn3rx53HzzzTRs2JD77ruPRx99lMqVK1+y7b59+3jttdcYNWoUVapU4c8//6RZs2YAdOvWjeHDh/PEE0/wyy+/cO211/o8VuOZadOmERcXR8+e6X/Va926NdOmTcPhcPh8tCxPHTlyhGuvvZYTJ04wduxYWrZsyerVq5k+fTrTp0/nyy+/JHfu3Dz88MO89NJLPr3fsWfPnowZM4Zu3bpd8pzD4WD58uVs3ryZPXv2sGfPHvbt28epU6eIiYkhOjqaunXr0r59e9q0aZOh/BEXF8frr79O48aNA/pvJl++fO6fixYtGrA4UpRS9ZP8gbOL2xVAbSCHB9vfD6wBzgGrXY81wHZgoifnDIaHP65+GWOCT1xcnK5YsUI/+OAD7d27t5YrV859dSpv3rx69dVX6+DBg3XSpEm6ceNGjYuLC3TImUY2btEBVqawbkUa2/s8p3Fpi05PnPflJCzfCXzgo9fr914KBw4c0AEDBmhkZKQCWq9ePe3Xr58+/fTT+sADD2jr1q01MjJSo6Ki9IEHHtDTp09fcoyLFy9qxYoVtWHDhtaqE0A9e/bU0qVLe/Q7SLiSv27duiyILGX9+vXTnDlz6qJFiy55LiYmRufOnat33HGHAtq9e3e/f37PmzdP77//fi1btmySFqb8+fNr9erVtWnTptqqVStt2LCh5siRQwHNmTOntmvXTl955RVdvHixxzF+8cUXCuiPP/7o19eUnpkzZ7pf58iRIwMSQ2o5zZMPyEigG/Awztadx4HH09mnoOtD/GugPFDB9SiS3vmC6WGFjjHh6cyZM/rrr7/qiy++qNdcc43mz5/f/SFdunRpveWWW3TkyJG6dOlSjY2NDXS4fpHNC53VKaxbk8b2Ps9pKRQ6Ge665ukjK3Larl279LXXXtOOHTtqiRIlNDo6WosUKaINGzbUoUOH6tatW9PcP6Ebzm+//eb3WM2lYmNjtVChQtqvXz+Ptt+0aZMC+sknn/g5spRt3LhRIyIiPOouNXLkSAX01Vdf9Uss58+f1//9738KaJ48ebRLly765Zdf6rp16/TkyZMp7nPmzBmdNWuWPvnkk1q/fn13HipUqJD26NFDf/zxx1QLztjYWK1evbrWqVNH4+Pj/fKaPLVw4UJ37J9//nlAYkgtp4nzudSJyAzgguvqlXsYTVV9Mc0dnfs+73rhSajqS+ntGwwaNWqkS5cu9Wqf1atXc+HCBXLkyJHkERUVdcm6hPWejWpqjMmoffv28eeff7q7oq1cuZL4+HhEhNq1a9OyZUtatWpFy5YtqVChQrb4Nykiy1S1UaDjCATXqGcn+G+yz0E4i5a70tnPZzlNRCoC09U16pqIROEc1fRqnPP6LAFuU9VMj1srIl2BrlWrVu2/efPmzB7Or86dO0e5cuVo27Yt33//faDDyXYWLVpE8+bNmTRpEr169Up3e1WlcOHC9O7dm48+unTgP1Vl9erVXLx4kcaNG/v8s/WBBx7g888/Z+fOnVx22WXpbt+jRw/mzp3L5s2bKVmypM/i2LJlCzfccAPr1q1jwIABjBw5MkNznB0+fJh58+YxZ84cZs2axd69e2nSpAmffvoptWvXTrLtxx9/zH333ceUKVO48cYbffVSMmTlypVceeWVAAGLJ7Wc5sk9OmVVNaPTq55J9HMunDd9hvWoa/369WP58uVe7RMZGZlqYZQ7d27y5s1L3rx5yZcvn/vnjK7LDl/gjNm/fz8///wzv//+O3/88Qc7duwAnCNFNWnShMGDB9OyZUuaN29uIzxlTw/hHBZ6smt5Ds5iJz0+yWki8jXQDigmInuA51X1UxF5EJiNsyfFZ74ockJNnjx5GDhwIMOHD2fHjh1UrFgx0CEFFYfDwdatWzl79izVq1dPcY6bzJg9ezYiQocOHTzaXkRo0KABy5Ytu+Q5VeW+++5jzJgxgHM46q+//tpnww+fO3eOiRMn0rNnT4+KHIA333yT6tWrM3r0aF544QWfxDFnzhx69epFREQEM2fOpFOnThk+VvHixenVqxe9evUiLi6OL7/8kv/97380bNiQZ599lqeeeoro6Gh27NjB0KFDad26NT169PDJ68iM/Pnzp/hzMPCkRWc4zsnIfsn0yUSicTbNt8vssTJwbq8nV8tIi85ff/3F8ePHiY2NTfKIi4u7ZJ0n68+fP8+ZM2c4e/ZskkfCuoSboz0RERFBwYIFKVSokPuRfDmldQnLBQoUsCFxTVBSVVasWMFPP/3E9OnTSfh3W6JECVq2bOlusalfv75NvOmSnVt0fCWQOS0jMpLTAmHPnj1UrFiRRx99lLfffjvQ4QSFEydOMGLECD777DP27NkDQLFixXjnnXe48847fXaeli1bEhsbyz///OPxPk899RTvvfcep0+fTvL5+t577/HII4/wyCOPULVqVZ5++mlq1qzJggULyJs3b6ZjnThxInfccQfz58+nXbt2Hu939dVXs3PnTjZv3pzpi7+jRo3ioYceolatWkybNo1KlSpl6ngpOXz4MA8++CDffPMNVapUoVu3bvz0008cPnyYf/75h8svv9zn5/TWwYMH3S1kixYtomnTVMdR8ZvMtOgsAqa6JiWLxTl3gKpqgQzEkQco6+1OoTS5WosWLfxx2FTFxsYmKXxSKoYSfj516hQnTpzg5MmTnDhxghMnTrBlyxb38unTp9M9X4ECBShUqBDFixenZMmSlCxZkhIlSqT4c/78+a0FyfjN+fPn+fXXX90j6+zduxcRoWnTprz66qt07dqV2rVr29+guYSIFAeexjnIjrt/iaq29/JQGcppWS1R17VAh+KRsmXL0rNnT8aOHcsLL7yQZESn7CY2NpaPP/6YF154gWPHjtGpUydeeOEF8ufPz/vvv0+fPn3Ily+fT67qnzhxgsWLFzNkyBCv9mvUqBExMTGsW7fO3X3pzJkzvPzyy3To0IERI0YgIlSqVImuXbsyePBg3n///UzHO2XKFEqVKkWbNm282u/OO++kX79+LF682D3qn7dUlddee41nnnmGrl27MnHiRL+1ZBQvXpzJkydzzz338NJLL/H+++9TtWpVfvrpp6AociDpqGsFCmSkPPAfTwqdd3DeJLlG02v+SUZE1vBff+ZInENTZ+T+nHGE+ORq/pIjRw53y0tmxcXFpVgMJV8+fvw4hw8fZt++fSxfvpxDhw4RH3/pHLK5cuVKtxgqWbIkZcuWJUeOHJmO34S//fv3M336dH766Sfmzp3L+fPnyZcvH9dccw1du3bluuuu87gLg8nWJuLsttYFuA/oCxxObycf5rQspSE4ZcKjjz7K5MmTGT9+PIMGedKrMLyoKtOnT+epp57i33//pX379vzf//0f9evXd2/TvXt3WrZsyaBBg7jmmmsy3Uoyb9484uPjvR6muGHDhgAsW7bMXeiMHTuWI0eO8Morr7gvNl1//fU8/PDDjBw5khtvvJGrrroqw7GeO3eOWbNm0a9fP6+Htb7hhhu45557mDlzZoYKHVVlyJAhDB8+nDvuuIPPP/+cqChPvk5nzjXXXMM111zjvME+yC7gJR4aOxS7ri0A2qmqI80NU963QqLFOOCgqsZ5exzXsSqS9MbN5sALqnqta3kIgKomL3JSOtbPqnp9etuFSjN/oDkcDo4ePcqBAwc4cOAABw8eTPXnI0eOkPxvLjIykgoVKlClShWqVKlC1apV3f+vXLmyzU2SjaXWJa1ChQp07dqVrl270rZtW6KjowMcaejJzl3XXK+9oYisTrgHVUSWqGrjdPbzWU7LSqE0GEFizZs3Z+fOnaxevZpixYoFOpwsERsby+TJk/m///s/Vq5cSfXq1Xnrrbfo0qVLil9uFyxYQNu2bRk9ejQDBw7M1LkHDhzI119/zdGjR726+JjSgASNGzv/KS1ZsiTJtufOnaN+/frExcWxZs2aDBdnP/zwAz169GDOnDke30+UWLNmzYiKiuKPP/7waj+Hw8FDDz3EqFGjuO+++/jwww8DNn9QsEn4+zx16lRAip3MdF3bBvwmIjOBiwkrVfWd9HZU1Z1eRemdkJxcLRxFRERQvHhxihcvTp06ddLcNjY2lsOHD7sLoH379rF9+3a2bt3Kli1bmDx5MsePH0+yT6lSpdzFT+JCqEqVKhQpUsSfL80EwPnz55k3b567uEnoktasWTNee+01unTpYl3STGYl3Ny4X0SuB/YB6X6Y+Dmn+U0otugAfPTRRzRt2pQePXowZcqUsG6tPXnyJGPGjOG9995jz5491KxZk7Fjx9KnT580i47WrVtTp04dxo8fn2KhM2rUKD777DO6d+/OM888k+bn5q+//kr79u297mEhIjRs2JDFixcDsHXrVpYuXcpbb711ybZ58uRh7NixtG3blmeffZZ33rn0q6SqMmfOHNasWUOHDh2oV6/eJdtMnTqVwoUL07ZtW69iTdCqVSs++OADYmJiLrlv8/Tp0/z999/kyZOHJk2auJ+Pi4vjnnvu4YsvvuDJJ5/kzTfftDyUyNy5c9m7d2/Qteh4Mtb/8yk90tnnNHAq0eN04v+nd85UjlmRLJpcLeFh8+gExtGjR/Wff/7Rr7/+Wl9++WW96667tHXr1lqqVKkkk28BWrhwYW3UqJH26tVLn3nmGZ06daru3bs30C/BeMnhcOjChQv1lltu0dy5cyug+fLl05tuuknHjRunBw8eDHSIYYfsPY9OF5xz49QG5gPLgG5pbO/znBaIRyjmtEmTJmmuXLm0WLFiOnHixLCbSHTHjh362GOPab58+RTQq666Sn/++Wev5kV55ZVXFNB9+/YlWf/tt98qoBUqVEh3/phjx44poK+//nqGXseLL76oIqJHjx7V1157TQHduXNnqtvff//9KiL6119/JVl/4sQJbdOmjTvHR0VF6YwZM5JsExMTo4ULF9Y777wzQ7Gqqn7zzTcK6JIlS5Ks37Nnj5YvX959/uLFi+vgwYP1hx9+0G7duimgL730Utj9HYaD1HJawD94PX2kUOj4bXI1smAWaZMxZ8+e1TVr1ujUqVP17bff1vvvv187duyolStX1oiICPeHU5kyZfTGG2/UN954Q+fNm6enTp0KdOgmBRcuXNDx48drgwYN3IXroEGDdPbs2XrhwoVAhxfWsnOhk90eoZ7T1q5dq02bNlVAb7/9dr148WKgQ8q0FStW6G233aaRkZEaGRmpt99+uy5btixDx1q6dKkCOnHiRPc6h8OhNWvW1Dp16mhsbKzedtttKiK6evXqFI8xf/58BXTWrFkZiiFhwsjvvvtOa9Wqpc2bN09z+5MnT2r58uW1fPny7gtZR48e1UaNGmmOHDl09OjRunv3br3yyis1b968unnzZve+c+fOVUC///77DMWqqrplyxYF9NNPP02y/s4779Q8efLoDz/8oN9//71269ZNRcRddL333nsZPqfxL68LnYTWEeAnYFryR2r7pXCcesCDrkddT/dL4TjJC50onN3qKgE5gVXAFRk9frJzhXRSyK7OnTunf/31l7777rvau3dvrVKlirvwERG94oortF+/fvrRRx/psmXLNCYmJtAhZ1v79+/X559/XkuUKKGA1qpVS0ePHq1nzpwJdGjZRnYudIDKrtx2BDgE/AhU9nBfn+S0QDxCsUUnQVxcnLvlon379iF58SomJkZ//PFHveaaa9yt1o8//rju2rUrU8eNi4vTggUL6sCBA93r/vnnnyRf5I8ePar58uXTvn37pniMd955RwE9cOBAhmK4ePGi5smTRwsUKKCAfvnll+nus3TpUs2VK5eWK1dOH330US1XrpxGR0fr9OnT3dvs3r1bCxYsqC1atNC4uDhVVR04cKDmzZtXz507l6FYVVXj4+M1d+7c+thjj7nX7d+/X3PkyKEPPfRQkm2PHz+uixYt0v3792f4fMb/UstpqQ5GICKnVLWAiKTYAVJVf09xx6THeAToDyRMb9wDGKOqXo0rmHhyNeAg/02udh3wLv9NrvaqN8dNjw1GEPqOHj3KkiVL+Oeff1i8eDH//PMPR44cAZyjwjVo0IAmTZq4H5UrV7Y+t360dOlSRo4cyeTJk4mNjeX666/nkUceoUOHDva+Z7FsPhjBIpyjdn7tWnUr8JCqpjn5g69yWqCEQ0774osvuPvuu2nQoAEzZ86kaNGiWR6Dw+Fg/vz5TJ8+nS1bthAVFUWRIkUoVKgQefPmJUeOHBw+fJiLFy8SGxvLhQsX2LRpE2vXruXixYuUKlWKhx56iPvuu4/ChQv7JKb27dtz5swZ9/w3r7zyCs899xyHDh1yD+Rwzz338M0333Dw4MFLBvnp27cvc+bMYd++fRmO4dZbb2Xy5Mk0aNCAJUuWeHST/pIlS7jnnntYt24dbdq04dVXX71kmo6E+XLeeustHn30UUqXLk379u2ZNGlShmMF57DYRYoU4ZdfnNNEvv766wwdOpRNmzZRrVq1TB3bZL1Uc1pK1Y+r+FmR2nOePoDVQN5Ey3mB1Zk9rr8fWItO2HI4HLpt2zadNGmSPv7449qqVSv3PSGAFi1aVDt37qwvvfSSbtiwIdDhhoXY2FidPHmytmjRwn0V86GHHtJNmzYFOrRsjezdonNJHgJWebKf5bTAmzZtmkZHR2vVqlX1zz//9GrflStX6gsvvKAvv/yyTpw4UdesWXNJ635cXFyK92AcOHBA33jjDXdvgdy5c2vdunW1Tp06WqZMGc2bN6+7m1PBggW1RIkSWrZsWa1UqZJ26NBBn3zySZ02bZrGxsZm6vWn5IknntDo6Gj3sTt27Kj16tVLsk1C97TEXdwS1KlTRzt37pypGPbs2aMPP/xwmvfmpCate14cDod269ZNc+fOrc8//7wCOmXKlMyEqqqqvXr10ipVqriXW7RooY0aNcr0cU1gpJbT0vpg3AM8ntojtf2SHWMNkCvRci6c8/EE/IPfk0coN/Mbz8XExOiKFSv0448/1nvuuUfr1KnjTlYNGzbUESNGWJN1Bhw5ckRff/11LVu2rAJauXJlHTFihJ44cSLQoRlNPSlkhwcwHBiMs0t0BZyTh76Oc+S1ImnsZzktSCxcuFArVKigIqK33HKLrlixIs3tL1y4oE8//bSKiPvzPeERHR2t5cqV01KlSmn+/PndN6Ffe+21OnToUB06dKi2b99eIyMjFdC2bdvqhAkT9Pz585ecJz4+PiD3EH366acK6JYtW9ThcGixYsX0nnvuuSS20qVL60033ZRk/fnz5zUqKkqHDh2alSF7ZdeuXVqkSBEF9IorrvBJsTh48GCNiorSuLg4PXfunEZGRgb1e2DSllpOS2t46UggH5CZ/iSfA4tFZKrrON2BTzNxPGN8LkeOHNSvX5/69eszYMAAAA4cOMCkSZOYMGECjz32GE888QQdO3bkjjvu4IYbbsjWM3WnZ926dYwcOZIJEyZw/vx52rdvz4cffsj1119PZGRkoMMzBuAW1/8HuP6fkOduxfnlt3Iq+1lOCxKtWrVizZo1vPbaa3z44Yd88803NGzYkDvvvJNbb72VEiVKuLfdvHkzN954I2vXrmXAgAG8/vrr5M6dmy1btrBq1SpWrVrF4cOHyZEjB3nz5qVAgQLs3buXxYsXM2fOHESEGjVq8PTTT9OnTx9q1KiRalwRERGXDFecFapWrQo4h3bOlSsXR44ccU/emTi2Ll268NVXXxEbG+seRnrdunXExcUlmYw02JQrV44lS5Ywe/ZsbrzxRp9M0FmpUiXi4uLYs2cP+/fvJz4+3j3/jwkjKVU/zsKI5ak9580DaAA8DDwE1PfFMf39IMya+U3mrF+/XocNG+YeojNPnjx6++2368yZM/3SBSEUxcfH67Rp0/Tqq69WQHPlyqX33ntvqiP8mMAjG7boAI2BkomW++IcYOc90mjJSXaMkMtpCY9watFJ7Pjx4zpixAj36I2RkZHaqVMn/fLLL3XmzJlavHhxLVasmP78889eH9vhcLhvgg9me/bsUUBHjRrl7qI2d+7cS7abNGnSJcMqf/LJJwokGdksO5g9e7YC+vvvv+uoUaPSHRLbBLfUclpad4pl+s5gEbkZ2Kyq7wGFgOdE5Mq09wo8Vf1JVQcULFgw0KGYIFCzZk1eeeUVtm3bxsKFC7nzzjuZMWMGnTt3pkyZMjz66KMsXbo04UtQtjNp0iQuv/xyunXrxsaNG3nttdfYvXs3n3zySboTyBqTxT4GYgBEpA3O7mrjgZPAmPR2DtWcFu4KFSrEo48+yrJly1i3bh3/+9//WL9+PXfeeSedO3cmX758/Pnnn1x33XVeH1tEQqIlulSpUkRHR7N9+3a2bdsGQOXKlzZMtmrVCoA///zTvW7lypXkz58/xe3DWcmSJQE4ePAgW7ZsIXfu3JQrVy7AURlfS6vQudoHx39WVU+LSCugPc4m/tE+OK5fiUhXERlz8uTJQIdigkhERAStWrVi9OjR7N+/n6lTp9K6dWs++ugjGjdu7C6Itm/fHuhQs4TD4WDo0KH07t2bQoUKMWnSJLZv386QIUPco/wYE2QiVfWY6+deOEdMm6KqzwJVPdjfclqQq1WrFq+++irbt29nwYIFfP3116xatYrLL7880KH5VUREBCVLluTAgQNs27aNqKioFL+0lylThpIlS7JixQr3ulWrVlG3bl2PRkkLJwndGw8dOsT27dupWLGijf4ZhlL9q06UDDIj3vX/64FPVPVnnHPeBDVr0THpiY6O5oYbbuC7777jwIEDjBkzhhIlSvDss89SuXJld0F09OjRQIfqF+fOnaNXr168/vrrDBgwgL///ptevXq5+3wbE6QiRSShc//VwLxEz3nS6d9yWoiIiIigdevW3HrrreTPnz/Q4WSJUqVKceDAAXbu3EnZsmVTvY+lXr16rFq1yr28bdu2bDmccrFixYiIiODgwYNs374927VoZRf+Lt/3isjHOG/wnCEi0VlwTmOyVOHChenfvz+///47O3bs4LXXXuPYsWPcf//9lCpViltuuYUDBw4EOkyfOXDgAO3atWPKlCn83//9H6NHj7YCx4SKr4HfReRH4DywEEBEquLsvpYey2kmaJUsWZL9+/dz8OBBd7eslNSrV49169YRExPDxYsX2bdvH5UqVcrCSINDZGQkxYoV4+DBg+zatYvy5csHOiTjB/7+gL4FmA10VNUTOIfufMrP5zQmYCpUqMCQIUNYt24dy5cv58EHH2T69Ok0aNCAP/74I9DhZdqaNWto2rQp69atY+rUqTz++OPW1G9ChjonlX4CGAe00v9urIvAObhAeiynmaCV0HXt4MGDXHbZZaluV79+fWJjY9m4cSM7d+4EoGLFilkUZXApUaIE+/bt49ixY2m+ZyZ0+bvQcQCVgDdFZArOq2AL/HzOTMtO/ZmNf4gIV155Je+88w6LFi0ib968tGvXjnfeeSdkBy2YMWMGLVq0IC4ujoULF9K9e/dAh2SM11R1kapOVdWzidZtUtXlHuwekjnNZA+lSpXiyJEj7NmzJ8nw2snVq1cPcN6bs2XLFiDlgQuyg0KFCrkHbyhevHiAozH+4O9C5wugJvA+8AFQC/jSz+fMtOzYn9n4T926dVm6dCndunXjiSee4Oabb+bUqVOBDssr77//Pl27dqVatWr8888/NGjQINAhGRMIQZXTRCSviCwVkS6BisEEj4TuaseOHUuz0Ln88svJlSsXK1eudA9KULdu3SyJMdgUKFCArVu3AtggOmEq8zMupa22qtZKtDxfRNb7+ZzGBJ2CBQsyZcoU3nnnHf73v/+xevVqpkyZEvTDL8fFxfHYY4/xwQcf0K1bNyZOnGiTpZrszCc5TUQ+A7oAh1S1dqL1nYCROCfsHquqb6RzqP8B33h7fhOeEt+Xk1ahExUVRe3atZkyZQqqSpUqVShQoEBWhBh0ChQowMWLFwFr0QlX/m7RWS4izRIWRKQpsNTP5zQmKIkITzzxBPPmzeP06dM0bdqUL78M3gbOU6dO0a1bNz744AOeeOIJvv/+eytyTHbnq5w2DuiUeIWIRAIfAp1xthT1FpFaIlJHRKYne1wmIh2B9cChjL4YE15KlSrl/rlmzZppbtuuXTv27NlD6dKleeWVV/wdWtBKPCKfteiEJ7+06IjIGkCBHMBfIrLL9VR5YKM/zulLItIV6Fq1qifTKhjjnTZt2rBixQp69epFnz59+PPPP3n33XfJlStXoENz27lzJ126dGHDhg18/PHHDBgwINAhGRMwvs5pqrpARComW90E2KKq21znnAR0V9XXcbb+JI+pHZAXZ1F0XkRmqKrD21hM+EjcopNeb4Hhw4fz0ksvkTt3bn+HFdQSt2QVKVIkgJEYf/FXhbqirAAADYtJREFU17WQ7i+sqj8BPzVq1Kh/oGMx4alkyZL8+uuvDBs2jDfffJOlS5fy3XffBcXIN4sXL6Z79+5cuHCBWbNm0aFDh0CHZEygZUVOKwPsTrS8B2ia2saqOgxARO4CjqRW5IjIAGAAYMPnhrmSJUtStmxZChYsmO4IYhEREdm+yIGkhU527b4X7vzSdU1VdyY8gFNACaBCoocx2V5UVBTDhw9n6tSpbNmyhQYNGjBjxoyAxvTtt9/Srl078uTJw99//21FjjEEd05T1XGqOj2N58cALwLLc+YM+rlNTSbkyJGDnTt3smbNmkCHEjISFzd58+YNYCTGX/x6j46I3Itz6M3ZOD9oZwMv+POcxoSaG264gWXLllG+fHmuv/56nnvuOeLj49Pf0YdUlddff51bbrmFhg0bsnjx4nT7eBuT3fg5p+0FyiVaLutaZ4zHIiIibG4zLyS+RycyMjKAkRh/8fdgBI8AjYGdqnoVcCVwws/nNCbkVKlShb///pt+/frx8ssv07lzZw4fPpwl546JiaFfv34MHTqU2267jblz59roM8akzJ85bQlQTUQqiUhOnHP0TPPFgW3KBGNSZv8mwp+/C50LqnoBQESiVXUjUN3P5zQmJOXOnZvPPvuMsWPHsmDBAho0aMCiRYv8es6jR4/SsWNHxo8fz4svvsiECROCalAEY4KMT3KaiHwN/A1UF5E9InKPqsYBD+JsJdoAfKOq63wRtE2CbUzK0ruXyYQ+fxc6e0SkEPADMEdEfgR2+vmcmWZJwQTSPffcw19//UWOHDlo06YN77//Pqrq8/Ns2rSJZs2asWjRIiZOnMhzzz1nXR6MSZtPcpqq9lbVUqqaQ1XLquqnrvUzVPVyVa2iqq/6Kmhr0TEmZYlHqjPhSfzxBSrFE4m0BQoCs1Q1JktOmkmNGjXSpUtt2h8TGMePH6dv37789NNP3HrrrXzyySdezWOjqpw7d46jR49e8jh8+DAjR44kKiqKH374gRYtWvjxlZhgJCLLVLVRoOMIVaGU0xJNmdB/8+bNgQ7HmKBx6tQpd/e1rPo+bPwjtZyWZYVOKLJCxwSaw+Fg+PDhPPPMM1SvXp2PP/6YyMjIFIuXlB4JMz6n5Morr+S7776jcuXKWfiKTLCwQif7sZxmTFKqSkREhPtnE7pSy2n+mkfHGOMDERERDBkyhKZNm3LrrbfSpk2bS7aJioqiSJEiFC1alKJFi1K5cmUaN27sXk7pUaRIEWyoWWOyB5sE25iUJXTXjo6ODnAkxl+s0DEmBLRv357Vq1fz+++/U7BgwSRFS4ECBezeGmNMqmwSbGNSt2HDBht9LYxZoWNMiChZsiS9evUKdBjGGGNM2KhRo0agQzB+5O9R14wxxhgTQDaSqDEmu7JCxxhjjAljNry0MSa7skLHGGOMMcYYE3ZseOk0iMhhkk4GVww4EqBwMirUYrZ4/cvi9b9QibmCqhYPdBDG/xJGXQN6ARmZSCdU/qZTYrEHTijHb7EHRmZiTzGnWaHjBRFZGmrzToRazBavf1m8/heKMRuTllD+m7bYAyeU47fYA8MfsVvXNWOMMcYYY0zYsULHGGOMMcYYE3as0PHOmEAHkAGhFrPF618Wr/+FYszGpCWU/6Yt9sAJ5fgt9sDweex2j44xxhhjjDEm7FiLjjHGGGOMMSbsWKHjIRHpJCL/isgWERkc6HiSE5FyIjJfRNaLyDoRecS1voiIzBGRza7/Fw50rImJSKSIrBCR6a7lSiKy2PU+TxaRnIGOMYGIFBKR70Rko4hsEJHmIfD+Pub6e1grIl+LSK5geo9F5DMROSQiaxOtS/E9Faf3XHGvFpEGQRLvW66/idUiMlVECiV6bogr3n9F5NqsjteYzAi3vBcMnyHJeZoDRSTatbzF9XzFgAaOdzkx2N57b3JjMLz3vsqVItLXtf1mEekbwNi9zpsZ/TyyQscDIhIJfAh0BmoBvUWkVmCjukQc8ISq1gKaAYNcMQ4GflXVasCvruVg8giwIdHycGCEqlYFjgP3BCSqlI0EZqlqDaAezriD9v0VkTLAw0AjVa0NRAK3Elzv8TigU7J1qb2nnYFqrscA4KMsijGxcVwa7xygtqrWBTYBQwBc//5uBa5w7TPK9VliTNAL07wXDJ8hyXmaA+8BjrvWj3BtF2je5MSgee8zkBuD4b0fRyZzpYgUAZ4HmgJNgOclay7OjiOTeTMzn0dW6HimCbBFVbepagwwCege4JiSUNX9qrrc9fNpnB84ZXDGOd612XjghoAEmAIRKQtcD4x1LQvQHvjOtUnQxCsiBYE2wKcAqhqjqicI4vfXJQrILSJRQB5gP0H0HqvqAuBYstWpvafdgS/UaRFQSERKZUmgLinFq6q/qGqca3ERUNb1c3dgkqpeVNXtwBacnyXGhIJwzHsB/wxJzMscmPg1fQdc7do+IDKQE4Pqvce73Bjw995HufJaYI6qHlPV4ziLjeQFSJbEnoG8meHPIyt0PFMG2J1oeY9rXVByNateCSwGSqjqftdTB4ASgYorBe8CTwMO13JR4ESiP/5gep8rAYeBz13dDMaKSF6C+P1V1b3A28AunB/iJ4FlBO97nCC19zQU/h3eDcx0/RwK8RqTmpD6+/Uw7wXba3oXz3OgO3bX8ydd2weKtzkxaN77DOTGYHvvE3j7XgfN7yAZT/JmhmO3QifMiEg+YArwqKqeSvycOofYC4ph9kSkC3BIVZcFOhYPRQENgI9U9UrgLMm6qQXT+wvgapLujjMhlQbykgVXb3wp2N7TtIjIMJxdaSYGOhZjspNQyXuJhWAOTC7kcmKCcMiNyQXre52erMibVuh4Zi9QLtFyWde6oCIiOXB+2E9U1e9dqw8mNA+7/n8oUPEl0xLoJiI7cDZBtsfZ37eQqykZgut93gPsUdXFruXvcH7IB+v7C9AB2K6qh1U1Fvge5/serO9xgtTe06D9dygidwFdgNv1vzH7gzZeYzwQEn+/Xua9YHpN3uZAd+yu5wsCR7My4GS8zYnB9N57mxuD7b1P4O17HUy/A2/zZoZjt0LHM0uAaq4ROXLivFFqWoBjSsLVX/RTYIOqvpPoqWlAwsgafYEfszq2lKjqEFUtq6oVcb6f81T1dmA+0NO1WTDFewDYLSLVXauuBtYTpO+vyy6gmYjkcf19JMQclO9xIqm9p9OAPq4RZZoBJxM12weMiHTC2f2km6qeS/TUNOBWcY7YUwnnjaH/BCJGYzIgHPNe0HyGZCAHJn5NPV3bB+wKfgZyYtC893ifG4PqvU/E2/d6NnCNiBR2tWpd41qX5TKQNzP+eaSq9vDgAVyHc2SIrcCwQMeTQnytcDZbrgZWuh7X4exH+iuwGZgLFAl0rCnE3g6Y7vq5suuPegvwLRAd6PgSxVkfWOp6j38ACgf7+wu8CGwE1gJfAtHB9B4DX+PsIx2L8wrhPam9p4DgHHVlK7AG54g5wRDvFpx9hxP+3Y1OtP0wV7z/Ap0D/fdgD3t48wi3vBcMnyGpvI50cyCQy7W8xfV85SCI2+OcGGzvvTe5MRjee1/lSpz3w2xxPfoFMHav82ZGP4/EtbMxxhhjjDHGhA3rumaMMcYYY4wJO1boGGOMMcYYY8KOFTrGGGOMMcaYsGOFjjHGGGOMMSbsWKFjjDHGGGOMCTtW6BhjjDHGGGPCjhU6xhhjjDHGmLBjhY4xPiYitUTkLhEpJyL5Ax2PMcYY42uW60wosELHGN/LATwE9ADOJH9SRCqKyHkRWenrE4tIbhFZKSIxIlLM18c3xhiT/YhIWRHplWx1pnOd5Szjb1boGON75YDPgS1Aale5tqpqfV+fWFXPu467z9fHNsYYk21dDTRIti7Tuc5ylvE3K3SMySARmee6ErVSRC6IyC0Aqjod+E5VZ6jqKQ+OU1FENorIOBHZJCITRaSDiPwpIptFpIk32xljjDG+IiKtgHeAnq58VxkylOvyisjPIrJKRNam0EJkjM9ZoWNMBqlqe9eVqI+BacCURM8d8PJwVYH/A2q4HrcBrYAngaEZ2M4YY4zJNFX9A1gCdFfV+qq6LdFz3uS6TsA+Va2nqrWBWT4O1ZhLWKFjTCaISB+gM3C7qsZn4lDbVXWNqjqAdcCvqqrAGqBiBrYzxhhjfKU6sDGTx1gDdBSR4SLSWlVP+iAuY9JkhY4xGSQiNwO3A7eoamwmD3cx0c+ORMsOICoD2xljjDGZ5hok4KSqxmXmOKq6Ced9PmuAV0TkOV/EZ0xa7IuRMRkgIl2AB4Auqnoh0PEYY4wxflIRHwwWICKlgWOqOkFETgD3ZvaYxqTHWnSMyZjxQFngT9fNmfcEOiBjjDHGDzYCxVwDCLTIxHHqAP+4hpt+HnjFF8EZkxZxdu83xmQVEakITHfdjOmvc+wAGqnqEX+dwxhjjEmNN7nOcpbxF2vRMSbrxQMF/TlhKM6J3By+Pr4xxhjjoXRzneUs42/WomOMMcYYY4wJO9aiY4wxxhhjjAk7VugYY4wxxhhjwo4VOsYYY4wxxpiwY4WOMcYYY4wxJuxYoWOMMcYYY4wJO1boGGOMMcYYY8KOFTrGGGOMMcaYsGOFjjHGGGOMMSbsWKFjjDHGGGOMCTv/DwR3QonpGxwJAAAAAElFTkSuQmCC", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAAKSCAYAAABWc4s6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3xUVfr/3/dOOiEJCSUJEIiCNFERFQFRVKSI2FBBUUH5wopgWRuiYl3FhV11baCuK+5P1LWBygIrgjRFOkoTAUPREFoIIaTO3PP7Y2bu9GRmMklIeN4vMTOnPefce+ZmzifPeY6mlFIIgiAIgiAIgiAIgiAIpzR6XXdAEARBEARBEARBEARBqHtEJBIEQRAEQRAEQRAEQRBEJBIEQRAEQRAEQRAEQRBEJBIEQRAEQRAEQRAEQRAQkUgQBEEQBEEQBEEQBEFARCJBEARBEARBEARBEAQBEYkEQRAEQRAEQRAEQRAERCQSBEEQBEEQBEEQBEEQEJFIEARBEARBEARBEARBoAGLREeOHKF58+bs3r07qPKPPvoo99xzT812ShAEQRAEoYHi/t1ryZIlaJpGQUFBwPILFizgnHPOwTCM2uukIAiCIAiV0mBFoueff55rrrmGtm3bBlX+oYce4v333+e3336r2Y4JgiAIgiA0QEL97jVw4ECio6OZNWtWzXZMEARBEISgiarrDtQExcXFvPvuu/zvf/8Luk7Tpk0ZMGAA06dPZ9q0aTXYO0EQBEEQhIZFON+9AEaNGsWrr77KbbfdVkM984/NZqOioqJWbQqCIAhCuMTExKDrtePj0yBFonnz5hEbG8uFF14I2L8IjB07lsWLF5OXl0dWVhZ333039913n0e9IUOG8Pjjj4tIJAiCIAiCEALe372cfP/990yaNIlff/2Vc845h3/+85+ceeaZZv6QIUOYMGECu3bt4vTTT6/xfiqlyMvLq3QbnCAIgiCcbOi6TnZ2NjExMTVuq0GKRMuXL6d79+7me8MwaNWqFZ9++ilpaWn88MMPjB07loyMDG666Saz3AUXXMDvv//O7t27g3aVFgQhPGbOnEnbtm3p27dvXXel2pSVlTFu3Di+/fZbCgoK6Ny5My+//DI9e/as664JgiDUCt7fvZw8/PDD/OMf/yA9PZ3HHnuMIUOG8OuvvxIdHQ1AVlYWLVq0YPny5bUiEjkFoubNm5OQkICmaTVuUxAEQRCqg2EY5Obmsn//frKysmr8d1eDFIn27NlDZmam+T46OppnnnnGfJ+dnc3KlSv55JNPPEQiZ509e/aISCQINcSHH36IxWIB7H/Rfe211+jcuTOXX355HfcsfKxWK23btmXFihW0atWKTz75hCFDhrB7924SExPrunuCIAg1jvd3LydPPfUUV1xxBQDvv/8+rVq1Yvbs2T7fv/bs2VPjfbTZbKZAlJaWVuP2BEEQBCFSNGvWjNzcXKxWq/mHlpqiQQauLikpIS4uziPtjTfeoHv37jRr1ozExETefvtt9u7d61EmPj4esO+rFwShZhg2bBh5eXm88sorPPbYY6SkpAQlEI0aNQpN09A0zWOrwslAo0aNePLJJ8nKykLXdYYPH05MTAzbt283y7zyyitm/zVN4/Dhw3XYY0EQhMji77sX4OFRmZqaSocOHdi2bZtHmfj4+Fr57uWMQZSQkFDjtgRBEAQhkji3mdlsthq31SBFoqZNm3L06FHz/ccff8xDDz3E6NGj+eabb9i4cSN33HEH5eXlHvXy8/MBu0onCELN4XSR1DTN9CoKhqZNm/L//t//48UXXwxY5s0330TTNHr06FFpW4Zh0KxZM6ZOnRq0/WDZsWMH+fn5tGvXzkwbOHAg/+///T+uu+66iNsTBEGoa7y/e4VCfn5+rX73ki1mgiAIQn2jNn93NcjtZt26deODDz4w33///ff06tWLu+++20zbtWuXT73NmzcTHR1Nly5daqWfgtDQOHjwIPPmzWPr1q0cPXrU/Kvt6aefzuTJkwH4z3/+Q/Pmzbn//vtp06YNmzZtYtGiRUF5EzVq1Ihbb7210jKzZs2ibdu2rF69mp07d3oINe6sXr2aw4cPM3jw4BBHWTklJSXceuutTJo0ieTkZDO9Y8eOdOzYkZ07dzJ79uyI2hQEQahrvL97Ofnxxx/JysoC4OjRo/z666906tTJzC8tLWXXrl1069at1voqCIIgCEJgGqQn0YABA9iyZYv5F6327duzdu1a/ve///Hrr78yefJk1qxZ41Nv+fLl9OnTx9x2JghC8LzyyivcdtttrF69mvfee49//vOfHDhwgGeeeYYnnnjCLHfLLbcwfPhwwK6I33vvvRGLR5STk8MPP/zASy+9RLNmzZg1a1bAsvPmzaNNmzYRFYUrKiq48cYbadeuHU8++WTE2hUEQTjZ8f7u5eTZZ59l0aJFbN68mVGjRtG0aVOuvfZaM//HH38kNja23gX6t9lsLFmyhI8++oglS5bUivt/Xl4e99xzD6eddhqxsbG0bt2aIUOGsGjRIrPMDz/8wJVXXkmTJk2Ii4uja9euvPTSSz79c259/vHHHz3Sy8rKSEtLQ9M0lixZYqYvXbqUyy67jNTUVBISEmjfvj0jR4708Mq32Wy8/PLLdO3albi4OJo0acKgQYP4/vvvPWzMnDmTlJSUyF0Y4aRm2bJlDBkyhMzMTDRNY86cOXViwz1sQXR0NC1atOCKK67gX//6F4ZhRLxPwslBsPe9bdu2HmEhNE2jVatWPvnez8z777/f5xCewsJCHn/8cTp27EhcXBzp6en069ePL774AqWUWW7nzp3ccccdtGrVitjYWLKzs7n55ptZu3ZtzVyMEGiQIlHXrl0599xz+eSTTwD405/+xPXXX8+wYcPo0aMHR44c8fAqcvLxxx8zZsyY2u6uINR7Vq5cyXnnncf//vc/3nzzTc4991w0TeOtt96iTZs2ft0jR40aFfGTzWbNmkWTJk0YPHgwN9xwQ6Ui0X//+18PL6Knn34aTdP49ddfufXWW0lOTqZZs2ZMnjwZpRT79u3jmmuuISkpifT0dP7+9797tGcYBrfddhuapvH+++/LdgZBEE4pvL97OXnxxRe577776N69O3l5eXz99dcex/d+9NFHjBgxol7FCfriiy9o164dl156KbfccguXXnop7dq144svvqgxm7t376Z79+4sXryYadOmsWnTJhYsWMCll17K+PHjAZg9ezaXXHIJrVq14rvvvuOXX37hvvvu4y9/+QvDhw/3WJwAtG7dmvfee88jbfbs2T4HLmzdupWBAwdy3nnnsWzZMjZt2sRrr71GTEyMKT4ppRg+fDjPPvss9913H9u2bWPJkiW0bt2avn371ogwINQPTpw4wdlnn80bb7wRct2+ffsyc+bMiNkYOHAg+/fvZ/fu3cyfP59LL72U++67j6uuugqr1Rpy/4T6QbD3/dlnn2X//v3mvw0bNni0ExcXx8SJEyu1VVBQQK9evfj3v//NpEmTWL9+PcuWLWPYsGE88sgjHDt2DIC1a9fSvXt3fv31V9566y22bt3K7Nmz6dixIw8++GDkL0KoqAbK3LlzVadOnZTNZguq/Lx581SnTp1URUVFDfdMEBo2ZWVlqlGjRqp79+4RbXfkyJGqTZs2lZbp2LGjGj16tFJKqWXLlilArV692qfc/v37laZpau7cuWbaU089pQB1zjnnqJtvvlm9+eabavDgwQpQL730kurQoYMaN26cevPNN1Xv3r0VoJYuXWrW/7//+z918cUXq5KSkkr76LRz6NChEEYvCIJw8hPqd69Dhw6p1NRU9dtvv9Vwz+yUlJSorVu3VvmcrozPP/9caZqmhgwZolauXKmOHz+uVq5cqYYMGaI0TVOff/55BHvsYtCgQaply5aqqKjIJ+/o0aOqqKhIpaWlqeuvv94n/6uvvlKA+vjjj800QD3xxBMqKSlJFRcXm+lXXHGFmjx5sgLUd999p5RS6uWXX1Zt27attH8ff/yxAtRXX33lk3f99dertLQ0s+/vvfeeSk5ODmbYQgMDULNnzw66/CWXXKLee++9iNgYOXKkuuaaa3zSFy1apAD1zjvvhGRHqB8Ee9/btGmjXn755YDttGnTRt17770qJiZG/fe//zXT77vvPnXJJZeY78eNG6caNWqk/vjjD582jh8/rioqKpRhGKpLly6qe/fufn9fHj161G8fIvE7LFgapCcRwODBgxk7dix//PFHUOVPnDjBe++9R1RUgwzTJAi1xvLlyzlx4gQDBw6sVbvr1q3jl19+MbeyXXTRRbRq1cqvN9G8efOIi4vjsssu88m74IIL+PDDDxk3bhxffvklrVq14sEHH+SOO+7gzTffZNy4ccydO5f4+Hj+9a9/Afajn//5z3+yevVqmjZtSmJiIomJiSxfvrxmBy0IgnASEep3r927d/Pmm2+SnZ1dwz2LDDabjQcffJCrrrqKOXPmcOGFF5KYmMiFF17InDlzuOqqq3jooYcivvUsPz+fBQsWMH78eBo1auSTn5KSwjfffMORI0d46KGHfPKHDBnCGWecwUcffeSR3r17d9q2bcvnn38OwN69e1m2bBm33XabR7n09HT279/PsmXLAvbxww8/5IwzzmDIkCE+eQ8++CBHjhxh4cKFQY1XqBqlFCdOnKj1f8rLG60hcNlll3H22WfXqCdgQ8XfvCgvL+fEiROUlZX5Leu+xauiooITJ05QWloaVNlIEs59z87O5q677mLSpEl+tygahsHHH3/MiBEjyMzM9MlPTEwkKiqKjRs3smXLFh588EF03VeOORm24zZYkQjsewRbt24dVNkbbrihytOQBEGomgULFgAwaNCgWrU7a9YsWrRowaWXXgrY4y0MGzaMjz/+2OcL+7x587j00kv9xh/7v//7P/O1xWLhvPPOQynF6NGjzfSUlBQ6dOjAb7/9BkCbNm1QSlFSUkJRUZH5r0+fPjUxVEEQhJOWUL57nXfeeQwbNqyGexQ5li9fzu7du3nsscd8vtjrus6kSZPIycmJ+B8Idu7ciVKKjh07Bizz66+/AngEBXenY8eOZhl37rzzTvMPHjNnzuTKK6/0OWnuxhtv5Oabb+aSSy4hIyOD6667jtdff53CwkIP+4FsO9P92RfCo7i42PyDVG3+Ky4uruuh1wgdO3Zk9+7ddd2NeodzXhw+fNhMmzZtGomJiUyYMMGjbPPmzUlMTGTv3r1m2htvvEFiYqLHd2ywx/9JTExk27ZtZlow2w5Dxfu+T5w40WO+v/rqqz51nnjiCXJycvz+Efrw4cMcPXq00mc12E9Bdto/WWnQIpEgCLXP/PnzadKkCRdeeGGt2bTZbHz88cdceuml5OTksHPnTnbu3EmPHj04cOCAR1DPiooKFi5cGPBUM+cpPE6Sk5OJi4ujadOmPunhHvcsCIIg1D/2798PwJlnnuk335nuLBcpQvHeCNXT49Zbb2XlypX89ttvzJw5kzvvvNOnjMVi4b333uP3339n6tSptGzZkhdeeIEuXbp4jLUhepkItcsLL7zgsUhfvnw5d911l0eau8gQKZRSEkvyFMT7vj/88MNs3LjR/Hf77bf71GnWrBkPPfQQTz75pEfgfmd7wdo92ZG9VYIgRIzff/+dLVu2cNNNN2GxWGrN7uLFi9m/fz8ff/wxH3/8sU/+rFmz6N+/PwArVqygsLCQK6+80m9b/vodaCz14SEvCIIgRIaMjAwANm/e7PcPIZs3b/YoFynat2+Ppmn88ssvAcucccYZAGzbto1evXr55G/bto3OnTv7pKelpXHVVVcxevRoSktLGTRoEMePH/dro2XLltx2223cdtttPPfcc5xxxhnMmDGDZ555hjPOOMPjr/7ett37KFSfhIQEioqK6sRuTXLXXXdx0003me9HjBjB0KFDuf766800f9t4qsu2bdvqzbbXkwnnHHSfFw8//DD333+/TwiXgwcPAnh48Y8fP54xY8b4fM92eve4lx01alQkuw743vemTZvSrl27Kus98MADvPnmm7z55pse6c2aNSMlJaXSZzW4noW//PIL3bp1C6PnNY94EgmCEDHmz58P1M1Ws+bNm/Ppp5/6/Lv55puZPXs2JSUlgP1Us86dO9O2bdta7aMgCIJQv+nTpw9t27blhRde8IlHYRgGU6ZMITs7O+JbjVNTUxkwYABvvPEGJ06c8MkvKCigf//+pKam+py8CfDVV1+xY8cObr75Zr/t33nnnSxZsoTbb7896D/wNGnShIyMDLM/w4cPZ8eOHXz99dc+Zf/+97+TlpbGFVdcEVTbQtVomkajRo1q/V9Ne9ukpqbSrl078198fDzNmzf3SIt0/NjFixezadMmhg4dGtF2TwX8zYuYmBgaNWpEbGys37LuW3Wjo6Np1KgRcXFxQZWNJNW574mJiUyePJnnn3/eQ1TXdZ3hw4cza9YscnNzfeoVFRVhtVo555xz6Ny5M3//+9/9xjYqKCgIuU+RRjyJBEGIGHPnzgVgwIABZtovv/xSo3tuS0pK+OKLL7jxxhu54YYbfPIzMzP56KOP+Oqrrxg2bBjz5s3jqquuqrH+CIIgCA0Ti8XC3//+d2644QauvfZaJk2axJlnnsnmzZuZMmUKc+fO5bPPPqsRT9o33niD3r17c8EFF/Dss89y1llnYbVaWbhwIdOnT2fbtm289dZbDB8+nLFjxzJhwgSSkpJYtGgRDz/8MDfccIOHh4Y7AwcO5NChQyQlJfnNf+utt9i4cSPXXXcdp59+OqWlpfz73/9my5YtvPbaa4BdJPr0008ZOXIk06ZN4/LLL6ewsJA33niDr776ik8//dQj6LbNZmPjxo0edmJjYwPGNRLqL0VFRezcudN8n5OTw8aNG0lNTfXZ4l/TNsrKysjLy8Nms3HgwAEWLFjAlClTuOqqq/xuLRIaBjVx38eOHcvLL7/Mhx9+6BHX+Pnnn2fJkiX06NGD559/nvPOO4/o6GiWL1/OlClTWLNmDSkpKbz33nv069ePPn368Pjjj9OxY0eKior4+uuv+eabb1i6dGmkhh8WIhIJghARfvnlF+bNm0dUVBS7du1i69atfP755wwdOrRGRaKvvvqK48ePc/XVV/vNv/DCC2nWrBmzZs3iggsuYNu2bUyfPr3G+iMIgiA0XK6//no+++wzHnzwQY9tXdnZ2Xz22Wce22IiyWmnncb69et5/vnnefDBB9m/fz/NmjWje/fu5u+0G264ge+++47nn3+ePn36UFpaSvv27Xn88ce5//77A3qBaJrmE3fPnQsuuIAVK1Zw1113kZubS2JiIl26dGHOnDlccsklZhuffPIJr7zyCi+//DJ33303cXFx9OzZkyVLltC7d2+PNouKiny2WZx++ukeC32hYbB27VrzUBGwb9UBGDlyZMSCEQdrY8GCBWRkZBAVFUWTJk04++yzefXVVxk5cqTfU6aEhkFN3Pfo6Giee+45brnlFo/01NRUfvzxR1588UX+8pe/sGfPHpo0aULXrl2ZNm0aycnJgP25unbtWp5//nnGjBnD4cOHycjIoFevXrzyyivVHXK10ZQE1RAEoRqsW7eOv/71ryxcuJCCggLi4+PJyspi0KBBPPLIIxGLzTBq1CiWLFnic/rE1VdfzcKFCzly5EjAvfJ33HEHs2bN4qmnnmLatGkcPnzYx1356aef5plnnuHQoUMeX5ZHjRrFZ5995rP3v2/fvhw+fNiMQREsgewIgiAINUtpaSk5OTlkZ2f7bG8IFZvNxvLly9m/fz8ZGRn06dOnVmPxCYIgCKcWkfwdVhUiEgmCUC8YNWoUixcvZv369URFRZGSkhJyG1deeSWJiYl88sknke9gFZSWllJUVMTUqVOZNm2aiESCIAi1TG1+wRYEQRCESFKbv8Nku5kgCPWGffv20axZM7p06RKyBw/YvX8iHVA0WGbMmMGf//znOrEtCIIgCIIgCIIQDOJJJAhCvWDr1q3mSQGJiYl+jx8+mdm3bx/bt283319yySURP6lBEARBCIx4EgmCIAj1FfEkEgRB8KJz58507ty5rrsRNq1bt6Z169Z13Q1BEARBEARBEISASBh3QRAEQRAEQRAEQRAEQUQiQRAEQRAE4dRBIi0IgiAI9Y3a/N0lIpEgCIIgCILQ4HHGgSsuLq7jngiCIAhCaJSXlwNgsVhq3JbEJBIEQRAEQRAaPBaLhZSUFA4ePAhAQkICmqbVca8EQRAEoXIMw+DQoUMkJCQQFVXzEo6IRIIgCIIgCMIpQXp6OoApFAmCIAhCfUDXdbKysmrljxuako3ZgiAIgiAIwimEzWajoqKirrshCIIgCEERExODrtdOtCARiQRBEARBEARBEARBEAQJXC0IgiAIgiAIgiAIgiCISCQIgiAIgiAIgiAIgiAgIpEgCIIgCIIgCIIgCIKAiESCIAiCIAiCIAiCIAgCIhIJgiAIgiAIgiAIgiAIiEgkCIIgCIIgCIIgCIIgICKRIAiCIAiCIAiCIAiCgIhEgiAIgiAIgiAIgiAIAiISNQjatm2Lpmk+/8aPHw/A22+/Td++fUlKSkLTNAoKCoJq94033qBt27bExcXRo0cPVq9e7ZFfWlrK+PHjSUtLIzExkaFDh3LgwIFID8+HmhjvlClTOP/882ncuDHNmzfn2muvZfv27R5l+vbt62PzrrvuqokhelAT43366ad92uvYsaNHmYZ0f6tqE07O+5ufn88999xDhw4diI+PJysri3vvvZdjx45V2qZSiieffJKMjAzi4+Pp168fO3bs8CiTn5/PiBEjSEpKIiUlhdGjR1NUVFSTQwUiP96KigomTpxI165dadSoEZmZmdx+++3k5uZWaffFF1+s6eHWyP0dNWqUT3sDBw70KFNX91cQBEEQBEGo34hI1ABYs2YN+/fvN/8tXLgQgBtvvBGA4uJiBg4cyGOPPRZ0m//5z3944IEHeOqpp1i/fj1nn302AwYM4ODBg2aZP//5z3z99dd8+umnLF26lNzcXK6//vrIDs4PNTHepUuXMn78eH788UcWLlxIRUUF/fv358SJEx7lxowZ42F76tSpkRtYAGpivABdunTxaHfFihUe+Q3p/lbVppOT7f7m5uaSm5vL3/72NzZv3szMmTNZsGABo0ePrrTNqVOn8uqrrzJjxgxWrVpFo0aNGDBgAKWlpWaZESNGsGXLFhYuXMjcuXNZtmwZY8eOrdGxQuTHW1xczPr165k8eTLr16/niy++YPv27Vx99dU+ZZ999lkP2/fcc0+NjdNJTdxfgIEDB3q0+9FHH3nk19X9FQRBEARBEOo5Smhw3Hfffer0009XhmF4pH/33XcKUEePHq2yjQsuuECNHz/efG+z2VRmZqaaMmWKUkqpgoICFR0drT799FOzzLZt2xSgVq5cGZmBBEkkxuvNwYMHFaCWLl1qpl1yySXqvvvuq2Zvq08kxvvUU0+ps88+O2B+Q7+//to82e+vk08++UTFxMSoiooKv/mGYaj09HQ1bdo0M62goEDFxsaqjz76SCml1NatWxWg1qxZY5aZP3++0jRN/fHHHxEcTdVUd7z+WL16tQLUnj17zLQ2bdqol19+ubrdrTaRGO/IkSPVNddcEzD/ZLq/giAIgiAIQv1CPIkaGOXl5XzwwQfceeedaJoWdhvr1q2jX79+Zpqu6/Tr14+VK1cCsG7dOioqKjzKdOzYkaysLLNMbRCJ8frDud0jNTXVI33WrFk0bdqUM888k0mTJlFcXBwxm8EQyfHu2LGDzMxMTjvtNEaMGMHevXvNvIZ8fytrsz7c32PHjpGUlERUVJTf/JycHPLy8jzuXXJyMj169DDv3cqVK0lJSeG8884zy/Tr1w9d11m1alUER1Q5kRhvoDqappGSkuKR/uKLL5KWlka3bt2YNm0aVqu1Ot0PmUiOd8mSJTRv3pwOHTowbtw4jhw5YuadLPdXEARBEARBqH8E/61bqBfMmTOHgoICRo0aFXYbhw8fxmaz0aJFC4/0Fi1a8MsvvwCQl5dHTEyMzyKsRYsW5OXlhW07VCIxXm8Mw+D++++nd+/enHnmmWb6LbfcQps2bcjMzOTnn39m4sSJbN++nS+++CJitqsiUuPt0aMHM2fOpEOHDuzfv59nnnmGPn36sHnzZho3btyg72+gNuvD/T18+DDPPfdcpduGnPfH3+fXmZeXl0fz5s098qOiokhNTT2p7m8w4/WmtLSUiRMncvPNN5OUlGSm33vvvZx77rmkpqbyww8/MGnSJPbv389LL71U3WEETaTGO3DgQK6//nqys7PZtWsXjz32GIMGDWLlypVYLJaT5v4KgiAIgiAI9Q8RiRoY7777LoMGDSIzM7Ouu1Ir1MR4x48fz+bNm31i9Lgv3Lp27UpGRgaXX345u3bt4vTTT4+Y/cqI1HgHDRpkvj7rrLPo0aMHbdq04ZNPPgkqHkptURP3N1CbJ/v9LSwsZPDgwXTu3Jmnn366VvpT00R6vBUVFdx0000opZg+fbpH3gMPPGC+Puuss4iJieFPf/oTU6ZMITY2tlrjCJZIjXf48OHm665du3LWWWdx+umns2TJEi6//PJId1sQBEEQBEE4hZDtZg2IPXv28O233/J///d/1WqnadOmWCwWn5OsDhw4QHp6OgDp6emUl5f7nCzlXqamidR43ZkwYQJz587lu+++o1WrVpWW7dGjBwA7d+6MmP3KqInxOklJSeGMM84wx9JQ728obZ5M9/f48eMMHDiQxo0bM3v2bKKjowO247w/VX1+3YPQA1itVvLz80+K+xvKeJ04BaI9e/awcOFCDy8if/To0QOr1cru3bvDHUJIRHq87px22mk0bdrU4/Nb1/dXEARBEARBqJ+ISNSAeO+992jevDmDBw+uVjsxMTF0796dRYsWmWmGYbBo0SJ69uwJQPfu3YmOjvYos337dvbu3WuWqWkiNV6wHxk+YcIEZs+ezeLFi8nOzq6yzsaNGwHIyMiotv1giOR4vSkqKmLXrl3mWBra/Q2nzZPl/hYWFtK/f39iYmL46quviIuLq7Sd7Oxs0tPTPe5dYWEhq1atMu9dz549KSgoYN26dWaZxYsXYxiGKY7VNJEaL7gEoh07dvDtt9+SlpZWZZ2NGzei67rPtqyaIpLj9eb333/nyJEj5lw9Ge6vIAiCIAiCUE+p68jZQmSw2WwqKytLTZw40Sdv//79asOGDeqdd95RgFq2bJnasGGDOnLkiFnmsssuU6+99pr5/uOPP1axsbFq5syZauvWrWrs2LEqJSVF5eXlmWXuuusulZWVpRYvXqzWrl2revbsqXr27FmzA3UQ6fGOGzdOJScnqyVLlqj9+/eb/4qLi5VSSu3cuVM9++yzau3atSonJ0d9+eWX6rTTTlMXX3xxzQ9WRX68Dz74oFqyZInKyclR33//verXr59q2rSpOnjwoFmmId3fqto8We/vsWPHVI8ePVTXrl3Vzp07Peam1Wo1y3Xo0EF98cUX5vsXX3xRpaSkqC+//FL9/PPP6pprrlHZ2dmqpKTELDNw4EDVrVs3tWrVKrVixQrVvn17dfPNN9f8YFVkx1teXq6uvvpq1apVK7Vx40aPOmVlZUoppX744Qf18ssvq40bN6pdu3apDz74QDVr1kzdfvvt9W68x48fVw899JBauXKlysnJUd9++60699xzVfv27VVpaalZpy7vryAIgiAIglB/EZGogfC///1PAWr79u0+eU899ZQCfP699957Zpk2bdqop556yqPea6+9prKyslRMTIy64IIL1I8//uiRX1JSou6++27VpEkTlZCQoK677jq1f//+mhieD5Eer7/y7nX27t2rLr74YpWamqpiY2NVu3bt1MMPP6yOHTtWwyO1E+nxDhs2TGVkZKiYmBjVsmVLNWzYMLVz506PdhvS/a2qzZP1/n733XcB52ZOTo5Zznv8hmGoyZMnqxYtWqjY2Fh1+eWX+7R95MgRdfPNN6vExESVlJSk7rjjDnX8+PGaHKZJJMebk5MTsM53332nlFJq3bp1qkePHio5OVnFxcWpTp06qRdeeMFDVKkv4y0uLlb9+/dXzZo1U9HR0apNmzZqzJgxHgK+UnV7fwVBEARBEIT6i6aUUtV2RxIEQRAEQRCEeoLNZqOioqKuuyEIgiAIQRETE4Ou1060IDndTBAEQRAEQTglUEqRl5fnczCDIAiCIJzM6LpOdnY2MTExNW5LPIkEQRAEQRCEU4L9+/dTUFBA8+bNSUhIQNO0uu6SIAiCIFSKYRjk5uYSHR1NVlZWjf/uEk8iQRAEQRAEocFjs9lMgSiYUxAFQRAE4WShWbNm5ObmYrVaiY6OrlFbtbOpTRAEQRAEQRDqEGcMooSEhDruiSAIgiCEhnObmc1mq3FbIhIJgiAIgiAIpwyyxUwQBEGob9Tm7y4RiQRBEARBEARBEARBEAQRiQQ7ZWVlPP3005SVldV1V2qNU23MMt6GjYy3YXOqjVcQBE+mTJnC+eefT+PGjWnevDnXXnst27dv9yhTWlrK+PHjSUtLIzExkaFDh3LgwAGPMnv37mXw4MEkJCTQvHlzHn74YaxWa20ORWig/PHHH9x6662kpaURHx9P165dWbt2rZmvlOLJJ58kIyOD+Ph4+vXrx44dOzzayM/PZ8SIESQlJZGSksLo0aMpKiqq7aEIDYxly5YxZMgQMjMz0TSNOXPm+JSJ1Pz8+eef6dOnD3FxcbRu3ZqpU6fW5NBqDBGJBMC+AHnmmWdOqQXIqTZmGW/DRsbbsDnVxisIgidLly5l/Pjx/PjjjyxcuJCKigr69+/PiRMnzDJ//vOf+frrr/n0009ZunQpubm5XH/99Wa+zWZj8ODBlJeX88MPP/D+++8zc+ZMnnzyyboYktCAOHr0KL179yY6Opr58+ezdetW/v73v9OkSROzzNSpU3n11VeZMWMGq1atolGjRgwYMIDS0lKzzIgRI9iyZQsLFy5k7ty5LFu2jLFjx9bFkIQGxIkTJzj77LN54403ApaJxPwsLCykf//+tGnThnXr1jFt2jSefvpp3n777RodX42gBEEpdezYMQWoY8eO1XVXao1Tbcwy3oaNjLdhc6qNVxBqgpKSErV161ZVUlJS112pNgcPHlSAWrp0qVJKqYKCAhUdHa0+/fRTs8y2bdsUoFauXKmUUmrevHlK13WVl5dnlpk+fbpKSkpSZWVlfu2UlZWp8ePHq/T0dBUbG6uysrLUCy+8UIMjE+ojEydOVBdddFHAfMMwVHp6upo2bZqZVlBQoGJjY9VHH32klFJq69atClBr1qwxy8yfP19pmqb++OOPgO0+9dRTqnXr1iomJkZlZGSoe+65J0KjEhoigJo9e7ZHWqTm55tvvqmaNGni8TydOHGi6tChQ8D+5Ofnq1tuuUU1bdpUxcXFqXbt2ql//etffsvW5u+wqLqRpgRBEARBEAShblFKUVxcXOt2ExISqhWE9NixYwCkpqYCsG7dOioqKujXr59ZpmPHjmRlZbFy5UouvPBCVq5cSdeuXWnRooVZZsCAAYwbN44tW7bQrVs3HzuvvvoqX331FZ988glZWVns27ePffv2hd1vITSUUlhLyuvEdlR8TNBz9KuvvmLAgAHceOONLF26lJYtW3L33XczZswYAHJycsjLy/OYn8nJyfTo0YOVK1cyfPhwVq5cSUpKCuedd55Zpl+/fui6zqpVq7juuut87H7++ee8/PLLfPzxx3Tp0oW8vDx++umnao5cCBalFNhq//kJgKV6z1B3IjU/V65cycUXX2yeQgb2Z+xf//pXjh496uFZ52Ty5Mls3bqV+fPn07RpU3bu3ElJSUlExlUdRCSqQ0pLSykvr5sHvzeFhYUeP08FTrUxy3gbNjLehk19GG9MTAxxcXF13Q1BCIni4mISE1Nq3W5RUQGNGjUKq65hGNx///307t2bM888E4C8vDxiYmJISUnxKNuiRQvy8vLMMu4CkTPfmeePvXv30r59ey666CI0TaNNmzZh9VkID2tJOW91u69ObP9pwz+ITogNquxvv/3G9OnTeeCBB3jsscdYs2YN9957LzExMYwcOdKcX/7mn/v8bN68uUd+VFQUqamplc7P9PR0+vXrR3R0NFlZWVxwwQWhDlUIF1sxxifNqy5XA+g3HYSo8J6h3kRqfubl5ZGdne3ThjPPn0i0d+9eunXrZopPbdu2rf6AIoCIRHVEaWkpCfHNURyv66540Lp167ruQq1zqo1ZxtuwkfE2bE7m8aanp5OTkyNCkSDUMOPHj2fz5s2sWLGixm2NGjWKK664gg4dOjBw4ECuuuoq+vfvX+N2hfqFYRicd955vPDCCwB069aNzZs3M2PGDEaOHFljdm+88UZeeeUVTjvtNAYOHMiVV17JkCFDiIqSJa5QPxg3bhxDhw5l/fr19O/fn2uvvZZevXrVdbdEJKorysvLURynUeyjRCn7F2odu8ucBQ2L0j3SdDQsbq+dPzWF4zU+ec7Xmkeao5zyzNPc89zb905TftLMUbnZVK4yupnrWV73KOcq496eMy9QG1qAPFcf3VvyLk+l5XXNq5zbe818rcw8Vzl7mllG803TNdD8pDkNuMorP21Unubsg5mmu/I0n/Kun/7a8i6nV9aGrnzScOuH73XxLV91Gl5jCmQTnza8+1OlTb2yNnzzXNcBs5wd/+2je6f5txX42vred/z0B7d++aS59QOfPuLTR/ex+Ou/T3nNda/82fTuN377rXweFB5lvG26lfdo3/yA+mvfT55XOdzuq3cfPR9mrrE7XyvvOeFh07ePyr0NZxlHOVVVmvO92ZYrz6ecrvlpQzPf+5Z375vn2I4XVdDl9H2Ul5eLSCTUKxISEigqKqgTu+EwYcIEM2Bqq1atzPT09HTKy8spKCjw8CY6cOAA6enpZpnVq1d7tOc8/cxZxptzzz2XnJwc5s+fz7fffstNN91Ev379+Oyzz8LqvxAaUfEx/GnDP+rMdrBkZGTQuXNnj7ROnTrx+eefA675deDAATIyMswyBw4c4JxzzjHLHDx40KMNq9VKfn5+wPnZunVrtm/fzrfffsvChQu5++67mTZtGkuXLiU6Ojro/gthYkmwe/TUke1IEan5mZ6e7nOiZFXP2EGDBrFnzx7mzZvHwoULufzyyxk/fjx/+9vfIjK2cBGRqI7RiEXTPEUiu7DiKxK5v3al4ZPmXd6vSORVPmiRyG8abm0423OVCSwSubfl3oZvedc6KjyRyG95jYDlqxKJXK8jKRJVIv7okRGJfMtXIhLpvuU82g1CJHIXK/yKRD5CQ5AiTiUikVaZSFRFH4MXiSppw0sQCNR+REUiP0JMsCKRXxGHQKJPqCJRgPYDiUR6DYlEHm1EQCTyl1ddkcgtrXKRSPlJ82xL6a7Bhy0S+S3vTyRy9kcOSxXqJ5qmhb3tqzZRSnHPPfcwe/ZslixZ4rOloXv37kRHR7No0SKGDh0KwPbt29m7dy89e/YEoGfPnjz//PMcPHjQ3DaxcOFCkpKSfBb47iQlJTFs2DCGDRvGDTfcwMCBA8nPzzfjIQk1h6ZpQW/5qkt69+7N9u3bPdJ+/fVXc3tidnY26enpLFq0yFx0FxYWsmrVKsaNGwfY52dBQQHr1q2je/fuACxevBjDMOjRo0dA2/Hx8QwZMoQhQ4Ywfvx4OnbsyKZNmzj33HNrYKSCO5qmRWzLV10SqfnZs2dPHn/8cSoqKkyRcuHChXTo0MHvVjMnzZo1Y+TIkYwcOZI+ffrw8MMPi0gkCIIgCIIgCEJgxo8fz4cffsiXX35J48aNzRgYycnJxMfHk5yczOjRo3nggQdITU0lKSmJe+65h549e3LhhRcC0L9/fzp37sxtt93G1KlTycvL44knnmD8+PHExvoXIl566SUyMjLo1q0buq7z6aefkp6e7hP7SDi1+fOf/0yvXr144YUXuOmmm1i9ejVvv/22efS3pmncf//9/OUvf6F9+/ZkZ2czefJkMjMzufbaawG759HAgQMZM2YMM2bMoKKiggkTJjB8+HAyMzP92p05cyY2m40ePXqQkJDABx98QHx8vMTOEjwoKipi586d5vucnBw2btxIamoqWVlZEZuft9xyC8888wyjR49m4sSJbN68mX/84x+8/PLLAfv25JNP0r17d7p06UJZWRlz586lU6dONXo9gkFEIkEQBEEQBEE4iZk+fToAffv29Uh/7733GDVqFAAvv/wyuq4zdOhQysrKGDBgAG+++aZZ1mKxMHfuXMaNG0fPnj1p1KgRI0eO5Nlnnw1ot3HjxkydOpUdO3ZgsVg4//zzmTdvHrp4DwpunH/++cyePZtJkybx7LPPkp2dzSuvvMKIESPMMo888ggnTpxg7NixFBQUcNFFF7FgwQKPLcqzZs1iwoQJXH755eZcfvXVVwPaTUlJ4cUXX+SBBx7AZrPRtWtXvv76a9LS0mp0vEL9Yu3atVx66aXm+wceeACAkSNHMnPmTCAy8zM5OZlvvvmG8ePH0717d5o2bcqTTz7J2LFjA/YtJiaGSZMmsXv3buLj4+nTpw8ff/xxhK9A6GhKKVXXnTgVKSwsJDk5mcTYp4giHsCMORRKTCLT0z/U7WbKs3wkYhJ5bDdz61el2828d3LIdjPZbibbzWS7mdfYZbuZq9zJut2ssKiCrGZ7OHbsGElJSQjCyUhpaSk5OTlkZ2dL7CxBEAShXlGbv8PkzwCCIAiCIAiCIAiCIAiCiESCIAiCIAiCIAiCIAiCiESCIAiCIAiCIAiCIAgCIhIJgiAIgiAIgiAIgiAIiEgkCIIgCIIgCIIgCIIgICKRIAiCIAiCIAiCIAiCgIhEgiAIgiAIgiAIgiAIAiISCYIgCIIgCIIgCIIgCIhIJAiCIAiCIAiCIAiCICAikSAIgiAIgiAIgiAIgoCIRIIgCIIgCIJQb3jxxRfRNI3777/fI720tJTx48eTlpZGYmIiQ4cO5cCBAx5l9u7dy+DBg0lISKB58+Y8/PDDWK3WWuy90BCx2WxMnjyZ7Oxs4uPjOf3003nuuedQSplllFI8+eSTZGRkEB8fT79+/dixY4dHO/n5+YwYMYKkpCRSUlIYPXo0RUVFtT0cQTjlEZFIEARBEARBEOoBa9as4a233uKss87yyfvzn//M119/zaeffsrSpUvJzc3l+uuvN/NtNhuDBw+mvLycH374gffff5+ZM2fy5JNP1uYQhAbIX//6V6ZPn87rr7/Otm3b+Otf/8rUqVN57bXXzDJTp07l1VdfZcaMGaxatYpGjRoxYMAASktLzTIjRoxgy5YtLFy4kLlz57Js2TLGjh1bF0MShFMaEYkEQRAEQRAE4SSnqKiIESNG8M4779CkSROPvGPHjvHuu+/y0ksvcdlll9G9e3fee+89fvjhB3788UcAvvnmG7Zu3coHH3zAOeecw6BBg3juued44403KC8v92uzvLycCRMmkJGRQVxcHG3atGHKlCk1PlahfvHDDz9wzTXXMHjwYNq2bcsNN9xA//79Wb16NWD3InrllVd44oknuOaaazjrrLP497//TW5uLnPmzAFg27ZtLFiwgH/+85/06NGDiy66iNdee42PP/6Y3Nxcv3aVUjz99NNkZWURGxtLZmYm9957b20NWxAaLCISCYIgCIIgCKckSilKTpTV+j/3bTjBMn78eAYPHky/fv188tatW0dFRYVHXseOHcnKymLlypUArFy5kq5du9KiRQuzzIABAygsLGTLli1+bb766qt89dVXfPLJJ2zfvp1Zs2bRtm3bkPsuhIdSCqO0pE7+hTJHe/XqxaJFi/j1118B+Omnn1ixYgWDBg0CICcnh7y8PI/5mZycTI8ePTzmZ0pKCuedd55Zpl+/fui6zqpVq/za/fzzz3n55Zd566232LFjB3PmzKFr164hX2dBEDyJqusOCIIgCIIgCEJdUFpczlXN7691u3MPvkJ8o9igy3/88cesX7+eNWvW+M3Py8sjJiaGlJQUj/QWLVqQl5dnlnEXiJz5zjx/7N27l/bt23PRRRehaRpt2rQJus9C9VFlpey+xVcUrA3afvgtWlx8UGUfffRRCgsL6dixIxaLBZvNxvPPP8+IESMA1/zyN//c52fz5s098qOiokhNTa10fqanp9OvXz+io6PJysriggsuCGmcgiD4IiJRHaMoQykNAAP7Tw0NTTmdvDTzp+b22vnTKfI7tX7lyFNo5mvNI81Rzo9Np0Xdkaa7WTTTlJ80czSamaYpVxnXSDzL6x7lXGXc23PmBWpDC5Dn6qN7S17l3Wz7K+9d1/292x3w04byY9MzTXer692+ZxuOnwbojg5r5k//aWBPN9Nw5Wk+5V0/fdpSvuX0ytpQyicNt37oXn3UNIVm+Lblr33v8Wl64PJ2m/i04d2fKm3qlbXhm2e+9p5g+G8f3TvNvy3neH3zfO87fvqDW7980tz6gU8f8emj+1j89d+nvOa6V/5sevcbv/1WPg8KjzLeNt3Ke7RvftD8te8nz6uc+4PDu4+eDzPX2J2vlc9Dx92mbx+VexvOMo5yqqo053uzLVeeTzld89OGZr73Le/eN8+xHS8yEAShZti3bx/33XcfCxcuJC4urlZtjxo1iiuuuIIOHTowcOBArrrqKvr371+rfRBOfj755BNmzZrFhx9+SJcuXdi4cSP3338/mZmZjBw5ssbs3njjjbzyyiucdtppDBw4kCuvvJIhQ4YQFSVLXEGoDvIJqiNiYmJIT08nL+/Fuu6KEAhvL9vQPcMFQRBOGdLT04mJianrbghCSMQlxDD34Ct1YjdY1q1bx8GDBzn33HPNNJvNxrJly3j99dcpKysjPT2d8vJyCgoKPLyJDhw4QHp6OmD/jDpjxLjnO/P8ce6555KTk8P8+fP59ttvuemmm+jXrx+fffZZ0P0XwkeLjaPth9/Wme1gefjhh3n00UcZPnw4AF27dmXPnj1MmTKFkSNHmvPrwIEDZGRkmPUOHDjAOeecA9jn4MGDBz3atVqt5OfnB5yfrVu3Zvv27Xz77bcsXLiQu+++m2nTprF06VKio6NDGa4gCG6ISFRHxMXFkZOTEzBQoCAIgiDUJ2JiYmrdy0EQqoumaSFt+6oLLr/8cjZt2uSRdscdd9CxY0cmTpyIxWKhe/fuREdHs2jRIoYOHQrA9u3b2bt3Lz179gSgZ8+ePP/88xw8eNDc1rNw4UKSkpLo3LlzQPtJSUkMGzaMYcOGccMNNzBw4EDy8/NJTU2toRELTjRNC3rLV11SXFyMrnuGurVYLBiG3cs0Ozub9PR0Fi1aZIpChYWFrFq1inHjxgH2+VlQUMC6devo3r07AIsXL8YwDHr06BHQdnx8PEOGDGHIkCGMHz+ejh07smnTJg9RVRCE0BCRqA6Ji4uTL9SCIAiCIAhCQBo3bsyZZ57pkdaoUSPS0tLM9OTkZEaPHs0DDzxAamoqSUlJ3HPPPfTs2ZMLL7wQgP79+9O5c2duu+02pk6dSl5eHk888QTjx48nNta/UPbSSy+RkZFBt27d0HWdTz/9lPT0dJ/YR8KpzZAhQ3j++efJysqiS5cubNiwgZdeeok777wTsItd999/P3/5y19o37492dnZTJ48mczMTK699loAOnXqxMCBAxkzZgwzZsygoqKCCRMmMHz4cDIzM/3anTlzJjabjR49epCQkMAHH3xAfHy8xM4ShGoiIpEgCIIgCIIg1HNefvlldF1n6NChlJWVMWDAAN58800z32KxMHfuXMaNG0fPnj1p1KgRI0eO5Nlnnw3YZuPGjZk6dSo7duzAYrFw/vnnM2/ePB+vEeHU5rXXXmPy5MncfffdHDx4kMzMTP70pz/x5JNPmmUeeeQRTpw4wdixYykoKOCiiy5iwYIFHn8wnzVrFhMmTODyyy835/Krr74a0G5KSgovvvgiDzzwADabja5du/L111+TlpZWo+MVhIaOpsI5g1MQBEEQBEEQ6hGlpaXk5OSQnZ0tntyCIAhCvaI2f4fJnwEEQRAEQRAEQRAEQRAEEYkEQRAEQRAEQRAEQRAEEYkEQRAEQRAEQRAEQRAERCQSBEEQBEEQBEEQBEEQEJFIEARBEARBEARBEARBQEQiQRAEQRAE4RRCDvYVBEEQ6hu1+btLRCJBEARBEAShwRMdHQ1AcXFxHfdEEARBEEKjvLwcAIvFUuO2omrcgiAIgiAIgiDUMRaLhZSUFA4ePAhAQkICmqbVca8EQRAEoXIMw+DQoUMkJCQQFVXzEo6IRIIgCIIgCMIpQXp6OoApFAmCIAhCfUDXdbKysmrljxuako3ZgiAIgiAIwimEzWajoqKirrshCIIgCEERExODrtdOtCARiQRBEARBEARBEARBEAQJXC0IgiAIgiAIgiAIgiCISCQIgiAIgiAIgiAIgiAgIpEgCIIgCIIgCIIgCIKAiESCIAiCIAiCIAiCIAgCIhIJgiAIgiAIgiAIgiAIiEgkCIIgCIIgCIIgCIIgICKRIAiCIAiCIAiCIAiCgIhEgiAIgiAIgiAIgiAIAiISCYIgCIIgCIIgCIIgCDRAkWjZsmUMGTKEzMxMNE1jzpw5Zl5FRQUTJ06ka9euNGrUiMzMTG6//XZyc3M92sjPz2fEiBEkJSWRkpLC6NGjKSoq8ijz888/06dPH+Li4mjdujVTp06tjeEJgiAIgiAIgiAIgiDUCA1OJDpx4gRnn302b7zxhk9ecXEx69evZ/Lkyaxfv54vvviC7du3c/XVV3uUGzFiBFu2bGHhwoXMnTuXZcuWMXbsWDO/sLCQ/v3706ZNG9atW8e0adN4+umnefvtt2t8fIIgCIIgCIIgCIIgCDWBppRSdd2JmkLTNGbPns21114bsMyaNWu44IIL2LNnD1lZWWzbto3OnTuzZs0azjvvPAAWLFjAlVdeye+//05mZibTp0/n8ccfJy8vj5iYGAAeffRR5syZwy+//FIbQxMEQRAEQRAEQRAEQYgoDc6TKFSOHTuGpmmkpKQAsHLlSlJSUkyBCKBfv37ous6qVavMMhdffLEpEAEMGDCA7du3c/To0VrtvyAIgiAIgiAIgiAIQiSIqusO1CWlpaVMnDiRm2++maSkJADy8vJo3ry5R7moqChSU1PJy8szy2RnZ3uUadGihZnXpEkTH1tlZWWUlZWZ7w3DID8/n7S0NDRNi+i4BEEQBKGmUUpx/PhxMjMz0fVT/m9OQj3AMAxyc3Np3LixfPcSBEEQ6hW1+b3rlBWJKioquOmmm1BKMX369Bq3N2XKFJ555pkatyMIgiAItcm+ffto1apVXXdDEKokNzeX1q1b13U3BEEQBCFsauN71ykpEjkFoj179rB48WLTiwggPT2dgwcPepS3Wq3k5+eTnp5uljlw4IBHGed7ZxlvJk2axAMPPGC+P3bsGFlZWezbt8/DviAIgiDUBwoLC2ndujWNGzeu664IQlA456p89xIEQRDqG7X5veuUE4mcAtGOHTv47rvvSEtL88jv2bMnBQUFrFu3ju7duwOwePFiDMOgR48eZpnHH3+ciooKoqOjAVi4cCEdOnTwu9UMIDY2ltjYWJ/0pKQk+aIiCIIg1Ftk245QX3DOVfnuJQiCINRXauN7V4MLIlBUVMTGjRvZuHEjADk5OWzcuJG9e/dSUVHBDTfcwNq1a5k1axY2m428vDzy8vIoLy8HoFOnTgwcOJAxY8awevVqvv/+eyZMmMDw4cPJzMwE4JZbbiEmJobRo0ezZcsW/vOf//CPf/zDw1NIEARBEARBEARBEIRTD8Nm8Puq7fw6dw2/r9qOYTPquktBoymlVF13IpIsWbKESy+91Cd95MiRPP300z4Bp51899139O3bF4D8/HwmTJjA119/ja7rDB06lFdffZXExESz/M8//8z48eNZs2YNTZs25Z577mHixIlB97OwsJDk5GSOHTsmf80SBEEQ6h3ye0yob8icFQRBEGqDXd9sYMWLn3H8jyNmWuOWaVz06A2c3r9bWG3W5u+wBicS1Rfki4ogCIJQn5HfY0J9Q+asIAiCUNPs+mYD8+99m7Z9u3LeXQNJbZ9J/o5c1s5YwO4lmxj06tiwhKLa/B12ysUkOtnI2fI8iY1jMAwFSqEMhaEUCgUGoLC/Vwqw/1QoNKUAHTTQHJsGdXQ0QLNoaGj2/YqaMo/Is2gatgorFkuMwwYow96uoQyUAgxQCgwMUKAMA4W9DzoaGgqlaeg6OKyADroGmqajaY50i2bfy6gUyjDQtRgMlN3NTtn75WET+9G0KFA4bNoUuqahOYeqYR+f442ugaZrLpsa6LoGykBZdTSLBcOwt6tpmn3MhmFeW/t1BQyF0hz2HV6Aum7f66npoCkNTddd9nVz5Oi6jq6BslmBKDQtCsMwMBRoysBQmr1d7McWKsOw30vNcZ0N7P9TumMsCs1xH9E1c/yarjnsKjTNnq4MKxAHSsMw7FdNU2AowzFWHHYdNtFQNvu1Vco+X5RS6BYdlELXHPPJ7Xqa43Vcb8NqAy3eYcc+Hw37TXPNYce8Uua8tb83AF3Z76DjP9d11hzX1DmvNMf11XSs5QZ6dBzKcF5DhcKwXzYFYDiupdOW+/W2t4dzfjrG5WHTnDf2G67rYCtXaJZYlKHZ56OjffvcsY8RQ2FTjjE75pKhKbA5ZofS0C2Ast87lP1zorDfP90xjxSgaxoV5aBHxaJhd081cHwOnZ9JQ6E0x/iV/XNkH6vCUBbHE0XDotl/2o0pdM1in1eO8eqaDig0Tae0VCM6OgabcthxfvYM7O0aCg37OJVyPpMUNkOhKd1+HTTNnDuOmQu6jq4c11rX0ZT9GhsGVJTr6FHRjs+//R4pTeF4FJnPOvuzAgzs19Z+33X7E8AxRuWYI7jNF3uO5uiXhjIUJRUWoqKiQIHNbX44nwE+z1gD81lsGJpjnjqeqY7PPrp9tDoayvnsdeTbKgwqiMISrZvPc+dnwrBPSgzDQCnNfi8dz1i7Tftzw/26ao7r7BwXjjlkPoU1jYpyAyPOgtKddnDME/vzyHBeV8eFVijzOWHTDPucwf77wvG4MOeMMu05x23vR0JSg9uxLgiCIAiCEDaGzWDFi5/Rtm9XBr42hhXf/8D+r1aTkZHBwNfGsOCed/j+r5+TffnZ9jXYSYqIRHXMsYMfYjuh2xclYC6yzQUTmItS5XivDCgvMXCtdnEsmlxJDu3GXGBojrVFQqx9keX0H1OORZljreuR5rTvFDPKSg3P9pwLQk2ZCyRN87IJNIrVXX33WAi6bBrKPc+1KC4rwadN3No203G914H4aMei2dkWbnaVfaHuMV7HT5tVUVGqXItBt7hgWoA+aA6bcRaLvQMeY3UuQs3uuMbpeG0tV1SU42PT/Rq631unsBGlacRoUThdAQ03e6YdNPP+uu4tlJcpbFaXQGPaQ/O4n+79AI0YzUKUZnGbj8rjnjlt2205xBRHemkpGDbdHJynPc3z2jr+r2saMUThkBw95qupozoFMKdtR7+UguJi7AKcQwMyRQxNc11X5RRaXWlxxNpFGNzHpczr7D4uZ7pdyICiYg33gHLOVs0k5ZAB3e8zGtEqFhzCnXkPnVWczwCHumgu85WGoaC4xNGecspOmsf9swuzrutq1481oox4u1Bhl55dbXuPSynHZ8aeZjPgRKnbNURDuV1Tj3Gbd9feD4s1wcOGs13XnHWbV7hsW22K4jI30cRpV7ks4RSV3SxjaChrgn18KLc5qlx98Ji3zn5BuU1RWq48Hqya475oTsHTmabc8m06NiPe7Toql01c7bunOp//JYaNMgzcr6Zyu5oKt/vqdo2tSsdKlKstn1fKdQ28rBdRjg2bacsdz/eer21YEQRBEARBEOzkrt3B8T+OEHt1O84/ozttihI5UF7Aj4U7aNu2LVPufYzC7w6Tu3YHrXp0qOvuBkREojqmfccYkhpbqi7ojvvq0Q9a4CywKbdFVAg442wFqBvYpkKzap71grVvELivlbWhFFqFFl5dA5xCT5V13NMM0Cp0j4Wdz5gr64/hriRrrvRKbCobUOHnI6x8y3rmaXYvI8PPvKusLmBYNVRFlJ98P9fMq01l0x3jDDBbAswRa4XFbrOqOn6um82qg9PjpdI56FnXVhaNYdX9D0mBT8x/NxHQcPTVn03lbsu9roKKslgMm3ee5ta85tum4721UbS/nrpsKt95qYCykjgMt7nnaj/A/VR20UChYY1xG6f7C+ccc/bZfc4qKC2JQyndLd1dsNU8ynqYjtKp0C1+yzkFGk/s7202KLHFYXjYdLsOynMM7h9VQ+mU657zx/0aeY5dM+talUaREWX2QbldTE8xzPMnQAJQ4dtNv48Q97RyzcZxtxSF//aVW76TeKxYPWQs+5RxtqG86jrr21Rx8M9zQRAEQRCEBk7R/qMA/Pj3OYxO6AWpkJzdnJeeGsSUKVO546HxTGt3O8WHCuu4p5UjIlEdY4sDW3yg3MCLac3xM3SDBBYyAuFY1QS0Walgo6FHqart+Mt3ikR+8ioVugx8z+0L9lrZcLn9eNWr1KYV0B1/oQ/1Gtkc9X3wc/+VZ7aGrRIhw6st97FYNbtdf4JFZf01NLQo59YU93r+rpmnTeW+5PS7qPfsrptRNIuf0wB8Fvze81ozPYgqFU79KC8Kw75FzJ89DVAGyl1YcvPyAnyEEWeuu7jh3a7TIyqgUfd8j7Hr9kvqLiiZ99GZ5l98MQzlK8YEutTKdT8VGobN4lvXzaZp10tcsVl1QDfzfEQXhc8tsXtMWaioiPIRWNzvvT+xyDCgvFxHuT0UPL3OPPvqPiSrTafM6kdE86jnsOmWVmGFMrdBuJd1v7z+RJ8yDMoDlPH+eLqLOOVYOeHWurewE8i20qCECspNTyJXund9l037u3LKRSQSBEEQBOGUJ3/XfrZ8soJtn30PQLuEDDRdI+viM+lyY2+ye5zFnDmfM3LAcNgLcWmJVbRYt4hIVMeoWAMVE0Y9f4tNDwLk2zRPsadSgcf9tYbms3j0rBxIRLFZNdfyzN+qqLL3hnea54LFr02loXRn/Bt/+X7sONFxiCf+qwW0qQPWSry0KhunFqhR79WwV5ZjC1hlVT2MmGIEYNEcW2gCdNjnGrkLPgq/6oAylRLfTjj7a3EXcvzY9tNvLUqBzU3M8BBrHFt+NH95DtGuUnXPuU3Ls03NEefG5z4ppxigeaZ7999ju5krXdNcQo9yt2logI6muQlJ7vfLY3ORr3Bg+KiiXn1zu5/mcA0NsODjaeUYXyBBS6FhKM0RT8erP17Cjj3Jfe5pDo8e3a097J9Z5e2Z496chs2GI8aXs4zmWcYUaTyFKWVoWA3XFklXHW8R0008cmA17F5B/kU/53Xytm+vU46nwOLvkest9oBLJAokCAVqoxQo0RzxjlBuZRU+nkxedU9QQYXmjEjlXs8lCinNmepKs6oKT+VJEARBEAThFMFaWs7OBevZ+ukKctfuNNNtyiAhI4VhHz5CUsumrgqGQf/Us9i1cyu7SvLIolMd9Do4RCSqazQFeoh/inVbNFZRKEC6perq3ib8rUq8GwnUpua2evK/I8Q/fldTnt4ifnUgzbdooDIBswIJSa41vifOXVSV6C4+Rtyvia6qEGaqqI+X5uJz75QpKnnYNAJ4y3jjaFxzD17l3R/3i+Nx7xwChyOQsrmoDDS/PNpw2FPekVJcFV057mKR/bVusddVbs5P7sKDz4AV9vmq2eyXxltkcaSZXike98x1bTX3OFAezXvZNO+hAmXYt2H5y8cVi8Yz2yUeuYsg3tfTfGS4LejtAaHdBASns5KzNaeg5Wdeam5zSnnNIeU+x8xOOWNGKfOWuo9ROdrS3Mfg7v2ElyjlLuY4++wmEnk7ttmU654FErY8hmjYbdqUXZgCXHHjAtV1F4lQptbsT5Txt+XLlaeZYo3hVcL9neH12oqBoRle9pTHTmFlprpaMwAbChsKw82i0pRHv02xyE0osolCJAiCIAjCKcbh7X+w9dMVbP9yFWWFxQBoFp22fbtyuIXBK397mdH6Ffz3kX+yJf4wWd3aM6TXFax7awHHfvqDOYdX0+HA1XU8isoRkaiusVrA6j++SUCc6/1ASkdl9a2+O7GqNAbmiiTkeEaOFZrfnlbWlnLYNAKMstK6Cs2mBbo6Lvytbwz8eEwFYdOGS3AJJDAFasMGmLFoQrinCtz2hFTpxeS5CNZ8BaJKcXq/uKth4LGKrMQ2CvtJeiqYue4Ux5yeIvbtST71/IgJ3qtuZbP3Vbnnedfz15bS0X08bFyeLnbd09euKyi5S7Byvy8eupiGw1vJMV5ds5+k52zHYziu+ewuUNjLOqURlwOT52V1k6Z0U+Wy65qaK6i0Up7OU2Y/3DptuItcmr1XmsVz/M6rZL+FLk83u9ZnPxnRY17gieYUq5RLAlMYGJqOrim3a6vMdj1fu+IhocAwNKItmHKJqXM6A5N7a7EK0J0Ci0aU8zQ7r3G6Pn5uHk2O9GhDIwbNbZguYcV58bwfE+4CU7SjTcNDKPNX3j4qC/bHSIVylXOXc7ynvuEj9kRh37qqm+V94yYpxyPDdX9tSr5CCIIgCILQ8KkoLmPH/HVs+WQ5BzbmmOmNW6bS+YaL6DS0J4ktmjB79hw2Fu1hntpCj5WFpEc3pnz5Bj5/dQNJrZpy2vhL+Onef5KRkVGHo6ka+YZXx1iKweK+BQf8rJoInK/cigQj4BjK7g3ijZ8kHwnBn/hRpaClwH27WRV42PTZaubHZiD7FQHEsKr66y72BGHTLGkAVt33mgWy6Z5mcxMKApXzd8usoKyegaB9inkkuPXO6iUS+bPvrz8VGti8gk8HrKd5lnOO068441XXPb0iQF+cQpJHnpuHj7MPyk1g8ScAeth0ig3KFF+8C3qLFO59ME/ic6vrbdJ9+5WpKjlKenuD2QUTlzDjsu308FFoOui6mweI28GHpk3nNXB69TnyLRYbyvuiKD/b1xyKiPOAeUPTUG4jU+7uKh7iiOcLw4CoaB2l/MQz8nL9844vpOs6uu7pTeTCJXR5eyIZBlgN+zY3sys+IpW7J5KLKKtOlObqm1/vMOWqawo9CgzDFdhbBfiMul8n5+soZfEKXO0r8virF43CoixVtK980gFKsHqERTPw3nhmTjePelYFexEEQRAEQWiYHNq2jy3/Wc6vX6+mvKgUAD1KJ/vys+l840Vk9e5EWXk5c+f+l/ff/3/Mn78AgPm/rmRR9HqGd7+Os7I70b3v+fS8/RJuvGkY2dnZ9OlzUV0Oq0pEJKpjYo5BjC2AclGZoBGMIORTR9ljElXmQBKKzUrKmiaU5hksO1AdHzcJwhOlnDatbsdu++RX8lrhtqqvQrxzz7IBNh2PrU+VVnD7aQMfD5uAdt0WmzYNbBa/ed71fPSOCnC4SwRp07HgtmpobjYrjY3lLQJUaK5YNCHYVMp5KpqzTGWClpfQYA0QW8cHL9FL8zzG3kO78Z6XSrn/cDbgKu+llWl2dxs8xwia7v3Z1DCLOss4DTuNObxu7CKRo6TDU8fjEpmrezfPKsBmcQ9Crplij4YNH+HErUFNcwYFdxe8fGMK2V96uCKhsILh3Izl8Kgx3Mt7d9te32LRiYpSHv30LO+5zczpZWc4Tyx0E74MX13M72lrVquGzRblISR5e6a56rrGb62AGKuXF5CXwOId/8iZV2YDm/L8XPur79EWUGGzUOLu1YSnwAS+gaud/0qx+NXk/YlR7jJTRVCfLUEQBEEQhPpDeVEpO+atYct/VnBw8x4zPTmrGZ1v7E3H63qS0DSJH3/8kSl3T+A///mUgoICs1z79u0o+M1K18S+/P5zFL//vI95X+5Dm/QJPx/bzIxPpmKxhHi6eS0jIlEdYykAS0UQX7Q99ql4/fR+XVkjhvvGlRAI16ZTBAnKpuZZzFusCUYwci6krKCC8l/y6lc4NgFsoPwdKR+MTRu4bxvzIaAAAsrfdg+fNvxce9Orx4+AVEk/VIWGwuK/zQBilhPDqnmKYf5EQD+2lVWzX9tA4wpwfQCU4UeYCuKeKquOe1Ar5a+cm4DhtO9vOBoBrrHzAii78KRpNp85q7kVNUUrR7wl1/A1u8qiPO37dRh0aUugwBIFyl2QcNtSZbYNvvfE0LDpboKEl3Zlikt+vINiDOWYQ+4Zzib831MFGDYNw6HueAbDDtAHN5uabsPbt9AwPek0j7Iu+xpWm4bNKWiZ7fvzeMKjTIUVYisMM8ks4uPJ5rUVEqiwalidKpbyFIjsRX1FUgWUlkEiuleWt2jk+1MBFUrH5vX5MbzKmq/dxK1y/8cyCoIgCIIg1CuUUhzcvJctnyxnx9w1VBSXAaBHWzj9im50vukiWvU4gz179/LSjNf5978/YOdOV7Dq1q1bc9ttI7jtthEc2l7C0yPe5oQ6xLbSHzhhHKWR3oROMb3oGtePZpa2dTTK4BGRqI7RjkejOcWFoIQeQijrZ9FsI0DgkioadP8rezCmPbYZub0Pa4x+PEeqqmpz8xwIZZwGAepVgc1tsR1iX+1/wq/Eq8cvmt0ZwxEjyHPh6sflwPu9m0hUmQ3vNgybZs5Xv8JJJTiFl8qr+LFp1cBdyKisAZ/+esUzClLY9CdweNQP0I5m/t/TM6nSK+0YshkuSHnlKVyqjgLcTkizt6/AouMR3FtVJgU77oEBlijlu90M/8KHx5Ypw+755HnqV2Wj1FxijuYQtcy23baK+alpXnKHSKT8iTqBnhHKHnxa1wF0HwHJcBeF/XxsbDbNJcS6C1nKv1jjrG+zasRYvRKdNr367P05sgtTrl/NLuHK//W1i0ga1liocG5xU+55rr6bZrzaKrdp2Px5+SnPl8rtjUKjTKmAp0EKgiAIgiCcbBg2g9y1Oyg+VEhCsyTSOrRi57y1bPlkBYe37TPLpbRtQeebetPpup5URCk+++xz3n/0bpYtW26WadSoETfccD23334bfftegq7r2GwGz13/JD0HdeWpD8fw/fc/sH//fjIyMujduxfP3PIObz32Ob2uOhuLJbRIwbWJiER1jCqO9v2resDC1TWGfbuH5rmA9SUIr59QxAF34SWoCqHbsOMSopTh+T5gWXebGg6RKHRBSxlAJZ5EHl4Snon+Pa2CsG13cKhKPAlwL21ui/5QxlmBj7dLcBXtAlOlW9y8ypsvrVD1nAxw/ZTuX7yoqg9GJcKkl5eL/yw3xUPzzvStoAH2k798C2l+37gJRRro3oGIfLbAedrUsOuLmgaaV8RzZwBrP4NyvdQ1lM3mKB/As8ZLYAD750RZFN7bK311XM0nT3nEI/Kcu5WFWbMYoGEQ8BnkV5yy33+7SOSMFeXlaVPJc8pqBYvVfwT8QEKNU0iz2nQwrHiG+9f82nQ3XV4OhhHjd1ze19f7KIEKq4bh5/nlETLLTcxzUqKsUORTTRAEQRAE4aRj1zcbWPHiZxz/44gr0f4lHABLTBSn9+9Gl2F9aHHuaSxatJi/Tbib2bPnUFpqj0ekaRqXX34Zt99+K9dddy2JiYkeNjZ9v5O8PUd4fOadREdH07fvJR75Nz80kHsvm8am73dyzsVn1ORwq4WIRHVNSTT244F8qa4m5LdBP4ud4OuHV0/ZILBIVNUoQxEyAohEoaCg0q1fAdpUhnPhGoZNZ18DjjGAzapiGVWCcvNCClkMC9arx59NwrCpCH+cYYp+ZoDtED+EmvdnLJjp7RSKAk0dtzJenTT7aA9w7asc+G3TqS0p0C2ewpSb9OTHpkv1UkphKA2F5hMIv9JPgALQUb77ruzZ3iKI+7W0gM1bUA3i/tj1MzfvJT82ldtrdywWHcNQXuUruaiOPkVZwGrx3vrlyvcOru2OzcAh2PjzmHImeAlzQLRFw0OX8vYCcrfp1Z7V5tyW6TtvA2phSsNilIlIJAiCIAjCSc+ubzYw/563aHF2NjGJcRzZ/oc9w/EFp+P1Pen9yFB2/bGbV95/l1nXfsT+/fvN+h07dmTkyNu49dZbaNWqVUA7+XnHAGjdvgVrFm5l2Zz1tD4jnZvu6wdAdudMj3InKyIS1THKpqMqQg9cFbKA5KxggMc51zWG2wLHucUtHK+lMPtpei+FaDPAOrJqbFThYVPJOP3arKSPzp9WCMlDy70N75PGgq4Xgk2va6+MaopofgmQbl6kKmwG9BbykEuCxsdjzF8T3jYDqzKVt+NeR1MegbZ9mgrQtKYZgT+b3jaVZ56uvMMiuxUN5DWlAboN3T12TmWilrsXk7KLPR7CkbuYEWCMCtAtVryfBy7JyzPBQ0zRDTw0Iu857fHe5WmjeR0A6LdfAQR7i6GhDOWaS16eTv62AoJ9S50l0CEIPnU977nN0DEqEX9VgOtsGBUIgiAIgiCczBg2gyXPfERsciMO/JRjT7RopJzfhkvuvo5V0//LtoVrmbjgddZv3GjWS0tL4+abhzFy5G10797d87u2H8rLKsjba/dSuqXTExQft3sfZXV0iUQ5W3MBSE1PjvAoI4uIRHWMqrCgosKMbu79RT7oOmF6EgVtxM2GCrwYCtpWqDaphidRwHqVt6VMD4cwhIUQRSKPetXxJAqjv8rd0ypko4Q//8K26VQmQqwf0Hunimoarooh9rk62q2mKbsnUSCbAaa0pml2oUcLXMyvmqIcHQ7gbVWZB5PFYrguUWX2vCobCnssLbvblE+HA11tpYPFtaHPb0nPbVWe6ZrNLXi0V9WA0mUQz59A8Zw0zfGxVsHOB/s90C327XGV2QsksOmGKyi4Z6XKx2C1SUAiQRAEQRBOXv5Ys4Plz/+HksOFAFiVwYqCbSzM/5nCbcXEf/oCGVoSf251FYX78oiOjuaqqwYzcuRtDBo0kJiYmErbLyspZ+2ibSybvZ6V837mRKFdGCo+XkpKs8b0ueYcLr72XJSyf1f/6G8LyGibRtfe7Wp87NVBRKI6Rtl0lC2MeD2hZXkVCnHBXE2vo8AiURUeHtWwG3IcJCdhiksu8SSMukGf/uZVzyDAIi5IgSnceuF4hJk2wxCmwhX8cHQ1HI8p7zkb5Fz0qFfZXxsCevZUXSZQc1pVw/Qr5hhVVCKwYGYJQsXw49GkYVR+bfzaU1g0sKGhVXFfvD2KNAWGI3C1Fqi/7lqXu7cNYGj+hJAAW8Ecr3Ud5wfbaxQB+my2p9kvq2HzFbSq8pqygeZ45gW8LQFEe4vSPIJ4++un4afRKL/XRhAEQRAEoW7JXbuT1a99ze8/bjfTvi/4hRNdEkm6IBv9v9ugAEpKSvhDs582cv+YcQx/8k+kpaVV2nZpcTmrv9nMstkb+HHBJkqKysy8tPRkTj+rFau/2ULH89pwxS0Xkt05k62rc/jobwv4cf5mnpo15qQOWg0iEtU5IYtEYRty/FDgfe5RNTWgsGwGW987wGqwNglTJAq0ZaXySpqb6BKux1Tw9czFY5iiSzg2Pby6quNJFK4XW7iTtMYmdwDC9EAK2JY/wvEg9G7PWUnXAgsn7uX89EUZppwQfGc00HTXRap0NvgRKXRnZyvpl4+uosCiKwLFQXJvT3ldJGVorsDeyk8FvPQux2ubDXSLtz3/o7U/O1zt2WM96fbS7g+kKrymLIBWmWijXNfDe5ucYWguByPlv32fp6mCKKx+SgqCIAiCINQN+zf8xurXvmbf99sA+xH2rS/qzJ7vNrGnUSHrf1hLWZld1GndujW33noL25duhMMwZPh1AQWikqJSflywmWVzNrD6f5spLS4385q1bMLF13bj4uvOpXOPbHRdZ/mXG5gx6XPuvWyaWS6jbRpPzRpDn2u61dwFiBAiEtU1hmb/F0EqXaeFKryEveD1XKmFZbM6nkTVCiIdCu5bN8L0dqm0buXbR8Le4hZmf0Oup/y+dBBcO2EJd347EtnPWaVmlPubCONvy1OoNs3tZV6KgPe1rszhR3f3JKpsv5pXvUpVKbc+eLWla2A4FQ7NTwH3Jtx3o2mATuVimPv1cJ+zFrvnUzDPL/d5atEAqx83Kn99tLhn27fS+Yg93tfZj037ayPwc9PLW8pN5kLTNPSAn9XANvXQH5jCKULbtm3Zs2ePT/rdd9/Nc889x1NPPcU333zD3r17adasGddeey3PPfccycnJfturqKjgiSeeYN68efz2228kJyfTr18/XnzxRTIzM2t6OIIgCMJJTt5POax+9Wv2rtgKgB6l0/H6XqT0a8+k55+hV0UTupa14MeyTVx4YQ8ee+xRBg++Eg344OYX2JW7lV0leWTRyWyz6FgJP87fxLI561mzcCvlpa5YjOlt0kxhqEP3Nui655/T+lzTjV5Xnc2m73eSn3eM1PRkuvZud9J7EDlpcCLRsmXLmDZtGuvWrWP//v3Mnj2ba6+91sxXSvHUU0/xzjvvUFBQQO/evZk+fTrt27c3y+Tn53PPPffw9ddfo+s6Q4cO5R//+IfHEXc///wz48ePZ82aNTRr1ox77rmHRx55JOT+KkNHGbU3WcL26gnJiNf76pw0FqDJKglz7VI98SSMuorwr48ZCLp61za0eq5tMeHZDGfuhTlGnzZqAQ9PolqyCYC7cBKkCAN4xPdxVg/GmlOQCtamu0k3TyK/1QL0wfRcCsKm9242XQvgHuPPjnuzhkLpvie4mR11v3Ru7dsU6LprK5/f2n67r+w6j9I84yT59F3zsWmKREHi/swyHNPAT6gnr7KeNnWLbDcT/LNmzRpsbjGrNm/ezBVXXMGNN95Ibm4uubm5/O1vf6Nz587s2bOHu+66i9zcXD777DO/7RUXF7N+/XomT57M2WefzdGjR7nvvvu4+uqrWbt2bW0NSxAEQTjJOPDzbla/Ppc9SzcDoFl0Ol3Xk9iLWvHyuzP44vnZKKU4kNiG0ZmX894Nk+k/aQRpZ7TkwE+7WffWAo799AdzDq+mw4GrOX70BD/892eWzdnAukXbqCh3eU23PL0ZF193Lhdfey7tz2ldZSBri0U/qY+5r4wGJxKdOHGCs88+mzvvvJPrr7/eJ3/q1Km8+uqrvP/++2RnZzN58mQGDBjA1q1biYuLA2DEiBHs37+fhQsXUlFRwR133MHYsWP58MMPASgsLKR///7069ePGTNmsGnTJu68805SUlIYO3ZsaB1WkfckqtxeGFu4qmsyXHGg2p5ETkKwHe4fxqux9Svs6wPV3IblbTOIPigI90S1oG34tRkeYQfadl+gh2ovTLQwt6q5fIeCHKfHtiXleXmCtK/r/mPUBMLzurjFQQrh1mi6s6HQL5S791KVO+K8PbWMQAKTb0vOceoa2NDNMj7VvR2+3EUY3eFNVGkv3cbjmKt2h6nADzDv3XKucdqfWyqEyeu0aYmMm5/QAGnWrJnH+xdffJHTTz+dSy65BE3T+Pzzz828008/neeff55bb70Vq9VKVJTvV9Pk5GQWLlzokfb6669zwQUXsHfvXrKysmpmIIIgCMJJycHNe1j9+lx2f7cJsItDHa+5EHV+M6a+/Tr/e+Ebs+xFF/VmxYrvaXfPZRz84mc+v9m1BaxxqzRa3tGLg48v47vpv/LeXY9gs7q+T2V1SHcIQ9047cyWVQpDDYUGJxINGjSIQYMG+c1TSvHKK6/wxBNPcM011wDw73//mxYtWjBnzhyGDx/Otm3bWLBgAWvWrOG8884D4LXXXuPKK6/kb3/7G5mZmcyaNYvy8nL+9a9/ERMTQ5cuXdi4cSMvvfRSyCKR/S/GtTfZlIE5uYP6eh+BNYDdA8AneknN4thuVmM2vRqu/tavUNC8bIZOnSztqrN1sVpxkMK0GYZJz11QoRrXqtgTVZXlgG4nVdb0/yYwhoFbXyvZ4ub0THEXpqryJAqAUjj0yarq+vZF0w2UQ9wM5RIrDXRduXbyVYFznDabpydRUNv4zMupXL8T/Nr0fH57eBO5iURVdtfccqZ5TB//zyP/99ci282EICgvL+eDDz7ggQceCPjl+tixYyQlJfkViAJx7NgxNE0jJSUlQj0VBEEQTnYObd3L6tfmkrP4Z8D+vfKMIRdQcmZjnn7ndVa8+D0Auq5z883DePTRR+jUqRPt2nXktQ9m0+TY6VgPQZwOpQYUHi6k/Mfv6RR7MbvW7Qcgu0tLLr6uGxdfey5tO2XU2VjrkgYnElVGTk4OeXl59OvXz0xLTk6mR48erFy5kuHDh7Ny5UpSUlJMgQigX79+6LrOqlWruO6661i5ciUXX3yxx5F4AwYM4K9//StHjx6lSZMmPrbLysrMIFlg90YCUIaGqm1PonDWoSFv/fJYuVTtvRQR1cJlI6gTsSqzGXR/3BZzkfSYqtS+u83qiCf+6gZzzSI9X2tw/jub9rmeJ99fATRNhfU50AAzoIwKceuXRkjlneg69mDHps3KOldJUqieRIZyzcGAdX3Ho4XppmX3XjLswlKIfzkybG6xjALOQ3dj9h+60uxiTzDddRN2tCiwWV19NE0Gase8hI4NyEF5mbqEd6WoOr6UIABz5syhoKCAUaNG+c0/fPgwzz33XEh/ZCstLWXixIncfPPNJCUlBSwX6LuXIAiCUL84/MvvrH59Lr8t3AjYxaH2g88jv100E99+jQ3T7OkxMTHcccdIHn74QU4//XSz/t3DH2T+PzZyMDmP1u1bsXfrIZShACugkdQsnhvGX8HF13Sj9RnptT6+k41TSiTKy8sDoEWLFh7pLVq0MPPy8vJo3ry5R35UVBSpqakeZbKzs33acOb5E4mmTJnCM88849upCAauDurrukHIi53gGw9Qtda2m4UoEkXEpre9GvAkCpCvjPDsASHGQfK+rqHUdaHCjRNVnXHWiKhVU4TXT01zv7bukyWI9sLc4mav6nQTCs1muMKUXahxbv0K9KEIUFdXaMFsk/SubziEE3ebQQqzpgdSiDYNpew2Am4D1HycxjQNbAZYLL5qftUeRQrDvvHQdU/9iKrKkeHeLYshnkRC1bz77rsMGjTIb4DpwsJCBg8eTOfOnXn66aeDaq+iooKbbroJpRTTp0+vtGzA716CIAhCveDIr3+w+vW57PrfBnuCptFu0LnktrJx7zsvs327/Yj7hIQE7rprLA88cD8tW7b0aKOosIQfPthJTHwUFYUaezYfBKDQdhBr0jG6tumBUawx/IEB9SawdE1zSolEdcmkSZN44IEHzPeFhYW0bt06IoGrlc+LYCuEmBcu1fB2CTHyiOtlmCJRuMNX1Q7oHA5V2KykXZ+skO5RdUSX+iLY1BHhTJ+Au72q3n4WrmCjcG4b8zIVRFuu2EKhoel4BpD210SAoRrOyMxVGvF8q+vgIfUEve8MDJvXEQGVePR4oPBQVH29ewI0ZNhtehcNakr53BM3YbiS4VqUBK4WKmfPnj18++23fPHFFz55x48fZ+DAgTRu3JjZs2cTHR1dZXtOgWjPnj0sXry4Ui8iCPzdSxAEQTi5MGwGuWt3UHyokIRmScSlJLJ2+jx2LljvdF8mu/855DQ9wZ/efZG9e/cCkJKSwj33jOfeeyfQtGlTjzbz9hzhy7eW8PW7yykpsnuVxjWK4cxL29C2Rwqdzj2dPn0u4pe1e7j3smls+n5nvQ00HWlOKZEoPd3uOnbgwAEyMlz7Cw8cOMA555xjljl48KBHPavVSn5+vlk/PT2dAwcOeJRxvneW8SY2NpbY2Fif9Frdbqac0UPCt+d3vRCUJ0yE4wNV0VitB8tWTqEowveyMqHH3G4W2XFWFpOkOnFqw429VK35U615UFvzp6Y//1WoKWGbd2s3qDYcm5vcj9EKAU3hGS1b83kREHt8IEuV5bwxFI4ATEHadNPldIui6geVb5KmAgyzijmpFFgs4d1M3QgQiLwK8dgSrnugcMrw3nvv0bx5cwYPHuyRXlhYyIABA4iNjeWrr74yDw6pDKdAtGPHDr777jvS0tKqrBPou5cgCIJw8rDrmw2sePEzjv9xxG9+m8u78ktSAaNnPmeuuVu0aMEDD9zPXXeN9fiDgVKKn5bvYPb07/hh7k8Ybl9wxjx7LVf938UkJsd7tJ/d2e7pmp93LNJDq7ecUiJRdnY26enpLFq0yBSFCgsLWbVqFePGjQOgZ8+eFBQUsG7dOrp37w7A4sWLMQyDHj16mGUef/xxKioqzL98LVy4kA4dOvjdalYZyqahbLXn1mZftvj54l9joSVUeJ5E1e1POIv8aizw3Y+Tjki7ldbRvMqENs7whB4twOsgbVajbrg1T95oKQFGEual0RSumERB21SuuqG77AXZ1QAeMGF6LwGe4/TrveS/Z3avp9AFDc0ATff3fK7cptIAwxawP5VhGEHczkDP1PD0NwxN83NSma9Xkje6eBIJlWAYBu+99x4jR470CEjtPCG2uLiYDz74gMLCQjNWULNmzbBY7IJux44dmTJlCtdddx0VFRXccMMNrF+/nrlz52Kz2cwQAKmpqR4xImttfLYKOPQDlB5Ai0+HZr3R9NDFaEEQhFOZXd9sYP69b5N5fntS2jZn3w+/eHyZOX5OY27/6GkKCgoAyMrK4pFHHuTOO+8gPt4l9pQWl7Pok9XMfnMJOVv+MNO7X9aJcy4+g3ef/pKz+rT3EYgAcrbmApCanlxDo6x/NDiRqKioiJ07d5rvc3Jy2LhxI6mpqWRlZXH//ffzl7/8hfbt25Odnc3kyZPJzMzk2muvBaBTp04MHDiQMWPGMGPGDCoqKpgwYQLDhw8399PfcsstPPPMM4wePZqJEyeyefNm/vGPf/Dyyy+H3N/aDlxd+ycWa+EJNpURxBiqdax8SDhEomrE6gk39pKPMBXBexuwKTebIZurskJl104LromIcYptiwtxuNW5Onq4DncBPYmCqKoUqNDFeN0RuNrehr8S/oM66ZpZOWSbzpBxlZ8y5ifTRthbe3XHiWqhnGxmryeeREJgvv32W/bu3cudd97pkb5+/XpWrVoFQLt27TzycnJyaNu2LQDbt2/n2DH7X3X/+OMPvvrqKwDzj3xOvvvuO/r27Rv5AVSC2vclas0DUGoXqhRAVCJaqyFora6ERm2gURbENq32ccnKsMGh71EleSJGCYLQoDBsBkuf/ZiEpknkrtlhfvmJ7dSMnanHOf7tLpqvbsyxgmN06NCBSZMe4ZZbbvbYnnxgXz5fvb2U/878nuP5JwCIS4jhilt6cO1dl9K2UwY2m8F/31vBh9MW8Ox/7kJ3+wOgYRh89LcFZLRNo2tvz99JpzKaUrUvG9QkS5Ys4dJLL/VJHzlyJDNnzkQpxVNPPcXbb79NQUEBF110EW+++SZnnOHaf5ifn8+ECRP4+uuv0XWdoUOH8uqrr5KYmGiW+fnnnxk/fjxr1qyhadOm3HPPPUycODHofhYWFpKcnMzeRweSFFf1Pnyg2ivkqiOU1AzKn9WannUhikTV/hSY9mrPZrXWZ2GKaOFscav2pfUXFDzYRsM0btiAYAIde5szr08weJYLN9h6dQRRewybMGwG3VffMuFeW48YycF42nnUdRtnCHPCrknpIc8jewyk8K6tEey19ZpnNgPM6xpyfyux6dGWZ5miijIuWjDdPL5cEE52nN+9qjNn1b4vMZaPgNRzIH9D5YWjGtnFokZt0RLtwpGW2NaeltgWolMqFZHUvi8x1k+CE3tciY3aoJ87Ba31NWH1XxAE4WTgwM+7Wf7CJ+Rt+M1M23g8h//l/8TvZfZtZ23jmvNg1hCajO7O8AfvND1NlVJs+n4nX0z/ju+/2mhuKUtvk8Y1f+rLoNt70rhJIw97y7/cwDMj3uHCQWdy80MDye6cSc7WXD762wJ+nL+Zp2aNoc813Wpp9OERid9hwdLgRKL6gvMm75k4iKTYIEWiSFAdD5tg1i1+41pETpgKerJG0JMoKJv+7EX4k+XTnJ+FXWjXJxTcvZdCGWf174E/kSjscQZZMfRxuhOuYAM1L0xFxqb3fA/lt0jYwhSeNkMSe8K16XecVbdjGITluWTaUMFcW89+hH0vcbu2yt1m1eMsqiij13/fEpFIqDdU9wu2MmwYX3eFlC5oF32AVpILRbtRJ/aiinLgt1lQdgRiU6Fkf9UNRifZvY4S26B5iUmqYAtq5RhoOQi9y8OQ3BmObcXYMg3+mI/eZ5YIRYIg1Dv2r9vJmjfnsXfFVjNtw/Ec1lr2sTl3F4bjr4KpqamcOHqcv7W/nf5/H80ZV51PWUk5iz9Zy+zp37Fr0+9m/W6XdOC6uy/lwkFdKz2dbPmXG5gx6XPy9rhiH2W0TeNPLww96QUiqF2RqMFtN6t3KC3sBV5Y5gxc+xlCrhxmtWoINuGZDDEOUgTEnEpjEtWQ/drbUudlp1bt+ieQdZ9LWe17q/l9WZWNcMyG8rH0iIijnP8Lx6b/7VJV2veqUnXfXQW0KgPuBDIasMkqCfPy+IQxqvo0ODdvJc0gLGHKIMQOa27/Vx42g3a4cwqxQXfXXtBiyHYz4RTj0PdwYg9675lollhIzIbEbNdG0MxBGAsvQ+/1L2h6AZzYByf2oE7shaLd9tdFe+yeQaUHoaIQCjZBwSbz8+rpvBcNxbkY215BS2gJ8elora5GlR7CWPMQWtoFaHHNI7L9TLa1CYJQUyil+GPVr6x547/8sfpXADSLTly7ppRsP8jio5vYXXoIgIEDB/DYY4/Su3cvRg4YDnuhVCn++dQc/vveCgqP2LeUxcZH0+/mHlx3V1+yu7QMaNudPtd0o9dVZ7Pp+53k5x0jNT2Zrr3bybH3fhCRqI5Rho4yam5iKu93SouIKBJSD5RW8zpYJVsiqt1cpQXcxRM/AWyr3ZOq+hH+WMPqm7+tX8G2FWkxrEYvbjBbb2rHZl0MM/L1XKOwCy3hGg72ani2r2nKJy0odDebIUxyzYLDkyiMu+fv+lTqTeSw6adMsCNWfsSvyj2YHDbDFfwEoZ6iSuwxiEju7L9ASmeznG6Jg6T2kNTe72dRWYvhxF5P4ejEXlTRbji+0y4gqQo4uhGObvT7GFBz2qE0HWKbQlwLiG+B5vhJnP2f5nwd3wKik/1ub/Pe1qZAtrUJglBtlFLsXb6VtdPnsX/9LgD0KAvRZzfng63fsPzrNTyVfSMD0s7h+MVNGdr/ZlISmtJYJWOz2ugT3ZHDFX/wwC3vmWE2mrdO5do/XcKgkb1JSm1UiXX/WCy6HHMfBCIS1TFhngYdni00glorRbQ/9mCoWnWFmxD75DcOUohthmSyOp5EYRK091IE72fNbWcLA+9hn0Q2w/PPqZbJ8NoOZgupv3p6oJxg2tN8w55X/tZuM0Qr7rWq9gAKglA8l2y4jiiLxA0LaNs1TpdIFIZBP1tXA88NV/u6Lp5EwqmFFp9u/wQc22r3FPKmYKtZrsq2ohIguSMkd/T5iBu7P0H9cAda/yVoZYftwlFJLpQcQJUegOL9cGwL9m2iht0rqfSgh0eSE4/3eqxLQHIISqr8KOz9AlLPRevyMDTtAeXHUNtewlg+Qra1CYIQMkopdi/+mTXT53Fwk118tsREYeuQxIx1X7Hpo+0AxMbGMPvQKv4vsx/562L4aP6XFFZAUjR0SNZoEaPYdiwaZcDZfdpz3bhL6TX4LCxR4uVY04hIVNdUd7tZCOsB58I17K0Xpj916FVVJUc2B1U/JGOhFI4QEdqCFfo4I2AzKKPedmrZ06ZW72ntiW7BUqnJ6kyBIMbi9y/g1TDp2hYV2EjgIfmtXUmHHBlhbqurTESr7HOjW+xfkOyNhGizknYD21T2w9RCDJ5v1g5zDulGXTxsBaEOadYbGrXB2DIN/eL/oGkuT3ClDIytf4NGbe3lqoFTjNJQaC0H+f6x4NAqjIWXoV36NVpKJyg94BKQSg443h+0v3emVRwDo8zhvbTX3o57o/nrUavXOzpggfhMiGmCsXIM5G9ES2zriJvUBhJaoVliwh6fbG0ThIaJMgx2fbOBtdPnc/gXe8wgS2w0RW1jeHPl5+zebD+a3n7o03jOPvssxgx9kFVHoHsLxSXNXW2dsCpWH4HNJ3KZ+OadDL/z2joY0amLiER1jaGhjFryPlHV1BWU35dB1qvbGDY+RHht43LQCjzOmltOVWIz0kar014Q3iKV16tlES6QvSD1hkh7E9XI/AnTq7A6JzorTVXqWVi53hPAR7DS/mjoVWyLqtym/8YrFZCMyre4VdobI3CJymzafXrCnClu1zYkNPEkEk4tNN2Cfu4UjOUjMJYNQ+/8kH2LWcFWu0DkDChdXcEjSDFKa3Gx3VZ8OjSp/FGorCUOjyOXoKQOr4acWXZ7Rrkjbz8YFVC8z1V5y1QUHhuHIT7DHnA7oTU4T25zikiNWqNZ4vz3Q7a2CUKDw7Da2DFvLWtnzOfoLvu2XEt8DIfSbbz+/X84tOkoANnZ2Tz44P3ccccoEhISKCsrp1PcHHJtBnl7raRGQ5wOcamN6TOmL9++8RmNK1K5/tbBdTm8UxIRieoYpbTAXjaRtoVjCRGp1WYQ7YQZCSRC1KJlFXD5GnpTId+f2guWHUmlIuh4KSGV9le3BggyiHVNbjsLYDKyRNyoUyAK3EBAk2HHMlKOyqHbdDvwK2DToTVYdXaYh6I52gxTtKlKyA8oFoonkXDqobW+Br3PLIz1kzAWXubKaNQ2YluzakKM0qLi7WJOYhv7e8CITkLlzELv+wVadCJgF6EoOWCPlVT4K2rVOGhxCejRLi8kW6lj+1suipWmDY8nQlwLh3DUBhKzoFEWFOeitkyFjP7ovWd6nNgmW9sEof5hq7Cx/atVrHtrPsf22ANPWxJi2J1cxPQfPuT4TyUAdOt2Do888hA33DCUqKgoigqK+fy9xXz6j2+JUrFQbv8G07hjOjdOuIJGWTB16t9Ys38N3WOHsPXHHIkjVMuISFTX1OLpZnUh1jhFqep4HngQ0va02o0PVCeL+EDI2s3OSSKGVd5cXcqoYQ60Ol3Ww5SOw/V2MQnPpvc18ngXqMm6cLDRfF6EWLWSaxugyao8tAShoaK1vga95VU1umWqVsQoPzGWNE2HhAz7P8cTUD/zUbQWFwOOrbSlB+1Bth2BtzmxD+UIvM2JvWA9YfdKKj2AOrLG1/D+bzDy10PSGWjJHdGaX2w/sW3tI2iZg9EtsjwRhJMFw2aQu3YHxYcKSWiWROZ57VE2G9u+WMm6t//H8T/sx8lbGsWwJeYg7675ilKjAoB+/S7nkUceol+/y9E0jV0//86Xby9l0X9WU1pcbtrofGlL/vfTZyxeuYV3Vz4P2L2OZrz/Mu+MXUx+3rHaH/gpjjyF6xj/gatrWlGp/UVpJLc9BdtWDYdqCVCnfnr1BG2ywdvUArwOkcpD7vivEqa5aoQKCx9VBzarRfXEsFC9ibQwDzYDl6AesgdTNQ7JDPszJiKRcAqj6RZocXGNfqOqcTEqjBhLmqbZg1/Ht0Brer5Pk0opKDti365WtMchHu1D5a+Hw6vAkgC2Yig7DIcOow794Fn/s3RsKV3QkjtCUge05E6Q1AEatQl53BL7SBCqx65vNrDixc9MIQggNjkBTdMoLbAfRa83imG1NYePNn5LubKi6zrDht3Eww8/QPfu3akot7L4kzV89c4yNq/cZbbTtlMG3S/rxOdvLGbck7fwSvdJLF++gv3795ORkUGfPhfxy9o9wGJS05Nre+inPCIS1TnhBRoNvm1PIurVEyT+TjerjaWFj426WM80yDVU+BMo/MtRO8Hd6yu1PkTN40dIhNvXas26MANXK8c2rCpCHvk1aU+voRnvJ9Ml9IQef0kLM26ceBIJQs1Tk2JUjWxr0zSIa2r/l9rN7Lex+xPU4VVo1/2GhhWKdqOObYfC7ahjv9i9mY7vBFsJHFmLOrIWcHtmWeLsnkdJHSC5kyki0fh0ND3apx8S+0gQqseubzYw/963adP3TNJuOosDP+VQviqXsmPF9gKxFpaU/MJXG7+nQtmIi4vj7jv/jwcf/DOnnXYaB/bl869nvuS/731PwaHjAFiidPpc041rxl5C197tMAzF93N/4sNpC3j2P3fRt+8lpn3DMPjobwvIaJtG197t6uISnNKISFTHqFoMXO0UiGrTM8O0WXsmccUgadioMBd2dUnDiKtz8tmsNMZNzZgMm7BnbLW2uIVZL8wtbtV6xlb7hlV+oSIZWl9iEglC/ac2trWB24lthdvQml4AqU3QUruZ+eaJbT1moEUnOoSjX1CFv0DhDnscpKM/o47+bC9vNhwFjdtBckeXcFSSh9owCVpeKbGPBCEMDJvBihc/I6ZdKh9/+xVdv80g0RGM/qjtBKVGBdHlOl/sXk5KkxQmTLibe+4ZT1paGuu/287Mx2aw8r8/YzhOQU3LSOaq0X24clRvmmakmHYsFo27pgzlmRHv8OSwGdz80ECyO2eSszWXj/62gB/nb+apWWOwWKrhLi2EhaZUXWwgEQoLC0lOTmbn3dfTONb3LyA1Ql1Eka4z16XatWk3qfmkneyE3EU/46xpInIdw2qjmuMM0WYktiuGZrKOxNRaFjddOk81fJHqwFUrZJvVFqZCj1B1vLycM9//iGPHjpGUlFSNDghC7eD87iVz1pea3pqlDBvG110hpYv/rW3LhkHBVvQhP/vYVYYNTuy2i0bHtrm8jwq32+MfBSLxNLt4lNIVLe1cVJNzUGvuh2Pb/NoRBMHOttkrWfTo+1iVjSjN/jkpj9f48o+VrDi8lay4ZjyYNQTbNW0Y/eQ9YNX536wf+eqdpfy+46DZzjkXn8HVYy+h91VnExUd+PO2/MsNzJj0OXl7XNvaMtqm8acXhtLnmm4B651q1ObvMPEkqmMUGqq2FkyaY1FYm+tCjTpaiNavuEvh1q2uYBNqbUUdeUlU93aGM9BwqU74m3DGqfl9GVTFsO+lOvk8lALhuibV2PoV4n2prpefUip0nbu6mqZy/00UXGOabDcThAZDTcdYqs7WNk23QOPT7VvLWrmOwlbKgOI/4Ng2VOF2u4h0eLV96xpA0W9Q9Bvqj3mu3wAxqVCej1p1N2RdZ98SF9+ihkYtCPUHpRS5a3ey4d2F7P7O7rEXpVkojLcyf/cmdhYVUKpK6HJmF+KiYqAYzmlzNm8/+qVHIOqExnFccUsPrh5zCW07ZQRlu8813eh11dls+n4n+XnHSE1PpmvvduJBVIeIJ1Ed4VQCd4y7ofY8iagbZ6JTAXfnJflEBUGo16jWvdHqqJ364qWlKn1bRcUqYvzUALW+NbPOArxHZozBzovj5eV0/td/xCtDqDeIJ1Hd4x0rCLBvbTv3hYhsATN2f4L64Q60IZvQivehCrbB0Z/sgbOPbQNl862U0BJSz0VLPde+BS61G1pc02r3RRDqA4bVxq5vNrDhXws5uMkVw0sD5h7cRmFpa+L1xmb5FlmpdOiQSNq2PSw/BIfL7N892nbK4Jo/XUK/4T1IaBxXByNp+Ign0SmE/9PNasgWwRzHHUQjYdiszaPG6sJmmFUiQD2V/Oppt0MipAkRkU9nyGjhflC0St9WWrG6wlQYEYJA08LYTBU+Lku1N9HtsbmrO0blaisIJHC1IAihUtMntpmxj8oOo7W4BK2FKxCushajcj5GrbkH0i+Hklw49ovdG6n4D9TvX7ue343a2IWjtG5oqedC6jloMU382pRT1IT6SPmJUrZ9/gMbZy4yTy9TFlhXvJsFuWsZ32ow3Rt34udm8H9PXcc53bvy8Uvf8N2nayg/cYQT0XDEqtF3aHczEHVth6QQag4RieoapdXa1iitDtyITHO1uJaoC5t1Yq+uqHU3kDqwGQl7IbUR4ejuobRVy8GHw/7+EPaJatUQpsJEq85DyE+V4FpRtf7lTBMvcEEQwqBGt7Y16w2N2mBsmeYT+whLHCp3vt1zqe9sNN2CqjhuD4idvx6OrEPlb7CfsnZiD5zYg9o32/UMTjwdLa2b6XVE6tmQ952coibUK04cPMbPH3zH5o+WUVZoP6msIkqx6NBPLM3fQpGtlGZNm7GpAPo0gw6d2/DTR5uYMW42iRZF98aQHgc/HK7gnneHcs2NV9btgIQaQUSiOkahoWozfs4pImScOkJ2XexrqX2Tp8q8jdg35pN5/tf6vQwjvk8EbIZ9E/xUC66l2v+QaJpR6zYFQRAqI9TYR1p0Y2jeG615b7MNVV4A+RvtwlH+BtSR9fbA2UW7UEW7YM9nbodNKIjPROswHloOAj0Gte0VOUVNOOk4siOXjf/6lu1fr8aosAJQqJcxb/9aVhfuoELZuOii3tx77wQalaTz93GzWF1gcObPe0iNgsGO8ELRqY350ZrLwT+SaN0suw5HJNQkIhLVMcoAZdTmCibcBVOYW2HqIFZ2JA5tCme5VSfr8jpSw2rTbN3E0YrMtp3Qqd1Tv7Ravrr22F21K2bU3fypA9GmOlHTw6ha2/dSEAQhGLTW16D3mYWxfhLGwstcGY3aBiXcaDEpkN4XLb2vmabKjtgFI6dolL8ein+3Z5bkora/AdvfAEs8NO0BjdthrHkALb0fenSjyA9SEIJAKcUfP25nw78WsmfZFjN9nzWfBQfWs+nEXmJiY7h11K38acyfKMwxmPfP7/l5xSIAcot0cssM+vbNpvdlXbAmWnl99r+Z/99vuDj+dgoOFtXV0IQa5pQTiWw2G08//TQffPABeXl5ZGZmMmrUKJ544gnTVV8pxVNPPcU777xDQUEBvXv3Zvr06bRv395sJz8/n3vuuYevv/4aXdcZOnQo//jHP0hMTAytQ+GuJcJd9ajqRObwNlp1S0o51x/1NPBwLZkMT3SpuyOmIrV9J+hmtPrmHebe2ZN9IV17/XPew7Dnezg260QlqqN7Xh1BPpzQVBKTSBCEk5RIxz7SYtMgox9aRj8A1IFlGIsGoXWbAtYTqCPr4MhqKDsCB5aY9dRnmdia9kBr3hut+UXQtAdadIhrBUEIEVuFjZ0L1rHxXws5tHUfAArFzyf28u2Rn9ldepCWLVvy3KRnuPzCQfz41Vaev/5DThSWAqDpGspQXHhjOz5c8haLv/wXfGlvOzs7m39MeZ3Pn11NanpyXQ1RqGFOOZHor3/9K9OnT+f999+nS5curF27ljvuuIPk5GTuvfdeAKZOncqrr77K+++/T3Z2NpMnT2bAgAFs3bqVuDh7tPYRI0awf/9+Fi5cSEVFBXfccQdjx47lww8/DKk/Ci0sASWcP+Aqx2Ipcn/8rbrfmqpPniDVXNhXY5Au0SXk47DCNxoWkdq643LUDrZkXZwaV72xhnrmV2h1IkNNfTpPIvFAg7rZclbbqNp7HDjtiEgkCMJJTE3GPlIleXYb7e40RR+lDDj2C+rgCtSBJbDvS1BWu1B16HvUlqmgRdlPT2veG615H2h2od1zSRBCxLAZ5K7dQfGhQhKaJZF5XnusJeVs/WwFP72/mOO5+QBYMfih4Be+O7qZwxXH6dWrJ8+Mnkb8ieZ888GPPP7CW2abGW3TGHh7L/rd3IMHB76MdiKeX3ds4fvvf2D//v1kZGTQu3cvnrnlHTLaptG1d7u6Gr5Qw2hKnVoHdl911VW0aNGCd99910wbOnQo8fHxfPDBByilyMzM5MEHH+Shhx4C4NixY7Ro0YKZM2cyfPhwtm3bRufOnVmzZg3nnXceAAsWLODKK6/k999/JzMzs8p+OI+w2zZ6GI1jYmpmsN7U0HqwqglUV2szWRSG2WaV1FdhyrPNKom491JgmxE5kS8s6iZeT61uV1Q18SwIbv5EtM0g2gt9DlXv1//xsgpOf+1LOU5cqDfU5vHBQsPG6Umk9/8OrekFvvmHVmEsvAyt5z/BVgYHV6AOroDifV4lNWhylpto1Astrql/m3KKmuBg1zcbWPHiZ+apZAAxiXEYNgNrSTkARUYZS/I3s7xgG9YoxbBhNzGw57Xs+vEQ33/1ExXl9rhE0bFR9Ln6HAaN7M05l5yBrtuDvS//cgPPjHiHCwedyc0PDSS7cyY5W3P56G8L+HH+Zp6aNYY+13Sr/cGfwtTm77BTzpOoV69evP322/z666+cccYZ/PTTT6xYsYKXXnoJgJycHPLy8ujXr59ZJzk5mR49erBy5UqGDx/OypUrSUlJMQUigH79+qHrOqtWreK6664Luj9K1V7galWLf2j2sHsyeRWESEiHRNVYLyq3GFm7VbUWyUl0EkfAriVxSKgFHJ5ENfsBVW62HC997NXQPHC3WZveRMh2M0EQTmEqOUVNKcMeJLtRW7Q2N9mFnHaj7Hkn9qIOLLeLPQdWQNEuOPoT6uhPqO1v2htI7mTfmtb8Irt4FJ+B2velnKImAHaBaP69b7HLdogVB7bQuVErzm18GuVF9q1iBdYTzDu8njXHd9EsvTn3//lhWsZ0ZMXsn3n38wVmO+3OasWgkb25fNj5NG7iGzerzzXdeGrWGGZM+px7L5tmpme0TROB6BTglBOJHn30UQoLC+nYsSMWiwWbzcbzzz/PiBEjAMjLs7uPtmjRwqNeixYtzLy8vDyaN2/ukR8VFUVqaqpZxpuysjLKysrM94WFhYA9aHVtBq5WNbW7pIYIp6sK+wKtdn3klGm3VqlGWKJw+qqoxnZF52I9DMK+l1qYwXyr/TlpiIvnCI1JC8W1p/o2nd41wc/3SIzT4S1VFzbDJayYRHK6mSAIpyahnqJm1muUhXbaCDjNvu5QxfvtHkaHvrf/PLYNjm1DHdsGO96x/3aIT4eSPGhyNtq5L6KlXwbHtmJsmSanqJ1iGDaD/01+n70lh2nSJJmRGX3NvB3F+4nWLCRa4tA6pvH0RXdR8KvBqhnbUcq+Pm2UHM/lw85n0O29OaNbVpX2+lzTjV5Xnc2m73eSn3eM1PRkuvZuh8WiV1lXAGWzUbrtJ2xHj2BpkkZcp7PRLPXD+++UE4k++eQTZs2axYcffkiXLl3YuHEj999/P5mZmYwcObLG7E6ZMoVnnnnGN0Np1T+Kq1KUzzutljyXTHsQ9oI73KVT7XsvaeEeEFQNHNF6wr22YXVWC18MU/b6YVX0Wy2IAagQgqbXoUdG5dTkrKqlGRspr5qwT5UPJKDU1PhDmLPVnGeu6gp0f83VwBglJpEgCEK1T1ED0BIy0NreCG1vBECVHoJDK1EHl6MOfg9Hf7YLRGD3OFp+M6pRG7SMy9FOuxVlWDHWP4be8irZetbAKco7yg9/n41RUEpWXFMoAUNBbgnsOA555Y2JSzrMdcnNOSPvXBbP2GrWPefiMxg0sjd9rjmH2PjQwpxYLDrnXHxGpIfT4Dnx4xKOzHwd68H9ZlpU8wzSRk2g0YV9665jQXLKiUQPP/wwjz76KMOHDwega9eu7NmzhylTpjBy5EjS09MBOHDgABkZGWa9AwcOcM455wCQnp7OwYMHPdq1Wq3k5+eb9b2ZNGkSDzzwgPm+sLCQ1q1bV3u7WdVf0et+pRsZ56UQgwBXRwgL8+QlVfsqUR14TFXDZpgnLwWeP8GHvQ7akKNZp8dU9U4CDK22Cnh9Qj9VMFi0iMRdCnULn0LTvYz6NBGgzXD7qgUj+kXKU8relt9rW5Pj1IIVjSNnU7abCYJwqhPxU9TimkHrq9FaXw2A8fs81LIboe0wOL4L8jfAiT2onf+Cnf+yB8JWVtTaP8MZd9m3qjX8oJynDM4j7H/+cCk5i35C2ewevKU22HL8GN8eXYVK0bi823Wk/hJH+fFESAbjRClNM5sw4NYLGXhbLzJPa1bHIzm1OPHjEg5Me4KE7r1o/uenick6jfK9v1Hw+b85MO0JWjz8l5NeKDrlRKLi4mIzIJcTi8WCYdg/dNnZ2aSnp7No0SJTFCosLGTVqlWMGzcOgJ49e1JQUMC6devo3r07AIsXL8YwDHr06OHXbmxsLLGxsT7ptRmTyGGxDjbC1KZE5CrvvQ4N3djJHZGobkyr8AMBm6JLiHfTqbeENU5npVDFosqMBRtgOMQOVxo0rKHFb/JquyaCLXu0WVmdEANGV9JXD68ef9vN3ISyiOEuvlUqxFY/MLZPFU22mwmCINTkKWpYiwDQz38VLToRVVFkD4K9fyEq9xso+g0AtfNd1M53IaEVWmZ/tIz+kN4XLbpxTfRKqGHKjpfwy5wf2fzhUo7+5gpl8nvpEVrFpfG/g3kYZ8BVZ41kz4Yj/L76BACpjqXmmddk88DbD8u2MD/U9BYwZbNxZObrJHTvRYtHX0Rz6A5xHc6kxaMvcuDFRzny/hsknN/npN56dsqJREOGDOH5558nKyuLLl26sGHDBl566SXuvPNOADRN4/777+cvf/kL7du3Jzs7m8mTJ5OZmcm1114LQKdOnRg4cCBjxoxhxowZVFRUMGHCBIYPHx7UyWbu1L5IFD5a0IsuP6WqvSYK/RpFIppJKP5LIYUg8aobLqo61cPdulPt6Rq6eFJ9b7QQPXu0ynSpmnIZq20hSFXPZljeLpVt/aopFGjh2gwg3AXhrVO1l1YQ1z6kPhtoYX8XDG17pbOoeBIJgiDULFp8uv23xbGt0PQCtOhEaDkQreVAAIzdn6N+uB3SzoOCzVD8O2rnv+yeRno0NOuJltEfLbM/JHcWL6OTnMO//M6mD5ey/atV5illpUY5qwt3sqLgFxrHncadTdO4sGkGP2xT/IpdQMrqmM7A23qRP28phbsO07xrWxGI/FAbW8BKt/2E9eB+mv/5aVMgcqLpOilDbyd30p8o3fYT8WeeGxGbNcEpJxK99tprTJ48mbvvvpuDBw+SmZnJn/70J5588kmzzCOPPMKJEycYO3YsBQUFXHTRRSxYsIC4uDizzKxZs5gwYQKXX345uq4zdOhQXn311ZD7o1RtbheyL3vDdrDx6GcoK4pIeS+dxN4UIZX0xvvP/8G2pNl3mFTbYyoEmw59pDbvROS+z4TSUFUjDNRWHc3RWg5YXG2bYeHHZgjhpioXUCLtNRWMSFRJX8Iap71ebdgUkUgQBKGWqOIUNbXnY3sMpCsWg1EGB5ejcp1eRrvgwDLUgWWojU/YvYwyrrALRul90aIDH6GtDFvEttAJlWMrt7Lrmw1smrWE/et3men7y46yvGAbW04c5LwzLqdX4ws4uv8EmwsUF6QpLkq30KR3Vy694xKaJ8ew7u0FHNxziM0FGiPT29bdgE5SIrEFTNmsGKUlqJJijNISjJJin9clWzcCULT0fxz/9muMkmKiW2aRevMYAGKysgGwHT1Sk8OtNppStR3RRAD7Frbk5GR+uuV2GseEFkAsXOx6Qi0v7qrpAlJp1crW6WEfweWvXRU4y6te5C5t8IvWWvVe0qq5EA3HZNCxViKIc5whV6zO5ytcT5DwbWqo2rep1cE4tWqME8Kwax9jtT4n4doMx2Sg7XFVUFhaQevnF3Ls2DGSkgIvNgThZMH53UvmrFCfUPu+xFg+AloOCnyKmp8g2er4LlTuN3bB6OAysJW6MrUoaNYLLdMhGiV3Mb2M1L4vMdZPghN7XOUbtUE/d4qcohZBjufms+U/y9n8yXJK8+3bCm3K4Kei3aws+I2YxNZkJ3Xl+P4Ks05UjAVruQ0t6lf6tzqNBKtLuCuOtjJn30birefz9/l/lmDTbiibjX3jhxHdOpu0//sztkN5WI8cwig+gVF8guOL52IrOEqjCy9BlZXaBZ/SYowS1z9VWoIqL6vamB9iO3Sl5ZQZAJRu30zupD+R8exrIXsS1ebvMBGJ6gjnTd54c+2JRE7BptY1oqCCxkbecm171Nb+iVjV9FYIq1Z1rmv4C/VaP9pbRKLQbQbt1RPuOI0w4wNBtederYpEoY3ThaqGZ0944ywstdLquW9lwS3UG0QkEuor/oWbtujnvhCUcKOsJQ4vo29cXkbuJLREy7gCYlJQ216Blleid3kYkjvDsa0YW6ZVKkgJdgybQe7aHRQfKiShWRKZ57VHd9v2pQyDfSt/YdOspeQs/tncplFgPcHKgh3sLCmjbbNzseXHogx7nq5rnHtpRy4fdgE9B5/FXb1eIC5V57vfP8JysJTkqASOWYsxWsTTt+Vwyo4avP/zs/Vuu1kkYgUppbAV5GM9uB/rgVwqHD/Lcn6l/LdfQdfBiEA8xago9LgE9PgEtLh49HjH6/gE9Ng4TqxejiW5CY0vvRI9oRFRzdJpdEEflGFw4MVHKd+XQ+vXPw55fLX5O+yU22520qE0+79asWX/X61HPgk30HG49rDHlqrdcToGGXZ8oKor+l5CrXoxiapDmPczHEnaGQGoNsWwCARBOqnxCLAcFtUQ7sKOD0T1PInCnT/VEdEiNc4g2qlerKfQxmluN6uOx6YgCIIQNNU9RU2LiodMR2wi/HgZFf+B2jXTWRoqClEHl6PFpKA1vQD94v9gLBuGsf4x9JZXydYzP+z6ZgMrXvyM43+4thE1bpnGRY/eQMseZ/DL7B/5adZ3HN972Mz/tXg/GwoPYovOpJH1XFppCuthAEXH89py2U3nc+nQ7qSmJ5t17poylGdGvMPNA++n0+Xp2OJKsJTGs21RHqsWbOGpWWPqnUAUbKwgpRRG0XGsB3OpOLDfLgYd3E/FwVysB/ZjPbQfVV4e2JBhQFQUUc3SiWraAr1Rol3ciY7h+Ddf0qj3ZcR1PMsl+DiEINf7eLN8VeM5MO0JynZsJWXo7cRkZVO6fTMFn/+b4nU/0OLhv5zUQatBPInqDKcSuGHYqNrzJAJq28PG3OIWLtVZiNaqTYe9Bu5JVK0FfpgeL5pjAVutbTQh2zTCtFkdT6IIeFqF4fES3ve86ngvVcNjKkC9KruiG2GedhiuV4/vGIP/3IR7bQ00i5edoNvxM84gKCy10vL/s3fecVJV5x9+zp3tne27sEtVAUFEpYtiA40Fewka7NFgQaNRjGIXSxKNUbH8Els0GmMvGA02RKWjdEE6bKHtLmzfuef3x+zO7uzOzM7caVve5/O5sHPvOec959w7M/d+533fc88X4pUhdBrEk0gQ2tLkZWRueAm2v9+2QOogVMFZkNwf/f0VGCfMQeUcE/Z+dmR++WwZc254jl8advG/nespq28gLTqKX+UPosDWAxVloBscHizV9jqW79/B5ipFvK0Pur75C7jngGxOvGAEx58/kl4Dsj3am/f+Mp6d8TbFW5oFqbw+Gfz2oXMYP3l46AYaAlrmCko75zdEZedR/dNiyj9+i7oNa0g4cizYbI1iUBG6qtJ7g0phy8gmOjuPqJw8orPzMetrKX/nn+TcNouEo8a1EWgCCQHzNq42wldOPhlTp1lOki2eRN2IUK9u5vLAEJSEw/63oFHWhQXrjg6WxR5rNlXYHMKaiYC+2xSyGNb8QGG01QorM2ypu42hbWH1sAlr6KluMmn9fWnxqGoqEGbvJeuCvDXvJYV2iERWTFq1aQTBZVsQBEGIKE4vo7oy9Pb3UacsgNJv0Ts/hZKvoHwNunyNs7y59mmM6BToMUxWS8MRYvbZzFdYd2AXa6rTyVVjOTIN+iVCeqMWoRtMimrLWb1/PxX2LKjvRxygTUjPSeG4c4/i+AtGcMgRvX2a0/GThzP2tGGsmL+BvcXlpOemMnTcgJB4EAV7yXhtt9OwZxcNJTuoL9rOnleewdYjA3v5Popn3YZZUeZSvmrJd23asKWlE5WdR1ROPtFZuUTl5BOVnUd0Th5RGTmo6Og2Niu/ncv+uR+RMOJo12OmSdnbrxCVk0/coGGWx9WaxNETSBgxPqhzF07CLhJ98MEHftc56aSTiI+PD0FvOjO+Pb668xMLzHfMypdBEMUMn/OeWB2n1SfnADyXGuv7T/i/mIOaXypc3bcwtVopi7nPLc6PDnKEW8jntu04fTcZQB4ki/c+yrB63QYQbmZg/bMkGEKaP234+b5uDjfzw4YgCILQoVHxuY57EXsV6pBr4JBr0HX70Ns/QW97D4o+B7MednyEueMjSOyDKjzT4WWUcWS3FYy2L1yHfV81B2qzOOngdBIrK6C2AQC71uyuVeTEwYaKVCpq0wBISI7j6DMO54QLRjL82IOxRfkvHNhsRsiTU1tdMt5+oMKRE6jEEQZWX7Kj+fWuYrDbXctXHcC+tzkMz0hKJiorDyMhkZpVy0g59TwSDh/pEIay8zBi41qb9Iqy2ci49DpKHruTkodvd4aA1W3dFNIQMGWzdehl7r0R9nAzw/Dvjlspxfr16+nXr1+IehQZmtzFlp5/OUntxDUGl2CFm/l32XQemwHkaAmaeN9OH5rGpQnApvUH0UiEuAUUbmbFZAArcAWSPDjsoV+Wx9kqPMkvgSFIIW7+2FR2y+N01vNrjoOQuNrPugoTZflnH2vXQUVNA3l3fi2hO0KnQcLNBMEz2rRjfjgU0g7FOOZNVIsvBq1NzK/Ohr3LIGscFH0G9urmygm9UAWTUYVnQeYol7pdmardFfxn+lNULNrqsr+8voYNlfWUVCVj13B6T1hcpiiYMIwTzh/BmF8NJTY+nM9//tM6DKzlkvFVi+eTceVNROcXNIs/xc2Jos3K/d4bj4oiOjsPFR1D3ZZf6PHrq4np1Zuo7HyicvKwJSYDYFZXsnnKRLJvuoek8ScFZUzBDgELJ10+3Ky4uJjsbM9xli1JTk4OcW86M/49jDYlkA6OLOjPE0ywdEjfbSqlw+xJRADP6q0rttOKbv4jkKTg7ubHp7YCyM/tqb0ADgfdXmB0oBRvYfhBL3R5uNzNY4v3SQubPpm3LNj4Y8S/t7EDd2/Cxr5acWWzmoutyZPI38qWBVFBEASho6EMG8YRszDnTcH85gKMwbdA2mAoW425+k9Q9D/n6ma6oRJ2fobe9h56x6dQtR297mn0uqchPhfVazKq8Ey/kmt3Fux1DWz+egVLXv0fJQt/cX5dN2iTzVU1FFfFs6s2DnBEwRw6MAMO7Gbwqb35wz+uCVo/gh0G1hKzro7df/8rsQcPIXHscVT/tJj9//uQ+pId1BfvBGDP/z3utQ1bWoYjJ1BOviMsrMX/th6ZKJuN6pVLKZp5PfFDjyTukCFt2qjbusnRVo+MoIyrs4eAhZOwi0RTp071K3Ts4osv7tq/9gS0upmFejqYy7T7+oAQzKdIX8PsrOZBCjBxU6fxtHXf0faFNe1wdAjmJdvapmp7OKjT6sv5tWxQ+WjAXdVAEnC56YbVuj7Ws5YgudGm5aTXzU34ZTdYOYl81W/RjmizcIe4Wb2GlEWbsrqZIAhCl0IVTMYY/xrm0hmYnx/ffCCxj1MgAlBRiVB4FqrwLEfi6+K56K3voXd8DNXF6PXPodc/B7GZqIIzHPVyjkUZrXLFmHbLK7aFm91rt7P0tS/4+cMFUO0Il1LA7toGkqOi2FdnsGJfAqDoP7QXx513FMedeyT//f1sipdBYq+8oPXFahhYE9pux75vt8Pzp7SYhl3FjpXCdhU79jWGhNn3lLJr3QqP7URl5xFT2K+NCBSVnYcR1/7zftygYURl51H29ivk3P4wqkXEUahyBXXmELBwIqubRQhnuNl5VwQh3MzHUxiBZb2dq5uF2W5AS15bQgfghORlfrw2GFjooJW6SplhH2fAq5t5btjLIethWJY9rJWJn9G4jXgPw/I6b5ZtBhBuFkCIm9W5VTbTcuiXNZt2VFQA4WaWVnFzhJt5L+Ph/eAiEvn+GVhR00Du7d9K6I7QaZBwM0HwDavijbbXQvGX6G3vo7d/BHV7mw/G9ED1Og1VcCbkHgc7P8VcOgMqtzSXSeyNccQspxgVaar3HWDVO/NZ/Or/aChqDqGqsptsrzLYWgn7GxT5cZqRGZrYPnmMufF0Djn2UPas38mS5+aw6cufWLhbcdPbN3LEhEEB98lrGFhjbp2EEeNdRaCWAlBpEQ27S9rkBXKHMzl0dh5RWTlE5fQkOrcnttQ0tv3ugqCEgbUdT9tcQZ0hFCwchPM7LKIiUXV1NVprEhISANiyZQvvvvsugwcPZuLEiZHqVlhoOslLzrkyvDmJAlrCHPwOcSPQkJQgeTqEnAjk6mnKgxTORNvKDGycfiXTba6nukNOomCJRM72fDBpOT+QhyXTfbEZbJHIpxBJ62KYsjQ/9rbL0fuKMi0miPdFJPJs04onUUVNA7m3iUgkdB5EJBKE8KHNeij5xiEYbXsfapsTE2OLd+Q0Sj8CNfwhVPpwKF+Nueox2DHHxWsp3JgNdjZ/s5J5z39I+fJtGI0RH3atKa5WbKmC0hrAMDjs6IM4+vRhvPTQB6jKbYzL70GvmBpioxqobYhie30s83eUYaT25j+//Cng1ce03c62aRcQ3asPGVfehH3PLqcXUH1pEVWLvsWsOuAo3J4IZLMRlZnjWBUsO4+orNzGxNC52PftofTPM8mf9ZzbMLBgLxnf2XMFhYsun5OoicmTJ3P22WdzzTXXUFZWxqhRo4iOjmb37t385S9/4dprr41k9wS3tHwECYe+2PqRJ9Qhbh3UsS7c8Vbe7IVKfPPQrnVzAY4zVDbDga/eRMEcf1Da8nH+/E3q7LG8D/baeGAG2sf26gcSbmalHu3mJPLoACjhZoIgCIIHlBENeSeg8k5AH/W4wzNp2/vore9BTbGj0N6l6K/PgZ6novr+GnX06+hvf4259A6MnqcFLfSsprqWf97zEns2lZLRN5uL77mUuPhYlzJ7fyni62ffZ8t/fySq1vH9ZqAoq4MtVbC9SmE3bBx5/CCmTD6ccacOIy3LkTs3q2cP3r/pMY4p/Jns+GZxprTaRmlVLyY/fonPApHWGnN/OQ27SmjY3WLbVULd1o1Or6Dtvzvfe0NeRKDo7DxnXiC3fbDbwxoGJrmCOh4RFYmWLl3K4487kl795z//IScnh2XLlvH2228zc+ZMEYmCjNNnLGj39b49kWiryVRdW/GveIRyA1mdWu8hQd7t+T9U5azrscfeBmJaMtqikn82NY5nZv/n1pEfyKvXiieblkPqAshJFMzn7RYXhveIxQCMuhMIfLEZSCioF++l9sKsrHn1eBdsPDfp+MyzZtN6cUvmmsQhS4KPiESCIAhC+yjDBjnHoHKOwex1OvqLU6H3ubDrB0fS6y3/Rm/5N8TnQvaxULkZds2HnGMCtv3n3zxM/fyNJEUZJAI1P+7gif8sIXpcP657+kYWvPpflr72JVG7awHHw3GtHbZVOcShaiOKkROHcMGZRzD65CEkpSW0sXFETjn5h29l7f50/v5DGjsOxNEzqYazhpRx7eFbyc0pd5Y1a2sahZ9Sp/hj31Pq8Ahq3K/rar0PSmuIiiYqI8tFBLKlpbP72UfJuPImUiadZVlkicSS8ZIrqGMRUZGoqqrKuXrZZ599xtlnn41hGIwePZotW7a0U7troHWwVhvz1aDlp98I0HJifO+0BpTWVgONLNVy5iSyqg94M+slSa9qedxf3MYBttdYINePv9mGm0p3pgfRQESX4PWiJV5nPRhhoG7asHam/cBfmyFyLAzN3PpW35PNoOcL87sTgiAIguCFmlIAjJFPQ1Qi7FmM3vwGestbUF0MW94EwPzht6hDpqH6nI+K821V7Nb8+TcPE/PDZsqUyaGT+3H4qH4s++EXlr/7C4k/bObZI6djU4oowNRQUgNbK2G3sjH21OGcfdYRjDjpUOITYz3a0HY7e156isSjxjLxpvvo9cUyDmzZRmp0LfkZigOfvUfpX+8n+q2XadhTillR5lPfbWnpDk+gzByisnKwZWZjVlVR9ubfybnjURKOGOPi4QOOMDCAmMJ+AQs4iaMnkHPrA+x56Sl2zvitc39UTr7kCeoGRFQkGjBgAO+99x5nnXUW//3vf7npppsAKC0tlVjxroalZ+fWTzz+NGI1TM0qynpYSlPd9nBXpk2ISKDjVG7/dGk/zAnQI5BvPYBp7CCeRL5OWDDG6amNUJ40f21aXdVRNYqUftcNLPRLtXlfh9pmq//9rScIgiAIPqLicx1f4+WrUZkjIXMEKnMEevgs2PlfzHVPQem3ULkVvfQ29LI7IG8iRr9fQ89foWxxPtmpqa6lfv5GUlLLuXJEA/YNH1K/AYYA/QZGs6Y4j5L9qVTUw5ZKKCGKkacNZ9p5IzniuIHExLquxGZWV9Gwd5cjD9CeXc6/azevp6G0CLO6km0Xn0iy1iQ31ilrUb9u08/NcxAX70gEnZlLVGZ2sxiUme3Yn5GNcpOzVtvtHPjyE/Z/9j4JR4xxPSZhYEIQiahINHPmTH79619z0003ccIJJzBmjONi/+yzzxg+fHgkuxY2tFZor24k7rEUxqAdoV9hd8wI2lO+P95ErcNLfHHVCTad3KYnN4nu8GAYiTEGw2Y7oYltioTIk8g/m75flw7nNwvvHUuiCwQkvARCuG16nB/3IYXK23FBAPr06ePWI/x3v/sd999/P3fffTefffYZW7duJSsrizPPPJP777+f1NRUj21qrbn77rt54YUXKCsrY9y4ccyePZuDDjoolEMRBCHYZI2DxN6Yqx5DjXud2rUrnAJE7MCTYeMrkFCAGnQjevMbsGcx7JyDuXMORKehep+D6vtryByF8vJA9M97XqJ/j/0cUbCdrRuT2bKrP/trY0mOraVvZilHFGxl6bZC1qteXPvUeRw8IAldvhf73g0cePt7Gvbswr63WRDSVZVeh2Xur3D8YbMR1SOzUQTKwZaWTvmHb5I6+SKSjj2ZqKwcjIQkr333hISBCeEioqubARQXF1NUVMSwYcMwGl3mFi5cSEpKCgMHDoxk10JKU3byRWddFd7VzcK+6leANgN4iA3LClwB2wukrqcV1QJIrNtuP8K4ulkLm9ZWpnLYtLqSlrVciQGsbhaATV8T07Q9ZLdu0904PYVEuuywW17FTUVZnFvDok2lLa80ZvjY1zbvJYsrjYEdFW3xLaasreJWUd1A9s3fy0pRnZB58+Yxfvx45s+fz7hx44Le/q5du7C3WFln5cqVnHTSSXz55ZdkZmZy9913c+mllzJ48GC2bNnCNddcw2GHHcZ//vMfj20+8sgjzJo1i5dffpm+ffty1113sWLFClavXk1cnG+eBbK6mSB0DPS297HPm0LNnizKfkylviKO6JQa0oaVE5exC1uL1c10+Tr0ptfRm/8FVTuaG0nq70h23fciVFJv5+5tazbyn3tfpXbxVk4buIGqulg27MoiJspOA/Xo6AZyeyXQy9iFqq0GpTB8vHdWCYlEpWcRlZ6JLSObqIwszJpqKj76N5nX/ZGEI0ZjS0lzCQML9kpgIKuBdVe6zepmALm5ueTm5rrsGzlyZIR6I4SGAFSpkGSC9mbAx9AvN+1orIon/pv0biaAUDtfwngsTlHYdcLORjBERivhQoGKoj7WdxYzAhAZLWJZwNWNiav9qO8oqgOz29yQf1j22rQ6t+JJ1FmZM2cOUVFRfPzxxyERibKyslxeP/zww/Tv359jjz0WpRRvv/2281j//v158MEHufjii2loaCAqqu2tqdaaJ554gjvvvJPJkx0Pjq+88go5OTm89957XHjhhUEfg68Ur1kNQOaAg4iKdoSnlJcUUb13H3EpqaT17NmmbHqfPsTEO5LfHti1mwO7S4lJTCS9sLelsiXrf0Y3NJBaUEB8kiPQpWrfPiqKi7DFxJLVv7+lsrt++QV7XS0puXkk9OgBQPWB/ZRv2+ZXWRUVRc5BBzvL7t26hbrKSpIys0nKyvS7bF11FXs3bwYgd9BgZ9myHTuoqSgnPr0HqTl5fpdtqK9n94b1Hs+nP2V9OffBuE7cnc9gXCdN5zPQ66T1+WwqG73DRt33fcg4ajd5x5c6j9vrU9j1fR9S+qVSq1uc+8PvRQ+7m/qtn1G3+u/E7vsC48Av6BX3o1fcT2V1TzavSKFsbTIJOooToxuIG1JLVLRJYnwtmUkHiM06gC2uAXutjbo9Ceh6A8cviRrQqNRkVHIP4vL7EJWehS09kzpbFPaYWGJ79qHHIYMw4hOd594EUgYchM0wqFo4j/Kv51CZU0h8ZbXzfGrTpOTVv6Ey0oka0Hz9BXruE0dPoCI5g6it64mPiSGuMcSscu8+itesls+IDvYZ0bLdzoLl3+et8tNPP2Gaps/lV61aRUNDQ1D7sGPHDi6++GIyMjKIj49n6NChLF682Hlca83MmTPJy8sjPj6eE088kfXr17u0sXfvXqZMmUJKSgppaWlcccUVHDhwIKj9DDZNPmNNybLDtgViE2tbOzPhc8mw4ecA/Ztb5Wbzc44by6JBm/73lxb1/Z36DnSWQkskBhpEm6qdLRQ2fcaqTTcqj2/jbJ1PzV98f2Mp50bjkvTtlFfutkD6KnQ27r33XhoaGjj++OOx2+3cd999IbVXV1fHP//5Ty6//HKP4RVNv4q6E4gANm3aRHFxMSeeeKJzX2pqKqNGjeL777/3aLu2tpaKigqXLdhkLRtB1rIR/PL1F859mx/9FVnLRlD+3LEuZTMWjSJr2QhWvPO6c9+6B08la9kIql+a4FK2x/djyFo2gsXP/8W5b+WDZ5O1bAT1r413KZvypaPdRX+927lv2b0XkLVsBMY7rmWTPh9L1rIRLJg13blv0QOXk7VsBNEfugqGsR87+rDowaud+xY8cC1Zy0YQP2e0S9mo94929Pe+S5z7Fj52G1nLRpA817Ws/V/jyFo2gp8eaF7Ce8nsh8laNoLUr11/KK599Riylo1gzYNnNI/t1RfIWjaC9AWu7e5/YTxZy0aw8eHTnfvWzvmArGUjyFwywqXs3tnHkbVsBNseO9m5b9vSxc7zWVNW7txf/PgJZC0bQfHjJzj31ZSVO8tuW9r8DLHtsZPJWjaCvbOPc7GXucRRdu2cD5z7Nj58OlnLRrD/BddzlL5gNFnLRrDs1Rec+9Y8eAZZy0ZQ+6rral+pX48ka9kIlsx+2LnvpwfOJ2vZCOz/cj2fyXMd7S587DbnvsX3XULWshFEvX+0S9n4OY6yq2deSPXKpWi7nUUPXk3WshHEfuyaCyf6Q8f5XPTA5c59C2ZNJ2vZCJI+H+tS1njHcY6qPpyByvsVUVO2saLIcb4aqqNg0kLM5PHseu5P6MbrpPihEyl+8FZ2/OFKdtx/H/H7PkHX1rN7YSHVJUloDYnxOzh05BrGTFnIwcetIaNgNzFJdRSetYKCM1bS87SfyT32F7JGbSH3mI0UnrWSuGEOL5yU31xP/TV/pPCkbykY/SG5tz9M5tW/p8e5U6lYeD855VMpef0yjPhEAHZvWO8897s3rHeGgCWYH5P94yjKnjkOs7qSmnUrKXn4dnoN/ieFx33Bxm+/ds5DMD4j0hccTc6+S1izcjnxQ45A2WzyGdE0tg72GdEZCbsn0fDhwykuLm7zK5MnxowZw/Lly+nXr19Q7O/bt49x48Zx3HHHMWfOHLKysli/fj09GhVNgEcffZQnn3zSxaV50qRJLi7NU6ZMoaioiM8//5z6+nouu+wyrr76al5//XVPpt1iNSeRVbQO8Ndty0at1vX4wjNNOXU92mwqEEx8GaAnm0GZHOv4I9goMIJ1/fhqt7s8wHby3De+nE4VsE3/P0sUgGFVCDGd9txW99im2c5xLzSFt/lYt2nemxJs+21SNdq08pOR5dBKIZI05fW5//77SUtL48orrwypvffee4+ysjIuvfRSt8d3797N/fffz9VXX+32ODhSEwDk5OS47M/JyXEec8esWbO49957/e+0IHRjKn/4CkM5vsfyqrZRNPN6orLzSIy39mN4ffF27GX7sJfvw9b4vRFDA/baGorumU580SbIA0zF9t81ewXGGI6Q1RSjhgNLvgMgOqXGeXzvxmyK1uVjxto5+MSVxKdXY9ggsXAfiYX7qG9oXKre0GzYnM7WxF8z7KyLUP85iew+e8juv4tdpYkkDjiYPcW7LI2ticTREyh+L5Y0IDWmls1TJgKOEDD6BNS0IESEsOckMgyDq6++moSEBJ/KP/PMM6xevTpoItHtt9/O/PnzmTdvntvjWmvy8/P5/e9/zy233AI4fuHKycnhpZde4sILL2TNmjUMHjyYRYsWcdRRRwHw6aef8qtf/Yrt27eTn5/fbj+aYgoXnnm15CTyox2fsfxDvsWHpYjkJApyfiAf2lGND82B5FDyx56DzpSTyLRoL8g2/ZnbYNj05/1mOSeRCTbtXbTxRCA5iQwrIreJitKW8wO1DHHzvQ07KqodbdzjMTtYzUk0fYHkd+mEzJ49m2uvvZbnnnuO3/72t+1XCIBJkyYRExPDhx9+2OZYRUUFJ510Eunp6XzwwQdER0e7aQG+++47xo0bx86dO8nLy3PuP//881FK8eabb7qtV1tbS21trYu9goKCoF6zEm7WftmuHkoSrnCz/aVFGCXbSIyOdq4yVbrxl6CGm1X+8BUlj92JbfBhRB/zK1KHj8S2p7QxKfK3xFx4DdEHH0paSgr2cofwU775Z3TZXmx2O0Z1NfbyfdTv3YWu3AsNDWh78xewMkxQGm0ajl8eAdAomwko6upt1MfEk9BQhVHYm6rEbDZuq2Hbz2VQaRCvbCgb1DdEUVMXS5ndjr0wjfFTxzJ4xMEkxxQTX/YJestbULuneew7e7Dhp/6sX9GH+rooqqnn4su+IqVHFdG/2YmJchsa5O91UrV7N1G7ioi3Kec5Kvl5XUDXiXxGdP7PiGCFm4UzJ1HYRaIJEyb4nc399ddfd7kpCITBgwczadIktm/fztdff03Pnj353e9+x1VXXQXAxo0b6d+/P8uWLePwww931jv22GM5/PDD+etf/8o//vEPfv/737Nv3z7n8YaGBuLi4njrrbc466yz2u1HJEQihxdR+H/5DcimX0l4WxLuZNmmxWWrocOIRL6gwm9TNQoS4RT9lLIqTOm23hU+5+wJgmDjd04iq+O0blMFIhJZTFytbHaLHnAmypK/rR1ls/A+UYCyWxQaLSaubrRpWSS6caGIRIJHtmzZQr9+/XjnnXecuYSa2L9/P5MmTSIhIYGPPvrIa/JpX+7NfEESVwuhQNvtIV8i3G2i4uw8Mi69LqBExWZtDWZFGfb9FdjL9lL65P3Y0tJJHHUs5oEKhxBUsQ972V7qi3eAhRQgKi4eW2oPbClp2NLS0aad6iXf8922DAwdjzKjqW2IorYhirJ6g7KGaq4avpFX1vSn9kACOXEQ1eJ7sULbiRqYxWl/uIDBRw9za1Pb69Br/oL+6X60ifN71W4a7Nx3CIm1B1G7bg15x63HOGEOKucYt+0IQkeiSyeu/uqrr8Jt0oWNGzcye/Zsbr75Zu644w4WLVrEDTfcQExMDFOnTvXJpbm4uJjs7GyX41FRUaSnp3t0e3b3axYEO9ys/QcorVXYPYm01paWeXQksvF61COSY8MCPnkSBXdifWstEKttrxKf2rKsa7aoqNz+2bGwNE73lZQ/4aD+7Hfa1G7DSH0+n5YEm6bKftoDlGHBk8htEqf2qwRUSFkMU8OPcy50WEpLS9vczwSTF198kezsbE499VSX/RUVFUyaNInY2Fg++OCDdlcn69u3L7m5ucydO9cpElVUVLBgwQKuvfbaUHVfENolVOJNaxslj91JwpFjyb7pHmIK+1G3dSNlb79CyWN3knPrAySMOhZdW4O9ohxzfxn2/eWYFeXY95e7/G02vnaUK0fX1baxZ1aUUbZ1o+cOKeUUfGypPTBaCEC21B7NW1o6tpQ0jLh4l+q1NTWsOPtk+qfWsbvfSRSeNpp16/ew/N/fkF66hzP676KyLppMMx4aA08qlZ2EYfmc+vsL6DtiULvPFcoWg05yRKHU9n6Rmi8eIz5jM7HpVRRkrAHWYPbuCfVg7t+ITUQiQXAh4qubhRvTNDnqqKN46KGHAEeOpJUrV/Lss88yderUkNkNflx8Z7o5j8wjsuVctUHthW9Y9ucLIL1Sm+9XH9rR7uoFgM95bIJIaG26PyGRGKdPWPbya5s3x+cUU1bz34DlUD5ldUU1N/nUfBundkxtkGx6t+RANYZWhjcnkYU6QofigQce4LHHHiM2Ntbt8a1bt1JYWGipbdM0efHFF5k6dapLQuqKigomTpxIVVUV//znP10SSmdlZWFr9MAYOHAgs2bN4qyzzkIpxfTp03nggQc46KCDnPki8/PzOfPMMy31T+j6hNrDxxfxxl+hSGuNrqrEXrkfs3I/9opydj37GDGF/YkbNIyqxfM58NWnDsGnphoVF0/Jn+5C2aLQ9XXWBhIVjS05BWw27LtLSRg5HluPDGzJqS6ij4qLY+dtV5N1w10kHzvJmi3ghYffJK04jzG9t7Jr/Rxev3EhNnscw3rUMLD/LrKT97N0WyGV2iR9bB9OmnY2vY8a6PcPzio+Fw0kDOpDwtgfqFnzIzUli4mu/wpbxf8w6nc4Ci6+GXPPQtRBV6HSh1selyB0JbqdSJSXl8fgwa5xgYMGDXIux5qbmwtASUmJS4hbSUmJ89er3NxcSktLXdpoaGhg7969zvqtmTFjBjfffLPzdVNcvHX8f/poCjcLb4BhIKJCAP4jlnNla88PgV4bdBy0/MxtLXmJNQ+JRjxeBy7tufeisHoNeXQiCbNCEjpzniemw3oTWcKzOhnScTYrIv7ZtOxJFMA43RVoz6OnnTLtD8FNX33ph5f3vNeORCB8WQguWmv+7//+j2nTprk9/ve//51rrrnGUsj///73P7Zu3crll1/usn/p0qUsWLAAgAEDBrgc27RpE3369AFg3bp1lJeXO4/94Q9/oLKykquvvpqysjKOPvpoPv3003a9kISOR2cOz2pC2+3seekpEo4cS87tD6Ma46jjDhlC9q0PUjLrD+z++1+xpWdjVldiVu7HPODY7E1/NwpBLvuqDoCbVaDrKsrY++oGz/0xHQKRio7BSE7FlpyKkeL4v+XfTcdsKakYKWnYklNQcQkopaheuZSimdeTdtbFxB0ypI2NmnUrHfOY4dviQ03sLalg+TfrWPbVOhb+byXRu8sYnZnKVxsLGVlQxJDhze/zyrpofjSHULJfoUcWctVLd/hly4WscZDYG3PVYxjHvEn8kCNgyBHA1Zh1ZejPJ0LFz2DWon95Gf3Ly5B+JOqgK1G9z0VF+ZY/VxC6It1OJBo3bhzr1q1z2ffzzz/Tu7cjuZcvLs1jxoyhrKyMJUuWcOSRRwLwxRdfYJomo0aNcms3NjbW/S91mhaJ20KNdtiymk/GqtUIPEcEJExpcDter/Ftrf73FytzFKrLxqUvrka0coT8BFvU8XSNhEo88uVUWsOzqBA6m5FAN//nh6dNUMbpppF2bboJG/MJ3Rjm5rdN/1Yoa22zuc9+VfS9TsvOt5ybznchCgESFRXFDTfcwOzZs5k8eTKnnHIKY8eOxWh84L3ooou47777mD17tt9tT5w4EXdpLydMmOB2f2tal1FKcd9993Hffff53RehfcIh3EDHCc9yZ0trja6rw6yuRFdVOsSdqhZb0+vqKuq3b6ahtAhbeiZFM69vFIIOOISe6krnjc3O26+yNAYVHYORmAyGwr53N/GHj8KWmoaRkISRlOwI70pORcXGUvLIHWRcMZ3k409FxcVbTPEAcYOGEZWdR9nbr7gIXwDaNCl7+xWicvKJG+Q+D1AT+/dV8uO361n+9TqWfLmGrWuLSY6CvHgYHAfpGY6bh+qaVL5en0JKaiVZh6Qz6LTjOPTs01j5woew9jMy0pIsjaMJZdgwjpiFOW8K5jcXYAy+BdIGQ9lq9Oo/Qflq1NH/RMVlo9e/gN72Huxdgl6wBL10BqrfFIdglHJwu7YEoavR7USim266ibFjx/LQQw9x/vnns3DhQp5//nmef/55AJ9cmgcNGsTJJ5/MVVddxbPPPkt9fT3XXXcdF154oU8rm4WHYCsz7X3hhOLRMFK/UltLPBwyImHfg02nc0UoTIZhnKE3odv+aSWHTqDmQz5Q73GO7aYXCsSsFZtW58ON0ONrHi3LXjZWxSVv7QXZZqCauNBx6NGjB4cddhgHH3wwzz77LA8//DBpaWlMmjSJ0047jb59+zJnzpxId7NDEi5RpSt43bS0E/TwrIYGzNpqdE0NZm01ZuUBdj//F2IHDCLp2EnU79hC7YY1mNVVRPfsTdSWXyh98gHi/vcRuqbKKfo0iUD+JmauXbvC63EjKRlbeha2pGSMxGSMpGSMhCRsSSmOvxv32ZqOJTZujT8sN3n39Ljgcq/ePTG9+2PEB+b5omw2Mi69jpLH7qR41u3s7j+B3fZkMm37yfzlK6qXfkfOrQ+0uf6qD9Sw4rtfWPb1OpZ/vY71y7eC1mTEQl4cnJQLSS5PnI5vj031Dfz+3TvIO6yvU9hqaGjgvUc/YnxsDCdddGJA4wFQBZMxxr+GuXQG5ufHNx9I7IMx/jVUgSOhvsoei655BL3xVfT6f0DlZvS6p9HrnoacYzEOugp6nYYy3K/AKAhdjbCvbtYR+Oijj5gxYwbr16+nb9++3Hzzzc7VzcDxS8Ldd9/N888/73RpfuaZZzj44BbL7e3dy3XXXceHH36IYRicc845PPnkkyQl+aZ6N2UnX3DGb0mKdp8LwHd8zZLR8lf1QPHvsrG8GpZFlApkSXor9rX1vCeWkwp1vtXNrNSzvtIYgGltdTPLK421WN3Mz7FGZnUz6yuNKZsFe4Cyuhx90zit2LTZMfwVbZTDJjYr7xU7RpTV94nd4tz6sbpZ60KG3b/3SWP9iuoGsqYtlpWiOjEff/wxixcv5u6778Y0TebPn88nn3zCJ598wooVK1BKERUV5bLwRmcmWCvDhFNUCafXTdo5v3ERbqqWfGdJuGlJs3dOFTtuvZzovF5kXHo9uqEeXVuDWVONWV1F+bv/pGHPLlJPOx9dV4tZU+04Xl3lLKdrqh3la2ucf9NQH5R5cEEpVHwCRnwiRkLj1vR3fAJGQiL2AxUc+HIOqWdfQmy/g5uPJyVjS0yhbscWiu6aRt59f3OEOVlE2+1sm3YBMYX93Hr3lDx8O3XbNlHw1BtBEw8XPfkixmf/pEdMjXPf3ro49MSLGXHDZdTV1LN64SanKLRm0SbsDSbRSpMTB7nxkBOniWmxrKhpQOLB2Qw/+xgGnDicl067l5I9dSxStVwx8yyO+9UYvvzke/5+37uM0LHkZMRw3eInMGzBSX6nTTvsmo+uLkbF50LWOJSHmy6tTSj6HHP9/8HOT0E3hv/F56L6X4oacDkqoaf7un7YEQR/CefqZt1SJOoIBEck8u/UBUcksrgEdacTifz1JtKBCTbuaLetEIhE7bSlWgoSFmy662v7/Q+uSOTbdFkXbHAj2ITaZvhFIo1yI574ZN6qSKRMh83Wu32pG223lmO5aTl6v99jJirK6upmdovvMRMV7UOomtv3vXuRyGMzLUSiTBGJOjUNDQ1ccskl/Otf/2pzbMeOHfzf//0fDz30kIhELQi1qBJqO9o00fV1DiGmqpKdf/wd0bk96XHxNVBfh66txayrxaytpuKDN2jYu4vU0y90ijq6rtYh+tTVomtrG187NrPO9XVT2bBgs2HEJYAC88B+YvochJGQgIqNdwo7RnwiKiaGsrdfIfmkM4gfNhIjoVEMSkxqFHocdVQ7X1ThFG/aXgt9qdu6KejXHMC895fx/BXPMSStgYLkGmKjGqhtiGJbRRwry6KI7d+LHb+UUlfjEOcSbZrceMiOayA71obR4qZOx9noOW4gw848moJxg4hJbM4f9stny/jk+ufYWWNnQ4WNinpIiYYBKXby42z86m+/pf/E4UEZUyDoyq3oDf9A//IS1Oxy7FQG9PwVxoArIe8EVOOXtt72PubSGVC5pbmBxN4YR8xyeiwJQiB0WZFo3rx5jB8/nvnz5zNu3Lhwme2QBNeTCHwRVILrSeSbzSY6n0jkbz+6qCdRmzKh9yRqW6aTehI1NxZym8qizXB4ErUpEognkY9ePW2KRNkxLF2zAXj12Cy8T5pEIn+uA6cNPzyJ2rTRKBL5WVk8iboGP//8M/v373fmWGzN+eefz7///e8w9yo0BHqDHS5hoMlOdH4h6VOnYd+7G3N/eaMwU0PFp+9iL9tL8omnu4g3boUbp7DTeMzqClhBQsUlYMTGomJiUXFxGHEJqNg4VEwM1Ut/IG7IEc7QKRUbhxEXj4qLx4htLBvXYl9cvEMEiotHRTvCgJrCs/JnPecxPGvnjN8G7OED4RVv3HqV5eSTMXVa0GzY7SbXDJjOYdG1lMbWk3bUMHbt1mxdtIG+MQ3kxsHCPVBjQlZcPblxmvSYGJc2onOTGXjKCA6edBQ5h/Xx6gn0y2fL+Pbht9i/Y69zX3LPDI6+/dwOIRC1RNvr0Ns/QK//Pyid13wgqR9qwOUQl4n+4VroeQrGobdC6mAoX4256jHYMccltE0QrBJOkSisOYnmzJlDVFQUH3/8cbcXiYJLuJ3BuovzWQfITdTBbIYqJ1G4VzeDUE2t52smdEMM4DoNxbkMfpOurfu4gFczunGBAP9NoVSLPPbuV/rzWNlqTiJ/+uqSGkqB6ffkuJZpXV3575QkdD5ahtK743e/+12YetLxqVnzIw2lRWTfdE8bTxNlGKSd8xt2zvgtNWt+bFeAMCsP0LCnlIbdpY7/95Ri37OLhj2l1O/YSsOuYhpKi9ixfIHHNsrffz2wARkGmCa2tHSnUKNiYjFi41AxsWCzUb3ke+IOPZyYgn4OYaexjIqNxYhpFHtabEZMbGNbLV/HUPPzaorvnU7e3Y97FG+ql/5Aj/MvC0i8CVbyZV9IHD2BnFsfYM9LT7Fzxm+d+6Ny8oMqEDXZShgxPiT5qfYWl7N64Sa+eGshA4w6imsUP+yIgY1rAbApjY6tJznaYGSGrfGezSHKaQPSD+3FoaePoe/xh5Fa4PvKZ/0nDqfvCcPYuXg9VbsqSMhKIf+og4IWYhZMlC0G1ftc6H0uunwNev3f0ZtegwMb0cvvdBSKz0cNugkyRjhyLGWOxDjmTcxvLsBcegdGz9Mk9EzoNIRNJLr33ntpaGjg+OOP54YbbuC+++5j5syZ4TLfRYmEWNMdBCIPY2xv6KF4YuooNlWLQ2Fa3SzUwlFoVuFyeWp3SSQdtlPpT/JqK0vDOxv3fRW34IzNqk2FY1VHq0sItl2K2JPNlkeVlbnVNF74PvZVe3zhfXfrfnnqp/bQasvPA6HLM2HChEh3ocNg37cHgJjCfm6PxxT2BaC+eAe2lLS2AtDuEhoahSBdXeWTTSMpmaiMHIyU1BbijUHlvP8Rf8RoYvse7BRljCYRp41I0/q14++aNT9SNPN6cm6b5Vm4WfI9PS64ImCvm/ghR4RFvGmZfLnk4ds9evgEK39PKMWb1pgo1u1NYm+xnXSdxFAU/lqxN9jZtGonqxZsZPWCjaxasJGiTbsByIzVjM+CRXshNqqelOj95McbFMYlE9UiYbNpwICJwxkw8Qh6jz+U2BTrCbMNm0GvUYdYrh8JVOog1FF/Qh9+L3rLf9CrH4f966F6J/p/J6HThqAOugrV9yJUVCLG4FscSbN3zYecYyLdfUHwibCJRHfffTcvvPAC999/P2lpaVx55ZXhMt2xUVj/xdmCqXDd1rs+4Acz9CvUWEzoHCgdbX489CdUnkSEsF2vNv0+0B4t3l9e5jBkhG0O2/8cCX5XdLuilvfz2fKoryKMd5ue7QXgSYRFAdOfCW9poEkH8yfcTLf6XxC6CbYeGQDUbd1IVEYWVcsWuAhA9UXbAdj9zMM+tdckANkysojKzCYqI5uozGzsFeXsffkpcu99koShbcMAa9atpHLe/0g7c0qn8boJp3gTTg8fcIwtUBGtPea9v4xnZ7xN8ZY9zn25vTO4ZtY5jJ/sOTRr/75KVi/c5BCEftjI2iWbqT7QOseYhuhKesTagRSG96ghNToOSHeWiM9NJfmQAkq/Xol9RCG/+utv6e6oqERU/6mYtnj0d5dBnwth23tQthK96Eb0j/eiDroK+l0M4EhmHdkuC4LPhDXcrKGhgVtuuYXnnnsunGa7OP7fpUdWsAmXSBWAMBVIjp+gzq37uXIZl+UHUR8S3HrB0QcLtjvQt6PXrli+TFt4gfgZuhMU3NgMDU2uJO5F1ZDOrRfRxlPTynS4xLu21Q6NXj2qKfzLXxHGbuGEN70prcyRVu5d8nzCwDG3ftYXkUjoZrQUVZInnsnu2Y94LGskpRCVkd1GAIrKyMaWmU1UehZGXLzbutpup2LO21R8+Cbxhw7vUl43XSE8K9zMe38Z9055gVEnH8opNwzHjK3BqI1jzf+KuXfKC9z92lWMnzwc0zTZ9nMJqxdsYtWCX1i1YCNb1xa3aU9FaWqMPUTb95EXZ6N3Qio9Y5sFodToOLAZ5A7rQ7/jh9Hn+MNI7ZPNbRPupQ8wYEz/8A2+E6Dic9GAcfBv4ag/oTe+hv75OUco2qpHYPVfHAXtXWMBAKF7IKubRYimxFMLz7yapOiY9isEje7iSeSvzfY9QHyyZ9GmtfmJROJqbSHpsH9z27ZIaBNXu+2SsmrT/epmPtmMyOpm1sfpi023hwyrSaR9W47e7WGbBZvKYdN9Emkvn6ON9Qy3P8H48PmrPNlsDzsqysdLoE24mR1fYhZUqxcVVQ1k3bhQElcLnYZgrm4Wd+hwdH0d0T17o2w2atevoW7zejKuvInk40/1KAD5a6erJEVuibbbu4R4Ew7sdpPfDJ1JXLrBl9v/ha20htSoBMobqjCzEhmVdiaVu+sYPLIfaxZtYv++tmGMtiSTsvoiqN1FXnw0fePT6Rufja3VUpo9Ds6neN02DtTZqB9+KBfdfip9B+ezafVOXn90DixaQWJsHbeueo7omOg2dror2rRjfjgU0g7FOOZNlDLQph12fIS5+nHYs6i5cP7JGINuhOzxjrxFguAHXXZ1M6GZZpHoqjCLRMH0JAr16mY+2PMWFuXy3Rfqy9zx8NpaHAstIRaJ3B4P8epmHmxaF4l8EBWCatPN6mZtDIZQJPJi01PdkNj05kRjeUU13Uok8uPzx7C6rLxuIdg02ms1ME/nUkVpi+meGq8hv0XGQESiRgHOTyqqG8ievkBEIqHTEKwb7HCJKuEUb0S46Zgs/+Znfn/K41TbFnFmr+Ek2JvPSWUDrCyDnTXNH+q2aANbagMllZupriwiPy6GAQlZDIjPI97m+ryRlJ9O4bhBFIwdRK/RhxCfnsxr9z3L3n8uo7gOfi5XzqXpD07V5MZA+sXDmTLzmnANv9Ogt72POW+KY3WzwbdA2mAoW425+k+w4xPIGAF7FuO8l0gfjhp4I6rwLJT7X5UEoQ3dRiQaO3Ysn376abe8uWw6yYvOCrdI1Bm8eixi2XspgLdAqwdWqzYDEV0sj9PXei7lHOKAtdPp/iG7fQITiSyJA8HwsAmbTf9CHV29QawvR++Lx5TbwwF4Ellbjh5rnkRNNn28d3Nt3u5zvbYNhcGTyMVeY10LNiuqG8i++QcRiYROQzBvsMMlqoh40/Gx201WzN/A3uJy0nNTGTpuALYAVuiqqapj06odrF++la/fWUrpwnWMzIDiGli3H6dwc0gy5MZpFu5RrNU7KTqwgl7x8RyckM8hCfmkRrkmlI5NTaBgzEB6jR1EwdiBHlcie+2+Z9n8z+9JVc3ecGW6mr4XjxGByAt62/uYS2dA5ZbmnYl9MI54CFUwGV2xAb3uafTGV8Fe7TieUIAaOA3V/1JUdHJkOi50GrqNSGQYBsXFxWRnZ7vsr6io4MEHH+SRRzzHend2mk7y4rOvDLsnkXWsXyo+Cxluwpss22zz/RzKS92TYNOBbbo7J+2epzCEuLmxGXaRyLKHjUa150kUApsu8+qXB4rduk134/QlP1EwQvn8tmlRDFMaZcHDJjBPojCJRC7XjNki3Mz38VZUN5Dz++9FJBI6DeG8wRa6B1YTSjdxoKyKDT9tZ8OP21i/fCsbftzG1nXFmGbzCgETcx3C0PKaGJJzY6k2ythQsoqdu37m6p4nkBvTg7KGA2TFJLm0bYuNIn/EwRSMPoReYweRNaiXS34rb9TX1fPfF99l95YiMnvnMemysyTEzAe0aYdd8x1JquNzIWtcm2Xvdc1u9Pr/Q/88G2odK8sRnYoacDnqkN+hEvIj0HOhM9DlRaJzzz2Xo446ij/+8Y/8+OOPDBniuuxmUVERvXr1wm63h7trYaPpJC85J4wikYZwraTmQiBJpENuM1jzob2H2LRn04/5Uc5/3IW4uW8+UJst2wnIk8hCRRWId05nEonC5ElEy6Jh8CRqazO0+Z6CbtPP68Bh0+GZY+lzT5n+rTTWyqalN6dqDMfzs25FdQM5t34nD9xCp0FEIiGYNCWUHn3KEH5968nN+Xse+5Qf5qx0JpRuYm9JhUMM+nErG37czvrlW53Lz7cmJSORtJ5x1JZtY6wZz0ele/i64mP6xGXTPz6XQxLy6R2XidHiJkcZiuwhvek1diAFYwaRO7wfUbEi7HRUdEM1evMb6LVPQsXPjp0qCtX7PNSgG1A9DotsB4UORzi/wyISBFlYWMhHH32E1pphw4aRkZHBsGHDGDZsGIcffjjr1q0jLy8vEl3rurR4iAxcsPH9Idi5KJBHm6ESrcIvhik8za0fffHz3LhPuuybTe/nxRPayzjbr9u2Az7iw/XT6fP/BXrJagtzoK1OmvK7v03FFcriIlzKb427ZXHLNk1883BULY8onCuxWbHpZ2ddVrS3aNPDQnXtGO7sbzpBEARr2O0mz854m9GnDOHu169i/vzv+PHDheTl5THztSv549nP8NcbX2f98m1s+GkbG37cxp6icrdtZRf0oEevRBpiKymq2MxPGxazddsmMouTOb7HEEgbzPi0DE7NuqRNsuMD9ZAUDRknHMLZD/+W2JQEtzaEjoeKikcNuAzdfyrs/C/mmr9C6Tz05n+hN/8Lco93JLnOPcFtkmtfvJYEwSoREYn+8hfHUoAxMTHMnz+fnTt3smzZMpYvX867776LaZo8+uijkeha2FFGIOEpTfhW399VnINHBASbdkOiQtCnsHtpWQ3fcm3C2jLdFrHiSdQocLqv2rQ3iHPvs0dYkAmCUe3H+Qx05lzScXV4rcBqBz3Njpv2WhfVFi8krdFa+T2vCgWmBXsKZ1/9FdK0iESCIHRTVszfQPGWPYz6dR+G9h1FalkMmdHpmGYC1fZXsWmHB89rj85x1lFK0eugbLL6pGDGV1OyfysrNi7hq7UrMH5WFMRm0C8+h4nx/ejXbwzJUc05gVJjABQHGmBvLeyqBbJ6UJu8lbH7kxl3yckiEHVSlDKg5ynYep6C3rMEveZJ9LZ3oPgLzOIvIO1QR5Lr3uehGpOPt85/pAESe2McMQtVMDlygxG6DBHNSVRfX090dPd0g2xyF1t63hVBCDfzUyQKyn29f5dNyFY3s2wz2Je9L0mk21s223+bbsPNQohSZuP/Vmr7njvHxSYa2g1xCyAPk9tiVkPcAguN8/4DkB/Xj8/jDGDVr5bitl/XQwChfBauH0fZ4ORB8v26bww3s2JSmS6rm/nehu9Jtt3ZtHIdVNQ0kHv7PAndEToNEm7WvQhmQunyPQfYsraIreuK2bq2mGVfr2Pjyh3kx2mGpEFii8/fygb4qcykuMbGwJG9yR4YT2nVDlZvWsbiZYs5cOAAybZ4+sVn0zcuh77x2RTGZRHV6oPYiI4ie0ghJau3srmsiI2D4ezJF5OWmEFZ5R7e+PgV8pfVcnjBIfx2/p8xAkiWLXQs9IEtjiTXv7wEDZWOnfF5qEOuhfg89PdXO1ZSO/RWSB0M5asxVz0GO+ZgjH9NhKIuSpfPSSS0EInOD4ZI5BsOkSiYp9uPJaiDJmSE2qbV+fF3pbFWNjuJSBSJxNVK+SISebFpAWXxoTmwxNXtiUSe61kVfpWyKhK1mB+/bQdJJPLHdqAikd9jdOR6svY+8T8PUpNNS6ubAa6Jq32noqaBPBGJhE6EiETdBysJpbXW7N5Zxpa1xc2C0Lpitq4tomz3gTbl8+M0IzNgjxlFba88Mgf2xMZ+Glb9QmxJNQv3KD4q+4Rys5j8mB70jc+mb3wOAxJySY9KatNefEYyeUf0J3d4P/KG9yfr0EKiYqP55bNlzLnhOX6x7+K97T9QVLuPvNgenNlrNP1tWZzy5G/pP7H9JNlC50PX7UNv+Ad63TNQXdy4V0Fib9TxH2Ek920uq03Mby6AstUYp/8koWddEBGJugHB9STyDadIFJCoYPWhO7z2rNsUkcgbHdeTyIvNtg36YLMjehJ5rhdRT6JwikRW5zaIIpFvwzVRNuurm7ldxa1dgisS+dKOeBIJnQ0RiboH7SWUvuvVK+g/tICt64rYstYhBG1ZW8S2n0uo2l/jsd2cwnQKD8ml8JBcSit2EPfZaqpsBhuOrGTFyhWsWbMWu91OvBHN73udT4+YWDbVFNE3IYeYNh+yioyD88kb3igKHdGflIJMt7lnAH75bBnfPvwf9u9oFr2Se2Vw9G3nikDUDdD2OvSWf6NXzILKzY6dyoYqOAs1+CZU+uGOcrsWYH5+PMYJc1A5x0Ssv0Jo6PKJq4VgEAltT/TE7o62khzZY2M+lgu2COaLXcs2lY8G3FW1LlCGn+77WeBrcK+ynKvJ6iqAjbnYrJgUBEEII8EMA3PXdlNC6VuevZhP3/+Cd/71EfYDBtGxMcQnxXLfxf/nsb5hM+jZP4veA/MoPCSXnD49qLcdoLhiO2vWreaHn97j+RdWkFETy40Fp7K4BPZ8VEGWLY4hGWM4OLkXmUaCU+w5pHE58+jEOHIP7+sUhHKH9SUmKd5jP1rTf+Jw+p4wjJ2L11O1q4KErBTyjzpIQsy6CcoWg+p3MXYVDd9fDjnHQsnX6K3/QW/9D/Q8FWPoDEgbDOBIZh3hPgudGxGJOi2e3vqeH2GcDy2Wn+/8/7hp8l4KwB/IWi3LD9ze7HlvU7dfpP2m/RyuspBs1lm3zR/+VgwSkfgWC5nNAMSTYOguyutL91XCPP9B8Sr0+5q17q3n7K9f9bXFkLFW+HU+A7iArM5P2JP1C4LQ2bESBuaJupp6SrbuoWjzHoq37KZo8x7WLt5M8ZY97C0t45zCP5AZC3EG1JiwuxaaPuyiYmz0aRSCCgfmUXhIDkZiAyXlO1i1ehU//TSX119bwS+//EJT0EWcEU2v2AwOi83n8Mw+AByTozHIA1qtypwUBwdqSBvbl5Nvm0L6QfkBCzqGzaDXqEMCakPo3BgJeZiAMewesMWhV/8FvfVt2PEx5o6PIXM0gGO1M0EIABGJIow2FdoM5lOa57aaBJvAHgqtPBQEe2UhH2qG5NnF+ziCkhTcn343CX6BhtX569ET7NWsvNkPlYARMpuBeBIFYtc9IZ/a7vIzlZVxBvQ+sfg5Hcj58Hs1NR3kHHeCIHR1WoaB/fGly13CwO6d8gJ3v3aVi1Bkt5vs3llG8ebdTiGoePMeijbvpmjzbo9LygNk6gaG5LomlK5SJh8XrSKq4TBOv3EkZO7np58W8eF7K1i5chWVlZXOsmlRCfSMzWBij2EMSM2nID6LxIa2j00GitiUBOLyMojKTCPrsD6MuGAM1/3mGkYdSOeYq88gc2Cv4EygIGSNg8TemKsewzjmTYxxL6GH3oFe+Sh6y5uw+wcAzNV/wbDFoTJHRrjDQmel24tEDz/8MDNmzODGG2/kiSeeAKCmpobf//73vPHGG9TW1jJp0iSeeeYZcnJynPW2bt3Ktddey5dffklSUhJTp05l1qxZREV13CkNzvOc/x5Mwbfli83wC1Mho6N52oSqPx1tnJaIsCeRG4+0kE6rFQ+4YI3TH0HDXy8gZ8X27ARrxcKWNq3mXgog31xjcnjH324Oe6xn0Z4gCB2OUIaANbXfFAZ235vXYBgGWmvy+mRy0S2T2L2zjD//7p8s+GwVJVv2ULxlD6Xb9tJQb/fablxiLHm9M8jtk0Fu70zsDQ0sfvUbRmZqeo4dRM5ph7Jlfwlrv/8JvbCEc3OGsHCP5q7776TMLEKhyI5JYWBsDr1zsjkkvYAslUx0Q6sPuAbHf8k908kcWEDGIT1Z+vL/WF26ia0HRTFjxnkMGTKElStXcsnVV5C3uhZbQU96jRTPHyF4KMOGccQszHlTML+5AGPwLZA2GHXQVejqnVDyNWBA0eeYRZ9D7gkYQ+9AZY2OdNeFTkbHVTTCwKJFi3juuec47LDDXPbfdNNNfPzxx7z11lukpqZy3XXXcfbZZzN//nwA7HY7p556Krm5uXz33XcUFRXxm9/8hujoaB566KFIDMUndOMzhGUvG+f3pX8NBMfxxM9Od6WHF09DD3CMXmfU20EzcNv+2gwkStLrA7eHRrXl3C4dwJOoVTtepdSAwoUsihKWV39rQbt2datXFpNIN31Y+l1ZO3MEWcLCh2bAl48KUjuCIHQ6ghkC1kRdTT17isvZW1zO7qJyfvp2PcVb9lA4MJfbzvgb2zYWsa94Pw21pku9OS/Nd3kdFW0jpzCd3N6Z5PbJIK/p/z6Z5PbOICbRxsaNG9mw4RfWr9/AV19+w/i0HLbX1HPjS7eiX2puK0bZuKXgQob1iCE6+VD6pZ5Ian0MqqUO1fi3shn06J9L1qACMgcVOP4f2Iu4tERn0axBBZg3PEf0ul38+vhzXVcdSy5k4n2/kZxBQtBRBZMxxr+GuXQG5ufHNx9I7IMx/nVIG4pe9Rh60+tQPBezeC7kTHCIRdnjItdxoVPRbVc3O3DgAEcccQTPPPMMDzzwAIcffjhPPPEE5eXlZGVl8frrr3PuuecCsHbtWgYNGsT333/P6NGjmTNnDqeddho7d+50ehc9++yz3HbbbezatYuYmPZXK2vKTr7knCvDtrpZ0MOEfEVZDXELLMdGJFY3Czj0qwXt9z/Q1c38H6tqzF1ieaUxSwl5A1sxzOoqZdZW4Aqkr9ZX/XLn8eLbVNut23SzupmvK39ZnVt33i4+2TRMDEsXrful4dtvKsCVxlqtqBZ6m3ZLOZQqqhvIufU7WSlK6DR0xtXNQu3h095KYK1DwGqr6xrFnwr2FJWxp7icPUXlzv/3Fjv+3r+vyotV7cwVVG2HkoZaevbLoWRDOUefcThjfnUYeX0yyO2TSWZ+GvX1dWzcuJH16zc0buudotD27dtp+SgzID6XGwtOZcFuKDN3ERNfQb+MLLJVCnG17j8joxNiyTikp0MIGlzg8BQ6OJ+o2Oh2509WHRMihTbtsGu+I0l1fC5kjXNZ9l4f2Ixe9Sf0xldBN7rCZR+DMXSGrHzWSZHVzcLAtGnTOPXUUznxxBN54IEHnPuXLFlCfX09J554onPfwIEDKSwsdIpE33//PUOHDnUJP5s0aRLXXnstq1atYvjwtl8KtbW11NbWOl9XVFQAjh+qwyXTNXkRhTtRbefC3eT4cYKCmC+7zXXhTxiI30Z9XLOpSecJ4zUUKW3TGhH0JGppVvm4iFswBMYWJyi0NluZ98dmkC+ikNr05N3Wnj0LptoY6DxvNEGIOKEWbyA0Hj4taQoBG3Xyodz2/FTK91Sy4aft7Ckq5/BjD2HL2iIeueol3n/+a/aWOEShA2XVPrcfHRtFZl4q6bmp2KJs/PTtemKjtzEhN58E3TxX1dFRvLPpcxIYSc6wWFaV/sD7321wikLbtm3D3W/aKbZ4+sfl0Ds1l4MyC8iLTyepygb1MCoTIMux1bWoFBcNNfUkH5bP2Mt+ReagAlILsyx7/MiqY0KkUIYNco7x+NWtkvqgRj2FHvIH9Ko/oze+DKXfYM79BrKPxhgyA3KOda7EJwgt6ZYi0RtvvMHSpUtZtGhRm2PFxcXExMSQlpbmsj8nJ4fi4mJnmZYCUdPxpmPumDVrFvfee28Qem+dzucy5r+I0VRS6WCO15cPT4e1oH/OhuVz2/eZsu4tZZ3O9dUV4ZxEEL58RO2b7zg2Q9CpkNn0Us97k4EEZQqC4A+hFm+abPiT5Lk1tdV1lO0+QNmu/ZSV7mffrv2Ov1tsRZt3U7xlD7t3lnFmr1s8trXsq3Uur2PiosnISyUjN5WMvFTSc1JdXjf9n5TWvBR8dXUNlxdey9gePYk9OIvKQQls2LeDXWu3k78zil/nHsW83VVMm3E1LT/LopWN/Oge9E7L5ZDs3vRKzKIH8URXaahtESdWh4sYZFeanEGFqKQESEkia3AhR5x1FNdPvZZRW9M57ubzKBwzyK9z4glZdUzoyKjEQtTIv6IPvRW9+s/oX16C0m8xvzgVssY4xKLc4z2KRe15LAldk24nEm3bto0bb7yRzz//nLi4uLDZnTFjBjfffLPzdUVFBQUFBWGz33kJ5KEniD/jRwpfumO1yxZyw4gnUXt0gJxELZJJt+t9YvlybzVOf2xaNdkav8ZpdYl3wr+Clxch1ntPLOZdAkd4m5UfvTvPG1MQgkag4o0vuEvybG+wk9s7k8tmnk757gM8ccPrlGzdS/meA07Rp6UQVH2gtn1DjTQlh27QddTpaup0NVEJMProo1g5dztnXHUM4ycPJz03lcy8VBJT410eKBsaGigqKmL79u1s3L6Kr5dvY/v2HWzfvoNt2xx/F+0s4u7eF1Bco/jwv0vZ8vGPVJr7SDR60DtqGMm5iuE9DHTmMRyUVUiGLZG4aoWuaKH8OIUgR+iMMhTJPTPo0TeHtL459OibS2rvLD6c/hwrdvzM3IZSZvzuD86E0r/57ZWSUFrotqjEXqgRj6MPvQW9+nH0hn/Aru8xvzwDMkdhDLkd8k5yeW/rbe9jLp0BlVscrwESe2McMQtVMDkyAxHCQrcTiZYsWUJpaSlHHHGEc5/dbuebb77hqaee4r///S91dXWUlZW5eBOVlJSQm5sLQG5uLgsXLnRpt6SkxHnMHbGxscTGxgZ5NN2B1k8h/q7XHi5CmUU6FKa1Izuzn22qQFZQskhEnkPDmOcpJPiazyYY4wx6GKQP+GszgJxW7TfuhUh4MFlpUNPZ1FhBiAjuxBuAwSP7cd+b1zDzgmd57o63GXvaMMuhZ/YGO/97YyHFW/YwdNwA7jz3GdYs3UTF7qo2XzGzb/+P17aiY6JIy0omLSup8f9k0jKTnX/vK6ng/+5+j59qPmf0pKFcf95vyE3OpHj/bp565xVe/mQ2R8aezqCje1ETu5eFK1aw7ZPtbN++3VUAKirCNE2vfRmY0JMe0fHMq9/Oken5HEMhSVGQHAVJ0WBTALEcywDYDVDvHG5sWmILIaj5/9TCLGwxbfMGTXpgKuYNz5GwVhJKC0JrVEJP1FF/Qg/+PXrNXxxi0e4FmF+dBRlHOTyL8ifB9g8w502BnqdgjHsJUgdD+WrMVY9hzpuCMf41EYq6MN0ucfX+/fvZsmWLy77LLruMgQMHctttt1FQUEBWVhb/+te/OOeccwBYt24dAwcObJO4uqioiOzsbACef/55br31VkpLS30Sg5oSTy0+O4yJqxsJe+ip5STSLfEz3Iymf8J1eTvGqDqTTY9BzN4qmS1s+otVgcnE6DSJqzXK8updASaudke7ScaDkLjaX5vK6vk0PYs97dq0W7OpGs+n39etHWWz+D5RjcnPrdgMcrLs9qiobiDnFklcLXQeAk36ufybn/n9KY/zty9v5ZAjezNv3rcUFRWRl5fH+PFHs3bxFm44/jH+POcmDj/m4HbbK99zgI0rdzi2FdvZuHIHm9cUUVdT77a81hrTqCczrwf7dlYyeGRfDjmyt1sBKC0rmcSUOI8hJKZpUrSziAsH3UFBKozLT0OXN3sfHVB1/LCrgtKqWL6veQtv9xkKRXpsMgfl9aFPRh49U7JIj0kmWccQU+fwBmpox7NJ2Qy03SSusAeDJ45oIQjlEp+e1O5ctkYSSguCb+jqYvSaJ9Dr/w/sjTnH0odD5XaHaHTsv1Etbqa1NjG/uQDKVmOc/pOEnoURSVwdQpKTkxkyZIjLvsTERDIyMpz7r7jiCm6++WbS09NJSUnh+uuvZ8yYMYwePRqAiRMnMnjwYC655BIeffRRiouLufPOO5k2bZp4C4UMa/mJ/HvqCUFSmM5os0UYT8CmgkC38SQKUT4rr6czRJ5E7V1CAeOvTasdsRqmhgokli8y+DtO8ToSuiF7i8sB+GnDEk69YBKbN292HuvTpw+zHnjIpVwTDfV2tq8vYePKHfzSKAZtXLmD3TvL3NqJiYumrqaeXQ2b6TkonYtOP4GD+/aiXB/g6fde5X9z/suRsadzxb1nthGjKisrKS4u5seV6ykqKqa4uJji4hKKi4tdXpeUlGC32xmfMoIxCYexuWgfc/YsYWPNNvrFFXBKxpGckJHJWw0/kWiPY2CvfvTL7EnP1GwyY1NIUXHE1hmoynrq9lah7Y2eRPsbt8bYsNZyV1V0AwPHDCMlP4PUPtkOj6DeWdxw1Q2M2pbOxPt+E5RcQZJQWhB8Q8Xnoo54GD3oJvTaJ9E/Pw97lzkO7t8A2z9G9zrNKTgrZWAMvgXz8+Nh13yQldK6JN1OJPKFxx9/HMMwOOecc6itrWXSpEk888wzzuM2m42PPvqIa6+9ljFjxpCYmMjUqVO57777Itjr7kAgD13hfmCLxANimGyGOSwlIlEwwcrVExab7eNx/oIxTndttOvBFCD+2rR6ESllUSjqZAKRFbrBEAWhNem5qQBcc8l0jvnVSJ6b+ahLeNY1U2/iyNjT2V1Uzn/+NtcpCG1ZU0R9XYPbNvP6ZtJvSE/6DelJ/6G96DekJxk9U5mY9VuG5+dzfHouFf9eyGIcaQ5+1aMPCTlJbC+r5O//fpqSp0qdwk9RUREHDhzweTwKxYkZfSnWVWyri2VE4njGp0C8DRJjDVSM4tycoZyvDnNUKG/cqAVqXRYNUzaDpNw0kvPSScpLJzk/3fF3fg+S89JJyE7jpZPv5Jdt6/i2eA8zLv8DAxpzBd1ww0zy1gQ/V5AklBYE31HxOajhD6IHTcdc8DvY8QnsX48570JIG4ox9A7odbpDLEobDDi8kOQ3o65Jtws36yhIuJmvWEiujL/JlYPxFtB+hmF1AJu+1nMp5wiFsXY6O1G4WQAhUdbC2wKxqb0mO3Yx0WaHxTCslqFf7dhtazMI4Wb+2jTsGBavPWXpp5TAQr+UJc/tAGwaXkL5vCDhZkJnI1BX/bq6ek7MuIq+mTaO65PDgZ17nccaoqNZUlLPzir378L4pFinGNQkCPUZnE9iSrxLuYaGBl555VVeuukFzss5jCJ7A//du5Q15RucHj6F8Qm8VfIT8yrartILkBAfT7+8Qgoz88hPzSY7MY206CSSVCyxdgOj2sReUUv1ngqw+3Y/EpuWSHJeOsl5PUjK69EoADmEoOT8dBKyUtv10vnls2XMueE5frHv4r3tP7jmCrJlccqTv5VQMEHoAOiSbzDnngJ9p8C2D6Bhv+NAxgiMw+8DIxbz8+MxTpiDEk+isCHhZoIQErqwd08wbPr6dNkdEtx2Rk8iKzFewfYkCtd14a/NQDyJLE1SANdBJOhEXRWESPLdd9+B8TNHRR/Gzt3VLC2FinpIiYZDkusZ2QMWmpqa9GQOHTHAIQg1egfl9s5wJrpuora2lqVLl7J06TLn9uOPP1FbU8vdfc/j56pdLNkTT5oxijHxo1BoVhyoJTGpjpMzBjBkWB8GFvQjgRii6xWqsoH68mpq9h5whH+V4diwA+XYgSo346o3THL69SQxO5WE7EZvoNw0Hn/uGYbvTGPCAxcz5LyjA56//hOHc8qTv+Xbh/9DfyPLuV9yBQlCByNrHCT2hrp9qDNWwrqn0Wufgj2LHOJRbBbE5TvKCV0SEYmEDk4wH7bcPSWG+umoE9n0VkR5+LurEokxBmrTh/ptdKQQ5STyajMY+GDTpUggOYksCUxW6zVXt1S3Owi4ghBBdu7YyQkZfUka2Itv1+xnX10NAPvqYDUJ9CpIpH/9Lxx8z7H8espFLnWrq6v56aefXAShFStWUl/fNkn10B59yYhOprJXDFOP7YMqrsW+rwp7VQ3oWDCB6BgGlwAlu6kBalo3ohTx6UkkZqWSkJVKYnaq4++m/7NSqdixm89//w/+tuVjhhw0khlXNy8Xf8esR1m5YCHDC04nrTCrTR+tIrmCBKHjowwbxhGzMOdNQS+4FmPwLdDvYvSyu2D7B1C7C1DoH66Cw2aikvpEustCkBGRSOhmdCLPnkjZ9PKQ6VxILYwPohF55u1kp8xZ39+Qs1DkJHLTh6CfQx9stikfbk+iSCSuDmSiRWAShHZJOWAjIzqZgvMP47ULT2XF/A3sK6kgPTeVoeMG8MXrH2J/oJS4PQ18++23LoLQ6tVrsNvtbdrM7JHOMUNGcljeAHpGpxNbbmf/xl2YDXYKS2KpLylyKa9sBtXUE2e3kTm4gJyhfUjISiExq0kESiMxO4X49BRs0d5jV3MO68MPf3mfGYMu56Ef32Ds2Oawkb59+zJj4uXE7tfkH3VQcCawEckVJAgdH1UwGWP8a5hLZziSVDcR3xOSCmHX9+jNb6K3voMacCVqyB9QcdmR67AQVEQkEjoBofImCtdDXJPNENjz+FAXgE0vVbRfOZAEvwjGvPrwoO/i2ROsXGHh9iby12sq7KubBehJ1Bk92QShGzAgrzebgaffeInjf30aw489hLKyMpYtW87jj3/IM088zc2JE3nozgdZsv+XNvVzs3I4dsgIhuYMIC8qleh9DezfvBuzpAFKqqlhh4tH0Laa3djz4plw3skMOeZItu7ZyZ+e/hsr5y7k5oLTOfr2cwMSWwybwdG3n8ucG57nyUnTsY3IpcxWTZo9HvuiYrZ8tZLjn7xavHwEoZuiCiZj9DwNds13JKmOz4WscSjDht67DHP53VA8F/3zbPTGV1EDb0ANugEVnRzprgsBIiKR0EkIdo6PLpKEw+uDqJ9j9NULRTwOvBDAdRWkS9KvUxOk3EuRWH3OL7Ey7KubBehJJO8xQeiQJOWkAfDjFwsYO3Y827fvYMeOHc7jfeKyIRHKGyrp3bOA8YOO5NDsfuQaKdj21rF/8y7MHSbs2E8V+531YlMSyBpcQNahhWQdWkjmwAI+uPJJBqRm8dCPb/DnW95wlg22h48jT9DVfPvwf9j/5QoA9gIpvTI55cmrJU+QIHRzlGGDnGPa3Jao9OHYjv8AXfwV5vK7YO9S9MqH0OufRw25HTXgCpQtvIszCcFDVjeLELK6mVXav1z9X93Mv/Y91fNvpbEg2Qz3SmMq/KubqUBWDLO6uhkmhqUVpjTKsJo4PMDVzVza8tFkGFY3a2sz9KubtbEZidXNbBY/DyKxupkywYJNWd1M6GwEujKMaTd59aS7qEsxmLngJYqLiwGIUVH0T81nauHxJOkYUnpmULFltyN5dCti0xLJbhSDsgcXkjWkkJRemY5lpVvgWAnseXpPGOLWwyfYAo5pNyVPkCAIltBaw7Z3MX+8F/ZvcOxM7IM67C5Un/NR1m/khRaEc3UzEYkihIhEvuL/5dmtRKJAbFoQFhSmw0kiWDZ9oHOJRIH01bowhaLN3Po21XbrNpvEMOWPPQIQw9qKRL7btCiGWRZsTFSUtizYhFUkUgAiEgndg2DcYDeJNzmH92HnrhKiqkz0vhq3X+XxGckOQahRDMoaXEhyfnobQcibrW8f/g/7d+xx7kvplcm4284RDx9BEDoc2qxH//IKeuVDUO0Q0UkbinH4vZA30etnnzbtbsPahGbCKRJJuJnQwYnE6mDdFF8WQFORiYLpPNE3AYRFBjrAVma1L6JfEMVbX0cdzPPos81AVhnrTKubdXRbgtAFaArP+uqef2HbU9Wc/8wwyBzciz7HDnUIQ0MKScxO81kQ8mRLVgITBKGzoIxo1EFXoPteiF73DHr1X6BsBeZXZ0P2eIzD70dljmhTT297H3PpDKjc4ngNkNgb44hZqILJ4R2EAIhI1K1oehaw7Dtm8T4nOM8fIgyFhXZOVmDJjq3TeZ5hI5yTyF9voiDlJPLLZgjwaZyWQr8s1gs0J1G4JrHzvLEEoUPRf+Jw8kccxPxH3ya+RxI5w/rQ78ThIRFvZCUwQRA6GyoqEXXoregBl6NX/Qn983NQOg/zswlQMBnjsLtRqY7PNb3tfcx5U6DnKRjjXoLUwVC+GnPVY5jzpmCMf02Eoggg4WYRojnc7KqwhZtpDSoSyzITQLiZM1OyhapW87tYoguEm7VHY1hKWG3SGOIWQB6kbpOTyN88PWA9DMtifiCHzfDmJFIAgeQksvlnz0EAOYkCsRlITiLDP5sKR7hZtoSbCZ2IcLrqC4IgCA505Tb0igfRm14DbYIyUP1+A4fejp47CdIOxTjmTZfcRVqbmN9cAGWrMU7/SULPCO93mPirdiM674/GysImBISHKRVPovaIoCdRU2hUK7y+QwLyJPLcRvDelZqWA/P+rtduN7cidcg/TgKIywz3xa5weD152ZSbzXlcENzQp08flFJttmnTpgHw/PPPM2HCBFJSUlBKUVZW1m6bdrudu+66i759+xIfH0///v25//77kd86BUEQOjYqsQBj9LMYpyyAXqeBNtG/vIT+6DCo3II6+Jo2ya2VMjAG3wKVm2HX/Mh0vBsjIpEgCG3R7jfddCwC3ekcBPCEHwxxwE0bHk6lY06DkZPIX5tej7Yt7dKqakyY7VbMwOOmwfFt17RZEYj8Epa09YtWt/o/XHi5Fnw9Q4LQxKJFiygqKnJun3/+OQDnnXceAFVVVZx88snccccdPrf5yCOPMHv2bJ566inWrFnDI488wqOPPsrf/va3kIxBEARBCC4qbTC2Y97EOGkuZI0Dsw4A/e0lmKv/jG6odq2QNthxvCkJthA2JCdRN0NylAoe8eHCEE+i9oigJ5Hy+jLINpXbyh31PAW8oqOV+oF6EoV7Mlt9OfhivqOebyHyZGVlubx++OGH6d+/P8ceeywA06dPB+Crr77yuc3vvvuOyZMnc+qppwIOb6V//etfLFy4MCh9FgRBEMKDyhqNceJ/0av/jP7xbqgvRy+fiV43GzX0TlS/SxzhZWWrHeXjcyPc4+6HeBJFGK3DuIH89Ct4xgc3AbmG2iOCnkStzptPfjrB8CRq9ac/vkHhIuBolHbrB2mUqrEtj95S7WyGha3RC0u12iSyVwgWdXV1/POf/+Tyyy8PaKWvsWPHMnfuXH7++WcAfvzxR7799ltOOeUUj3Vqa2upqKhw2QRBEITIo5RCDboJEgqhx2GQWAjVReiF0zA/HYNZNBdz9Z8gsY/D60gIK+JJJAiCK17u4SPlSdR5iKAnURP+eIOEQLVp12YkPNEsJxPXHsWQ9oahDG05nZFPBtxWtDpOa9UEwRfee+89ysrKuPTSSwNq5/bbb6eiooKBAwdis9mw2+08+OCDTJkyxWOdWbNmce+99wZkVxAEQQgNyrBhHPmwY3Wz/ImonqehN70OZavQX57hKHPknyRpdQQQTyKhY+OLa4IndwVLdZV1m1Y9vHRgwww6Xoxo2u4LNZHyPrFGhHMSgV/eRNZp1Vl/bFo2bD0ZtDYtmtR4tOl9PrX1cXqx2X7FABChSAgRf//73znllFPIz88PqJ1///vfvPbaa7z++ussXbqUl19+mT/96U+8/PLLHuvMmDGD8vJy57Zt27aA+iAIgiAEF1UwGWP8a1C+Fv3zM1Bf5nJcL70dc/Et6No9kelgN0U8iYQw0JmePqw+oWnrz3btEJHZ82A0Ep5EHWn87dNBJC1f8xMFME5v14LXZpvCmSzYtPomU1Z/DmlyzvF7nArLK3+1YzMkWI7H6yDXu9Bh2bJlC//73/945513Am7r1ltv5fbbb+fCCy8EYOjQoWzZsoVZs2YxdepUt3ViY2OJjY0N2LYgCIIQOlTBZIyep8Gu+ejqYlR8Ljo2G/3jXbDjE/TPs9Gb30ANuR110NUoW0yku9zl6XaeRLNmzWLEiBEkJyeTnZ3NmWeeybp161zK1NTUMG3aNDIyMkhKSuKcc86hpKTEpczWrVs59dRTSUhIIDs7m1tvvZWGhoZwDkXwiQ7hm2MZ358TgzjOdlY56haeRIF4u4Tdppslymm7DHzQrveI5aOx7kmEVU8iywYD8CSKCKqT9VfoLLz44otkZ2c7k00HQlVVFYbhettqs9kwTctvcEEQBKGDoAwbKucYjD7nO/5PG4jt2Lcwjv8I0oZA3T700tswPxmB3v4xOuCEk4I3up1I9PXXXzNt2jR++OEHPv/8c+rr65k4cSKVlZXOMjfddBMffvghb731Fl9//TU7d+7k7LPPdh632+2ceuqp1NXV8d133/Hyyy/z0ksvMXPmzEgMyW+6REiUz3TuDKy+z2EQx+nDCbV6DXXwi6WZSHgSBeMS9OcysLr5YFM3bsF9m0Vgbtu5AfF8NABByyKBmdP+N9AxPzKFDoRpmrz44otMnTqVqChXx/Xi4mKWL1/Ohg0bAFixYgXLly9n7969zjInnHACTz31lPP16aefzoMPPsjHH3/M5s2beffdd/nLX/7CWWedFZ4BCYIgCGFH5R6HcfJ3qJFPQVwW7N+A+c35mF+cit73U6S712VRupvLcLt27SI7O5uvv/6aY445hvLycrKysnj99dc599xzAVi7di2DBg3i+++/Z/To0cyZM4fTTjuNnTt3kpOTA8Czzz7Lbbfdxq5du4iJad8FrqKigtTUVBaddTVJ0eFxmdMalNUQiAAf0Cw/T1is6PCoaHoVjkvcDCyMxhIaZVidIh8eCt0eN5tXP7Jgs916HmwaluVsbTHUyMRajjxtPUmyZZum9zF6nfPQ2fQc4ma3eD412KzNrTLs1q4DpVHt2HQ/TjsqyuJ7U5ntjtOjzehAbPpfraK6geybfqC8vJyUlBQrloUuzGeffcakSZNYt24dBx98sMuxe+65x21C6RdffNGZ4LpPnz5ceuml3HPPPQDs37+fu+66i3fffZfS0lLy8/O56KKLmDlzpk/3XdB87yXXrCAIQudD11egV/0ZvfZvYNYCCtX/N6jDZqLicyPdvZATzu+wbi8SbdiwgYMOOogVK1YwZMgQvvjiC0444QT27dtHWlqas1zv3r2ZPn06N910EzNnzuSDDz5g+fLlzuObNm2iX79+LF26lOHDh7drt+kkLzwzfCKRAx8e1DuFzVaXrZscLP49FAb6NtAWRKJAbQYm2Pj8NOlSLkDBxhebbcpEQCRSVm22I56Ew6Y/10MYbLY5ZFkksiZkACib3dr7RDWO021d1/evaxHTjUjk4/vdMH32unIpoiwKU8pRF4/j9ExFdQPZ0xfIA7fQaRCRSBAEofOjD2xBL5+J3vofx46oJNSht6AOuQ4VFR/ZzoWQcH6Hdbtws5aYpsn06dMZN24cQ4YMARwu0DExMS4CEUBOTg7FxcXOMk0eRC2PNx1zR21tLRUVFS6b4As+xCX5/GATiTinzhBb1YiP4UFBlZU7atRfp8pJ5KYdX9sKss3Qnk6FY0l671ub/EzK0Tl3+9vfcCxl7+lYi63t4Fv3zV0ZdxOmmgUbL1sbmxams7le+MPjBEEQBEEQrKCSemMc/TLGSXMh4yhoOID+8R7Mj4/A3PyW13xF2rSjS77B3PxvdMk3aNMexp53Hrq1SDRt2jRWrlzJG2+8EXJbs2bNIjU11bkVFBSE3GbXwIcnFw8PxW1z4ig3m5u8OUHvf0dUQdzgo54VVK+wjqqhReI0BcOmv5dZkG36dCot29Q+XRdBtal9s+m2F5avYe1RcAvqp4jLRAXSX0EQBEEQhPCjskZjTPwSNebvkNATKreiv7sU8/MT0LsXtSmvt72P+eFQzLmnoL+7DHPuKZgfDkVvez8Cve/YdFuR6LrrruOjjz7iyy+/pFevXs79ubm51NXVUVZW5lK+pKSE3NxcZ5nWq501vW4q05oZM2ZQXl7u3LZt2xbE0XR1fPwJXjdvPiVJ1rjUaa7rXjzyJSmzb2XbClUdCi9PpIoQCGkhewp24GsSdtdK1jd/Er+3sRnwYL0Z8FA+yDbbPZWWbUbAS8uyImrRM8fpJWTx4vPB08plM5r+xuc6bb20BEEQBEEQIoNSBkbfCzFOW44aehfYEmD3AszPJmDOvwxd6Xjm1tvex5w3BdIOxZj4JcZ5JRgTv4S0QzHnTRGhqBXdTiTSWnPdddfx7rvv8sUXX9C3b1+X40ceeSTR0dHMnTvXuW/dunVs3bqVMWPGADBmzBhWrFhBaWmps8znn39OSkoKgwcPdms3NjaWlJQUl82BrzEIgW9aN//v/+a/aNLSMyeQupHB3/mNEKEw7ekZFNAolPvYGtqfi9YLszduXq47dyKef5vvY2yzAlswaGdagmmqjT1fro1gXD+ttVq8XkIB2NR+1Q2KTe2fTRfrlk+s9SvC767qFn/4WLnlvIpEJAiCIAhCR0BFJWAMvR3j9J9Q/S4GFHrLvzE/Ohz78rsxl9wGPU/BOOZNVOZIVHQSKnMkxjFvQs9TMJfeIaFnLYhqv0jXYtq0abz++uu8//77JCcnO3MIpaamEh8fT2pqKldccQU333wz6enppKSkcP311zNmzBhGjx4NwMSJExk8eDCXXHIJjz76KMXFxdx5551MmzaN2NhYv/oTHDHE9wYcK5xZsWH9abJ9m577b3Vuwp+cO0JogicU+dBOkyeR5/n17YRF4vSEx6br+MM+Tn+vh2B5EvnjOGP1mlWudf1qwopNp9Bm7ZwqQ1s7/37qzi2LugzTnZePp3aVQ8L1F/EkEgRBEAShI6ES8lCjn0MffA3m0hlQOg9W/8lxrO+FbX4AVMrAGHwL5ufHw675kHNMhHreseh2ItHs2bMBmDBhgsv+lsuuPv744xiGwTnnnENtbS2TJk3imWeecZa12Wx89NFHXHvttYwZM4bExESmTp3KfffdF65htKLp6amz4unJpTOPyT8si2FGAJE0bTrRfh2twPD6AOvtoHbzV/sES2gJj80W70UvjkzBtRlAI5Yf8nUbMcPXlpShLfqwWlypDsf7xJJw7EZc8m2cAQhEFjymHFUd8+O3XYUj7MzSKoAW6giCIAiCIIQYlT4c44Q5sP1DzEU3Qk0petVj6J3/xTjiEVRLMSjNEQmkq4vl1qaRbicSect23kRcXBxPP/00Tz/9tMcyvXv35pNPPglm1/zEwsNd4wNPd/DO0c5/goBP41a+Fw0ayno0DBptoaIK0POttclIXFOhNdl2cjrR28YP2grTHdo7LBDvJUs2/RDuffTgC4j2GohAaJwgCIIgCEIoUUpBwRmoqAT0l5MhKhH2/YQ59xTodTrGsHtRqYdA2WpH+Xj3uYW7I91OJOpwaLD0tG7hsUEDKoAcG+HPERSYP0fQcon4Ou5wZ/hqFX7jd2UrOqNyzE+wxB1frqlgC0m+DDsonkR+2AvMZiRoO6qwjLPZbcY/m27Cxtqv1FinVV3fWjGbl6j3F6UtXvMWP9uVw2awRDRBEARBEISOhMo5Dp3YG5IHQHJ/2PB3h4fRjo+hz4VQtRMS+0DWuEh3tcPQ7RJXdz28pYn1mDrWAv5kw22vvq9bJPBgOxLd7Wj2VON/QbKtlG9bKAjd1Hp+j3XEq906bXsclnd1q0Z8tulv3F+TDeVeTG3fpvJ/sJF4XxvW7Hbe61YQXTDNtAAAx2hJREFUBEEQhO6GMmwYR8yC4i+gajtq9AuQfzJoEza9DiVfOcSjmpJ22+ouiCdRp8ZP0Uc7nJYCyzVqoXKE4tSCGlbnra1QDS/cNtubr6bn5SB5EkXCi8hp25vNgFpWHltv12bY3yaBfBBY8yQKfIiuHi8+XLIObFY9KK16BPmRNNpdOX/stSwbyM8+fth0OjCKSiQIgiAIQidAFUzGGP8a5tIZ6B0tUsbY4sBeA8VzMT8cijroKtTg36PisiLX2Q6AiEQRxrnUtyU81fPy6BTwalj+2WwKcbP2OBrg47ql6k19dV+5vVXarAlTrb0OfMkg7awZnMTVvsxVk80Q+B92ndxE2vXPVka8Xz6BJHvy7sHkrZ7Vube8slWrer7b924vJOdTeX+HebapUMpC8moXL6amnb6O20M5XzrRtBKbP0JWYz1BEARBEITOgCqYjNHzNNg135GkOj7XEWK2+3vMH++FXd+h1/4NveFF1CHTUINuQMWkRbrbEUFEok6P7zfpTUuXB55bqP0GWj74aUfwRUjshARvGptXdxBlPZeIa0O+VVPK4RlmxWRLm3420HQdBRNv89q5vIlaiApuGmnn8rGI9/dJaMZp/fpRBDDWxnrhERUbQ3S9iGEejyhNu0vKexyDn6ubNc0J+C5MtS6k/FzdrI2QJQiCIAiC0PFRhg1yjnG9hck+GuPEz6Doc8yf7oO9y9CrHkH//Bxq8HTUwdeiopMi1eWIICJRhNHO1aL8v9v2r17zA0vgQkb7Dbg89Cs3yaCt4s/DUzDDzcKNP6fVUn9bPMJ61jTc1lMBpLfSrR5EfXJg0hZzuzfZaDVHoT297ifGJ5uW3yPuvV1CO85Gm/54SgXBpGpl02d7hlWvngDGqKDNeQmFV4+TFm9Mf739PAlh7fUhsNhlQRAEQRCEDoFSCvInYuSd5Ehq/dN9UL4G/eM96HVPowbfgjroSpQtLtJdDQuSuDriWE//6ZrgV7ezBSp+KDebj2h3dS1u2rctEG+pJuHO7y2Aum074eMWiM1Wm6/9DOZjoY9DtE7TZdqioaDbcGuwfZtt+hBs76zW7Qe99TDbdNOgz+fSr860fFO47lOezp5yszUJWq0/Mtv7mAPfrgVvbfgyKe7qGa02l+PaEV7WchORSBAEQRCELoRSClVwBsYpC1Bj/g5J/aBmF3rpbZgfDMVc/3e0WR/pboYc8SSKMNp0bIHja4hSMG/qffQ9iciDRATcgbR1sx5FLa/tKcdzaMCeYS1a9KGtYM9sSM+Uh3MSOpuer/V2bYbgbRKScTqFDA/XUHv1DW2tY04BxoJNK0u8Nwojfr2/WpZtL1+Pp3athn55sumT4OSfzaY5aTekThAEQRAEoROiDBuq74Xo3uegN/4TvXIWVO1AL7oBveZx1NA7UL0vcISveUCb9jb5j7yV70iISBRxrHsShR9rDwTWE3MHgvWHlw4RbtZE62GEuG/uxKrW8xGAFubeZjvHA3aAa21IubcZnDG1Cv1qMVntjjME5zZs4/THppULqCn+yoMwFbxx6rbXjBWR26/wrVY2fVUTW5dTpu9haq2Th/sq3LWx6UMdQRAEQRCETooyolEDLkP3vQi94R/oVY/CgU3o769Cr/4LxtA7oeAMVKuVffS29zGXzoDKLY7XAIm9MY6YhSqYHP6B+ImEm0WYoIUn+WIrQJtNK7HpxnCuUPY1kgQyFg/BKIGFVFmI8Asm7sLUrIbjeRu0t+ibgHHTYEjstByYm4bbizIKBSEfp782LXciEJtu3nXuQsRaV2znG7LNeVSNm/Pv9sKAdXP5Fm2475t2eja51HG+Vo3HPWxGi03hsrkfjI+bIAiCIAhCF0fZ4jAO+R3GGatQw+6FmB5Qvgbz2ymYnx6N3vEpuvFhUW97H3PeFEg7FGPilxjnlWBM/BLSDsWcNwW97f0Ij6Z9xJOok2JZKNIBeCwojy/aNWpVK7LuXeHBXcTHqp7wPO+6vapeDXqaoXZW4A4Az4Ei3udcWfck0m68NBxNhv5Zs/VgQ2awxQkLl03lzpiPJq2EYeH+GvGvGQsXtVPQ8LFua0HQyk8iqtX/7pt3g4cY4pZd9+Q91CQSeemO+w6Y7f/s465dRXP+IbcGPcy3l34KgiAIgiB0RVRUIurQW9AHXYle+zf02qdg34+YX58DWWNQQ+5EL50BPU/BOObNZg+jzJEYx7yJ+c0FmEvvwOh5WocOPRNPom6H1Z+LFb4mjW6TRNryz9MtPZf82wISViy5/QT6M7z7487xBHLe/Pz5vz2vqaBoHa264pNHlRVaCFHhsenGkyjUNj2MUbV3CRi08SjxdaPlu1rhyDvm4+ZWhPTpcvXTNbFJzWwcq+sBHzalm4VNN+PQjVubY4YGQ7UaQ8tjujnpc8sk1y02hXI/757ewgqHTdzYdLHjZr5d5spdv9zUcTuvgiAIgiAI3QMVk4Zx2F0YZ6xEDboRbHGw63v0l6dC5RZUz1PbhKApZWAMvgUqN8Ou+ZHpuI+IJ1GE6awhWW7x9Ou3i+tJVxlse3TdcVr2JKKF95IHhwZP/hOW3yMtH4Jb7fLSlQBoMQoPXiNBEdlam7SCDmTsCpTp1bbHQ1r759WjWvzRTjLoNjZ1i//98XppakipFh9gPtZ32nTjpdVS0PNokxZ99UOt1ab3MXqzadO+fUZ7nGBBEARBEITuh4rLQg1/CH3I9ehVj6I3/B20Hb1wGvYdH2Mcdheqx2HNFdIGAziSWUeoz74gIlHEad+zI7iE8KbeQ4JqjW4RfeHPWH0PhWnrnRAEYcETbtvVrR4j/Runx9JNHijaQ6shvHQ8hSaGyqS35+eAGm3VsLvT586m1etHeXzhaj9o4/TQT1/EPOt9aCGEeWjE4ziN1iV87IjSLey5H7SLzZaii+FGdPHJptniPeCDQOW0qVG2ppcWxunHiWnOKaTar+tZufMsEqm2fztXN7OJSCQIgiAIgqAS8lAjHsfMGov+7lLAgB2fYO74BFV4Lmrs/6GMaChb7SgfnxvR/raHiEQRplN5Ell8orT+IOp7zTZz6K+3gktdH8p4ePgPuoCivb4MIH5J+RYq0qZthamsjlO3cXQI/UpyLQw0CW0R0GRDarKVzuynDBuAUW3NrklbjyBPHWl9jbb0KvImrrZu250nkU82W0q/ftp0Z8TTh0QbIaZ9oajtYbP9nxxa2m9Z0PDhQm15rKW3lCAIgiAIggCAKjwb/ePdkNgb4rJg69toezWGEY3WJubqP0FiH8gaF+muekVEoogTbk8iq1iPTQnXY0SbpdpD5UkE7h/+VXiemVTrh7VQehM12WxpPxgNe/HqCaodN42F1maLi8AHm+15HfmEUwTxvwnrSezbjsjrvLYs3zJJsj/23eXIabe8G/u+egoqQJlt2vI4Tpf5d5PTx1f7TbmLPNhw6YeLTQWGlxDA9ux68gry9uaXOwhBEARBEAQnyrBhHDHLsbpZz1NQo1+AtMHoXQscAtGOORjjX+vQSatBbvEiTufxJArAH0hZF4ocz2a+1XYtpaw/APvaWZdxOV4Ez0vFcydcrhfXGDe/cLvQkQ/9D4ou5SFfj6ciAet9YfNg8uyR0a7JUIqanky687Dx1ZZT3279zmvXqmWbyoNNn5rxxWZrzV41Ci8+1GsbVudjH9vYtDhOZW//Nwd3x5vC8XwJN2tDp/jyEgRBEARBCBuqYDLG+Ncwl85A7/gEaLxjSuzjEIgKJke0f74gIlGAPP300zz22GMUFxczbNgw/va3vzFy5Eif6zevXtXFsfQs0fTg4uP8tBYe2n2285CdxtfT4RK+FMg51G564r09p80AFBt3o/dlVbOm1DABGXUXuuLFZjC82FxMttee5dPpWbVr14PJivjRWEe5y/PjS3UXccA/m62FHp+aUdph0+cKLRpXLRIz+1K3ZRmbH3GZLmFYpn+CjfPjQ6NcVnLz47wY9hbeVr579ygAm0VPIsN0nyuqZV13HkV1PghogiAIgiAI3QxVMBmj52mwa74jSXV8LmSN6/AeRE2ISBQAb775JjfffDPPPvsso0aN4oknnmDSpEmsW7eO7Oxsn9rQWqFNC0+kvoZMuKlnOSGv5QfnULhIBOMX7PYH5Kr/eHj4b4r7CMI4Vdtd3m1aNtsiP5CfGpz1Ubp2NizSaKi9yXyoGLJxthba/PHOsVKv1UB88szx1JS/q3A1HWis5/9nkfZex2NIlWr20PHWtTbtNYpo3j47POVbMnDWbWvPS/iasrdIlu3muEvZ1n3xEuLmrnzTbklcLQiCIAiC4BZl2CDnmPA88wQZEYkC4C9/+QtXXXUVl112GQDPPvssH3/8Mf/4xz+4/fbbfWpDmwbatJph2aUl74ebrk7th6dM6/atenMow6LA5M1mOw36GurhzmbrV85d3myaGIayNkeq+dd43eYPrxWxWTTp4oXkV+SPZYMOf6mm68+Py0kRwEp1ujns0K8mlFWbCoXdtQs+1/STll5kVr99glDPNw+iFn8aPiZ/bt240zPHT+8n1dpjyo88QYZDePFYz+NHtx0V5YMnkTu7TZ5ELev5IvQoINq30Lg22Jo8iTzMrTubCmgQTyJBEARBEISuhohEFqmrq2PJkiXMmDHDuc8wDE488US+//57n9sx7QZ2C8twtf0lPvQapbIovChMrEXUtZdXyHN/lLYQRuPBputrzy5apq8rH7mz2TKZL752PQDxBOUxr66XKg7PN8vCQns2rXiXtFPeaNWsr+24qoN+2G0Ow/J7mpT2PW+OCxqlrD6se7HpNWypRT2/z42X96ZH0Us7xNRWoWq+hrg56rqvoNrYbDEfSrdJ6KxalvEyDuUS+qVdjnn2XMKLV497m05vR6PB9RvdnYjk6ZjN9Jy42l2fG/fpehGJBEEQBEEQuhoiEllk9+7d2O12cnJyXPbn5OSwdu3aNuVra2upra11vi4vL3f8X1OPPToYnkS+YjVcA8s6lBHAA6xlm95W+WnHpjWvJxPDw0Ooz3Ut1LNZqacs2lQAdmxWQ2mVSWs91LeHfDuGvwKls2ETw5+QGKf4YMewt93vCzabI3eO35eCYcdmaZwa1WB6CE9qp3pUQ5tz4t1W09+m4z3WcrePXk1KN2C0JxK5wzAdwgvgErboTsBo02x9+9e7J68e041Q7E2AAce1bjebBRx/PYls7dhwV0/bwfTwWdtOXe0pgVs79Srsjnq6c6y+IAjOa7WioiLCPREEQRAE/2j67grHfZeIRGFi1qxZ3HvvvW32n73gbxHojSAIgiAEh/3795OamhrpbghCu+zfvx+AgoKCCPdEEARBEKwRjvsuEYkskpmZic1mo6SkxGV/SUkJubm5bcrPmDGDm2++2fnaNE327t1LRkYGKnTrcYeViooKCgoK2LZtGykpKZHuTsSR+WhG5sIVmY9mZC5c6UzzobVm//795OfnR7orguAT+fn5bNu2jeTk5Db3Xp3pvRcsZMzdY8zQPcctY+4eY4buM+5w3neJSGSRmJgYjjzySObOncuZZ54JOISfuXPnct1117UpHxsbS2xsrMu+tLS0MPQ0/KSkpHTpN6i/yHw0I3PhisxHMzIXrnSW+RAPIqEzYRgGvXr18lqms7z3gomMufvQHcctY+4+dIdxh+u+S0SiALj55puZOnUqRx11FCNHjuSJJ56gsrLSudqZIAiCIAiCIAiCIAhCZ0FEogC44IIL2LVrFzNnzqS4uJjDDz+cTz/9tE0ya0EQBEEQBEEQBEEQhI6OiEQBct1117kNL+uOxMbGcvfdd7cJq+uuyHw0I3PhisxHMzIXrsh8CEJk6I7vPRlz96E7jlvG3H3oruMOJUrL2rWCIAiCIAiCIAiCIAjdHiPSHRAEQRAEQRAEQRAEQRAij4hEgiAIgiAIgiAIgiAIgohEgiAIgiAIgiAIgiAIgohEgiAIgiAIgiAIgiAIAiISCRaYNWsWI0aMIDk5mezsbM4880zWrVvnUqampoZp06aRkZFBUlIS55xzDiUlJRHqcfh4+OGHUUoxffp0577uNhc7duzg4osvJiMjg/j4eIYOHcrixYudx7XWzJw5k7y8POLj4znxxBNZv359BHscGux2O3fddRd9+/YlPj6e/v37c//999NyrYCuPBfffPMNp59+Ovn5+SileO+991yO+zL2vXv3MmXKFFJSUkhLS+OKK67gwIEDYRxFcPA2F/X19dx2220MHTqUxMRE8vPz+c1vfsPOnTtd2ugqcyEIHZGnn36aPn36EBcXx6hRo1i4cGGkuxQ05J6te92bdbd7sO5yr9Ud76nk3imyiEgk+M3XX3/NtGnT+OGHH/j888+pr69n4sSJVFZWOsvcdNNNfPjhh7z11lt8/fXX7Ny5k7PPPjuCvQ49ixYt4rnnnuOwww5z2d+d5mLfvn2MGzeO6Oho5syZw+rVq/nzn/9Mjx49nGUeffRRnnzySZ599lkWLFhAYmIikyZNoqamJoI9Dz6PPPIIs2fP5qmnnmLNmjU88sgjPProo/ztb39zlunKc1FZWcmwYcN4+umn3R73ZexTpkxh1apVfP7553z00Ud88803XH311eEaQtDwNhdVVVUsXbqUu+66i6VLl/LOO++wbt06zjjjDJdyXWUuBKGj8eabb3LzzTdz9913s3TpUoYNG8akSZMoLS2NdNeCQne/Z+tO92bd8R6su9xrdcd7Krl3ijBaEAKktLRUA/rrr7/WWmtdVlamo6Oj9VtvveUss2bNGg3o77//PlLdDCn79+/XBx10kP7888/1scceq2+88Uatdfebi9tuu00fffTRHo+bpqlzc3P1Y4895txXVlamY2Nj9b/+9a9wdDFsnHrqqfryyy932Xf22WfrKVOmaK2711wA+t1333W+9mXsq1ev1oBetGiRs8ycOXO0Ukrv2LEjbH0PNq3nwh0LFy7UgN6yZYvWuuvOhSB0BEaOHKmnTZvmfG2323V+fr6eNWtWBHsVOrrTPVt3uzfrjvdg3fFeqzveU8m9U/gRTyIhYMrLywFIT08HYMmSJdTX13PiiSc6ywwcOJDCwkK+//77iPQx1EybNo1TTz3VZczQ/ebigw8+4KijjuK8884jOzub4cOH88ILLziPb9q0ieLiYpf5SE1NZdSoUV1uPsaOHcvcuXP5+eefAfjxxx/59ttvOeWUU4DuNRet8WXs33//PWlpaRx11FHOMieeeCKGYbBgwYKw9zmclJeXo5QiLS0N6N5zIQihpK6ujiVLlrh8FhmGwYknnthlP4e70z1bd7s36473YHKvJfdUTci9U3CJinQHhM6NaZpMnz6dcePGMWTIEACKi4uJiYlxvkmbyMnJobi4OAK9DC1vvPEGS5cuZdGiRW2Odbe52LhxI7Nnz+bmm2/mjjvuYNGiRdxwww3ExMQwdepU55hzcnJc6nXF+bj99tupqKhg4MCB2Gw27HY7Dz74IFOmTAHoVnPRGl/GXlxcTHZ2tsvxqKgo0tPTu/T81NTUcNttt3HRRReRkpICdN+5EIRQs3v3bux2u9vPorVr10aoV6GjO92zdcd7s+54Dyb3WnJPBXLvFApEJBICYtq0aaxcuZJvv/020l2JCNu2bePGG2/k888/Jy4uLtLdiTimaXLUUUfx0EMPATB8+HBWrlzJs88+y9SpUyPcu/Dy73//m9dee43XX3+dQw89lOXLlzN9+nTy8/O73VwIvlFfX8/555+P1prZs2dHujuCIHQxuss9W3e9N+uO92ByryXIvVNokHAzwTLXXXcdH330EV9++SW9evVy7s/NzaWuro6ysjKX8iUlJeTm5oa5l6FlyZIllJaWcsQRRxAVFUVUVBRff/01Tz75JFFRUeTk5HSbuQDIy8tj8ODBLvsGDRrE1q1bAZxjbr2CSFecj1tvvZXbb7+dCy+8kKFDh3LJJZdw0003MWvWLKB7zUVrfBl7bm5um8SxDQ0N7N27t0vOT9NNzpYtW/j888+dv4RB95sLQQgXmZmZ2Gy2bvE53J3u2brrvVl3vAeTe63ufU8l906hQ0QiwW+01lx33XW8++67fPHFF/Tt29fl+JFHHkl0dDRz58517lu3bh1bt25lzJgx4e5uSDnhhBNYsWIFy5cvd25HHXUUU6ZMcf7dXeYCYNy4cW2W1v3555/p3bs3AH379iU3N9dlPioqKliwYEGXm4+qqioMw/Uj1mazYZom0L3mojW+jH3MmDGUlZWxZMkSZ5kvvvgC0zQZNWpU2PscSppuctavX8///vc/MjIyXI53p7kQhHASExPDkUce6fJZZJomc+fO7TKfw93xnq273pt1x3swudfqvvdUcu8UYiKbN1vojFx77bU6NTVVf/XVV7qoqMi5VVVVOctcc801urCwUH/xxRd68eLFesyYMXrMmDER7HX4aLmChtbday4WLlyoo6Ki9IMPPqjXr1+vX3vtNZ2QkKD/+c9/Oss8/PDDOi0tTb///vv6p59+0pMnT9Z9+/bV1dXVEex58Jk6daru2bOn/uijj/SmTZv0O++8ozMzM/Uf/vAHZ5muPBf79+/Xy5Yt08uWLdOA/stf/qKXLVvmXHXCl7GffPLJevjw4XrBggX622+/1QcddJC+6KKLIjUky3ibi7q6On3GGWfoXr166eXLl7t8ptbW1jrb6CpzIQgdjTfeeEPHxsbql156Sa9evVpfffXVOi0tTRcXF0e6a0FB7tkcdId7s+54D9Zd7rW64z2V3DtFFhGJBL8B3G4vvviis0x1dbX+3e9+p3v06KETEhL0WWedpYuKiiLX6TDS+kaku83Fhx9+qIcMGaJjY2P1wIED9fPPP+9y3DRNfdddd+mcnBwdGxurTzjhBL1u3boI9TZ0VFRU6BtvvFEXFhbquLg43a9fP/3HP/7R5curK8/Fl19+6fZzYurUqVpr38a+Z88efdFFF+mkpCSdkpKiL7vsMr1///4IjCYwvM3Fpk2bPH6mfvnll842uspcCEJH5G9/+5suLCzUMTExeuTIkfqHH36IdJeChtyzOegu92bd7R6su9xrdcd7Krl3iixKa62D758kCIIgCIIgCIIgCIIgdCYkJ5EgCIIgCIIgCIIgCIIgIpEgCIIgCIIgCIIgCIIgIpEgCIIgCIIgCIIgCIKAiESCIAiCIAiCIAiCIAgCIhIJgiAIgiAIgiAIgiAIiEgkCIIgCIIgCIIgCIIgICKRIAiCIAiCIAiCIAiCgIhEgiAIgiAIgiAIgiAIAiISCYIgCIIgCIIgCIIgCIhIJAhCB0JrDcA999zj8loQBEEQBEEIPnLvJQhCa5SWTwJBEDoIzzzzDFFRUaxfvx6bzcYpp5zCscceG+luCYIgCIIgdEnk3ksQhNaIJ5EgCB2G3/3ud5SXl/Pkk09y+umn+3STMmHCBJRSKKVYvnx56DvZiksvvdRp/7333gu7fUEQBEEQBKvIvZcgCK0RkUgQhA7Ds88+S2pqKjfccAMffvgh8+bN86neVVddRVFREUOGDAlxD9vy17/+laKiorDbFQRBEARBCBS59xIEoTVRke6AIAhCE7/97W9RSnHPPfdwzz33+BwXn5CQQG5uboh7557U1FRSU1MjYlsQBEEQBCEQ5N5LEITWiCeRIAhh46GHHnK6B7fcnnjiCQCUUkBz8sSm1/4yYcIErr/+eqZPn06PHj3IycnhhRdeoLKykssuu4zk5GQGDBjAnDlzglJPEARBEAShIyL3XoIg+IuIRIIghI3rr7+eoqIi53bVVVfRu3dvzj333KDbevnll8nMzGThwoVcf/31XHvttZx33nmMHTuWpUuXMnHiRC655BKqqqqCUk8QBEEQBKGjIfdegiD4i6xuJghCRLjrrrt49dVX+eqrr+jTp4/ldiZMmMDhhx/u/EWsaZ/dbnfG1dvtdlJTUzn77LN55ZVXACguLiYvL4/vv/+e0aNHB1QPHL+8vfvuu5x55pmWxyIIgiAIghAq5N5LEARfEE8iQRDCzsyZM4Nyk+KNww47zPm3zWYjIyODoUOHOvfl5OQAUFpaGpR6giAIgiAIHRW59xIEwVdEJBIEIazcfffdvPLKKyG9SQGIjo52ea2UctnXFHNvmmZQ6gmCIAiCIHRE5N5LEAR/EJFIEISwcffdd/Pyyy+H/CZFEARBEARBkHsvQRD8JyrSHRAEoXvwwAMPMHv2bD744APi4uIoLi4GoEePHsTGxka4d4IgCIIgCF0LufcSBMEKIhIJghBytNY89thjVFRUMGbMGJdjCxcuZMSIERHqmSAIgiAIQtdD7r0EQbCKiESCIIQcpRTl5eVhs/fVV1+12bd58+Y2+1ov7mi1niAIgiAIQkdC7r0EQbCK5CQSBKHT88wzz5CUlMSKFSvCbvuaa64hKSkp7HYFQRAEQRAihdx7CULXRWmRZQVB6MTs2LGD6upqAAoLC4mJiQmr/dLSUioqKgDIy8sjMTExrPYFQRAEQRDCidx7CULXRkQiQRAEQRAEQRAEQRAEQcLNBEEQBEEQBEEQBEEQBBGJBEEQBEEQBEEQBEEQBEQkEgRBEARBEARBEARBEBCRSBAEQRAEQRAEQRAEQUBEIkEQBEEQBEEQBEEQBAERiQRBEARBEARBEARBEAREJBIEQRAEQRAEQRAEQRAQkUgQBEEQBEEQBEEQBEFARCJBEARBEARBEARBEAQBEYkEQRAEQRAEQRAEQRAERCQSBEEQBEEQBEEQBEEQEJFIEARBEARBEARBEARBQEQiQRAEQRAEQRAEQRAEARGJBEEQBEEQBEEQBEEQBEQkEgRBEARBEARBEARBEBCRSBAEQRAEQRAEQRAEQUBEIkEQBEEQBEEQBEEQBAERiQRBEARBEARBEARBEAREJBIEQRAEQRAEQRAEQRAQkUgQBEEQBEEQBEEQBEFARCJBEARBEARBEARBEAQBEYkEQRAEQRAEQRAEQRAERCQSBEEQBEEQBEEQBEEQEJFIEARBEARBEARBEARBQEQiQRAEQRAEQRAEQRAEARGJBEEQBEEQBEEQBEEQBEQkEgRBEARBEARBEARBEBCRSBAEQRAEQRAEQRAEQUBEIkEQBEEQBEEQBEEQBAERiQRBEARBEARBEARBEAREJBIEQRAEQRAEQRAEQRAQkUgQBEEQBEEQBEEQBEFARCJBEARBEARBEARBEAQBEYkEQRAEQRAEQRAEQRAERCQSBEEQBEEQBEEQBEEQEJFIEARBEARBEARBEARBQEQiQRAEQRAEQRAEQRAEARGJBEEQBEEQBEEQBEEQBEQkEgRBEARBEARBEARBEBCRSBAEQRAEQRAEQRAEQUBEIkEQBEEQBEEQBEEQBAERiQRBEARBEARBEARBEAREJBIEQRAEQRAEQRAEQRDowiLRnj17yM7OZvPmze2Wvf3227n++utD3ylBEARBEIQuSnv3Xl999RVKKcrKygD49NNPOfzwwzFNM3ydFARBEATBK11WJHrwwQeZPHkyffr0abfsLbfcwssvv8zGjRtD3zFBEARBEIQuiD/3XgAnn3wy0dHRvPbaa6HtmCAIgiAIPhMV6Q6EgqqqKv7+97/z3//+16fymZmZTJo0idmzZ/PYY4+FuHeCIHQE7HY79fX1ke6GIHRKoqOjsdlske6G0IHw996riUsvvZQnn3ySSy65JEQ9EwShI2CaJnV1dZHuhiB0WmJiYjCM8Pj4dEmR6JNPPiE2NpbRo0c7961atYrbbruNb775Bq01hx9+OC+99BL9+/cH4PTTT+ePf/yjiESC0MXRWlNcXOwMdxAEwRppaWnk5uailIp0V4QOgLt7r08++YTp06ezbds2Ro8ezdSpU9vUO/3007nuuuv45ZdfnPdkgiB0Lerq6ti0aZOElgpCABiGQd++fYmJiQm5rS4pEs2bN48jjzzS+XrHjh0cc8wxTJgwgS+++IKUlBTmz59PQ0ODs8zIkSPZvn07mzdv9tlNWhCEzkeTQJSdnU1CQoI84AqCn2itqaqqorS0FIC8vLwI90joCLS+99q2bRtnn30206ZN4+qrr2bx4sX8/ve/b1OvsLCQnJwc5s2bJyKRIHRBtNYUFRVhs9koKCgImyeEIHQlTNNk586dFBUVUVhYGPLnly4pEm3ZsoX8/Hzn66effprU1FTeeOMNoqOjATj44INd6jSV37Jli4hEgtBFsdvtToEoIyMj0t0RhE5LfHw8AKWlpWRnZ0vomdDm3mv27Nn079+fP//5zwAccsghrFixgkceeaRN3fz8fLZs2RK2vgqCED4aGhqoqqoiPz+fhISESHdHEDotWVlZ7Ny5k4aGBqemESq6pJRbXV1NXFyc8/Xy5csZP36818lsuuGtqqoKef8EQYgMTTmI5CZFEAKn6X0kub0EaHvvtWbNGkaNGuVSZsyYMW7rxsfHy/2XIHRR7HY7QFhCZAShK9P0Hmp6T4WSLikSZWZmsm/fPufrJgHIG3v37gUcCp0gCF0bCTEThMCR95HQktb3Xv6wd+9euf8ShC6OfGcIQmCE8z3UJUWi4cOHs3r1aufrww47jHnz5nn9tXPlypVER0dz6KGHhqOLgiAIgiAIXYbW916DBg1i4cKFLmV++OGHNvVqamr45ZdfGD58eMj7KAiCIAhC+3RJkWjSpEmsWrXK+YvWddddR0VFBRdeeCGLFy9m/fr1vPrqq6xbt85ZZ968eYwfP94nryNBEIRw880333D66aeTn5+PUor33nsvIjYuvfRSlFIopYiOjiYnJ4eTTjqJf/zjH7JqSTv4Ond9+vRxlmvaevXq1eZ46wfu6dOnM2HCBJd9FRUV/PGPf2TgwIHExcWRm5vLiSeeyDvvvIPW2lluw4YNXHbZZfTq1YvY2Fj69u3LRRddxOLFi0MzGUKXo/W91zXXXMP69eu59dZbWbduHa+//jovvfRSm3o//PADsbGxHkPRBEEQIoXce3V+5N7LGl1SJBo6dChHHHEE//73vwHIyMjgiy++4MCBAxx77LEceeSRvPDCCy45it544w2uuuqqSHVZEATBK5WVlQwbNoynn37a77oTJkxw+3Bm1cbJJ59MUVERmzdvZs6cORx33HHceOONnHbaaS6rRgpt8XXu7rvvPoqKipzbsmXLXNqJi4vjtttu82qrrKyMsWPH8sorrzBjxgyWLl3KN998wwUXXMAf/vAHysvLAVi8eDFHHnkkP//8M8899xyrV6/m3XffZeDAgW5XoxIEd7S+9yosLOTtt9/mvffeY9iwYTz77LM89NBDber961//YsqUKZIrThCEDofce3UN5N7LArqL8tFHH+lBgwZpu93ebtlPPvlEDxo0SNfX14ehZ4IgRIrq6mq9evVqXV1dHemuBASg3333XZ/LH3vssfrFF18Mio2pU6fqyZMnt9k/d+5cDegXXnjBLzvdCV/nrnfv3vrxxx/32E7v3r31DTfcoGNiYvTHH3/s3H/jjTfqY4891vn62muv1YmJiXrHjh1t2ti/f7+ur6/XpmnqQw89VB955JFuvy/37dvnsR9d5f0kBA9/7r201nrXrl06PT1db9y4McQ9EwQhUnSV7wq59+qcdKV7r3C+l6IiJ0+FllNPPZX169ezY8cOCgoKvJatrKzkxRdfJCqqy06HIAhu0FpHbEWdhISELpXE8fjjj2fYsGG88847XHnllRHpQ2VlJeA6t3V1ddTX1xMVFUVsbGybsvHx8RiGw6m2vr6euro6bDabyypN7soGEytz17dvX6655hpmzJjBySef3KZfpmnyxhtvMGXKFJdlyZtISkoCYNmyZaxatYrXX3/d7djS0tL8H5DQbfHn3gtg8+bNPPPMM/Tt2zcMvRMEoSMg917BI9L3XuG876qvrw/qsu9y7+WdLhlu1sT06dN9ukk599xz2yzTKghC16eqqoqkpKSIbF1xueeBAweyefPmiNlvmtvdu3c79z322GMkJSVx3XXXuZTNzs4mKSmJrVu3Ovc9/fTTJCUlccUVV7iU7dOnD0lJSaxZsyZkfW89d7fddpvL9fLkk0+2qXPnnXeyadMmXnvttTbHdu/ezb59+xg4cKBXu+vXr3faF4Rg4Ou9F8BRRx3FBRdcEOIeCYLQkZB7r+ASyXuvcN53+RK65y9y7+WZLi0SCYIgdEceeughly+5efPmcc0117jsa/klHSy01l3qF7pw0nrubr31VpYvX+7cfvOb37Spk5WVxS233MLMmTOpq6tr056vdgVBEARBCAy59+p8yL2XZyS+ShCEbktCQgIHDhyImO1Qcc0113D++ec7X0+ZMoVzzjmHs88+27nPnRtsoKxZsyaiYSNN57Ll3N56661Mnz69TThxaWkpgMuKltOmTeOqq67CZrO5lG36lSmUq1+2nrvMzEwGDBjQbr2bb76ZZ555hmeeecZlf1ZWFmlpaaxdu9Zr/YMPPhiAtWvXyhLkgiAIQsiRe6/gEsl7r3Ded1166aXB7Dog917eEJFIEIRui1KKxMTESHcj6KSnp5Oenu58HR8fT3Z2tk9ffFb54osvWLFiBTfddFPIbLSHu3MZExNDTEyMT2Wjo6PdxruH+hoJZO6SkpK46667uOeeezjjjDOc+w3D4MILL+TVV1/l7rvvbnNjeuDAAeLi4jj88MMZPHgwf/7zn7ngggvaxMaXlZV1iNh4QRAEoWsg917BI9L3XuG87wpmPiKQe6/2kHAzQRCETsCBAwec7q8AmzZtYvny5UF1XfbVRm1tLcXFxezYsYOlS5fy0EMPMXnyZE477TS3rrlCM6GYu6uvvprU1FRef/11l/0PPvggBQUFjBo1ildeeYXVq1ezfv16/vGPfzB8+HAOHDiAUooXX3yRn3/+mfHjx/PJJ5+wceNGfvrpJx588EEmT54cjGELgiAIQqdD7r26BnLv5T/iSSQIgtAJWLx4Mccdd5zz9c033wzA1KlTg5bMz1cbn376KXl5eURFRdGjRw+GDRvGk08+ydSpU0Oy+ldXIhRzFx0dzf3338+vf/1rl/3p6en88MMPPPzwwzzwwANs2bKFHj16MHToUB577DFSU1MBGDlyJIsXL+bBBx/kqquuYvfu3eTl5TF27FieeOKJQIcsCIIgCJ0SuffqGsi9l/8o3RkyJwmCIASBmpoaNm3a9P/s3XdYE9n3P/B36FVQULCgIDYQFQUbigWx4NobduyNtSGuuvbeFQuuZe2997ViQbGBAiooqCigFBGk9+T+/vDHfM0H1yWYZBJyXs+TR7mZ3DmBgTk5c+deWFlZiS21SQiRHP0+EUII+S90riBEOuT5u0RlR0IIIYQQQgghhBBCRSJCCCGEEEIIIYQQQkUiQgghhBBCCCGEEAIqEhFCCCGEEEIIIYQQUJGIEEIIIYQQQgghhICKRIQQFUSLOhLy6+j3iBBCSEnROYOQXyPP3yEqEhFCVIampiYAIDs7m+dICFF+Rb9HRb9XhBBCyP9SV1cHAOTn5/McCSHKreh3qOh3SpY0ZL4HQghREOrq6jA2Nsbnz58BAHp6ehAIBDxHRYhyYYwhOzsbnz9/hrGxsVySFUIIIcpJQ0MDenp6SEpKgqamJtTUaIwCIZISiURISkqCnp4eNDRkX8IRMBr7RwhRIYwxJCQkIDU1le9QCFFqxsbGMDc3p0IrIYSQn8rPz8f79+8hEon4DoUQpaWmpgYrKytoaWnJfF9UJCKEqCShUIiCggK+wyBEKWlqatIIIkIIISUmEonoljNCfoGWlpbcRuJRkYgQQgghhBBCCCGE0MTVhBBCCCGEEEIIIYSKRIQQQgghhBBCCCEEVCQihBBCCCGEEEIIIaAiESGEEEIIIYQQQggBFYkIIYQQQgghhBBCCKhIRAghhBBCCCGEEEJARSJCCCGEEEIIIYQQAioSEUIIIYQQQgghhBBQkYgQQgghhBBCCCGEgIpEhBBCCCGEEEIIIQRUJCKEEEIIIYQQQgghoCIRIYQQQgghhBBCCAEViQghhBBCCCGEEEIIAA2+A1BVIpEIcXFxMDQ0hEAg4DscQgghRCKMMWRkZKBKlSpQU6NrTkTxUe5FCCFEWckz76IiEU/i4uJgYWHBdxiEEELIL4mNjUW1atX4DoOQ/0S5FyGEEGUnj7yLikQ8MTQ0BPDth1yuXDmeoyGEEEIkk56eDgsLC+58Roiio9yLEEKIspJn3kVFIp4UDXMuV64cJSqEEEKUFt22Q5QF5V6EEEKUnTzyLppEgBBCCCGElFm+vr6wtbVF06ZN+Q6FEEIIUXhUJCKEEEIIIWWWp6cnwsPDERgYyHcohBBCiMKjIhEhhBBCCCGEEEIIoSKRvNGQZ0IIIfIkFAoRFBSEY8eO8R0KIYQQQkiZUZRfxcbG8h2KVFGRSM5oyDMhhBBZ+fr1K27evIkHDx5wbYWFhWjZsiUGDx6MzMxMHqMjhBBCCFFO+fn58PX1BWOMazt//jwGDRqEP//8k8fIpI+KRIQQQogSioyMxIkTJ5Cens61HThwAB07dsTatWu5Nm1tbTg7O6NDhw5ISUnhI1RCeEWjuAkhhPyKr1+/okWLFvj9999x9+5drr127dpo2rQp2rVrx7Xl5+fj3LlzYsUkZUNFIkIIIUSB5eTk4MmTJ7h165ZYe5cuXeDu7o6goCCurXHjxqhduzYsLCzEtr116xZu3LiB6tWryyVmQhQJjeImhBDyK4yNjeHq6goTExOx4s/w4cPx5MkTjB49mmvbvXs3evfujSFDhvARqlRo8B0AIYQQQr5JTExESEgI7OzsULVqVQCAn58funfvDjs7O7x48YLbtmXLljA1NYVQKOTa2rRpg8jISLnHTQghhBBSVgkEAqxevRqzZ89GhQoVfrptQUEBtLS04OzsLKfopI9GEhFCCCE8+Pz5MwICAsTahg8fji5duuCff/7h2uzt7VGpUiXUqFFD7OrV4cOH8eTJE3Ts2FFuMRNCCCGEqAKRSITDhw9DJBIB+FYo+q8CEQBMmTIF4eHhGD9+vKxDlBneRhJduHBB4td07NgRurq6MoiGEEIIkZ3CwkLk5OTA0NAQAPD69WvY2NjAwMAAqampUFdXBwA0adIE0dHRUFP7v2s4VatWRWJiIi9xk7KD8i5CCCGk5DZv3ozp06fj2rVrOHDggESvtba2llFU8sFbkahXr14SbS8QCPDmzRvUrFlTNgERQgghMrB27VosWrQIkydPxqpVqwB8m+jQyMgIVatWRUJCAndr2YoVK7By5Uqx1wsEArnHTMoeVc67fH194evrK3ZrJiGEEPIzmpqa0NHRQatWrfgORe54vd0sISEBIpGoRA89PT0+QyWEEEJ+ijGGESNGoFatWoiPj+faK1SogOzsbISGhnJt6urqiIuLQ1hYGFcgAqggRGRLVfMumriaEEKIpDw9PfHq1SuMGzeO71DkjrcikYeHh0RDmIcOHYpy5crJMCJCCCGkZCIjI/Hnn39i6dKlXJtAIMCzZ8/w7t07PHr0iGvv1asXXr58icuXL4v1UZY+hBPFR3kXIYQQIhlLS0uVvIAnYN/Pgklk7vshz5GRkUhLS6MkjBBCFNjLly/h7+8PFxcX1KtXDwBw584dtG/fHhYWFoiJieG2vXjxIrS0tNCyZcsy/7c9PT0dRkZGdB4jSoOOWUIIIT/z4sULeHl5Yfv27Qo3r5A8z2FUJOIJJSqEEKJ4hEIh3r59i7p163JtvXr1wvnz57F27Vp4e3sDALKysjBlyhS0bNkSo0aNEptoWlXQeYwoGzpmCSGE/Ezbtm3h7++PAQMG4Pjx43yHI0ae5zBeJq7OyclBSkqK2DwMABAWFob69evzERIhhBAVl5CQgPr16yMzMxNfv37lbgfr2LEjsrOzUb16dW5bfX197N69m69QCZEI5V2EEELIf9u3bx9mzJgBHx8fvkPhldwvfZ46dQq1a9fGb7/9hoYNG+Lx48fcc8OGDZN3OGXKmzdv8ObNG+Tm5nJtIpEINFiMEELEPX/+HNOmTcP69eu5NjMzMxgYGEBHRwevX7/m2j09PXH9+nUMGDCAj1AJ+SWUdxFCCCElY2VlhTNnzqBy5cp8h8IruReJli1bhqdPnyIkJAR79+7F6NGjceTIEQCgYsYvcnV1RZ06dfDixQuu7ciRI1BTU8Nvv/0mtm1RshgUFMS1PXr0CH379sWiRYvEtt22bRsWLVqEt2/fcm2fP3/GhQsXxJJNAMjNzYVIJJLiuyKEkF8jEokQGhqKlJQUri0yMhKbNm3C3r17uTaBQIDbt28jOTkZTZo04SNUQqSO8q5v80Ha2tqiadOmfIdCCCFEweTm5opdHCQ8FIkKCgpgZmYGAHBwcIC/vz927NiBJUuWqOTM4dJkYGAAQ0NDsdVL8vLyAKDYfBmvX7/GixcvkJ+fz7VFR0fjzJkzuHv3rti2O3bswOLFi/H+/XuuLSgoCD179oSnp6fYth07doSGhgbOnj3LtYWEhKB9+/aYOHGi2LZHjx7Fxo0bERERwbVlZWUhJCQEHz58kPDdE0LIj3Xr1g329vY4d+4c1+bi4oIxY8Zg0aJFYh+Ua9asCQ0NXu7EJkQmKO/6NhowPDwcgYGBfIdCCCFEwXh5ecHe3h47d+7kOxSFIfciUaVKlfD8+XPu6woVKuDGjRt49eqVWDuRXFhYGNLT02FnZ8e1DR06FAkJCWJXy4FvBZobN27A1taWa3NwcMC2bdswefJksW0HDhyICRMmiM3Hoaenh+bNm4vtCwAyMjLAGBNb2jk+Ph537twpNuror7/+gpeXl9jPPTQ0FI0bN4arq6vYtp6enmjRooXYEtLJycnYuXMnLl26JLatqlwZJYSIS09Pxx9//IF27dpBKBRy7Y6OjtDX18eXL1+4tgoVKmDXrl3o16+fynxQJqqJ8i5CCCHkxwoKChAXF4f8/Hyxz7qqTu6rm338+BEaGhowNzcv9lxAQABatWolz3B4U1ZX2MjJyUFGRgbKlSsHHR0dAN+KRHfv3oW+vj66d+/Obbt8+XKEhYVhxowZcHBwAADcu3cPAwYMQM2aNREQEMBt6+zsjPv37+PEiRPo378/AODhw4dwcnKClZUVoqKiuG179+6NO3fuYOvWrRgyZAgXw7p162BhYYFp06Zx28bHx0NdXR0mJiZQV1eX2feFECJdjDGEh4cjMzMTzZs3B/DtRG9qaor09HQ8efKEu7UkPT0d2tra0NbW5jPkMqesnsfKGsq7/g8ds4QQQv4XYwwBAQFo3bo136H8VJle3axatWo/bM/NzYWmpiYuXbpUbE6bHj16yCM0IgW6urpit7sBQOXKlTFw4MBi286dO7dYm7OzM+Lj44u1b9q0CTExMWjWrJnYvrp3746KFSuKbZuUlITU1FSxD4QfPnzAhg0bULNmTbEi0cSJE3H+/Hls2bIFv//+OwAgMTERa9asQc2aNcVup2OM0YgDQhRE0dwqbdq04W6R1dTUxLJly2Bqaoo6depw29KHQaLKKO+SrYSEhB8W4AghhCiurKws6OvrA/g2J6WiF4jkTSEmXrh69SqGDRuG5OTkYs8JBAKx2waIamrSpEmxiWTt7e1x4cKFYtueP38eSUlJYrPSV6xYETNnzoSBgYHYtkVzNllYWHBtb9684QpK3xeJBgwYgIcPH2Ljxo3caKavX7/i+vXrsLS05EYzEEKk6+nTp9i3bx8GDRoEJycnAEC7du2go6MDQ0NDiEQibt61/71dlhBSHOVdvy4lJQUdO3ZEeHg4EhMTqRhNCCFK4uvXr3B2dkaPHj2wfPlyGgTwA3Kfk+hHJk+ejAEDBiA+Ph4ikUjsoeiJSu/evVG+fHn069eP71DI/2diYoJ69erByMiIa6tVqxbWrFmDBQsWiG175coVFBQUoGvXrlxbpUqVMGPGjGJLA0dHR+PTp0/Q0tLi2sLCwjBw4EAMHjxYbNs5c+agX79+uH//PteWm5uLjx8/0pxJhEho+/bt2Lp1K3bv3s211axZE1+/fsWlS5eKTcxPCPk5Zc67FEX58uWRnZ2NgoKCYnMuEkIIUVzXr19HWFgY9u/fj6SkJL7DUUgKMZIoMTERXl5e3OobymTq1KkYNWoU9u/fz3copJT+dyWjOnXqYN26dcW2u3jxImJiYlCrVi2uTU1NDa1bty42nP/mzZsICgrC8OHDubagoCA4Ozujbt26YsssBgYGQk9PD7Vr1xYrQBGiahhj2L17Nw4cOIDDhw9zI/xGjhyJ7Oxsbo6xIkXznhFCJKPMeZeiEAgEOHToEGrUqAFTU1O+wyGEEFJC7u7uSElJQevWrVGpUiW+w1FICnH5tV+/frhz5w7fYZRKu3btYGhoyHcYRA7MzMzQtGlTlC9fnmtzcnLCvXv3cPToUbFtly1bhi1btojdIpeSkgINDY1iBSVPT0/Y2dnh4sWLXFtMTAz27NmDoKAgGb0bQhTD9yPrBAIBDh48iHv37uHw4cNcu5OTEw4fPgwXFxc+QiSkzFHmvEuRODg4iBWICgoKeIyGEELIvwkODkZGRgb39cSJE9GgQQMeI1JsCjGSaOvWrejfvz/u3buHBg0aQFNTU+z5KVOmlKpff39/rF27Fk+fPkV8fDzOnj2LXr16iW3j6+uLtWvXIiEhAY0aNcKWLVvEJkcmpDQ6d+6Mzp07i7X16NED2dnZSE1NFWs3MjKCoaEhbGxsuDZ/f/9ik/ICwJo1a6ClpQV3d3exOZcIUTbp6emYPXs2bty4gZcvX3ITzXt5eaFbt27FbuEkhEiPrPIuVfbs2TP069cP27dvR6dOnfgOhxBCyP936tQpDB06FF26dMGZM2domoISUIgi0dGjR3H9+nXo6Ojgzp07YpNHCQSCUicrWVlZaNSoEUaNGoU+ffoUe/748ePw8vLC9u3b0bx5c/j4+KBz586IiIjghp7Z29ujsLCw2GuvX7+OKlWqlCouoro0NTWLrcZ248aNYvMUGRsbo2PHjmIFS8YYVq1aha9fv6J9+/ZckejGjRvYs2cPOnfujBEjRsj8PRBSWtnZ2dDT0wMA6Ovr48KFC/j06ROuXLnCFfB79uzJY4SEqAZZ5V2KytfXF76+vjKdb2nRokV4//49/vrrLyoSEUKIArG2toZQKIRIJEJubi6Xi5J/J2AKMIuuubk5pkyZgtmzZ8ussicQCIqNJGrevDmaNm2KrVu3AgBEIhEsLCwwefJkzJ49u8R937lzB1u3bsWpU6dK/Jr09HQYGRkhLS2NVsQgJVJQUIDFixfj1atXOHjwIPcHbvHixVi0aBFGjRolNrFvr169UL16dfz555+0PC/hVXh4OMaOHYvs7GwEBwdz7SdOnICxsTE6dOgAdXV1HiMkpUHnMeUlj7xLEcnymM3NzcXSpUvh7e3N3ZbOGKNVcwghRM6EQiHCwsLQsGFDru3x48do2rSpUp/z5Jl3KcRIovz8fLi7u8v1h5afn4+nT59izpw5XJuamhpcXV3x8OFDqe8vLy+PW24d+PZDJkQSmpqaWLZsWbH2bt26QVdXV+y+2oSEBJw/fx4CgQBLly7l2q9fv463b9+iU6dOYhNwEyJNeXl5+Pr1K1ecNDMzQ2BgIIRCIT58+ABLS0sAwIABA3iMkhDFV758+RIXGVJSUkrcLx95V1mno6OD5cuXi7VNnz4d0dHRWLlyJerVq8dTZIQQojoSExPh5uaGt2/fIjIykstFmzdvznNkykUhsgMPDw8cP35crvv88uULhEJhsZU9zMzMkJCQUOJ+XF1d0b9/f/zzzz+oVq3avxaYVq5cCSMjI+5RtGoPIb/KwcEBf/zxB9zc3Lg2AwMDHDt2DMuWLYORkRHXvmfPHnh6eopNtJ2fn49bt24hKytLrnGTsunUqVOoXLmy2O0qJiYmOH78OGJjY7kCESHkv/n4+GDjxo3YuHEj5s2bB+DbnHeLFi3CokWLuLnv5s+fL1G/fORdqiY2Nhbbtm3DuXPnJCrgEUIIKb2KFStCU1MTampqeP78Od/hKK0SjSTy8vIqcYcbNmyQOAihUIg1a9bg2rVraNiwYbEJFEvTp7zcvHmzRNvNmTNH7PuYnp5OhSIiMwYGBnB3dy/W3rp1a6SkpKB9+/Zc29OnT9GhQweYm5sjLi6Ou2qdlZUFfX19ucVMlBNjDEKhEBoa304nNWvWxNevX/Hs2TMUFhZy7b179+YzTEKUkoeHB/f/vn37YsmSJfj999+5tilTpmDr1q24efMmpk+fXuJ+lTnvUhYWFhYIDQ3F+fPn4eTkxLUvWbIEHz58gKenJxwcHHiMkBBClBtjDHfv3sXu3buxd+9eaGhoQE1NDQcOHECFChWKzQNLSq5ERaLv55AAwCX/devWBQBERkZCXV291Ce7Fy9eoHHjxgCAly9fij0nq3u5TU1Noa6ujsTERLH2xMREmczfoq2tDW1tbblMnkjIv/n999/FPmAAQHJyMiwsLNC4cWOx3zcXFxckJibi8OHDaNWqlbxDJUogODgY06dPR6dOnfDnn38CABo3bgx/f384OTnRPEOESNG1a9ewevXqYu1dunSRaB5FgJ+8SxXZ2NiIrVzKGMPevXvx4cMHdO/encub4+LiEBoaCgcHB27hFEIIIT+Xm5uLAQMGICkpCa6urtyFlaIaBSm9EhWJbt++zf1/w4YNMDQ0xP79+7mJ+b5+/YqRI0fC2dm5VEF837+8aGlpwcHBAX5+ftxk1iKRCH5+fsU+REuTp6cnPD09uYmnCOFbt27d0K1bN2RnZ3NteXl5eP78OXJzc1G1alWu/ezZs9i5cyfc3d1pJTWC8PBw3L17F69evcKMGTOgra0NgUBQ6nMBIeTfmZiY4Pz585gxY4ZY+/nz52FiYiJRX3zkXeSbPXv24Pz582IroJ0/fx6TJk1C165dcfnyZa797NmzqFy5Mho3bgxtbW0+wiWEEIXBGENwcDCaNGkCANDV1cXcuXPx5s0buLi48Bxd2SLxxNXr16/H9evXuQIR8G1ixWXLlqFTp07FkpefWbBgAXr27Cmz4baZmZl4+/Yt9/X79+8REhKCChUqoHr16vDy8oKHhwccHR3RrFkz+Pj4ICsrCyNHjpRJPIQosu+Xg9TW1kZiYiKCgoJQo0YNrv3mzZu4evVqsQr9lStX0K5dO+jq6sotXiJ/KSkpSEhIgK2tLQBg0KBBiIiIwNixY+kDDCEytnjxYowZMwZ37tzhJuB8/Pgxrl69il27dpWoD1nnXeTnBAIB2rdvL3bLd1F7nTp1xH4uhYWFcHd3R0FBAaKjo1G9enUA3wp8jx8/Rtu2bdGyZUu5xk8IIXwpLCxEhw4d4O/vj8DAQDg6OgIApk6dynNkZZPERaL09HQkJSUVa09KSkJGRoZEfX38+BFubm7Q0tJC9+7d0aNHD3To0AFaWlqShvVDQUFBYifiojmBPDw8sG/fPri7uyMpKQkLFixAQkIC7O3tcfXq1WKTWUsT3W5GlEW5cuWKVeV///132NjYcH+YAeD169fo2rUrTExMEBMTI1ZsImXHnTt30Lt3b1hYWCA4OBjq6upQU1PDkiVL+A6NEJUwYsQI2NjYYPPmzThz5gyAb7cz3b9/v8Srtsg67yKlM2HCBEyYMAGMMa4tLS0Nzs7OiImJQbVq1bj2ixcvYuPGjZg+fTpXJBKJRBgyZAhq1aqF2bNn03yChJAyR0NDA5aWlnjy5AlCQ0PFPosQ6ROw789IJTB8+HDcu3cP69evR7NmzQB8u5I1c+ZMODs7Y//+/RIFIBKJEBAQgIsXL+L8+fOIj49Hx44d0bNnT3Tr1g0VKlSQqD9lUXS7WVpaGsqVK8d3OISU2o0bNzB27Fg0aNAAFy9e5NrPnTuHxo0bi41EIsorJSUF1tbWsLCw4FZzJKqNzmPKSVXzLqBsHLPHjx/HxYsX0a9fP266hA8fPsDKygpaWlrIysriFgzYtm0bHj9+jKFDh6Jjx448Rk0IIZJJSEjAsmXLsHTpUu4Opk+fPkFNTQ2VK1fmOTp+yPMcJnGRKDs7G97e3tizZw8KCgoAfKvsjR49GmvXrv3lqxevXr3iEpegoCA0b94cPXr0wKBBg8TmRlF2ZSFRIaSISCTC169fuXkxMjIyYG5ujuzsbLx8+RL169fnOUIiqTt37uDBgwfchNQAEBYWhnr16tGE1AQAncf48O7dO+zduxdRUVHw8fFBpUqVcOXKFVSvXr3Uf2dVJe8Cyu4xm5SUhEOHDiE1NRWLFy/m2rt3745Lly5h69at8PT0BPBtgZahQ4fC3t4ea9asoYnKCSEKhzGGpk2b4unTp5g6dSp8fHz4DkkhKHSRqEhWVhbevXsHALC2tpbJ0NakpCQcPXoUfn5+cHZ2hre3t9T3IW/f324WGRlZ5hIVQoBvH2TGjRuHuLg4hIeHc0nohQsXYGBggHbt2kFNTY3nKMm/iYiIQL169SAQCPDs2TPY29vzHRJRQGX1A7eiunv3Ltzc3NCqVSv4+/vj1atXqFmzJlatWoWgoCCcOnXql/dRFvOu76naMXvz5k08fPgQffv25eaSu3HjBjp16oQ6deogIiKC29bb2xsfP37E9OnTS3z7Iim7CgoKoKmpyX198OBB7N69G926dRP7u1CzZk0IBALcuHEDNWvWBPDtItPRo0fRqlUrDB8+nNs2Ly+P5i8kJXb37l14e3tjy5YtaNGiBd/hKAR5nsMknpOoSHx8POLj49GmTRvo6uqCMSa1qxEZGRk4evQodu/ejaCgoDI1fw+tbkZUgbW1Nfz8/JCTk8P9XWCMwcvLC+/evcPRo0cxcOBAnqMk3/s+Iaxbty6GDh0KIyOjMjeSgBBlNXv2bCxbtgxeXl4wNDTk2l1cXLB169Zf6luZ8q7evXvjzp076NChg1QKY2WZq6srXF1dxdrq16+Pv//+u1jOfunSJURERIgt3uLv749p06ahbdu22LhxI9ceExMDExMTmvuoDMrOzkbnzp3x7NkzxMfHcx9EExIScPfuXW4C9SJJSUnIzMzkbnEEvs0Ju3PnTmRlZYkViWrVqoWCggL4+flxIx+Tk5ORn58Pc3NzGtWm4h49eoTCwkK0bt0aANC2bVs8efKEjgueSHwpPzk5GR06dECdOnXQtWtXxMfHAwBGjx4t0cpmP+Lv7w8PDw9UrlwZ69atQ/v27fHo0aNf6pMQwp/vVzvLzs6Gq6srqlWrhu7du3Ptfn5+2LlzJ1JTU3mIkOTm5mLhwoWoXbs20tLSuPYDBw5g69atqFixIo/REUKKvHjxAr179y7WXqlSJXz58qVUfSpj3jV16lQcOHCA7zCUVpUqVTB69GiMGjVKrH3z5s1YtWqV2AprERERCA4ORmRkpNi2Xbt2hYGBAfz9/bm20NBQzJkzB8ePHxfbNi8vTwbvgkiDSCTCjRs3xIqtenp6iIuLQ3Z2Nh4/fsy1d+vWDceOHeMWASry4MEDPHjwAObm5lxbq1atsGjRIrG/Vzk5Ofj48SMSExPFtt23bx+qVKmCESNGFOs3MTERpbzhhSiZmzdvok2bNujXrx/i4uK4dioQ8UfikUTTp0+HpqYmYmJiYGNjw7W7u7vDy8sL69evl6i/hIQE7Nu3D7t370Z6ejoGDBiAvLw8nDt3jhsaSwhRfvr6+ti+fTtEIpHYrWbr1q3D1atXERsbi6VLl/IYoWrS0NDAiRMnEB0djYMHD+L3338HQCdmQhSNsbEx4uPjYWVlJdYeHBws0Yg/Zc+72rVrhzt37vAdRpnTqVMndOrUSaytW7duuHjxIgwMDMTaiy4oVKpUiWsLDAzEqlWr0LVrV7i7u3PtdnZ2+PjxI+7cucPdxhYYGIh9+/ahcePGGDNmjFgfampqqFevHo1SkoMTJ05g0KBBsLa2Rt++fbnz/t69e1GlShVYW1tz29rY2Ih97ivSoEGDYm0tW7bkVt4roquri69fv+Ldu3dik+MnJSVBTU1N7O9abm4unJ2dIRKJEB8fzxWVXrx4geTkZDRs2LBMT7CvipycnGBjY4PatWuLjZQl/JF4JNH169exevXqYivb1K5dG9HR0RL11b17d9StWxfPnz+Hj48P4uLisGXLFklDUiq+vr6wtbVF06ZN+Q6FEF7871xEnTp1gp2dndiQ5NDQUMycORNhYWHyDq/MY4zh7t273NU5DQ0NbNmyBSdOnOAmNiWEKJ6BAwdi1qxZSEhIgEAg4FYp8/b2Fvv7+TOyzrv8/f3RvXt3VKlSBQKBAOfOnSu2ja+vLywtLaGjo4PmzZvjyZMnUts/ka7KlSujW7duaNeunVh7bGwsvn79ilq1anFtNjY2mDx5sthIYeDbHQi5ubliH/xCQ0Oxbds2nD9/XmzbQYMGwdHREc+fP+fazpw5AxMTE7HCEwBMmzYNgwYNEssTIiIisGLFChw9elRs2wcPHuD69etITk7m2tLS0vDs2bNio6Q+f/6M+Ph45Obmcm0ikQj5+fkQiUQ//D4pg5ycHBw+fFiswNq9e3dUr14dHTt2FBvx1aZNG9SqVUvqF4uMjY3h4OAg1u+qVauQmZkpNkIpISEBVlZWMDU1hZmZGde+bds2tG/fHmvXruXaCgsL8ddff8Hf31+hb5MlxX0/SkxPTw+3b9/GyZMnqUikKJiEDAwMWGRkJPf/d+/eMcYYCwwMZBUqVJCoL3V1dTZ9+nSuvyIaGhosLCxM0tCUSlpaGgPA0tLS+A6FEIUzZcoUBoC5u7vzHUqZIhKJ2G+//cYAsFOnTvEdDlFydB6Tr7y8PDZmzBimoaHBBAIB09TUZGpqamzo0KGssLCwRH3IOu/6559/2Ny5c9mZM2cYAHb27Fmx548dO8a0tLTYnj17WFhYGBs7diwzNjZmiYmJ3DaNGjVi9evXL/b49OkTt83t27dZ3759JY6Pjln5S09PZ+/fv2d5eXlcW2BgIJs/fz7bv3+/2LbOzs7MwsKChYeHc21///03A8C6desmtm2tWrUYAHbv3j2u7cSJEwwAa9Omjdi29vb2DAC7du0a13b58mUGgDk4OIht6+TkxACwM2fOcG23b99mAFi9evXEtu3ZsyczNjZmJ06c4NpCQ0OZtbU1a926tdi227dvZ1OnTmX+/v5cW2FhIcvMzGTysHDhQgaAde7cWaxdKBTKZf+l8f0xwxhjc+bMYVZWVuzw4cNc26tXrxgApq+vL/Zebt26xa5evcq+fv0qr3CJBDIzM5mrqys7duwY36EoFXmewyS+3czZ2RkHDhzgbgspupq1Zs0atG/fXqK+7t+/j927d8PBwQE2NjYYNmwYTWZLCEHXrl0RExMjNmeCUCjklmcmpSMQCNCkSRPcvHkTHz9+5DscQogEtLS0sGvXLsyfPx8vX75EZmYmGjdujNq1a5e4D1nnXW5ubnBzc/vX5zds2ICxY8dykyNv374dly9fxp49ezB79mwAQEhIiNTiycvLExshkZ6eLrW+SckYGhoWGxng6OgIR0fHYtt+P8dRkf79+8PJyUlspS0AWLRoEZKSksRuiapRowZGjRpV7HeiaMTT9wvGaGpqomrVqmIjVYBvo53V1dXFJmIuGqHyfRvw7XhKTU0VG8GSnZ2Nd+/eFRuFc+HCBfzzzz9o0KABnJ2dAQCRkZGwtbVFvXr1xFaC/fz5M4yNjaGlpVXs+1ES0dHROHToELp3746GDRsCAIYNG4YDBw6gdevWYosNKfJKs//7/lesWIEVK1aItRUWFqJr167Q0tISey8rV67EjRs3sH37dowfPx7At9FjISEhaNGiBa2yxjNfX1/cvHkTwcHB6Nq1K40eUkSSVpVevHjBKlWqxLp06cK0tLRYv379mI2NDTMzM2Nv374tVaUqMzOT7d69m7Vq1Yq7Mubj48PS09NL1Z8yoKtZhEjmzz//ZAKBgK1du5bvUJRGXl4e++OPP1hERATXlp6ezqKjo3mMipQVdB5TXvLIu/A/I4ny8vKYurp6sdFFw4cPZz169JCo75KOJCoaPfG/DzpmiSQKCgrY169fi41K+fjxI4uIiBA7ntLT09mDBw9YUFCQ2LYHDx5ks2bNYs+fP+fa/Pz8GADWqFEjsW27devGNDU1xUbM5ObmsuTk5B/G9/XrV7FRNAMHDmQA2OTJk8W2E4lEJXq/ZcGkSZNYnTp12LNnz7i2ixcvMgDM1taWx8gIY99G0Xl6erIHDx7wHYpSUeiRRHZ2doiMjMTWrVthaGiIzMxM9OnTB56enqhcuXKpClX6+voYNWoURo0ahYiICOzevRurVq3C7Nmz0bFjR1y4cKFU/SoiX19f+Pr60n2zhEiAMYYvX76AMVZsPjTy7+bMmYMNGzbg7du3OH36NIAfX9UlhCi+/11VqIhAIICOjg5q1aqFnj17lmhCVz7yri9fvkAoFBYbuWFmZobXr1+XuB9XV1eEhoYiKysL1apVw8mTJ4tNkltkzpw5Yt+39PR0WFhYlO4NEJWloaEBY2PjYu0/mjDe0NDwh8fj0KFDi7W5uLggKSmp2OqE79+/R0FBgdixeu/ePXTs2BG9e/fGmTNnuPYmTZpwK9AVjaDy8PDA58+f0aZNG7F+VWlBCl9f32JtmZmZMDMzg5OTk1h79+7dYW1tjVmzZpX6syz5b98vXKOuro6tW7fyHBH5GQFjirm2oFAoxMWLF7Fnz54yVSQqkp6eDiMjI6SlpaFcuXJ8h0OIUnj06BFatGjBff2/K6URcSEhIejfvz8WLFiAYcOG8R0OKWPoPCZf7du3x7NnzyAUClG3bl0A325XUVdXR7169RAREQGBQID79++XapUyaeddAoEAZ8+eRa9evQAAcXFxqFq1Kh48eCD2IfqPP/7A3bt3xZbblrbvL9BFRkbSMUsUGmMM0dHRMDc3h46ODoBvt2ZOnDgRXbt2xeXLl7lt7ezsEBYWhosXL6Jbt258haw0GGPIysriVux79+4datWqBXV1dSQmJsLExAQAkJ+fX+rb/UhxQqEQQ4cORb169bBgwQKVKlhKkzzzLomLRN+vOCDW0f+/klW9enW6z7MEKLkm5NdkZWXBxcUFEydOxIgRI/gOR2FRokNkhc5j8uXj44N79+5h79693Pc7LS0NY8aMQevWrTF27FgMHjwYOTk5uHbtGs/RFi8S5efnQ09PD6dOneLagG+jHlJTU4utdCULdMwSZZaWloakpCSxVeUiIiJgZmb2w5FO5L/l5ubi+vXrCA8P5+ZFA77N4fT27VusXbsWrVu35jHCsuHy5cvo1q0bNDQ08Pz5c9jY2PAdklJS6CKRmpoaV/0reun31UBNTU24u7tjx44dXPX7R54/fw47O7sSjwIICwtD3bp1i00ap6woUSHk12zYsAEzZszgblWgBOmbrKwsfPnyBTVq1OA7FFLG0XlMvqpWrYobN24UGyUUFhaGTp064dOnT3j27Bk6depU7PYVQP551/8WiQCgefPmaNasGbZs2QLg22jQ6tWr4/fffxf7gCYrdMwSQv5LTk4OzMzMkJGRgcePH6NZs2Z8h1QmbNq0CdWqVUPfvn35DkVpyfMcJvF9GmfPnkXt2rWxc+dOhIaGIjQ0FDt37kTdunVx5MgR7N69G7du3cK8efN+2k/jxo2RnJxc4v22bNkSMTExkoZLCCmjpk2bhsWLF+P48eNUIPr/GGOYOHEiGjdurBAjCQgh0pOWlobPnz8Xa09KSuJW7TI2NkZ+fv4PXy+PvCszMxMhISHcCmXv379HSEgI14+Xlxd27dqF/fv349WrV5g4cSKysrK41c5kxdfXF7a2tmjatKlM90MIUX66urqIjIzEjh07xP5m+Pj4YMyYMYiOjuYxOuXBGBObg3fq1KlUIFIiEl8eWr58OTZt2oTOnTtzbQ0aNEC1atUwf/58PHnyBPr6+pgxYwbWrVv3r/0wxjB//nzo6emVaL//lvQoG5q4mhDpUFNTw4IFC8TaHj16hPT0dHTq1ImnqPiVlZWFiIgIpKWl/XQkJyFE+fTs2ROjRo3C+vXruQ8ugYGB8Pb25kbrPHnyBHXq1Pnh6+WRdwUFBaF9+/bc10WTRnt4eGDfvn1wd3dHUlISFixYgISEBNjb2+Pq1avFJrOWNk9PT3h6enJXYQkh5GfMzc0xbtw47uuCggKsXbsWcXFxaNq0KcaPH89jdIqPMYY5c+bg7du3OHLkCE17oIQkvt1MV1cXwcHBqFevnlj769ev0bhxY+Tk5ODDhw+wtbVFdnb2v/bTrl07iSetOnLkSJmZdZ6GPBMiXZ8/f0aTJk0QFxeH06dPo3fv3nyHxIv8/Hz4+/vD1dWV71BIGUfnMfnKzMzE9OnTceDAARQWFgL4tuqSh4cHNm7cCH19fW4Ej729fbHXq3reBdAxSwgpvQcPHmDnzp3YtWsXNDU1AQDJyckoX748LaLyPyIiItCwYUPk5+fj0qVL+O233/gOqUxQ6DmJGjdujEaNGmHnzp1cVbCgoABjx45FaGgogoODERAQgKFDh+L9+/cyCbosoESFEOnKzc3FlClTcO/ePTx58kSllnlnjNFKEUTu6DzGj8zMTERFRQEAatasya3SQ/4bHbOEEGlhjKFt27YoKCjA3r17iw2gUHXXrl1DZGQkJk+ezHcoZYY8z2ES327m6+uLHj16oFq1amjYsCEA4MWLFxAKhbh06RIAICoqCpMmTZJupIQQ8hM6OjrYuXMn0tLSxApECQkJMDc35zEy2WKMYdCgQXBxccHYsWOpWERIGWdgYMDlX6Rk6FZ/Qoi0vX79GiEhIRCJRGVmYaVf9f2Kup07dxabnoYoF4lHEgFARkYGDh8+jMjISABA3bp1MXjwYJW6cv+r6GoWIbJ35swZDB06FNu2bcOIESP4DkcmTp06hf79+0NLSwuvXr1CzZo1+Q6JqAg6j8lfUFAQTpw4gZiYmGJzBp05c4anqJQHHbOEEGn69OkTt8JkEVUd3b1jxw7s2LED165dQ8WKFfkOp0xS6JFEAGBoaIgJEyZIOxZCCJGqU6dOIScnBy9evOA7FJnp06cPVq9ejfLly1OBiJAy7NixYxg+fDg6d+6M69evo1OnToiMjERiYqLKzsFGCCF8qlq1KqpWrcp9HRERgcGDB2P//v2ws7PjMTL5ysjIwKJFi5CQkIBDhw5h+vTpfIdEflGpRhIBQHh4+A+vZPXo0UMqgZV1dDWLENkTiUTYv38/hg4dyk0ySAiRDjqPyVfDhg0xfvx4eHp6wtDQEKGhobCyssL48eNRuXJlLF68mO8QFdb3t5tFRkbSMUsIkQk3NzdcvXoVXbp0wZUrV/gOR64iIiJw7NgxLFiwQCVHUsmDQk9cHRUVhd69e+PFixcQCAQoennRwSDp/d4FBQXo0qULtm/fjtq1a0v0WmVEiQoh/GGMwdPTE7169RIbGqxsCgsLsX//fowYMQLq6up8h0NUFBWJ5EtfXx9hYWGwtLSEiYkJ7ty5gwYNGuDVq1dwcXFBfHx8ifpRtbzre3TMEkJk6cuXL5g2bRrWr18PMzMzvsORue/nICKyJ89zmMTr9U2dOhVWVlb4/Pkz9PT0EBYWBn9/fzg6OuLOnTsSB6CpqYnnz59L/Dpl5enpifDwcAQGBvIdCiEq5/Dhw/jrr7/QvXt3xMXF8R1OqS1YsABjxoxB//79+Q6FECIn5cuXR0ZGBoBvtzi8fPkSAJCamors7OwS96NqeRchhMiLqakpDh06JFYgCg8PRylv3FFofn5+qFOnTpme0kGVSVwkevjwIZYsWQJTU1OoqalBTU0NrVu3xsqVKzFlypRSBTF06FDs3r27VK8lhJCS6tevH8aOHYs1a9agSpUqfIdTavXr14e+vj7c3d35DoUQIidt2rTBjRs3AAD9+/fH1KlTMXbsWAwaNAgdOnSQqC/KuwghRPauX78Oe3t7eHt7l6lCEWMMCxcuRHR0NDZu3Mh3OEQGJJ64WigUcquYmZqaIi4uDnXr1kWNGjUQERFRqiAKCwuxZ88e3Lx5Ew4ODtDX1xd7fsOGDaXqlxBCvqejo4OdO3eKnajj4+ORmJgIe3t7/gKT0JAhQ+Dq6qoSQ5kJId9s3boVubm5AIC5c+dCU1MTDx48QN++fTFv3jyJ+qK8ixBCZO/t27coKCjA+/fvUVhYWGbmxxQIBLh06RJWrFiBpUuX8h0OkQGJi0R2dnbcZInNmzfHmjVroKWlhZ07d5Z6ZZ2XL1+iSZMmAIDIyEix52jiK0KItBX9XSkoKIC7uzsCAwNx9OhR9OrVi9/AfiIvLw8ikQi6uroAQAUiQlRIYWEhLl26hM6dOwMA1NTUMHv27FL3p2p51/fzQRJCiLxMmjQJtWvXRvv27aGhUapFxRVKYWEh9z6MjY2xZs0aniMisiLxxNXXrl1DVlYW+vTpg7dv36Jbt26IjIyEiYkJjh8/DhcXF1nFWqbQ5ImE8C8jIwMDBw7EvXv3EBQUhDp16vAd0r+aNGkSAgICcOrUKZWbbJYoJjqPyZeenh5evXqFGjVq8B2K0qJjlhDCt6ioqFIPrOBTXFwcOnTogFWrVqFnz558h6OS5HkOk7ikWXQVCwBq1aqF169fIyUlBeXLl/+lq0+pqanYvXs3Xr16BeDbnBujRo2CkZFRqfskhJCfMTQ0xMWLF/H69WuxAlFiYqJCjdT5/PkzTp8+jaSkJLx7946KRISooGbNmiEkJERqRSLKuwghRH4YY1i6dCmWLl2Ky5cvK90qu+vXr8fr168xZ84cdO3atczcOkd+TKKJqwsKCqChocGtqFGkQoUKv1QgCgoKgrW1NTZu3IiUlBSkpKRgw4YNsLa2xrNnz0rdLyGE/Bc1NTXY2tpyXxddqff09ERhYSGPkf2fSpUqITg4GHv27EGXLl34DocQwoNJkybBy8sLW7duxcOHD/H8+XOxhyQo7yKEEPmLiopCYWEhAgIC+A5FYqtXr8bMmTNx6dIlKhCpAIlvN6tZsybOnj2LRo0aSS0IZ2dn1KpVC7t27eLucywsLMSYMWMQFRUFf39/qe1LUdCQZ0IU0+rVqzF79mz06NED58+f5zscQhQWncfkS02t+HU9gUAAxhgEAoFE8+2oYt4F0DFLCOFXXl4erly5otBzYBLFJc9zmMRFot27d+PMmTM4ePAgKlSoIJUgdHV1ERwcjHr16om1h4eHw9HREdnZ2VLZjyKhRIUQxXX79m1YWlrCysoKAJCTk4Pnz5+jefPmcouBMQZvb2/0798fLVq0kNt+CSkpOo/JV3R09E+fl+Q2NFXMuwA6ZgkhRBIbN25EQUEBZs6cWSYXNVA2Cj0n0datW/H27VtUqVIFNWrUKLZsammGKZcrVw4xMTHFkpXY2FgYGhpK3J8ioxU2CFF87du3F/t69erVWLx4MWbPno2VK1fKJYYDBw5gw4YN2L59Oz58+ICKFSvKZb+EEMUkzQmrVSnvAij3IoQonqysLEyePBnOzs4YOXIk3+EU8/LlS3h7e0MkEqFJkyZwdXXlOyQiRxIXiWQxPM7d3R2jR4/GunXr4OTkBAAICAjAzJkzMWjQIKnvj0+enp7w9PTkKoGEEMX35csXAOCWjJaH3r174/Lly2jZsiUViAghAICDBw9i+/bteP/+PR4+fIgaNWrAx8cHVlZWEq02o0p5F0C5FyFE8Rw4cAB79+7F6dOn0bt3bxgbG/Mdkpj69etj06ZNePHiBTp06MB3OETOJL7dTBby8/Mxc+ZMbN++nZsoVlNTExMnTsSqVaugra3Nc4TSR0OeCVEuL1++RP369bnhtvfv30deXp5MT5xFf55piC9RRHQek6+//voLCxYswLRp07B8+XK8fPkSNWvWxL59+7B//37cvn27xH2pYt4F0DFLCFEcQqEQHh4eGD16dLER7IT8iELPSQR8Wzb11KlTePfuHWbOnIkKFSrg2bNnMDMzQ9WqVUsdTHZ2Nt69ewcAsLa2hp6eXqn7UnTS/iGLRCJERETAxsZGCtERQn4mPz8fjRo1wuvXr7F7926MGjVKKv2KRCI8fPgQrVq1kkp/hMgSfeCWL1tbW6xYsQK9evWCoaEhQkNDUbNmTbx8+RLt2rXjRjxKQpXyLoCOWUII+S+XL19G586duUUNiOKQ5zms+FIZ/+H58+eoU6cOVq9ejXXr1iE1NRUAcObMGcyZM0fiAAoKCtChQwe8efMGenp6aNCgARo0aFDmExVpiouLg4ODA1q2bImUlBS+wyGkzCsoKEDHjh1RpUoV9OnTR2r9rly5Eq1bt8aCBQuk1ichpGx4//49GjduXKxdW1sbWVlZJe6H8i5CCFE8WVlZSE9P5zWGf/75B926dUObNm2Qn5/PayyEXxIXiby8vDBixAi8efMGOjo6XHvXrl1LtWSqpqYmnj9/LvHryP8xMzODUChEWloaVq9ezXc4hJR5+vr62Lx5MyIiIsTuIZ87dy4uXLiA0t7FW1R0L1pVjRBCilhZWSEkJKRY+9WrVyUaRUx5FyGEKJbLly+jbt26vF8kzM3NhZGREZo3bw4tLS1eYyH8krhIFBgYiPHjxxdrr1q1KhISEkoVxNChQ7F79+5SvZYA6urq3IpLmzdvxsePH3mOiBDVYGBgwP3/4cOH3K0gERERpepv7dq1CAwMVMhVLggh/PLy8oKnpyeOHz8OxhiePHmC5cuXY86cOfjjjz8k6ovyLkIIURxaWlr49OkTrly5gry8PN7i6NOnD168eCG3lXyJ4pL4ZkNtbe0fDoWLjIws9Qo8hYWF2LNnD27evAkHBwfo6+uLPb9hw4ZS9atKunbtitatW+P+/ftYsmQJdu7cyXdIhKiUBg0aYPbs2UhLSxNbVpox9tOJp4VCIdTU1LhtHB0dZR4rIUT5jBkzBrq6upg3bx6ys7MxePBgVKlSBZs2bcLAgQMl6kvV8i5fX1/4+vpCKBTyHQohhBTTsWNHHDt2DD179uR94QALCwte908Ug8QTV48ZMwbJyck4ceIEKlSogOfPn0NdXR29evVCmzZt4OPjI3EQP5vRXSAQ4NatWxL3qehkMfFUQEAAWrduDXV1dYSFhaFu3bpS6ZcQUnLfF4VSUlLg4uKCWbNmYeDAgT8sFs2cOROfPn3Czp07xUYmEaLoaBJg/mRnZyMzMxOVKlUq1etVMe8C6JglhJD/lZKSgiFDhmDZsmVwcHDgOxzyEwq9ullaWhr69euHoKAgZGRkoEqVKkhISEDLli3xzz//FLsaRX5MVj/kHj164OLFi+jXrx9OnjwptX4JIZKbP38+li1bhvr16yMkJKTYShFRUVGoW7cuCgsLcenSJfz22288RUqI5OgDt3wtW7YMQ4YMoTnLfgEds4QQZfD8+XM0bNhQLvuaPHkytm7dioYNGyIkJOSno98JvxR6dTMjIyPcuHEDFy9exObNm/H777/jn3/+wd27d0tVIPp+lQ1lExsbi3bt2sHW1hYNGzZUiKLM8uXLIRAIcOrUKQQGBvIdDiEqbe7cuVi2bBm2bt3KFYgYY0hLSwMA1KxZE7dv38by5cupQEQI+amTJ0+iVq1acHJywrZt20q15D2g3HkXIYSUZUKhEB07dkSjRo3w5MkTuexz7ty5GDRoEHx9falARDgSjySKjY2V+r2KFStWxIMHD1C7dm2p9itr8fHxSExMhL29PRISEuDg4IDIyMgSFctkWQn08PDAgQMH0KFDB9y8eVOqfRNCfs3Ro0cxefJkrF+/Hh4eHnyHQ0ip0agM+QsLC8Phw4dx7NgxfPz4ER07dsSQIUPQq1cviZawV9a861fRMUsIUXQjR47E4cOHsXnzZkyYMIHvcIgCUeiRRJaWlmjbti127dqFr1+/SiUIZV1lo3LlyrC3twcAmJubw9TUFCkpKfwGBWDx4sXQ1NSEn58fFYkIUTB79+5FcnIyrUJICJFY/fr1sWLFCkRFReH27duwtLTEtGnTYG5uLlE/ypp3EUJIWbd06VK8e/dO5gWiwsJCmfZPlJvERaKgoCA0a9YMS5YsQeXKldGrVy+cOnXql5brKywsxF9//QVHR0eMHz8eXl5eYo/S8vf3R/fu3VGlShUIBAKcO3eu2Da+vr6wtLSEjo4OmjdvXuqhfU+fPoVQKFSIGeEtLS0xceJEAMDs2bMh4WAxQogMXb58Gdu3b8eMGTP4DoUQosT09fWhq6sLLS0tFBQUSPRaWeVdhBBCfk21atVk/nmysLAQTZs2xbRp05CamirTfRHlJPHtZkUYY7hz5w6OHDmC06dPQyQSoU+fPtizZ4/EfclqlY0rV64gICAADg4O6NOnD86ePYtevXpxzx8/fhzDhw/H9u3b0bx5c/j4+ODkyZOIiIjgVgyxt7f/YaX1+vXrqFKlCoBvs8I7Oztj165dcHJyKlFssh4u9vnzZ1hbWyMzMxMnTpxA//79pb4PQgghqotu3ZG/9+/f48iRIzhy5AgiIiLQtm1bDB48GP369YORkVGJ+6HVzeiYJYQovs+fP0NbW1uiv+8lce7cOfTu3RsVKlTAu3fvYGxsLNX+iWwo9OpmP/Ls2TOMHj0az58/h1AolEZcUicQCIoViZo3b46mTZti69atAACRSAQLCwtMnjwZs2fPLlG/eXl56NixI8aOHYthw4b9dLvvR1ulp6fDwsJCpj/kRYsWYfHixahduzbCwsKgqakpk/0QQghRPfSBW75atGiBwMBANGzYEEOGDMGgQYNQtWpVvsNSKnTMEkKUxfLly7FkyRKsXLlS6iM8GWO4ffs2UlJS0K9fP6n2TWRHoeckKvLx40esWbMG9vb2aNasGQwMDODr61vqQO7du4ehQ4fCyckJnz59AgAcPHgQ9+/fL3WfP5Ofn4+nT5/C1dWVa1NTU4OrqysePnxYoj4YYxgxYgRcXFx+WiACgJUrV8LIyIh7yOO2tBkzZsDU1BRv3rzB3r17Zb4/QgghhMhGhw4d8OLFCwQHB8Pb2/uXC0TyzrsIIYSUnKmpKfLz8/H48WOp9y0QCODi4kIFIvKvJC4S7dixA23btoWlpSUOHDgAd3d3vHv3Dvfu3Sv1BFunT59G586doauri2fPnnEjbtLS0rBixYpS9flfvnz5AqFQCDMzM7F2MzMzJCQklKiPgIAAHD9+HOfOnYO9vT3s7e3x4sWLH247Z84cpKWlcY/Y2Nhffg//xdDQEPPmzQPwbTLr7Oxsme+TEELIjzHGkJiYiHv37uHvv//GH3/8gV69eqFRo0YYOXIkoqKi+A6RKLDly5fD1tZWKn3xkXfxydfXF7a2tmjatCnfoRBCSIkMGjQIT58+xfHjx6Xar6Le9UMUi8S3m1lYWGDQoEEYMmQIGjVqJJUgGjdujOnTp2P48OEwNDREaGgoatasieDgYLi5uZW4aPMz/3u7WVxcHKpWrYoHDx6gZcuW3HZ//PEH7t69K5Oq7ffkNVwsLy8PdevWRXR0NFavXo0//vhDZvsihBACZGZm4s2bN4iMjERERAQiIyO5R1pa2r++TkNDA2PGjMG8efOU4jYiunVH/j5+/IgLFy4gJiYG+fn5Ys9t2LChxP3II+9SRHTMEkJU2ZMnTzBw4EDMnj0b48aN4zscIiF5nsM0JH1BTEwMBAKBVIOIiIhAmzZtirUbGRnJbMZ1U1NTqKurIzExUaw9MTFR4qVkJeHr6wtfX1+5VXG1tbWxZMkSeHh4YOXKlRg7dizKly8vl30TQkhZVVBQgA8fPhQrBEVERCAuLu5fXycQCGBpaYk6deqgbt26qFOnDszNzbFr1y5cu3YN27dvx759++Dp6YnZs2fD1NRUju+KKDI/Pz/06NEDNWvWxOvXr2FnZ4cPHz6AMYYmTZpI1BcfeRchhJDSYYyBMQY1tVLPFAMA2LlzJ96/f4+AgAAqEkkgPj4e06ZNQ0BAAExNTeHu7o5x48bBxMSE79BkRuIiUVGBKDs7+4dXsho2bChxEObm5nj79i0sLS3F2u/fv4+aNWtK3F9JaGlpwcHBAX5+ftzoIpFIBD8/P/z+++8y2ScAeHp6wtPTk6sEysOQIUOwdu1avHz5EmvWrMHKlSvlsl9CCFFmjDEkJCT8cETQu3fvfrjyZZGKFSuiTp06YsWgOnXqwNraGjo6OsW279u3L/z9/TF37lzcv38f69evx44dO7glyeV1viCKa86cOfD29sbixYthaGiI06dPo1KlShgyZAi6dOkiUV985F2EEEIkt2bNGmzbtg2+vr747bfffqmvjRs3okWLFnB0dJRSdGVfQkICnJ2d8e7dOwDAp0+fEBoaCh8fH1y+fLnsfi+ZhD5//sy6du3K1NTUfvgojRUrVjBbW1v26NEjZmhoyO7du8cOHTrEKlasyDZv3lyqPhljLCMjgwUHB7Pg4GAGgG3YsIEFBwez6Ohoxhhjx44dY9ra2mzfvn0sPDycjRs3jhkbG7OEhIRS77Ok0tLSGACWlpYm830xxtiFCxcYAKarq8s+ffokl30SQoiyyc3NZefOnWMDBw5kRkZGDMC/PnR1dVmjRo1Y//792dy5c9mBAwfYo0ePWEpKSqn3LxKJ2JUrV1iTJk24/VSoUIGtXr2aZWVlSfGd/jp5n8dUnYGBAXv79i1jjDFjY2P28uVLxhhjISEhrEaNGhL1Jau8S9HRMUsIUTaTJ09mANjIkSP5DkXlCIVC1qFDBwaAWVlZsZs3b7I9e/YwW1tbBoBVrlyZxcbGyi0eeZ7DJC4SDR48mLVq1YoFBgYyfX19dv36dXbw4EFWt25ddunSpVIFIRKJ2LJly5i+vj4TCARMIBAwHR0dNm/evFL1V+T27ds/TOw9PDy4bbZs2cKqV6/OtLS0WLNmzdijR49+aZ//ZevWrczGxobVqVNHromKSCRiTk5ODAAbP368XPZJCCHKID8/n125coV5eHgUKwypqakxa2tr5ubmxqZOncp8fX3ZzZs3WUxMDBMKhTKLSSQSsVOnTrF69epxsZibm7OtW7eyvLw8me1XEvSBW77MzMxYeHg4Y4wxGxsbdv78ecbYtyKRvr6+RH3JKu9SdHTMEkKUTVhYGDt16hTLzs7mOxSVs3r1agaA6enpsVevXnHtaWlpzM7OjgFgTZo0YZmZmXKJR57nMIknrq5cuTLOnz+PZs2aoVy5cggKCkKdOnVw4cIFrFmz5peWTs3Pz8fbt2+RmZkJW1tbGBgYlLovRcfH5In37t1DmzZtoK6ujlevXqF27dpy2S8hhCgaoVAIf39/HDt2DKdPn0ZycjL3XJUqVeDu7o4BAwagcePG0NbW5jXOQ4cOYdGiRfjw4QMAoEaNGli0aBGGDh0KDQ2J7xqXGpoEWL569eqF3377DWPHjoW3tzfOnz+PESNG4MyZMyhfvjxu3rwpcZ+qlHcBdMwSQlRTVFQU/vjjDwwaNAh9+/blOxylEB0djXr16iE3Nxd///03Ro8eLfb8hw8f0LRpU3z58gV9+/bF8ePHoa6uLtOY5HkOk7hIVK5cOTx//hyWlpaoUaMGjhw5glatWuH9+/eoX78+LbNeQnwlKt26dcPly5cxYMAAqS+pSAghikwkEuHRo0c4duwYTp48KbaCU8WKFdG/f38MHDgQrVq1+uXJIaUtPz8ff//9N5YtW4b4+HgAQN26dbF06VL07duXl3jpA7d8RUVFITMzEw0bNkRWVhZmzJiBBw8eoHbt2tiwYQNq1KjBd4gKj45ZQogqWr16NWbPno0OHTqU6oKCKhowYABOnjyJdu3a4datWz9cuOv+/ftwcXFBQUEB3N3dcfDgQWhqasosJoUuEjVt2hTLli1D586d0aNHDxgbG2PlypXYvHkzTp06xU3qRH7s+9XNipZDlmei8vz5c9jb24MxhqCgIDg4OMht34QQIm+MMTx79gzHjh3D8ePHERsbyz1Xvnx59OnTBwMHDkS7du14HZVTUtnZ2fD19cWqVauQkpICALC3t8fy5cvh5uYm9dVHf4Y+cBNlQ8csIUQZZWZm4vDhw3j27Bl27Ngh8evDw8Nx6NAhNGnSBP369ZNBhGXL3bt30a5dO6ipqSE4OPinC3OdPn0agwYNQkFBATp37gxfX19YW1vLJC6FLhIdOnQIhYWFGDFiBJ4+fYouXbogJSUFWlpa2LdvH9zd3WUVa5nCZ6IybNgwHDp0CJ06dcK1a9fkum9CCJGHly9f4tixYzh27JjYxQsDAwP06tULAwcORMeOHaGlpcVjlKWXnp6ODRs2YMOGDcjIyAAAODk5YcWKFWjbtq3cYqAP3PyYNGkSlixZAlNTU75DUSp0zBJClFF6ejpMTU1RUFCAyMhImjJEhoRCIRwcHBAaGoqJEydi27Zt//maq1evok+fPsjJyQEANG/eHCNHjsSIESOkOmWBQheJ/ld2djZev36N6tWrU7IiAT4TlaioKNSrVw8FBQXw8/ODi4uLXPdPCCGyEBkZiePHj+PYsWMIDw/n2nV1ddGtWzcMHDgQbm5u0NXV5TFK6fry5QvWrFmDLVu2IDc3FwDQsWNHLF++HE2bNpXpvukDN3/KlSuHkJAQWq5eQnTMEkKU1bRp01CpUiWMGjUK5ubmfIdTZu3cuRPjx4+HsbEx3rx5U+L6xtOnTzFv3jxcv34dIpEIAFCtWjXMnz8fo0ePlsp8RUpTJAoICICjoyOvk3oqK74TlcmTJ2Pr1q1o2rQpHj9+LNdbFAghRFo+fPiAEydO4NixYwgODubatbS00KVLFwwcOBDdu3cv8xPyxsXFYfny5di5cycKCwsBfJvoeOnSpbCzs5PJPvk+j6kyQ0NDhIaGqlyRKDY2FsOGDcPnz5+hoaGB+fPno3///iV+PR2zhBBVc/ToUdSpUweNGzdWuPkWFc3Xr19Rp04dfPnyBZs3b8bkyZMl7iMhIQFHjx7FunXrEBcXBwBwcHBAQEDAL9dM5HkO+6Ujxc3NDZ8+fZJKIPfu3cPQoUPRsmVLrs+DBw/+0mppisjX1xe2trYyv8L7X+bNmwd9fX0EBgbizJkzvMZCCCGSiIuLw6ZNm9CyZUtYWVlh1qxZCA4Ohrq6Orp06YK9e/ciMTER58+fx6BBg8p8gQj4tiKbr68vIiMj4eHhATU1NZw7dw4NGzbEsGHDaL5AUowy5l0aGhrw8fFBeHg4rl+/jmnTpiErK4vvsAghRCHl5uZi9OjRcHR0RFhYGN/hKLzZs2fjy5cvsLW1xYQJE0rVh7m5OaZPn453795h48aNMDY2VspBNb9UJPrFO9U4p0+fRufOnaGrq4vg4GDk5eUBANLS0rBixQqp7ENReHp6Ijw8HIGBgbzGYWZmBi8vLwDA3LlzuSvPhBCiiBhjuHbtGtzc3FCtWjVMmzYNjx49gkAgQPv27bF9+3YkJCTgypUrGDFiBIyNjfkOmRdWVlbYt28fXr58iX79+oExhkOHDqFevXqYMGECPn78yHeIRAoyMjJ+aRSRsuZdlStXhr29PYBvibipqSk3gTshhJR1+fn5ePjwIZKSkkq0fXJyMjp37gwbGxuZjSouK+7fv4+dO3cCAP76669fXqVMR0cH06ZNQ2RkpEKfV/+NQow5W7ZsGbZv345du3aJ/UBatWqFZ8+e8RhZ2ebt7Q0TExNERERg//79fIdDCCHFZGVlYfv27bC1tUWXLl1w9epVMMbg5OSETZs24dOnT7h16xbGjx9P8+J9x8bGBidPnsTTp0/h5uaGwsJC7NixA7Vq1VLokSLk5969e4d58+Zh8ODB+Pz5MwDgypUrEl8hllXe5e/vj+7du6NKlSoQCAQ4d+5csW18fX1haWkJHR0dNG/eHE+ePCnVvp4+fQqhUAgLC4tSx0sIIcqka9eucHJywoULF0q0fdWqVXH27FmEhYXR1CI/kZaWBg8PDwDA6NGj0aZNG6n1XbFiRVSoUEFq/cnLLxWJduzYATMzs18OIiIi4oc/DCMjI6Smpv5y/+THypUrh7lz5wIAFi5cyM3ITgghfIuJicGsWbNgYWGBiRMn4vXr1zA0NMTUqVPx5s0bBAQEYMqUKahcuTLfoSq0Jk2a4J9//oG/vz+cnZ1RuXJlNGvWjO+wSCncvXsXDRo0wOPHj3H69GlkZmYCAEJDQ7Fw4UKJ+pJV3pWVlYVGjRrB19f3h88fP34cXl5eWLhwIZ49e4ZGjRqhc+fOXMELAOzt7WFnZ1fsUTS3AwCkpKRg+PDh3FVfQghRBc2aNYOJiYnEt9lSgejfMcYwfvx4REVFoUaNGli3bh3fISkGVkpv3rxhV69eZdnZ2YwxxkQiUWm7YlZWVuzGjRuMMcYMDAzYu3fvGGOM7d+/n9nY2JS6X0W0detWZmNjw+rUqcMAsLS0NF7jycnJYRYWFgwAW7t2La+xEEJUm0gkYgEBAax///5MXV2dAWAAmLW1NfPx8eH976WyE4lELD4+Xmr9paWlKcR5TFW0aNGCrV+/njEmnis9fvyYVa1aVaK+5JF3AWBnz54Va2vWrBnz9PTkvhYKhaxKlSps5cqVJe43NzeXOTs7swMHDpRo27S0NO4RGxtLxywhRGllZ2czoVBYom0LCgpYTk6OjCNSfjt27GAAmLq6Onv48CHf4fyUPPMuiUcSJScnw9XVFXXq1EHXrl0RHx8P4NvQrBkzZpSqUDV27FhMnTqVW2UrLi4Ohw8fhre3NyZOnFiqPhWVosxJVERHRwdLliwBAKxYsYJGbhFC5C4/Px+HDx9Gs2bN0KpVK5w8eRJCoRAuLi44f/48IiIiMHXqVFqN6BcJBAJaNleJvXjxAr179y7WXqlSJXz58kWivvjIu/Lz8/H06VO4urpybWpqanB1dcXDhw9L1AdjDCNGjICLiwuGDRv2n9uvXLkSRkZG3INuTSOEKDNdXd0Sr1D28OFDlCtXDr169ZJtUErMz88Pnp6eAL7dht2iRQueI1IcEheJpk+fDg0NDcTExEBPT49rd3d3x9WrV0sVxOzZszF48GB06NABmZmZaNOmDcaMGYPx48eXauk5Iplhw4bB1tYWX79+xdq1a/kOhxCiIpKSkrBs2TJYWlpi6NChCAoKgra2NkaNGoXQ0FD4+fmhR48eUFdX5ztUQnhnbGzMXZj7XnBwMKpWrSpRX3zkXV++fIFQKCw2TYGZmRkSEhJK1EdAQACOHz+Oc+fOwd7eHvb29njx4sW/bj9nzhykpaVxj9jY2F96D4QQoiyePn2KgoICaGho8B2KQgoLC0OfPn1QWFiIQYMG4Y8//uA7JIUi8VFz/fp1XLt2DdWqVRNrr127NqKjo0sVhEAgwNy5czFz5ky8ffsWmZmZsLW1VYllixWBuro6li9fjt69e8PHxwe///47zfNBCJGZ58+fY9OmTTh8+DC3qlLlypUxadIkjB8/HhUrVuQ5QkIUz8CBAzFr1iycPHkSAoEAIpEIAQEB8Pb2xvDhwyXqS1nzrtatW0MkEpV4e21tbaVbdpgQQn5m27ZtOHjwIMaNG4eRI0f+63ZTp05Fjx49uDyL/J9Xr17B1dUV6enpcHZ2xt69e0s8QktVSPzdyMrKEhtBVCQlJaXUJ+KYmBgwxqClpQVbW1s0a9aMS1RiYmJK1SeRTM+ePdGiRQtkZ2dj6dKlfIdDCCljhEIhLly4ABcXFzRq1Ah79uxBXl4eHB0dcejQIXz48AHz5s2jAhEh/2LFihWoV68eLCwsuKJOmzZt4OTkhHnz5knUFx95l6mpKdTV1ZGYmCjWnpiYKPPbIH19fWFra4umTZvKdD+EECJrHz9+xKNHj/Do0aOfbicQCFCzZk3Y2NjIKTLl8PLlS7Rr1w4JCQlo2LAhzp49SxcTfkDiIpGzszMOHDjAfV10NWvNmjVo3759qYKwsrJCUlJSsfbk5GRYWVmVqk9FpaiJikAgwKpVqwAAu3btwtu3b3mOiBBSFqSnp2PTpk2oU6cOevbsidu3b0NdXR0DBgxAQEAAnjx5giFDhkBLS4vvUAlRaFpaWti1axeioqJw6dIlHDp0CK9fv8bBgwclviWTj7xLS0sLDg4O8PPz49pEIhH8/PzQsmVLmeyziKLNB0kIIaXl7u6Oo0ePYtasWXyHonSuX7+O1q1b4/Pnz7C3t8etW7dgYmLCd1gKSeLbzdasWYMOHTogKCgI+fn5+OOPPxAWFoaUlBQEBASUKgjG2A+X5svMzISOjk6p+lRUnp6e8PT0RHp6OoyMjPgOR0zbtm3h5uaGK1euYMGCBThy5AjfIRFClNS7d++wZcsW7NmzBxkZGQCA8uXLY9y4cfD09KQJZAkpJQsLi1/+/ZFV3pWZmSl2ken9+/cICQlBhQoVUL16dXh5ecHDwwOOjo5o1qwZfHx8kJWV9dNbJgghhPyfRo0aoVGjRj/dJjg4GAcOHEDr1q3Rt29fOUWmuEQiEXx8fDBz5kyIRCI4OTnh4sWLqFChAt+hKSyJi0R2dnaIjIzE1q1bYWhoiMzMTPTp0weenp4Sz2Pj5eUF4Nsolvnz54vdxiYUCvH48WPY29tLGiL5BStWrMCVK1dw9OhRzJw5E40bN+Y7JEKIkmCM4fbt29i0aRMuXrwIxhgAwMbGBlOnTsXQoUOhr6/Pc5SEKKe+ffuiWbNmxa4er1mzBoGBgTh58uR/9iHrvCsoKEhsVHnR/jw8PLBv3z64u7sjKSkJCxYsQEJCAuzt7XH16tVik1lLm6+vL3x9fSEUCmW6H0IIUQT37t2Dj48PPnz4oPJFoo8fP2LUqFG4ceMGgG/nox07dtAtZv9BwIqyeB4UJRJ3795Fy5YtxW430NLSgqWlJby9vVG7dm2+QpSZopFEaWlpCres8+DBg3H06FF06dIFV65c4TscQoiCEwqFOHz4MNatWye20pCbmxumTZuGjh07/nDUAlFuinweK4sqVqyIW7duoUGDBmLtL168gKura7G5fn5ElfMugI5ZQkjZ8Pr1a4SGhqJRo0aoV69esefv37+P06dPw97eHh4eHjxEyL+8vDz4+Phg2bJlyMzMhK6uLtatW4eJEycqbU4qz3NYqYpEubm5eP78OT5//lxslYkePXpIHMTIkSOxadMmlTphK3Ki8u7dO9SrVw+FhYW4ffs22rVrx3dIhBAFdffuXUyfPh3BwcEAAD09PYwYMQKTJ0/+YeJCyg5FPo+VRbq6uggJCUHdunXF2l+/fo3GjRsjJyenxH2pYt4F0DFLCCkbhgwZgiNHjmDVqlU0N9H/YIzh/PnzmDFjBqKiogAALVq0wL59+4qdP5WNPM9hEk9cffXqVVSvXh0tWrRAjx490KtXL+7Ru3fvUgWxd+9eOlkrEGtra4wbNw4AMHv2bPA42IwQoqCioqLQr18/tGvXDsHBwShXrhxWrlyJjx8/wtfXlwpEhEhZgwYNcPz48WLtx44dg62trUR9qVreJatFQ4KDg9G3b19ERERItV9CCPkZR0dHODk50Yqw3ykqDjVr1gy9e/dGVFQUKleujAMHDiAgIEDpC0TyJvFIotq1a6NTp05YsGCB1O4hX7JkyU+fX7BggVT2o0gU/WpWQkICrK2tkZ2djbNnz6JXr158h0QIUQDp6elYvnw5fHx8kJ+fDzU1NYwbNw5LliyhZEXFKPp5rKy5ePEi+vTpg8GDB8PFxQUA4Ofnh6NHj+LkyZMSnadVMe8CpH/MVqxYEV++fIGVlRV3xZoQQviUlZWFz58/o0aNGlBTk3g8iNIRiUQ4c+YMli1bhtDQUADfRrVPnz4ds2fPhoGBAc8RSo9C325Wrlw5BAcHw9raWmpB/O/kyAUFBXj//j00NDRgbW2NZ8+eSW1ffPt+8sTIyEiFTq7nzZuH5cuXw8bGBs+fP4eGhsTznBNCygihUIg9e/Zg3rx5+Pz5MwDA1dUVGzZsKDZHClENVCSSv8uXL2PFihUICQmBrq4uGjZsiIULF6Jt27YS9aNKedf3pH3Mfj+vBY26JoQogqtXr8LNzQ0ODg4ICgriOxyZKSgowMGDB7FmzRpuNKehoSF+//13TJ8+vUxeuJRn3iXxp/5+/frhzp07Ui0SFc1l8b309HSMGDGi1LewKSpPT094enpyP2RFNnPmTPz111949eoVDh48SEvUEqKibt++jWnTpuH58+cAgDp16mD9+vX47bfflHbyP0KU0W+//Ybffvvtl/tRpbyLEEJUSWJiIjQ0NGBhYcF3KDLj7++PiRMnIjw8HABgbGyMKVOmYOrUqbSsvZRIPJIoOzsb/fv3R8WKFdGgQQNoamqKPT9lyhSpBffixQt0794dHz58kFqfikJZrsCuX78e3t7esLCwQGRkJHR0dPgOiRAiJ2/fvsXMmTNx7tw5AN9OwgsXLsSkSZPEVkUiqklZzmOk5Mpq3iWrUdz6+vrIzs4GQCOJCCHy5ebmhufPn8PPz6/YPJBCoRCZmZkKPyBBUl+/foWXlxf27dsHADA1NcXs2bMxbtw4GBoa8hucHCj0SKKjR4/i+vXr0NHRwZ07d8SuIgsEAqkWidLS0pCWlia1/ojkPD094ePjg9jYWGzbtg1eXl58h0QIkbG0tDQsW7YMmzZtQkFBAdTV1TFhwgQsWrQIpqamfIdHiEoSCoXYuHEjTpw4gZiYGOTn54s9n5KS8sv7KKt5l6xGcRsbG4sViWhkJSFEXuLi4hAXF4cPHz4UKxKpq6uXuQKRn58fPDw88OnTJwDAuHHjsHLlSho5JCMSF4nmzp2LxYsXY/bs2VKbDGvz5s1iXzPGEB8fj4MHD8LNzU0q+yClo6Ojg8WLF2P06NFYsWIFRo8eXeb+6BBCviksLMTu3bsxf/58JCUlAQA6d+6MDRs2SLx6EiFEuhYvXoy///4bM2bMwLx58zB37lx8+PAB586dk3iiacq7pMPY2BhxcXEAvl3hpg8rhBB52bZtG7S1tWFjY8N3KDK3ZcsWbiBK7dq1sW/fPjg5OfEcVdkm8e1mFSpUQGBgoFTnJLKyshL7Wk1NDRUrVoSLiwvmzJlTJoePKdMw/cLCQjRo0ACvX7/GvHnzsHTpUr5DIoRImZ+fH6ZPn44XL14AAOrVq4cNGzbQB0byr5TpPFYWWFtbY/Pmzfjtt99gaGiIkJAQru3Ro0c4cuRIiftSxbwLkP4xW7duXURGRgIAQkND0bBhw1/ukxBCfsXQoUNhZmaGefPmoXz58nyH88s2bNiAGTNmAABGjx6NTZs2QV9fn+eo+KHQq5sVzRb+559/yiomlaBsyfWZM2fQt29f6OnpISoqCmZmZnyHRAiRgsjISHh7e+PixYsAgPLly2Px4sWYMGFCsTnnCPmesp3HlJ2+vj5evXqF6tWro3Llyrh8+TKaNGmCqKgoNG7cuEzeJiYtspqTqFq1atytD2fOnKFJvwkhvMrIyOD+tmVkZCj98u/fjyD6888/sWzZMpW+rVeh5yQSCoVYs2YNrl27hoYNGxb7ELFhw4YS9SPJ3DYl7ZPITu/evdGsWTM8efIEy5Ytw5YtW/gOiRDyC75+/YqlS5diy5YtKCwshLq6Ojw9PbFw4UK6ZYIQBVStWjXEx8ejevXqsLa2xvXr19GkSRMEBgZCW1v7P1+vynmXrOYkysrK4v7/5s0bqfVLCCH/JTExEXfu3IGGhgb69u0L4Nv8wBs3bkRSUpLSF4iOHTuGqVOnAgAWLFiARYsWqXSBSN4kLhK9ePECjRs3BgC8fPlS7DlJfnA/Wn71R+hgUAwCgQCrVq2Ci4sLduzYgSZNmqBv37509ZgQJVNYWIidO3diwYIFSE5OBgB07doV69atU4n72glRVr1794afnx+aN2+OyZMnY+jQodi9ezdiYmIwffr0/3w95V3Sl5mZyf2/6LYzQsoykUiEEydO4Pz588jJyUHnzp0xZMgQ+jzAg7CwMAwcOBA2NjZckcjAwADTpk3jNzApuHPnDoYPHw7GGCZPnkwFIh5IfLsZkQ5lHabftWtXXLlyBcC3Sa27d++OwYMHw83NrURXMgkh/Ll+/TqmT5+O8PBwAICtrS02bNiAzp078xwZUUbKeh4rKx4+fIiHDx+idu3a6N69O9/hKAVpHrP5+flieU+bNm1w9+7dXw2x1PLy8vDx40cwxlC5cmWVnbODyM7bt28xYsQIBAQEiLVXrFgRu3btQs+ePXmKTDW9e/cOI0eORJ06dfD333/zHY7UfPz4EU2aNEFSUhIGDBiAo0ePSm2xLGWn0HMSkV8jq/vi5SU9PR2bNm3CkSNH8Pr1a67d2NgY/fr1w+DBg9GmTRuoq6vzGCUh5HuvX7+Gt7c3Ll++DAAwMTHBkiVLMG7cOGhoSDyglBAAVCQiykeax+z/rmZWsWJFJCYmyu1qd05ODm7duoULFy7Az88P79+/h0gkAvBtNJidnR0GDRqEMWPGoGLFinKJiZRdDx8+RNeuXZGamgoDAwNMnToVBgYG2LNnD3er5dq1a+Ht7c1zpKotISEBhYWFMDMzU8p5JfPz89G2bVs8evQI9vb2ePDgAXR1dfkOS2EoXJGoT58+2LdvH8qVK4c+ffr8dNszZ86UKpDU1FTs3r0br169AvDtCndZXm5d2ZNrxhhCQkJw+PBhHD16lFsCFgCqVq2KgQMHYvDgwWjcuDENDySEJ9nZ2Zg7dy62bt2KwsJCaGhoYPLkyZg/f36ZWPGC8EvZz2PKKCIiAlu2bOFyJRsbG0yePBl169aVuC9Vy7sA6R6zHz9+hIWFBQBAXV0dQqEQsbGxqFatmjRC/aHPnz/j8uXLuHDhAq5fv47s7Gyx53V1daGmpiY2V5KBgQFmzpwJLy8vpZ+jhPAjMDAQ7dq1Q3Z2Nlq0aIFjx46hRo0aAL6NYJs1axY2bdoE4Nuy7BMnTuQzXJXm5eWFjRs3YsaMGVi3bh3f4Ujsjz/+wNq1a2FsbIynT5+iZs2afIekUOSZd5Vo7JaRkRH3Qd/IyOinj9IICgqCtbU1Nm7ciJSUFKSkpGDjxo2wtrbGs2fPStUnkS2BQIDGjRtj3bp1iImJwe3btzFmzBgYGxvj06dPWL9+PRwcHGBra4ulS5fi7du3fIdMiEr59OkT2rRpAx8fHxQWFqJ79+4ICwvDhg0bqEBEiBI6ffo07Ozs8PTpUzRq1AiNGjXCs2fPYGdnh9OnT0vUl6rlXb6+vrC1tUXTpk2l1mdRIcbY2Bh2dnYAvn1fpe3Dhw9YvXo1WrVqBXNzc4waNQrnzp1DdnY2qlWrhkmTJuGff/5BXFwcsrKykJmZibi4OOzZswdNmjRBZmYmFi5cCFtbW240KSElFR8fj169eiE7Oxuurq64efMmVyACAG1tbWzcuJFb9Xry5Mnw8/PjK1yVl5eXBw0NDVStWpXvUCQWEhLCLZqwb98+KhDxjZXQ4sWLWVZWVkk3l0jr1q3ZiBEjWEFBAddWUFDAPDw8mLOzs0z2ybe0tDQGgKWlpfEdilTl5uayc+fOsf79+zMdHR0GgHs0a9aMbdq0icXHx/MdJiFl2qNHj5i5uTkDwExMTNiVK1f4DomUQWX1PKaoatasyebPn1+sfcGCBaxmzZoS9aWKeRdj0j1mnz59ygCwqlWrslGjRjEAbM6cOVKIkrHMzEx28eJF1rt3b6ampiaWSzVp0oQtWrSIPXv2jIlEop/2IxQK2fHjx5mlpSX3+oEDB7IHDx6wwsJCqcRKyq7c3FzWsmVLBoDZ2Nj89PdGJBKxYcOGMQCsQoUKLCoqSo6Rqq6hQ4cyCwsLdvnyZa5NKBSyvLw8HqOSXGFhIWvatCkDwPr37893OApLnnlXiYtEampqLDExUSZB6OjosFevXhVrDwsLY7q6ujLZJ99UIblOS0tj+/fvZ506dRJLctTU1FinTp3Yvn37yvT7J4QPBw8eZNra2gwAs7Ozo0SNyIwqnMcUia6uLnvz5k2x9sjISIlzJVXMuxiT7jHr7+/PALA6deqw3bt3MwCsefPmpe7v1atXbM2aNczFxYVpaWmJFYZcXFzYtm3bWGxsbKn6zszMZDNmzBDLxYyMjFi3bt3Y2rVrWWBgoFjBkBCRSMRGjhzJADBjY2MWGRn5n6/Jzs5mjo6ODABr2LAhy8jIkEOkqs3NzY0BYHv27OE7lF+yefNmBoCVK1eOffr0ie9wFJY8864Sz1jKZDi/dbly5RATE4N69eqJtcfGxsLQ0FBm+yWyVa5cOQwfPhzDhw9HYmIijh8/jiNHjuDx48e4fv06rl+/jgkTJqBbt24YMmRImV0hLT8/HykpKUhOTkZ2djbU1NSgrq4OdXV1sf//rO1H7WpqajTfE+EIhUL8+eefWLNmDQCgR48eOHToEP0NJaSMaNeuHe7du4datWqJtd+/fx/Ozs4S9UV5168rut1MX18fnTp1AvBt7paUlBSxCa1/Jjk5GYcOHcKBAweK3eZnaWmJbt26YeLEibC1tf2lWPX19bFu3ToMHDgQa9euxbVr15CWloZLly7h0qVLAABDQ0M4OzujXbt26NevH3R1dREVFQVHR0doaWn90v6J8tmyZQv27t0LNTU1HD9+HLVr1/7P1+jq6uLs2bNwdHTE8+fPMXToUJw+ffqni9kwxhATE4OgoCCkpqbCwcEB9vb2UnwnZduqVauwePHiYucFZfLx40fMnTsXwLf3U6VKFZ4jIoAEq5upqakhMTFRJiskTJkyBWfPnsW6devg5OQEAAgICMDMmTPRt29f+Pj4SH2ffFPlCT/fvXuHo0eP4vDhw0q1QppIJEJaWhqSk5ORnJzMFX6+f/yoLTMzU2YxCQSCHxaTtLW1Ua1aNdSoUQM1atSApaUl9/8aNWqgfPnyVGAqQ9LT0zF48GBuvok///wTS5cupSVDiUyp8nmMD9u3b8eCBQswYMAAtGjRAgDw6NEjnDx5EosXLxZLrHv06PHTvlQx7wKke8xmZWXhw4cPUFNTg42NDezs7BAWFoY9e/Zg5MiRP31tfHw8Vq5cib///hs5OTkAAA0NDbi6uqJr167o3LkzateuLbPzdGFhIUJCQnD37l3cuXMH9+7dQ1pa2g+3tbGxgb+/P0xMTPDlyxeIRCIYGxuXyYt65Bs/Pz907twZQqEQGzZswPTp0yV6/YMHD+Di4oK8vDx4enpi8+bNYvlIQUEBLl++jF27dsHf379Ynuzi4oJ58+ahbdu2lMdIyMPDA+XKlcOyZcuUZhGCvn374syZM2jevDkePHhAP/OfULjVzYBvRaLvJ7D+NykpKRIHkZ+fj5kzZ2L79u0oLCwEAGhqamLixIlYtWpVmTwRUXL98xXSqlSpAnd3d9SoUYMbMSOrfwUCAbKysv6z8JOSksItLyspgUCA8uXLQ19fHyKRCCKRCEKhkHv879dFbbJiaGgoVjT63yKSmZkZFZGUxLt379CjRw+Eh4dDR0cHu3fvxuDBg/kOi6gAOo/JV0kTZ4FAAKFQ+NNtVDHvAmR7zK5YsQJz585Fq1atcP/+/R9u8/XrV6xZswabNm3iikP29vYYPXo03N3deVuqXigUIjQ0FHfv3sXFixdx+/ZtCAQC7i6CRo0aITs7m1vqXE1NDdWrV4etra3Yo27dujA2NublPRDpePfuHZo2bYqvX79i+PDh2LdvX6nywWPHjmHQoEEAgPr168PJyQnGxsaIi4vDrVu3EB8fz22rqakJW1tbVKpUCXfu3EFBQQEAoGLFiujcuTPc3NzQqVMnmJqaSudNllHZ2dnQ19cHAKU5L1+4cAE9e/aEhoYGnj59ioYNG/IdkkJT2CKRj4/Pf1YlPTw8Sh1MdnY23r17BwCwtraGnp5eqftSdJRcixMKhbh37x6OHDmCkydPIjU1le+Q/pW+vj5MTEy4R4UKFX76tYmJCYyMjEo1MqqkxaT/bcvJyUFsbCyio6MRHR2NDx8+cP///Pnzf+5XR0cH1atX/2ERydLSElWqVFG4kV6q6NatW+jfvz9SUlJQpUoVnDt3Tqqr9xDyM3QeU36qlHcBsj1mP336BCsrKxQUFOCff/6Bm5ub2H63bNmCtWvXciN2WrZsiaVLl8LFxUXhLsqkpqZCIBAgMjISrVu3Rn5+folfa2RkhJo1a8LU1BRaWlrQ1NQU+1dXVxfGxsYwMjKCsbEx938zMzNYWVnh06dPyMnJgaWlJUxMTGT4Lsn/iouLQ7t27fDmzRs0b94cd+7cgY6OTqn7O3jwICZOnMjdmvm9SpUqYeTIkRg8eDBsbGygqakJAIiOjsaqVatw5MgRpKenc9sLBAK0aNECffr0gb29PSpWrAhdXV3o6elBV1cXurq6KCwsRG5uLhhjqFSpUql+r8LCwnDp0iUEBATg0aNHSE5OhqGhIRo3bowWLVqgS5cucHJy4uLlW3R0NB48eIDy5cujTZs22LFjB5KTk7F06VKF+7vyvzIyMlC/fn3ExsZi1qxZWLVqFd8hKTyFLRIlJCSgUqVKUg8iJycHjDEuOYmOjsbZs2dha2vL3edd1lBy/e/y8vJw9epVXLx4EVlZWRCJRGDfJlnn/i/tf/X09H5Y3PlRAUjZr7BmZ2cjJibmhwWk6OhofPr06T/nINPQ0EC1atVgaWmJVq1aoUePHnB0dKQhonK0bds2TJkyBUKhEE2bNsW5c+foPm4iV3Qek4+HDx8iOTkZ3bp149oOHDiAhQsXIisrC7169cKWLVskOjepWt7l6+sLX19fCIVCREZGyuyY9fLywsaNG2FiYoIdO3agYsWKuHr1Kv766y/u4leDBg2wfPlydOvWTeE/xAHAixcvcOjQIZiYmGD8+PEoV64cEhMTERERgVevXiE8PJz79/sR4dKgp6cHLS0trsj0fcFJU1MTGhoaqF+/Pt6/f4+goCA4OjpiyJAhCAoKQmBgINLS0lBQUADGGCpXrgxLS0uoqakhOzsbAoGA6+/7h6amptgoqh/ln0WPkn4tEAigp6cHAwMD6Ovrcw9zc3Pu4lu1atV4PR6io6PRuXNnREREwNLSEgEBAVLJKZKTk3Hz5k2EhYUhKysLFSpUQJMmTdChQ4efznVVUFCABw8e4OrVq7hy5QpCQ0Ml2q+RkREcHR3h7OyMNm3aoEWLFtDV1f3X7cPCwvD777/jzp07/9m3sbExunTpgr59+6J79+68fi44cuQIhgwZAhcXF/j5+fEWh6QYYxg2bBgOHz4MKysrvHz5ssxfpJAGhSwSqaurIz4+XiZFok6dOqFPnz6YMGECUlNTUa9ePWhqauLLly/YsGEDJk6cKPV9/qrU1FS4urqisLAQhYWFmDp1KsaOHVvi11NyTRRVfn4+Pn78+MMC0ocPHxAbG8vdnvA9c3NzdO/eHT169ECHDh1+ejImpVdQUIApU6Zg+/btAIDBgwfj77//pu83kTs6j8mHm5sb2rVrh1mzZgH49qG9SZMmGDFiBGxsbLB27VqMHz8eixYtKnGfyph3SYOsj9msrCy4uLjgyZMnxZ6rV68e5s2bh0GDBpXZCypF8zRFRUUhLS0N+fn5KCgoEPs3OzsbaWlpSE1NRWpqKvf/6OhopKamwtDQEAYGBmK3I6mCChUqoGnTpujatSsGDBgAc3Nzue37zp07GDRoEBISEmBhYQF/f39YWlrKbf8l8enTJ5w7dw7Xrl3DmzdvkJqaiuzsbOTk5HC3pxX5vshXRFdXF/3798fQoUNhZmaGrKwsZGVlIT4+HteuXcPRo0chEomgrq4ONzc3tG/fHi1btoSlpSWSkpIQGBiIu3fv4p9//kFycjLXb4UKFTBkyBCMHDkSjRs3lsv34nsPHjzAvHnz4ODggLVr18p9/6XBGMP69esxc+ZMqKur49atW2jTpg3fYSkFhSwSyXIkkampKe7evYv69evj77//xpYtWxAcHIzTp09jwYIFePXqldT3+auEQiHy8vKgp6eHrKws2NnZISgoqMRDYym5JspKKBQiPj4e0dHRiIiIwNWrV3H16lVkZGRw2+jq6qJTp07o0aMHfvvtN5iZmfEYcdmRnJyMfv364c6dOxAIBFixYgVmzZqlFFejSdlD5zH5qFy5Mi5evAhHR0cAwNy5c3H37l1u3puTJ09i4cKFCA8PL3Gfyph3SYM8jtnMzEwsWbIEp0+fRkFBAZo1a4ZBgwahd+/eZbY4JA2MMeTk5EBXVxcCgQCZmZn4/PkzCgoKihWaitqysrLw8uVLGBoaonnz5jhz5gweP34MGxsbdOvWDRUrVuRuC/r06ROio6MhEAi4iypF/X3f9/e31hWdW7+fy7Lo8V9ff98mEom4okTRIyMjA3FxcYiJiUFMTIxYoUNNTQ29e/fGvHnzZLrS1+fPnzFz5kwcOHAAAGBnZ4crV66gWrVqMtunLBQWFiInJweamprQ1tZGQUEBXr16hQcPHuDevXu4e/duiUa59e7dGz4+Pqhevfq/biMUCvH48WOcP38ehw4dEuu3ZcuW8PHxQbNmzaTyviSVlpaG9PR0mJqaKvSFwwULFmDp0qUAgLVr18Lb25vniJSHXPMupgB0dXVZdHQ0Y4yx/v37s0WLFjHGGIuJiWG6urp8hlYiycnJrEaNGiwpKanEr0lLS2MAWFpamgwjI0Q+cnNz2bVr19jvv//OqlevzgBwD4FAwFq2bMlWrlzJwsLCmEgk4jtcpfTy5UtmZWXFADADAwN24cIFvkMiKo7OY/Khra3NYmJiuK9btWrFli1bxn39/v17ZmBgIFGfyp53lRYds0QR5eXlsaCgILZhwwbWvHlzLn9SU1NjXl5eLDs7W6r7EwqFbMeOHax8+fJcnjZx4sQy+3shEonYw4cP2ZgxY5ilpSWrVKkSs7KyYg0aNGDOzs5s+vTp7NGjRxL3W1hYyK5cucIGDBjAtLS0uO/lvHnzWGFhoQzeyc9t376dAWA9e/aU+75L6sKFC9zxvXTpUvpMICF5nsMUokjUoEEDtmnTJhYTE8PKlSvHHjx4wBhjLCgoiJmZmZWqz7t377Ju3bqxypUrMwDs7NmzxbbZunUrq1GjBtPW1mbNmjVjjx8/lmgfX79+ZQ0bNmS6urps69atEr2WEhVSVolEIhYSEsKWLFnCHB0dxQpGAJi1tTWbPn06u337NsvPz+c7XKVw4cIFZmBgwAAwKysr9uLFC75DIoTOY3JSvXp1dvfuXcbYtw+Turq67ObNm9zzz58/Z+XLl5eoT1nkXcqAjlmiDF6+fMkGDBjA5U2NGjVib968kUrfT58+ZS1btuT6tre3l/jzDykuLi6ODR06lPu+urq6suTkZLnGsHnzZqaurs6GDh0q1/2WVHJyMjM3N2cA2IwZM/gORympXJHo5MmTTFNTk6mpqTFXV1eufcWKFaxLly6l6vOff/5hc+fOZWfOnPlhkejYsWNMS0uL7dmzh4WFhbGxY8cyY2NjlpiYyG3TqFEjVr9+/WKPT58+ifWVkJDAnJycWEJCQonjo0SFqIqPHz+y7du3s65duzJtbW2xgpGxsTEbPHgwO3bsGEtNTeU7VIUjEonYqlWrmEAgYABYu3btJBqxSIgs0XlMPiZMmMBatmzJ/P39mZeXFzMxMWF5eXnc84cOHWKOjo4S9SmLvEsZ0DFLlMmlS5dYxYoVGQBWrlw5dvr0aYleLxKJ2Js3b9jhw4fZxIkTWd26dbn8y8DAgPn4+LCCggIZRa+aDh06xPT09BgA5ujoKPO/NTk5OczOzo5ZWlqyzMxMJhKJFPJnWlhYyNzc3BgAVq9ePZaTk8N3SEpJ5YpEjDEWHx/Pnj17xoRCIdf2+PFj9urVq1/u+0dFombNmjFPT0/ua6FQyKpUqcJWrlxZqn1MnDiRnTx58l+fz83NZWlpadwjNjaWEhWicjIyMtiZM2fYiBEjmKmpqVjBSENDg7m6urLNmzez9+/f8x0q73JyctiQIUO478+ECRNo5BVRKPSBWz6SkpKYs7MzEwgEzNDQkJ05c0bseRcXF/bnn39K3K8s8y5FRccsUTYfP35krVq14nKBSZMmsZSUlGLbpaWlscePH7Pdu3czLy8v1rlzZ2ZiYlJsNLeGhgYbPHgw+/jxIw/vRjWEhoZy3/s2bdpI/XbB7wmFQu5CoiSDFeQpLy+PjRs3jgFgurq67OnTp3yHpLTkeQ4r8cTV8lIUjjQnYhUIBDh79ix69eoF4NvqTXp6ejh16hTXBgAeHh5ITU3F+fPn/7PPxMRE6OnpwdDQEGlpaWjVqhWOHj2KBg0a/HD7RYsWYfHixcXaacJPoqqEQiEePXqECxcu4OLFi8UmSm3YsCF69OiBHj16wMHBQaUm/IyLi0Pv3r3x5MkTqKurY/PmzZg0aRLfYREihiaulq+0tDQYGBhAXV1drD0lJQUGBgY/XU76Z2SRdykqOmaJMiooKMCff/6JdevWAfi2vHuTJk1QUFCAhIQExMfHIysr64ev1dLSQuPGjdGiRQu0b98ebdu2hbGxsRyjV03Pnj1D+/btkZ6eju7du+P06dPcJOrSdvv2bejp6aFx48alPg/IQkREBJYvX44rV67gy5cvAIATJ06gf//+PEemvFRu4mrGGPv7779Z/fr1mZaWFtPS0mL169dnu3btkkrf+J+RRJ8+fWIAuHvwi8ycOZM1a9asRH0+fvyYNWrUiDVs2JA1aNCAbd++/afb00giQn4uMjKSrV+/nrVt25apqamJXfmqXLkymzVrFsvKyuI7TJl78uQJq1KlCgPAypcvz/z8/PgOiZAfolEZyk2WeZeiomOWKLObN2+y+vXrFxsdVPQwNzdnHTp0YFOmTGE7duxgjx8/Zrm5uXyHrbLu3r3LdHR0GAA2bNgwsVGbsuDr68smTZrE7t+/L9P9/Je8vDy2bNkybjLvojxe0tslSXHyPIdpyLYEVTILFizAhg0bMHnyZLRs2RIA8PDhQ0yfPh0xMTFYsmQJzxEW16xZM4SEhJR4e21tbWhra8suIEKUXO3ateHl5QUvLy8kJyfjypUruHDhAq5evYr4+HisXr0aZ86cwf79+7m/E2XN0aNHMWrUKOTm5sLGxgYXL16EtbU132ERQsoYZcy7CFF1HTp0QGhoKO7du4f4+HhoaGjA3NwclStXhrm5OQwMDPgOkXynTZs2OHHiBHr37o2DBw9CW1sb27dvLzYaVFouXbqEK1euwMHBAa1atZLJPv6Lv78/Jk2ahLCwMABAly5dMHv2bLRs2VKhRjmREpB5GaoETE1N2ZEjR4q1HzlyhJmYmPxy//ifkUR5eXlMXV292DxFw4cPZz169Pjl/f3M1q1bmY2NDatTpw5dzSKkBHJzc9mpU6dY1apVuSVhZ82aVaaujgmFQvbnn39yV1x+++03+ttAFB6NylBess67FA3lXoQQvhw8eJAbId+jRw/2+fNnqfbv7+/Pjh49ytasWcPmz5/PgoODpdr/fykoKGDHjx9nLVq04PJYU1NTdujQIVriXsrkmXcpxCQfBQUFcHR0LNbu4OCAwsJCqe9PS0sLDg4O8PPz49pEIhH8/PxkPkLB09MT4eHhCAwMlOl+CCkrtLW10bdvX7x48QLDhg2DSCTC6tWr4eDggKdPn/Id3i/LyMhAnz59sGLFCgDAH3/8gfPnz9N8GYQQmZF33sU3yr0IIXwZOnQojh8/Di0tLVy4cAFVqlSBg4MDxo8fj927d+PNmzfc3HClMXfuXAwaNAhWVlZYsmQJ7O3tpRf8d4RCIUQiEfd1fHw81q9fD2tra7i7u+PRo0fQ0tLC+PHj8fr1awwZMkQl5rorqxSiSDRs2DD89ddfxdp37tyJIUOGlKrPzMxMhISEcLeEvX//HiEhIYiJiQEAeHl5YdeuXdi/fz9evXqFiRMnIisrCyNHjiz1+yCEyE758uVx4MABnDt3DpUqVUJYWBiaN2+ORYsWoaCggO/wSuX9+/dwcnLC+fPnoaWlhQMHDmD16tUyG4pMCCGAbPIuQgghP9avXz/cv38fjo6OKCwsxLNnz7Bz506MGTMGderUQZUqVeDh4YELFy4gJydHor4dHBzQvn17lC9fXiqx5ufn48uXL2CM4cOHD/Dy8kKNGjWgpaUFfX19NGzYEObm5qhSpQq8vb0RExODihUrYsGCBYiJicH27dthYmIilVgIf3hb3czLy4v7f2FhIfbt24fq1aujRYsWAIDHjx8jJiYGw4cPx5YtWyTu/86dO2jfvn2xdg8PD+zbtw8AsHXrVqxduxYJCQmwt7fH5s2b0bx589K9oRLy9fWFr68vhEIhIiMjaYUNQkrhy5cvmDRpEk6ePAkAaNy4Mfbv3/+vqwsqort376Jv375ITk6Gubk5zp49y/39I0QZ0EpRykXWeZcyoGOWEMInxhiio6Px9OlTBAYGIiAgAE+ePEF+fj63jb6+Prp27Yo+ffqgU6dOqFChQon6TkhIgL6+PgwMDEo1gufp06dYvXo1Ll68iNzcXFSqVAlpaWnIy8v74fYCgQD29vbw9PTEkCFDoKOjI/E+iWTkeQ7jrUj0owLOjwgEAty6dUvG0cgfJSqE/Lrjx49j0qRJSElJgZaWFhYvXgxvb29oaCjEnPw/FBMTAx8fH2zZsgWFhYVo0qQJzp8/j2rVqvEdGiESofOYclH1vAugY5YQonhyc3Px8OFDnD9/HmfOnEFsbCz3nEAgQJMmTdChQwd0794dLVu2/NfR5np6esjJycH79+9haWlZon0+fPgQ4eHhePnyJUJDQ3+4rbOzM2bOnAlHR0dkZmYiKioKxsbGsLOzg76+fqnfN5GcShSJVB0lKoRIR0JCAsaNG4eLFy8CAJo3b479+/ejbt26PEcmLiQkBOvWrcOxY8cgFAoBAO7u7tizZw/09PR4jo4QydF5jCgbOmYJIYqMMYagoCCcOXMG58+fx6tXr8Ser1ixIrp164b27dujadOmqFu3LgQCAYRCIbS1tSEUCvHly5cf3u7FGMOjR4+wd+9eHDt2DBkZGWLPq6urY9CgQZgxYwbq1KmDp0+fQk9PD02aNKG5hRSEyhaJwsPDERMTIzbkTiAQoHv37jxGJV10uxkh0scYw4EDBzBlyhSkp6dDR0cHK1euxJQpU6Cmxt/Ua4wx3LhxA2vXrsXNmze59vbt22PmzJno0qULnXiJ0qIP3MpPFfKu79ExSwhRJnFxcbh16xauXr2Ky5cvIzU1Vex5CwsLVK9eHbGxsRg8eDDmz58PLS0tJCYmIjY2FrGxsYiJicH79+9x5coVREVFca+tXLky2rVrh4YNG8LW1hYODg6oWrWqnN8hkYTKFYmioqLQu3dvvHjxAgKBgJvhvejDU9FV97KEEhVCpC82NhajR4/GjRs3AABt2rTB3r17UbNmTbnGkZ+fj+PHj2PdunV4/vw5gG9XaPr37w9vb284ODjINR5CZIHOY8pLFfMugI5ZQojyKigowL1793Dp0iUEBgYiMDCw2HxB5cuXR0ZGxr+uUqmnp4d+/fph5MiRaNOmDa8XUonkVK5I1L17d6irq+Pvv/+GlZUVnjx5guTkZMyYMQPr1q2Ds7Mz3yFKHSUqhMgGYww7duyAt7c3srKyoK+vj3Xr1mH8+PEyH7WTnp6OnTt3wsfHB58+fQLwbQLCMWPGYNq0af95jzghyoTOY8pLFfMugI5ZQkjZkZ2dDX9/fxw9ehS3b98Wm8tIXV0dVapUQfXq1WFhYQELCws0bdoUbm5uMDAw4DFq8itUrkhkamqKW7duoWHDhjAyMsKTJ09Qt25d3Lp1CzNmzEBwcDDfIUoN3W5GiHxERUVh5MiR8Pf3BwB06tQJf//9NywsLKS+r48fP2LTpk3YuXMn0tPTAQDm5uaYMmUKJkyYILVlSQlRJPSBW3mpUt71PTpmCSFlUVhYGDZt2gQTExN4enrC3NxcoRdxIaUjz3OYQowxEwqFMDQ0BPAtcYmLiwMA1KhRAxEREXyGJnWenp4IDw9HYGAg36EQUqbVrFkTt2/fxsaNG6Gjo4Pr16+jQYMG2L9/P6RVG3/+/DmGDx8OKysrrFu3Dunp6bCxscHu3bvx4cMHzJkzhwpEhBCFo0p5FyGElHWvX7/Grl27cO/ePVSrVo0KROSXKUSRyM7Ojlt2r3nz5lizZg0CAgKwZMkSuc8lQggpO9TU1DBt2jSEhISgefPmSEtLw4gRI9CzZ08kJCSUqk/GGG7evInOnTujUaNGOHjwIAoLC9G2bVtcunQJL1++xKhRo6CtrS3ld0MIIdKhrHlXamoqHB0dYW9vDzs7O+zatYvvkAghhFfZ2dmIiopCvXr1MHToUL7DIWWEQtxudu3aNWRlZaFPnz54+/YtunXrhsjISJiYmOD48eNwcXHhO0SpoyHPhMhXYWEh1q1bhwULFqCgoAAVKlTAtm3b4O7uXqLXFxQU4MSJE1i3bh1CQkIAfCtC9evXD97e3mjatKkMoydE8dB5THkpa94lFAqRl5cHPT09ZGVlwc7ODkFBQT9c7vlH6JglhJQ1sbGxqF69OjQ0NJCfn0+r5pZhKjcn0Y+kpKSgfPnyZfZAp0SFEH68ePECHh4e3JwbAwYMgK+vL0xNTX+4fUZGBnbt2gUfHx9uUkA9PT2MHj0a06ZNU+ir7oTIEp3HyhZly7tSUlLQpEkTBAUF/evf7/9FxywhpKzJycmBk5MTTExMcOnSJejo6PAdEpERlZuT6EcqVKigNImKJHx9fWFra0ujDgjhSYMGDfD48WMsXLgQ6urqOHHiBOrXr4/z58+LbRcXF4dZs2bBwsICM2bMQGxsLCpVqoSlS5ciJiYGmzdvpgIRIaTMkEbe5e/vj+7du6NKlSoQCAQ4d+5csW18fX1haWkJHR0dNG/eHE+ePJFoH6mpqWjUqBGqVauGmTNnlrhARAghZZGuri5u376Nc+fO0VQHRGoUtkhUVtHE1YTwT1NTE4sWLcLjx49Rv359fP78Gb169cLw4cPx8OFDjBw5EpaWllizZg3S0tJQt25d7Ny5E9HR0Zg3b16Jb20ghBBVkpWVhUaNGsHX1/eHzx8/fhxeXl5YuHAhnj17hkaNGqFz5874/Pkzt03RfEP/+yiaXNvY2BihoaF4//49jhw5gsTERLm8N0IIUVTjx4+HoaEhtmzZwncopIygqc8JISrLwcEBQUFBWLhwIdauXYuDBw/i4MGD3POtW7fGzJkz0a1bN6ipUU2dEEJ+xs3NDW5ubv/6/IYNGzB27FiMHDkSALB9+3ZcvnwZe/bswezZswGAm/Ptv5iZmaFRo0a4d+8e+vXr98Nt8vLykJeXx32dnp5ewndCCCHKo+hvG62oS6SFPvUQQlSajo4OVq9ejfv376N27doQCATo27cvHj58iHv37qFHjx5UICKEkF+Un5+Pp0+fwtXVlWtTU1ODq6srHj58WKI+EhMTkZGRAQBIS0uDv78/6tat+6/br1y5EkZGRtzDwsLi194EIYQooH/++QeZmZno378/36GQMoJGEhFCCAAnJyeEhYUhLS2N5rgghBAp+/LlC4RCIczMzMTazczM8Pr16xL1ER0djXHjxoExBsYYJk+ejAYNGvzr9nPmzIGXlxf3dXp6OhWKCCFljkAggL6+Pt9hkDKEikRy5uvrC19fXwiFQr5DIYT8D01NTSoQEUKIgmrWrFmJb0cDAG1tbZrIlRBCCJEQ3UMhZzRxNSGEEEJUjampKdTV1YtNNJ2YmAhzc3OZ7ptWliWEEEJKjopEhBBCCCFEprS0tODg4AA/Pz+uTSQSwc/PDy1btpTpvukCHSGEEFJydLsZIYQQQgj5ZZmZmXj79i339fv37xESEoIKFSqgevXq8PLygoeHBxwdHdGsWTP4+PggKyuLW+2MEEIIIfyjIhEhhBBCCPllQUFBaN++Pfd10aTRHh4e2LdvH9zd3ZGUlIQFCxYgISEB9vb2uHr1arHJrKWN5oMkhBBCSk7AGGN8B6GK0tLSYGxsjNjYWJQrV47vcAghhBCJFK0UlZqaCiMjI77DIeQ/Ue5FCCFEWckz76KRRDzJyMgAAFqKlRBCiFLLyMigIhFRCpR7EUIIUXbyyLtoJBFPRCIR4uLiYGhoCIFAIPZcUZVQla50qeJ7BlTzfdN7Vo33DKjm+1al98wYQ0ZGBqpUqQI1NVoHgyi+n+VepaFKv+8lQd+P4uh7Uhx9T8TR96M4+p4UV/Q9CQ8PR926dWWed9FIIp6oqamhWrVqP92mXLlyKveLoYrvGVDN903vWXWo4vtWlfdMI4iIMilJ7lUaqvL7XlL0/SiOvifF0fdEHH0/iqPvSXFVq1aVy4U5uvRHCCGEEEIIIYQQQqhIRAghhBBCCCGEEEKoSKSQtLW1sXDhQmhra/Mdityo4nsGVPN903tWHar4vlXxPROiqv5fe3ceG1XZvnH8mrZ0o3SxtTMsFlARUGpFECzoiwkNiMQNxUgK4hIUQQQ1iooiRhCi0bhEUEncF1wiuATQWqiI1hawBepSMaIYaKmKbVFQCnO/f7yZ+TEW+ZX2zExn+v0kk9Bzzszz3HeYnouHM3N4vweiH83Rk+boSSD60Rw9aS7UPeGLqwEAAAAAAMCVRAAAAAAAAGCRCAAAAAAAAGKRCAAAAAAAAGKRCAAAAAAAAGKRqN156qmn1KtXLyUmJmro0KEqLy8P95QctXDhQp111lnq0qWLsrOzdckll6i6ujrgmL/++kvTp09XZmamUlJSdNlll2n37t1hmrHzFi1aJJfLpVmzZvm3RWPNO3fu1MSJE5WZmamkpCTl5uZq48aN/v1mprlz56pr165KSkpSQUGBtm3bFsYZt92hQ4d07733qnfv3kpKStJJJ52kBx54QIffHyDS6163bp0uvPBCdevWTS6XSytWrAjY35L69uzZo8LCQqWmpio9PV3XXXed/vjjjxBWcWyOVnNTU5Nmz56t3Nxcde7cWd26ddNVV12lXbt2BbxGpNUM4OiiPa/5OJXbduzYobFjxyo5OVnZ2dm6/fbbdfDgwVCWEjStzXXR1BMnMl80nSedyoOR3JNQ5cUtW7bo3HPPVWJiok444QQ99NBDwS6t1UKVJx3piaHdWLZsmcXHx9tzzz1nX331lU2ZMsXS09Nt9+7d4Z6aY0aPHm3PP/+8VVVVWWVlpV1wwQWWk5Njf/zxh/+YqVOn2gknnGDFxcW2ceNGO/vss23YsGFhnLVzysvLrVevXnb66afbzJkz/dujreY9e/ZYz5497eqrr7aysjL74Ycf7MMPP7Tvv//ef8yiRYssLS3NVqxYYZs3b7aLLrrIevfubfv37w/jzNtmwYIFlpmZaR988IFt377d3nrrLUtJSbHHH3/cf0yk171y5UqbM2eOvfPOOybJli9fHrC/JfWdf/75lpeXZ1988YV9+umndvLJJ9uECRNCXEnLHa3m+vp6KygosDfeeMO+/fZbKy0ttSFDhtigQYMCXiPSagbw7zpCXvNxIrcdPHjQBgwYYAUFBVZRUWErV660rKwsu+uuu8JRkqNam+uiqSdOZb5oOk86lQcjuSehyIsNDQ3mdrutsLDQqqqq7PXXX7ekpCR75plnQlXmMQlFnnSqJywStSNDhgyx6dOn+38+dOiQdevWzRYuXBjGWQVXXV2dSbJPPvnEzP73BunUqZO99dZb/mO++eYbk2SlpaXhmqYj9u7da3369LGioiIbMWKEP0xEY82zZ8+2c84551/3e71e83g89vDDD/u31dfXW0JCgr3++uuhmGJQjB071q699tqAbePGjbPCwkIzi766/3mCa0l9X3/9tUmyDRs2+I9ZtWqVuVwu27lzZ8jm3lpHCjr/VF5ebpLsp59+MrPIrxlAoI6Y13xak9tWrlxpMTExVltb6z9myZIllpqaan///XdoC3BQW3JdNPXEicwXbedJJ/JgNPUkWHlx8eLFlpGREfCemT17tvXt2zfIFbVdsPKkUz3h42btxIEDB7Rp0yYVFBT4t8XExKigoEClpaVhnFlwNTQ0SJKOO+44SdKmTZvU1NQU0Id+/fopJycn4vswffp0jR07NqA2KTprfu+99zR48GCNHz9e2dnZGjhwoJYuXerfv337dtXW1gbUnJaWpqFDh0ZszZI0bNgwFRcX67vvvpMkbd68WevXr9eYMWMkRW/dPi2pr7S0VOnp6Ro8eLD/mIKCAsXExKisrCzkcw6GhoYGuVwupaenS+oYNQMdRUfNaz6tyW2lpaXKzc2V2+32HzN69Gg1Njbqq6++CuHsndWWXBdNPXEi80XbedKJPBhtPTmcU/WXlpbqP//5j+Lj4/3HjB49WtXV1fr9999DVE3wtCZPOtWTOGdKQFv9+uuvOnToUMDJQpLcbre+/fbbMM0quLxer2bNmqXhw4drwIABkqTa2lrFx8f73ww+brdbtbW1YZilM5YtW6Yvv/xSGzZsaLYvGmv+4YcftGTJEt166626++67tWHDBt18882Kj4/X5MmT/XUd6e97pNYsSXfeeacaGxvVr18/xcbG6tChQ1qwYIEKCwslKWrr9mlJfbW1tcrOzg7YHxcXp+OOOy4qevDXX39p9uzZmjBhglJTUyVFf81AR9IR85pPa3NbbW3tEfvl2xeJ2prroqknTmS+aDtPOpEHo60nh3Oq/traWvXu3bvZa/j2ZWRkBGX+odDaPOlUT1gkQthMnz5dVVVVWr9+fbinElQ///yzZs6cqaKiIiUmJoZ7OiHh9Xo1ePBgPfjgg5KkgQMHqqqqSk8//bQmT54c5tkFz5tvvqlXX31Vr732mk477TRVVlZq1qxZ6tatW1TXjf9pamrSFVdcITPTkiVLwj0dAHBUR8lt/5+OmOuOpqNmvqMhD6It2kOe5ONm7URWVpZiY2Ob3flg9+7d8ng8YZpV8Nx000364IMPtHbtWvXo0cO/3ePx6MCBA6qvrw84PpL7sGnTJtXV1enMM89UXFyc4uLi9Mknn+iJJ55QXFyc3G531NXctWtXnXrqqQHb+vfvrx07dkiSv65o+/t+++23684779SVV16p3NxcTZo0SbfccosWLlwoKXrr9mlJfR6PR3V1dQH7Dx48qD179kR0D3wn9J9++klFRUX+//WRordmoCPqaHnNpy25zePxHLFfvn2RxolcF009cSLzRdt50ok8GG09OZxT9UfT+8inrXnSqZ6wSNROxMfHa9CgQSouLvZv83q9Ki4uVn5+fhhn5iwz00033aTly5drzZo1zS6HGzRokDp16hTQh+rqau3YsSNi+zBy5Eht3bpVlZWV/sfgwYNVWFjo/3O01Tx8+PBmt8j97rvv1LNnT0lS79695fF4AmpubGxUWVlZxNYsSfv27VNMTOCv1djYWHm9XknRW7dPS+rLz89XfX29Nm3a5D9mzZo18nq9Gjp0aMjn7ATfCX3btm36+OOPlZmZGbA/GmsGOqqOktd8nMht+fn52rp1a8A/bnz/+Pnn4kIkcCLXRVNPnMh80XaedCIPRltPDudU/fn5+Vq3bp2ampr8xxQVFalv374R+VEzJ/KkYz05pq+5RlAtW7bMEhIS7IUXXrCvv/7arr/+ektPTw+480Gku/HGGy0tLc1KSkqspqbG/9i3b5//mKlTp1pOTo6tWbPGNm7caPn5+Zafnx/GWTvv8LtgmEVfzeXl5RYXF2cLFiywbdu22auvvmrJycn2yiuv+I9ZtGiRpaen27vvvmtbtmyxiy++OKJuBX8kkydPtu7du/tvefrOO+9YVlaW3XHHHf5jIr3uvXv3WkVFhVVUVJgke/TRR62iosJ/54WW1Hf++efbwIEDrayszNavX299+vRp17d0PVrNBw4csIsuush69OhhlZWVAb/XDr+zRKTVDODfdYS85uNEbvPd7n3UqFFWWVlpq1evtuOPPz4ib/f+b44110VTT5zKfNF0nnQqD0ZyT0KRF+vr683tdtukSZOsqqrKli1bZsnJycd8u/dQCUWedKonLBK1M08++aTl5ORYfHy8DRkyxL744otwT8lRko74eP755/3H7N+/36ZNm2YZGRmWnJxsl156qdXU1IRv0kHwzzARjTW///77NmDAAEtISLB+/frZs88+G7Df6/Xavffea2632xISEmzkyJFWXV0dptk6o7Gx0WbOnGk5OTmWmJhoJ554os2ZMyfgl3uk17127dojvocnT55sZi2r77fffrMJEyZYSkqKpaam2jXXXGN79+4NQzUtc7Sat2/f/q+/19auXet/jUirGcDRRXte83Eqt/344482ZswYS0pKsqysLLvtttusqakpxNUET2tyXTT1xInMF03nSafyYCT3JFR5cfPmzXbOOedYQkKCde/e3RYtWhSqEo9ZqPKkEz1xmZm1/LojAAAAAAAARCO+kwgAAAAAAAAsEgEAAAAAAIBFIgAAAAAAAIhFIgAAAAAAAIhFIgAAAAAAAIhFIgAAAAAAAIhFIgAAAAAAAIhFIgAAAAAAAIhFIgAAAAAAAIhFIgDtiJlJkubNmxfwMwAAAMKDfAZ0LC7jXQ6gnVi8eLHi4uK0bds2xcbGasyYMRoxYkS4pwUAANBhkc+AjoUriQC0G9OmTVNDQ4OeeOIJXXjhhS0KIOedd55cLpdcLpcqKyuDP8l/uPrqq/3jr1ixIuTjAwAABNOx5rPWZDPyFNB+sEgEoN14+umnlZaWpptvvlnvv/++Pv300xY9b8qUKaqpqdGAAQOCPMPmHn/8cdXU1IR8XAAAACfdcsstGjduXLPtrclnx5rNyFNA+xEX7gkAgM8NN9wgl8ulefPmad68eS3+zHtycrI8Hk+QZ3dkaWlpSktLC8vYAAAATikvL9fYsWObbW9NPjvWbEaeAtoPriQCEDIPPvig/1Liwx+PPfaYJMnlckn6vy9G9P18rM477zzNmDFDs2bNUkZGhtxut5YuXao///xT11xzjbp06aKTTz5Zq1atcuR5AAAAkerAgQPq1KmTPv/8c82ZM0cul0tnn322f79T+eztt99Wbm6ukpKSlJmZqYKCAv35559tnj8AZ7FIBCBkZsyYoZqaGv9jypQp6tmzpy6//HLHx3rxxReVlZWl8vJyzZgxQzfeeKPGjx+vYcOG6csvv9SoUaM0adIk7du3z5HnAQAARKK4uDh99tlnkqTKykrV1NRo9erVjo5RU1OjCRMm6Nprr9U333yjkpISjRs3jjulAe0Qi0QAQqZLly7yeDzyeDx66qmn9NFHH6mkpEQ9evRwfKy8vDzdc8896tOnj+666y4lJiYqKytLU6ZMUZ8+fTR37lz99ttv2rJliyPPAwAAiEQxMTHatWuXMjMzlZeXJ4/Ho/T0dEfHqKmp0cGDBzVu3Dj16tVLubm5mjZtmlJSUhwdB0DbsUgEIOTmzp2rl19+WSUlJerVq1dQxjj99NP9f46NjVVmZqZyc3P929xutySprq7OkecBAABEqoqKCuXl5QXt9fPy8jRy5Ejl5uZq/PjxWrp0qX7//fegjQeg9VgkAhBS9913n1566aWgLhBJUqdOnQJ+drlcAdt8n6f3er2OPA8AACBSVVZWBnWRKDY2VkVFRVq1apVOPfVUPfnkk+rbt6+2b98etDEBtA6LRABC5r777tOLL74Y9AUiAAAAtNzWrVt1xhlnBHUMl8ul4cOH6/7771dFRYXi4+O1fPnyoI4J4NjFhXsCADqG+fPna8mSJXrvvfeUmJio2tpaSVJGRoYSEhLCPDsAAICOy+v1qrq6Wrt27VLnzp0dvx19WVmZiouLNWrUKGVnZ6usrEy//PKL+vfv7+g4ANqOK4kABJ2Z6eGHH9Yvv/yi/Px8de3a1f/gC6ABAADCa/78+XrhhRfUvXt3zZ8/3/HXT01N1bp163TBBRfolFNO0T333KNHHnlEY8aMcXwsAG3DlUQAgs7lcqmhoSFk45WUlDTb9uOPPzbb9s/brrb2eQAAAJFs4sSJmjhxYtBev3///lq9enXQXh+Ac7iSCEDEW7x4sVJSUrR169aQjz116lRu3woAAHCYY81m5Cmg/XAZ/yUOIILt3LlT+/fvlyTl5OQoPj4+pOPX1dWpsbFRktS1a1d17tw5pOMDAAC0J63JZuQpoP1gkQgAAAAAAAB83AwAAAAAAAAsEgEAAAAAAEAsEgEAAAAAAEAsEgEAAAAAAEAsEgEAAAAAAEAsEgEAAAAAAEAsEgEAAAAAAEAsEgEAAAAAAEAsEgEAAAAAAEAsEgEAAAAAAEAsEgEAAAAAAEDSfwHxaIjdN+fhCAAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -730,14 +726,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -831,7 +825,7 @@ ], "metadata": { "kernelspec": { - "display_name": "pybamm", + "display_name": "dev", "language": "python", "name": "python3" }, @@ -862,7 +856,7 @@ }, "vscode": { "interpreter": { - "hash": "187972e187ab8dfbecfab9e8e194ae6d08262b2d51a54fa40644e3ddb6b5f74c" + "hash": "bca2b99bfac80e18288b793d52fa0653ab9b5fe5d22e7b211c44eb982a41c00c" } } }, diff --git a/examples/scripts/pouch_cell_cooling.py b/examples/scripts/pouch_cell_cooling.py index d2093aed07..4a2163ad9c 100644 --- a/examples/scripts/pouch_cell_cooling.py +++ b/examples/scripts/pouch_cell_cooling.py @@ -11,10 +11,9 @@ {"current collector": "potential pair", "dimensionality": 2, "thermal": "x-lumped"} ) -# update parameter values, to use: -# 1) a spatially-varying ambient temperature -# 2) a spatially-varying surface heat transfer coefficient -# 3) a spatially-varying edge heat transfer coefficient +# update parameter values, to use a spatially-varying ambient temperature and a +# spatially-varying edge heat transfer coefficient that is zero everywhere except +# at the right edge of the cell param = model.param L_y = param.L_y L_z = param.L_z @@ -35,7 +34,7 @@ def h_edge(y, z): "Ambient temperature [K]": 298, "Negative current collector surface heat transfer coefficient [W.m-2.K-1]": 0, "Positive current collector surface heat transfer coefficient [W.m-2.K-1]": 0, - "Negative tab heat transfer coefficient [W.m-2.K-1]": 10000, + "Negative tab heat transfer coefficient [W.m-2.K-1]": 0, "Positive tab heat transfer coefficient [W.m-2.K-1]": 0, "Edge heat transfer coefficient [W.m-2.K-1]": h_edge, } diff --git a/examples/scripts/pouch_cell_isothermal.py b/examples/scripts/pouch_cell_isothermal.py deleted file mode 100644 index 7f7186edec..0000000000 --- a/examples/scripts/pouch_cell_isothermal.py +++ /dev/null @@ -1,44 +0,0 @@ -# -# Example showing how to customize thermal boundary conditions in a pouch cell model -# -import pybamm - -pybamm.set_logging_level("INFO") - -# load model -model = pybamm.lithium_ion.SPM( - {"current collector": "potential pair", "dimensionality": 2} -) - -# update parameter values, to use: -# 1) a spatially-varying ambient temperature -param = model.param -L_y = param.L_y -L_z = param.L_z -parameter_values = model.default_parameter_values - - -def T_amb(y, z, t): - return ( - 300 - + pybamm.InputParameter("T_top") * (z >= L_z) - + pybamm.InputParameter("T_right") * (y >= L_y) - ) - - -parameter_values.update({"Ambient temperature [K]": T_amb}) - -# create and solve simulation -var_pts = {"x_n": 4, "x_s": 4, "x_p": 4, "r_n": 4, "r_p": 4, "y": 16, "z": 16} -sim = pybamm.Simulation(model, parameter_values=parameter_values, var_pts=var_pts) -sim.build() -sim.solve([0, 3600]) - -# plot -output_variables = [ - "Negative current collector potential [V]", - "Positive current collector potential [V]", - "X-averaged cell temperature [K]", - "Voltage [V]", -] -sim.plot(output_variables, variable_limits="tight", shading="gouraud") diff --git a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py index cac043e85f..05caeaa6cb 100644 --- a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py +++ b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_1D_current_collectors.py @@ -93,9 +93,6 @@ def set_boundary_conditions(self, variables): param = self.param T_amb = variables["Ambient temperature [K]"] T_av = variables["X-averaged cell temperature [K]"] - T_av_top = pybamm.boundary_value(T_av, "right") - T_av_bottom = pybamm.boundary_value(T_av, "left") - z = pybamm.standard_spatial_vars.z # find tab locations (top vs bottom) L_y = param.L_y @@ -129,12 +126,12 @@ def set_boundary_conditions(self, variables): top_cooling_coefficient = ( param.n.h_tab * neg_tab_area * neg_tab_top_bool + param.p.h_tab * pos_tab_area * pos_tab_top_bool - + param.h_edge(L_y / 2, z) * non_tab_top_area + + param.h_edge(L_y / 2, L_z) * non_tab_top_area ) / total_area bottom_cooling_coefficient = ( param.n.h_tab * neg_tab_area * neg_tab_bottom_bool + param.p.h_tab * pos_tab_area * pos_tab_bottom_bool - + param.h_edge(L_y / 2, z) * non_tab_bottom_area + + 10 * non_tab_bottom_area ) / total_area # just use left and right for clarity @@ -143,11 +140,16 @@ def set_boundary_conditions(self, variables): self.boundary_conditions = { T_av: { "left": ( - bottom_cooling_coefficient * (T_av_bottom - T_amb), + bottom_cooling_coefficient + * pybamm.boundary_value( + T_av - T_amb, + "left", + ), "Neumann", ), "right": ( - -top_cooling_coefficient * (T_av_top - T_amb), + -top_cooling_coefficient + * pybamm.boundary_value(T_av - T_amb, "right"), "Neumann", ), } From 5b8eb25ebfb78ffcf4d93223ea7fe52d790dd522 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Tue, 8 Aug 2023 23:16:49 +0100 Subject: [PATCH 021/129] #3321 move x-full inside pouch folder --- CHANGELOG.md | 4 + .../notebooks/models/thermal-models.ipynb | 86 ++++++++++++------- .../full_battery_models/base_battery_model.py | 2 +- pybamm/models/submodels/thermal/__init__.py | 1 - .../submodels/thermal/pouch_cell/__init__.py | 1 + .../thermal/{ => pouch_cell}/x_full.py | 15 ++-- tests/unit/test_citations.py | 2 +- 7 files changed, 70 insertions(+), 41 deletions(-) rename pybamm/models/submodels/thermal/{ => pouch_cell}/x_full.py (93%) diff --git a/CHANGELOG.md b/CHANGELOG.md index 090185ce2d..a678f09745 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,10 +2,12 @@ ## Features +- The parameter "Ambient temperature can now be given as a function of position `(y,z)` and time `t`. The heat transfer coefficient parameters can also depend on `(y,z)`. - Numpy functions now work with PyBaMM symbols (e.g. `np.exp(pybamm.Symbol("a"))` returns `pybamm.Exp(pybamm.Symbol("a"))`). This means that parameter functions can be specified using numpy functions instead of pybamm functions. Additionally, combining numpy arrays with pybamm objects now works (the numpy array is converted to a pybamm array) ([#3205](https://github.com/pybamm-team/PyBaMM/pull/3205)) ## Bug fixes +- The `OneDimensionalX` thermal model has been updated to account for edge/tab cooling and account for the current collector volumetric heat capacity. It now gives the correct behaviour compared with a lumped model with the correct total heat transfer coefficient and surface area for cooling. ([#3042](https://github.com/pybamm-team/PyBaMM/pull/3042)) - Fixed a bug where the "basic" lithium-ion models gave incorrect results when using nonlinear particle diffusivity ([#3207](https://github.com/pybamm-team/PyBaMM/pull/3207)) - Particle size distributions now work with SPMe and NewmanTobias models ([#3207](https://github.com/pybamm-team/PyBaMM/pull/3207)) - Fix to simulate c_rate steps with drive cycles ([#3186](https://github.com/pybamm-team/PyBaMM/pull/3186)) @@ -16,6 +18,8 @@ ## Breaking changes +- The class `pybamm.thermal.OneDimensionalX` has been moved to `pybamm.thermal.pouch_cell.OneDimensionalX` to reflect the fact that the model formulation implicitly assumes a pouch cell geometry. +- The "lumped" thermal option now always used the parameters "Cell cooling surface area [m2]", "Cell volume [m3]" and "Total heat transfer coefficient [W.m-2.K-1]" to compute the cell cooling regardless of the chosen "cell geometry" option. The user must now specify the correct values for these parameters instead of them being calculated based on e.g. a pouch cell. - Added option to use an empirical hysteresis model for the diffusivity and exchange-current density ([#3194](https://github.com/pybamm-team/PyBaMM/pull/3194)) - Double-layer capacity can now be provided as a function of temperature ([#3174](https://github.com/pybamm-team/PyBaMM/pull/3174)) - `pybamm_install_jax` is deprecated. It is now replaced with `pip install pybamm[jax]` ([#3163](https://github.com/pybamm-team/PyBaMM/pull/3163)) diff --git a/docs/source/examples/notebooks/models/thermal-models.ipynb b/docs/source/examples/notebooks/models/thermal-models.ipynb index 4d046ac993..dcf1a761e5 100644 --- a/docs/source/examples/notebooks/models/thermal-models.ipynb +++ b/docs/source/examples/notebooks/models/thermal-models.ipynb @@ -7,9 +7,9 @@ "source": [ "# Thermal models\n", "\n", - "There are a number of thermal submodels available in PyBaMM. In this notebook we give details of each of the models, and highlight any relevant parameters. At present PyBaMM includes a lumped thermal model, a 1D thermal model which accounts for the through-cell variation in temperature, and a 2D pouch cell model which assumed the temperature is uniform through the thickness of the pouch, but accounts for variations in temperature in the remaining two dimensions. Here we give the governing equations for each model. \n", + "There are a number of thermal submodels available in PyBaMM. In this notebook we give details of each of the models, and highlight any relevant parameters. At present PyBaMM includes an isothermal and a lumped thermal model, both of which can be used with any cell geometry, as well as a 1D thermal model which accounts for the through-cell variation in temperature in a pouch cell, and \"1+1D\" and \"2+1D\" pouch cell models which assumed the temperature is uniform through the thickness of the pouch, but accounts for variations in temperature in the remaining dimensions. Here we give the governing equations for each model (except the isothermal model, which just sets the temperature to be equal to to the parameter \"Ambient temperature [K]\"). \n", "\n", - "A more comprehensive review of the pouch cell models can be found in references [4] and [6] at the end of this notebook." + "A more comprehensive review of the pouch cell models, including how to properly compute the effective cooling terms, can be found in references [4] and [6] at the end of this notebook." ] }, { @@ -75,8 +75,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### \"lumped\" option\n", - "This option allows any electrochmical model to be solved, coupled to a lumped thermal model that can be used to model any aribitrary geometry. The user may specify the total heat transfer coefficient $h$, surface area for cooling $A$, and cell volume $V$. The relevant parameters are: \n", + "The relevant parameters to specify the cooling conditions are: \n", "\n", "\"Total heat transfer coefficient [W.m-2.K-1]\" \n", "\"Cell cooling surface area [m2]\" \n", @@ -102,11 +101,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 1D (through-cell) model\n", + "## Pouch cell models" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1D (through-cell) model\n", "\n", "The 1D model solves for $T(x,t)$, capturing variations through the thickness of the cell, but ignoring variations in the other dimensions. The temperature is found as the solution of a partial differential equation, given here in dimensional terms\n", "\n", - "$$\\rho_k c_{p,k} \\frac{\\partial T}{\\partial t} = \\lambda_k \\nabla^2 T + Q(x,t)$$\n", + "$$\\rho_k c_{p,k} \\frac{\\partial T}{\\partial t} = \\lambda_k \\nabla^2 T + Q(x,t) - Q_{cool}(x,t)$$\n", "\n", "with boundary conditions \n", "\n", @@ -116,14 +123,21 @@ "\n", "$$ T\\big|_{t=0} = T_0.$$\n", "\n", - "Here $\\lambda_k$ is the thermal conductivity of component $k$, and the heat transfer coefficients $h_{cn}$ and $h_{cp}$ correspond to heat transfer at the large surface of the pouch on the side of the negative current collector, heat transfer at the large surface of the pouch on the side of the positive current collector, respectively. The heat source term $Q$ is as described in the section on lumped models. Note: the 1D model neglects any cooling from the tabs or edges of the cell -- it assumes a pouch cell geometry and _only_ accounts for cooling from the two large surfaces of the pouch. \n", + "Here $\\lambda_k$ is the thermal conductivity of component $k$, and the heat transfer coefficients $h_{cn}$ and $h_{cp}$ correspond to heat transfer at the large surface of the pouch on the side of the negative current collector, heat transfer at the large surface of the pouch on the side of the positive current collector, respectively. The heat source term $Q$ is as described in the section on lumped models. The term $Q_cool$ accounts for additional heat losses due to heat transfer at the sides of the pouch, as well as the tabs. This term is computed automatically by PyBaMM based on the cell geometry and heat transfer coefficients on the edges and tabs of the cell.\n", + "\n", + "The relevant heat transfer parameters are:\n", + "\"Negative current collector surface heat transfer coefficient [W.m-2.K-1]\"\n", + "\"Positive current collector surface heat transfer coefficient [W.m-2.K-1]\"\n", + "\"Negative tab heat transfer coefficient [W.m-2.K-1]\"\n", + "\"Positive tab heat transfer coefficient [W.m-2.K-1]\"\n", + "\"Edge heat transfer coefficient [W.m-2.K-1]\"\n", "\n", "The 1D model is termed \"x-full\" (since it fully accounts for variation in the x direction) and can be selected as follows\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -136,9 +150,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Pouch cell models\n", + "## Higher dimensional pouch cell models\n", "\n", - "The pouch cell thermal models ignore any variation in temperature through the thickness of the cell (x direction), and solve for $T(y,z,t)$. The temperature is found as the solution of a partial differential equation, given here in dimensional terms,\n", + "These pouch cell thermal models ignore any variation in temperature through the thickness of the cell (x direction), and solve for $T(y,z,t)$. It is therefore referred to as an \"x-lumped\" model. The temperature is found as the solution of a partial differential equation, given here in dimensional terms,\n", "\n", "$$\n", "\\rho_{eff} \\frac{\\partial T}{\\partial t} = \\lambda_{eff} \\nabla_\\perp^2T + \\bar{Q} - \\frac{(h_{cn}+h_{cp})A}{V}(T-T_{\\infty}),\n", @@ -172,12 +186,28 @@ "\n", "The heat transfer coefficients $h_{cn}$, $h_{cp}$ and $h_{egde}$ correspond to heat transfer at the large surface of the pouch on the side of the negative current collector, heat transfer at the large surface of the pouch on the side of the positive current collector, and heat transfer at the remaining, respectively.\n", "\n", - "As with the \"x-lumped\" option, the relevant heat transfer parameters are:\n", + "The relevant heat transfer parameters are:\n", "\"Negative current collector surface heat transfer coefficient [W.m-2.K-1]\"\n", "\"Positive current collector surface heat transfer coefficient [W.m-2.K-1]\"\n", "\"Negative tab heat transfer coefficient [W.m-2.K-1]\"\n", "\"Positive tab heat transfer coefficient [W.m-2.K-1]\"\n", - "\"Edge heat transfer coefficient [W.m-2.K-1]\"\n" + "\"Edge heat transfer coefficient [W.m-2.K-1]\"\n", + "\n", + "The \"2+1D\" model can be selected as follows" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "options = {\n", + " \"current collector\": \"potential pair\",\n", + " \"dimensionality\": 2,\n", + " \"thermal\": \"x-lumped\",\n", + "}\n", + "model = pybamm.lithium_ion.DFN(options)" ] }, { @@ -198,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -221,7 +251,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -238,7 +268,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -270,7 +300,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -294,26 +324,18 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 10, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "hi\n", - "hi\n" - ] - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1169e50029dc4054a65d583321a6a919", + "model_id": "97a1370f6f8745b0a4b2a7bb4df5b477", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=1154.8765298002877, step=11.548765298002877)…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=1154.7667871396477, step=11.547667871396477)…" ] }, "metadata": {}, @@ -322,12 +344,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "45569a0e5cca46fcb25956cd0ca8673d", + "model_id": "fb646d540c774a10af2ee25e79251283", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=1154.8765298002877, step=11.548765298002877)…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=1154.7667871396477, step=11.547667871396477)…" ] }, "metadata": {}, @@ -336,10 +358,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 20, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -387,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { diff --git a/pybamm/models/full_battery_models/base_battery_model.py b/pybamm/models/full_battery_models/base_battery_model.py index 7db3df4d7c..b6d91c2774 100644 --- a/pybamm/models/full_battery_models/base_battery_model.py +++ b/pybamm/models/full_battery_models/base_battery_model.py @@ -1061,7 +1061,7 @@ def set_thermal_submodel(self): thermal_submodel = pybamm.thermal.pouch_cell.CurrentCollector2D elif self.options["thermal"] == "x-full": if self.options["dimensionality"] == 0: - thermal_submodel = pybamm.thermal.OneDimensionalX + thermal_submodel = pybamm.thermal.pouch_cell.OneDimensionalX self.submodels["thermal"] = thermal_submodel(self.param, self.options) diff --git a/pybamm/models/submodels/thermal/__init__.py b/pybamm/models/submodels/thermal/__init__.py index 56415df559..056a555e3f 100644 --- a/pybamm/models/submodels/thermal/__init__.py +++ b/pybamm/models/submodels/thermal/__init__.py @@ -1,5 +1,4 @@ from .base_thermal import BaseThermal from .isothermal import Isothermal from .lumped import Lumped -from .x_full import OneDimensionalX from . import pouch_cell diff --git a/pybamm/models/submodels/thermal/pouch_cell/__init__.py b/pybamm/models/submodels/thermal/pouch_cell/__init__.py index f43462d838..7d0ddedbdf 100644 --- a/pybamm/models/submodels/thermal/pouch_cell/__init__.py +++ b/pybamm/models/submodels/thermal/pouch_cell/__init__.py @@ -1,2 +1,3 @@ +from .x_full import OneDimensionalX from .pouch_cell_1D_current_collectors import CurrentCollector1D from .pouch_cell_2D_current_collectors import CurrentCollector2D diff --git a/pybamm/models/submodels/thermal/x_full.py b/pybamm/models/submodels/thermal/pouch_cell/x_full.py similarity index 93% rename from pybamm/models/submodels/thermal/x_full.py rename to pybamm/models/submodels/thermal/pouch_cell/x_full.py index da95e2a46a..64a6e687c6 100644 --- a/pybamm/models/submodels/thermal/x_full.py +++ b/pybamm/models/submodels/thermal/pouch_cell/x_full.py @@ -3,7 +3,7 @@ # import pybamm -from .base_thermal import BaseThermal +from ..base_thermal import BaseThermal class OneDimensionalX(BaseThermal): @@ -80,6 +80,8 @@ def set_rhs(self, variables): Q_cn = variables["Negative current collector Ohmic heating [W.m-3]"] Q_cp = variables["Positive current collector Ohmic heating [W.m-3]"] T_amb = variables["Ambient temperature [K]"] + y = pybamm.standard_spatial_vars.y + z = pybamm.standard_spatial_vars.z # Define volumetric heat capacity for electrode/separator/electrode sandwich rho_c_p = pybamm.concatenation( @@ -100,10 +102,11 @@ def set_rhs(self, variables): L_z = self.param.L_z L_cn = self.param.n.L_cc L_cp = self.param.p.L_cc - h_cn = self.param.n.h_cc - h_cp = self.param.p.h_cc + h_cn = self.param.n.h_cc(y, z) + h_cp = self.param.p.h_cc(y, z) lambda_n = self.param.n.lambda_(T_n) lambda_p = self.param.p.lambda_(T_p) + h_edge = self.param.h_edge(y, z) # Negative current collector volume_cn = L_cn * L_y * L_z negative_tab_area = self.param.n.L_tab * self.param.n.L_cc @@ -111,7 +114,7 @@ def set_rhs(self, variables): negative_tab_cooling_coefficient = ( -self.param.n.h_tab * negative_tab_area / volume_cn ) - edge_cooling_coefficient_cn = -self.param.h_edge * edge_area_cn / volume_cn + edge_cooling_coefficient_cn = -h_edge * edge_area_cn / volume_cn cooling_coefficient_cn = ( negative_tab_cooling_coefficient + edge_cooling_coefficient_cn ) @@ -119,7 +122,7 @@ def set_rhs(self, variables): area_to_volume = ( 2 * (self.param.L_y + self.param.L_z) / (self.param.L_y * self.param.L_z) ) - cooling_coefficient = -self.param.h_edge * area_to_volume + cooling_coefficient = -h_edge * area_to_volume # Positive current collector volume_cp = L_cp * L_y * L_z positive_tab_area = self.param.p.L_tab * self.param.p.L_cc @@ -127,7 +130,7 @@ def set_rhs(self, variables): positive_tab_cooling_coefficient = ( -self.param.p.h_tab * positive_tab_area / volume_cp ) - edge_cooling_coefficient_cp = -self.param.h_edge * edge_area_cp / volume_cp + edge_cooling_coefficient_cp = -h_edge * edge_area_cp / volume_cp cooling_coefficient_cp = ( positive_tab_cooling_coefficient + edge_cooling_coefficient_cp ) diff --git a/tests/unit/test_citations.py b/tests/unit/test_citations.py index d388f8d2ba..bfa5820382 100644 --- a/tests/unit/test_citations.py +++ b/tests/unit/test_citations.py @@ -206,7 +206,7 @@ def test_timms_2021(self): citations._reset() self.assertNotIn("Timms2021", citations._papers_to_cite) - pybamm.thermal.OneDimensionalX(param=None) + pybamm.thermal.pouch_cell.OneDimensionalX(param=None) self.assertIn("Timms2021", citations._papers_to_cite) self.assertIn("Timms2021", citations._citation_tags.keys()) From 15999e1521a0055e3f509b431258e05f76cf7480 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Tue, 8 Aug 2023 23:34:17 +0100 Subject: [PATCH 022/129] #3321 update example --- CHANGELOG.md | 2 +- examples/scripts/thermal_lithium_ion.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a678f09745..79ec82cf11 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,7 +2,7 @@ ## Features -- The parameter "Ambient temperature can now be given as a function of position `(y,z)` and time `t`. The heat transfer coefficient parameters can also depend on `(y,z)`. +- The parameter "Ambient temperature [K]" can now be given as a function of position `(y,z)` and time `t`. The "edge" and "current collector" heat transfer coefficient parameters can also depend on `(y,z)`. - Numpy functions now work with PyBaMM symbols (e.g. `np.exp(pybamm.Symbol("a"))` returns `pybamm.Exp(pybamm.Symbol("a"))`). This means that parameter functions can be specified using numpy functions instead of pybamm functions. Additionally, combining numpy arrays with pybamm objects now works (the numpy array is converted to a pybamm array) ([#3205](https://github.com/pybamm-team/PyBaMM/pull/3205)) ## Bug fixes diff --git a/examples/scripts/thermal_lithium_ion.py b/examples/scripts/thermal_lithium_ion.py index ead024a663..68b6cabdf0 100644 --- a/examples/scripts/thermal_lithium_ion.py +++ b/examples/scripts/thermal_lithium_ion.py @@ -25,9 +25,9 @@ "": 5, "Positive current collector surface heat transfer coefficient [W.m-2.K-1]" "": 5, - "Negative tab heat transfer coefficient [W.m-2.K-1]": 10, - "Positive tab heat transfer coefficient [W.m-2.K-1]": 10, - "Edge heat transfer coefficient [W.m-2.K-1]": 5, + "Negative tab heat transfer coefficient [W.m-2.K-1]": 0, + "Positive tab heat transfer coefficient [W.m-2.K-1]": 0, + "Edge heat transfer coefficient [W.m-2.K-1]": 0, } ) # for the lumped model we set the "Total heat transfer coefficient [W.m-2.K-1]" From a72d0e358c5b38a88bcc3a2cb109948aec097599 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Wed, 9 Aug 2023 15:32:09 +0100 Subject: [PATCH 023/129] #3321 issue warning when using lumped option --- pybamm/expression_tree/exceptions.py | 6 ++++++ .../full_battery_models/base_battery_model.py | 15 ++++++++++++++- 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/pybamm/expression_tree/exceptions.py b/pybamm/expression_tree/exceptions.py index 3d064df520..6a3b244beb 100644 --- a/pybamm/expression_tree/exceptions.py +++ b/pybamm/expression_tree/exceptions.py @@ -15,6 +15,12 @@ class OptionError(Exception): pass +class OptionWarning(UserWarning): + """Option warning: the chosen options may not give the desired output.""" + + pass + + class GeometryError(Exception): """Geometry error: Raised if the an unimplemented geometry is used.""" diff --git a/pybamm/models/full_battery_models/base_battery_model.py b/pybamm/models/full_battery_models/base_battery_model.py index b6d91c2774..1725713af3 100644 --- a/pybamm/models/full_battery_models/base_battery_model.py +++ b/pybamm/models/full_battery_models/base_battery_model.py @@ -4,6 +4,7 @@ import pybamm from functools import cached_property +import warnings class BatteryModelOptions(pybamm.FuzzyDict): @@ -498,7 +499,7 @@ def __init__(self, extra_options): and options["cell geometry"] != "pouch" ): raise pybamm.OptionError( - options["thermal"] + " model must have pouch geometry." + options["thermal"] + " model must have pouch cell geometry." ) if options["thermal"] == "x-full" and options["dimensionality"] != 0: n = options["dimensionality"] @@ -602,6 +603,18 @@ def __init__(self, extra_options): f"Possible values are {self.possible_options[option]}" ) + # Issue a warning to let users know that the 'lumped' thermal option now uses + # the total heat transfer coefficient, surface area for cooling, and cell + # volume parameters, regardless of the 'cell geometry option' chosen. + if options["thermal"] == "lumped": + message = ( + "The 'lumped' thermal option now uses the parameters " + "'Cell cooling surface area [m2]', 'Cell volume [m3]' and " + "'Total heat transfer coefficient [W.m-2.K-1]' to compute the cell " + "cooling term, regardless of the value of the the 'cell geometry' " + "option. Please update your parameters accordingly." + ) + warnings.warn(message, pybamm.OptionWarning, stacklevel=2) super().__init__(options.items()) @property From 06c567787a729e294c8d4759db7ef2b00ece77b0 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Wed, 9 Aug 2023 15:43:52 +0100 Subject: [PATCH 024/129] #3321 update warning --- .../full_battery_models/base_battery_model.py | 21 +++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/pybamm/models/full_battery_models/base_battery_model.py b/pybamm/models/full_battery_models/base_battery_model.py index 1725713af3..e5305f359a 100644 --- a/pybamm/models/full_battery_models/base_battery_model.py +++ b/pybamm/models/full_battery_models/base_battery_model.py @@ -175,7 +175,10 @@ class BatteryModelOptions(pybamm.FuzzyDict): (default), "differential" or "algebraic". * "thermal" : str Sets the thermal model to use. Can be "isothermal" (default), "lumped", - "x-lumped", or "x-full". + "x-lumped", or "x-full". The 'cell geometry' option must be set to + 'pouch' for 'x-lumped' or 'x-full' to be valid. Using the 'x-lumped' + option with 'dimensionality' set to 0 is equivalent to using the + 'lumped' option. * "total interfacial current density as a state" : str Whether to make a state for the total interfacial current density and solve an algebraic equation for it. Default is "false", unless "SEI film @@ -603,12 +606,18 @@ def __init__(self, extra_options): f"Possible values are {self.possible_options[option]}" ) - # Issue a warning to let users know that the 'lumped' thermal option now uses - # the total heat transfer coefficient, surface area for cooling, and cell - # volume parameters, regardless of the 'cell geometry option' chosen. - if options["thermal"] == "lumped": + # Issue a warning to let users know that the 'lumped' thermal option (or + # equivalently 'x-lumped' with 0D current collectors) now uses the total heat + # transfer coefficient, surface area for cooling, and cell volume parameters, + # regardless of the 'cell geometry option' chosen. + thermal_option = options["thermal"] + dimensionality_option = options["dimensionality"] + if thermal_option == "lumped" or ( + thermal_option == "x-lumped" and dimensionality_option == 0 + ): message = ( - "The 'lumped' thermal option now uses the parameters " + f"The '{thermal_option}' thermal option with " + f"'dimensionality' {dimensionality_option} now uses the parameters " "'Cell cooling surface area [m2]', 'Cell volume [m3]' and " "'Total heat transfer coefficient [W.m-2.K-1]' to compute the cell " "cooling term, regardless of the value of the the 'cell geometry' " From ade84d31195be5d3fdd971ee81aaff28cfc4762f Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Wed, 9 Aug 2023 15:49:16 +0100 Subject: [PATCH 025/129] update changelog --- CHANGELOG.md | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cc841d6485..c5c7f8cf7f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,11 +2,8 @@ ## Features -- The parameter "Ambient temperature [K]" can now be given as a function of position `(y,z)` and time `t`. The "edge" and "current collector" heat transfer coefficient parameters can also depend on `(y,z)`. +- The parameter "Ambient temperature [K]" can now be given as a function of position `(y,z)` and time `t`. The "edge" and "current collector" heat transfer coefficient parameters can also depend on `(y,z)` ([#3257](https://github.com/pybamm-team/PyBaMM/pull/3257)) - Processed variables now get the spatial variables automatically, allowing plotting of more generic models ([#3234](https://github.com/pybamm-team/PyBaMM/pull/3234)) - -## Breaking changes - - Numpy functions now work with PyBaMM symbols (e.g. `np.exp(pybamm.Symbol("a"))` returns `pybamm.Exp(pybamm.Symbol("a"))`). This means that parameter functions can be specified using numpy functions instead of pybamm functions. Additionally, combining numpy arrays with pybamm objects now works (the numpy array is converted to a pybamm array) ([#3205](https://github.com/pybamm-team/PyBaMM/pull/3205)) ## Bug fixes @@ -22,8 +19,8 @@ ## Breaking changes -- The class `pybamm.thermal.OneDimensionalX` has been moved to `pybamm.thermal.pouch_cell.OneDimensionalX` to reflect the fact that the model formulation implicitly assumes a pouch cell geometry. -- The "lumped" thermal option now always used the parameters "Cell cooling surface area [m2]", "Cell volume [m3]" and "Total heat transfer coefficient [W.m-2.K-1]" to compute the cell cooling regardless of the chosen "cell geometry" option. The user must now specify the correct values for these parameters instead of them being calculated based on e.g. a pouch cell. +- The class `pybamm.thermal.OneDimensionalX` has been moved to `pybamm.thermal.pouch_cell.OneDimensionalX` to reflect the fact that the model formulation implicitly assumes a pouch cell geometry ([#3257](https://github.com/pybamm-team/PyBaMM/pull/3257)) +- The "lumped" thermal option now always used the parameters "Cell cooling surface area [m2]", "Cell volume [m3]" and "Total heat transfer coefficient [W.m-2.K-1]" to compute the cell cooling regardless of the chosen "cell geometry" option. The user must now specify the correct values for these parameters instead of them being calculated based on e.g. a pouch cell. An `OptionWarning` is raised to let users know to update their parameters ([#3257](https://github.com/pybamm-team/PyBaMM/pull/3257)) - Added option to use an empirical hysteresis model for the diffusivity and exchange-current density ([#3194](https://github.com/pybamm-team/PyBaMM/pull/3194)) - Double-layer capacity can now be provided as a function of temperature ([#3174](https://github.com/pybamm-team/PyBaMM/pull/3174)) - `pybamm_install_jax` is deprecated. It is now replaced with `pip install pybamm[jax]` ([#3163](https://github.com/pybamm-team/PyBaMM/pull/3163)) From 5d5b9f9aa3a55a4d32cae6a706b52bde66480956 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Wed, 9 Aug 2023 16:58:48 +0100 Subject: [PATCH 026/129] update thermal test --- .../test_lithium_ion/test_thermal_models.py | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_thermal_models.py b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_thermal_models.py index a61b118434..a6663d0eda 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_thermal_models.py +++ b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_thermal_models.py @@ -10,12 +10,8 @@ class TestThermal(TestCase): def test_consistent_cooling(self): - # use spme for comparison instead of spm as - # much larger realistic temperature rises - # so that errors can be more easily observed + # Test the cooling is consistent between the 1+1D and 2+1D SPMe models C_rate = 5 - options = {"thermal": "x-lumped"} - spme_1D = pybamm.lithium_ion.SPMe(options=options) options = { "thermal": "x-lumped", @@ -31,7 +27,7 @@ def test_consistent_cooling(self): } spme_2p1D = pybamm.lithium_ion.SPMe(options=options) - models = {"SPMe 1D": spme_1D, "SPMe 1+1D": spme_1p1D, "SPMe 2+1D": spme_2p1D} + models = {"SPMe 1+1D": spme_1p1D, "SPMe 2+1D": spme_2p1D} solutions = {} for model_name, model in models.items(): @@ -78,8 +74,6 @@ def test_consistent_cooling(self): def err(a, b): return np.max(np.abs(a - b)) / np.max(np.abs(a)) - self.assertGreater(1e-5, err(solutions["SPMe 1D"], solutions["SPMe 1+1D"])) - self.assertGreater(1e-5, err(solutions["SPMe 1D"], solutions["SPMe 2+1D"])) self.assertGreater(1e-5, err(solutions["SPMe 1+1D"], solutions["SPMe 2+1D"])) From 1d89b82bc1e4ebdc448b1c7e1c256d4a545c203a Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Wed, 9 Aug 2023 18:04:25 +0100 Subject: [PATCH 027/129] #3321 fix docs --- docs/source/api/models/submodels/thermal/pouch_cell/index.rst | 1 + .../api/models/submodels/thermal/{ => pouch_cell}/x_full.rst | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) rename docs/source/api/models/submodels/thermal/{ => pouch_cell}/x_full.rst (56%) diff --git a/docs/source/api/models/submodels/thermal/pouch_cell/index.rst b/docs/source/api/models/submodels/thermal/pouch_cell/index.rst index 0f8ebde631..43462d3655 100644 --- a/docs/source/api/models/submodels/thermal/pouch_cell/index.rst +++ b/docs/source/api/models/submodels/thermal/pouch_cell/index.rst @@ -4,5 +4,6 @@ Pouch Cell .. toctree:: :maxdepth: 1 + x_full pouch_cell_1D_current_collectors pouch_cell_2D_current_collectors diff --git a/docs/source/api/models/submodels/thermal/x_full.rst b/docs/source/api/models/submodels/thermal/pouch_cell/x_full.rst similarity index 56% rename from docs/source/api/models/submodels/thermal/x_full.rst rename to docs/source/api/models/submodels/thermal/pouch_cell/x_full.rst index 9488bb435d..25be9c98de 100644 --- a/docs/source/api/models/submodels/thermal/x_full.rst +++ b/docs/source/api/models/submodels/thermal/pouch_cell/x_full.rst @@ -1,7 +1,7 @@ One Dimensional Model ===================== -.. autoclass:: pybamm.thermal.x_full.OneDimensionalX +.. autoclass:: pybamm.thermal.pouch_cell.x_full.OneDimensionalX :members: .. footbibliography:: From 77a2007bf0666adf558fa681d9e811cb54d8f319 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Wed, 9 Aug 2023 18:05:09 +0100 Subject: [PATCH 028/129] #3321 fix docs --- docs/source/api/models/submodels/thermal/index.rst | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/source/api/models/submodels/thermal/index.rst b/docs/source/api/models/submodels/thermal/index.rst index 9cbfcd5b9a..5a4059073a 100644 --- a/docs/source/api/models/submodels/thermal/index.rst +++ b/docs/source/api/models/submodels/thermal/index.rst @@ -7,5 +7,4 @@ Thermal base_thermal isothermal lumped - x_full pouch_cell/index From 9299095ba53d5dacb38ad5b58ea7b7151159540a Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Thu, 10 Aug 2023 09:56:14 +0100 Subject: [PATCH 029/129] #3321 update test --- .../test_lithium_ion/test_thermal_models.py | 79 +++++++++++++------ 1 file changed, 53 insertions(+), 26 deletions(-) diff --git a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_thermal_models.py b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_thermal_models.py index a6663d0eda..4d2f50e8d5 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_thermal_models.py +++ b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_thermal_models.py @@ -10,49 +10,76 @@ class TestThermal(TestCase): def test_consistent_cooling(self): - # Test the cooling is consistent between the 1+1D and 2+1D SPMe models - C_rate = 5 + "Test the cooling is consistent between the 1D, 1+1D and 2+1D SPMe models" + # Load models + options = {"thermal": "lumped"} + spme_1D = pybamm.lithium_ion.SPMe(options=options) options = { "thermal": "x-lumped", "current collector": "potential pair", "dimensionality": 1, } spme_1p1D = pybamm.lithium_ion.SPMe(options=options) - options = { "thermal": "x-lumped", "current collector": "potential pair", "dimensionality": 2, } spme_2p1D = pybamm.lithium_ion.SPMe(options=options) + models = {"SPMe 1D": spme_1D, "SPMe 1+1D": spme_1p1D, "SPMe 2+1D": spme_2p1D} - models = {"SPMe 1+1D": spme_1p1D, "SPMe 2+1D": spme_2p1D} - solutions = {} + # Set up parameter values + parameter_values = pybamm.ParameterValues("NCA_Kim2011") + C_rate = 5 + h_cn = 10 + h_cp = 5 + h_tab_n = 250 + h_tab_p = 250 + h_edge = 100 + # for the lumped model, the total heat transfer coefficient is the area-weighted + # average of the heat transfer coefficients + param = spme_1D.param + L = param.L + L_y = param.L_y + L_z = param.L_z + L_tab_n = param.n.L_tab + L_tab_p = param.p.L_tab + L_cn = param.n.L_cc + L_cp = param.p.L_cc - for model_name, model in models.items(): - var_pts = {"x_n": 3, "x_s": 3, "x_p": 3, "r_n": 3, "r_p": 3, "y": 5, "z": 5} - parameter_values = pybamm.ParameterValues("NCA_Kim2011") + h_total = ( + h_cn * L_y * L_z + + h_cp * L_y * L_z + + h_tab_n * L_tab_n * L_cn + + h_tab_p * L_tab_p * L_cp + + h_edge * (2 * L_y * L + 2 * L_z * L - L_tab_n * L_cn - L_tab_p * L_cp) + ) / (2 * L_y * L_z + 2 * L_y * L + 2 * L_z * L) - # high thermal and electrical conductivity in current collectors - parameter_values.update( - { - "Negative current collector" - + " surface heat transfer coefficient [W.m-2.K-1]": 10, - "Positive current collector" - + " surface heat transfer coefficient [W.m-2.K-1]": 5, - "Negative tab heat transfer coefficient [W.m-2.K-1]": 250, - "Positive tab heat transfer coefficient [W.m-2.K-1]": 250, - "Edge heat transfer coefficient [W.m-2.K-1]": 100, - "Negative current collector" - + " thermal conductivity [W.m-1.K-1]": 267.467 * 100000, - "Positive current collector" - + " thermal conductivity [W.m-1.K-1]": 158.079 * 100000, - "Negative current collector conductivity [S.m-1]": 1e10, - "Positive current collector conductivity [S.m-1]": 1e10, - } - ) + parameter_values.update( + { + "Negative current collector" + + " surface heat transfer coefficient [W.m-2.K-1]": h_cn, + "Positive current collector" + + " surface heat transfer coefficient [W.m-2.K-1]": h_cp, + "Negative tab heat transfer coefficient [W.m-2.K-1]": h_tab_n, + "Positive tab heat transfer coefficient [W.m-2.K-1]": h_tab_p, + "Edge heat transfer coefficient [W.m-2.K-1]": h_edge, + "Total heat transfer coefficient [W.m-2.K-1]": h_total, + # Set high thermal and electrical conductivity in current collectors + "Negative current collector" + + " thermal conductivity [W.m-1.K-1]": 267.467 * 100000, + "Positive current collector" + + " thermal conductivity [W.m-1.K-1]": 158.079 * 100000, + "Negative current collector conductivity [S.m-1]": 1e10, + "Positive current collector conductivity [S.m-1]": 1e10, + } + ) + # Solve models + solutions = {} + var_pts = {"x_n": 3, "x_s": 3, "x_p": 3, "r_n": 3, "r_p": 3, "y": 5, "z": 5} + for model_name, model in models.items(): solver = pybamm.CasadiSolver(mode="fast") sim = pybamm.Simulation( model, From 4afa2487b0219a93fd84cce94f9c7f0d5010fa5d Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 19:33:02 +0530 Subject: [PATCH 030/129] Add parallel `nox` sessions and multiple matrices --- .github/workflows/test_on_push.yml | 47 +++++++++++++++++++++++++++++- 1 file changed, 46 insertions(+), 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 8fb1aae588..4b7cf08a6c 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -19,6 +19,8 @@ jobs: cancel_others: "true" paths_ignore: '["**/README.md"]' +# TODO: add concurrency syntax for groups and cancelling in-progress jobs + style: needs: pre_job if: ${{ needs.pre_job.outputs.should_skip != 'true' }} @@ -35,7 +37,7 @@ jobs: python -m pip install pre-commit pre-commit run ruff - build: + install_requirements: needs: style runs-on: ${{ matrix.os }} strategy: @@ -43,6 +45,7 @@ jobs: matrix: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.8", "3.9", "3.10", "3.11"] + name: Install dependencies on ${{ matrix.os }} with Python ${{ matrix.python-version }} steps: - name: Check out PyBaMM repository @@ -113,6 +116,14 @@ jobs: if: matrix.os == 'ubuntu-latest' run: nox -s pybamm-requires + unit_and_coverage_tests: + needs: install_requirements + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + name: Run unit and coverage tests on ${{ matrix.os }} with Python ${{ matrix.python-version }} + + steps: - name: Run unit tests for GNU/Linux with Python 3.8, 3.9, and 3.10 and for macOS and Windows with all Python versions if: (matrix.os == 'ubuntu-latest' && matrix.python-version != 3.11) || (matrix.os != 'ubuntu-latest') run: nox -s unit @@ -125,14 +136,48 @@ jobs: if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 uses: codecov/codecov-action@v2.1.0 + integration_tests: + needs: unit_and_coverage_tests + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + python-version: ["3.8", "3.9", "3.10", "3.11"] + name: Run integration tests on ${{ matrix.os }} with Python ${{ matrix.python-version }} + + steps: - name: Run integration tests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s integration + doctests: + needs: install_requirements + runs-on: ${{ matrix.os }} + strategy: + # THe doctests take the least time to run, so we can fail other jobs quickly if they fail + fail-fast: true + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + python-version: ["3.8", "3.9", "3.10", "3.11"] + name: Run doctests on ${{ matrix.os }} with Python ${{ matrix.python-version }} + + steps: - name: Install docs dependencies and run doctests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s doctests + examples-tests: + needs: install_requirements + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + python-version: ["3.8", "3.9", "3.10", "3.11"] + name: Run example tests on ${{ matrix.os }} with Python ${{ matrix.python-version }} + + steps: - name: Install dev dependencies and run example tests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s examples From 157d72498d7774dff3b7b4ba26076eebd0811949 Mon Sep 17 00:00:00 2001 From: Saransh Chopra Date: Thu, 10 Aug 2023 10:44:15 -0400 Subject: [PATCH 031/129] Update benchmark_on_push.yml --- .github/workflows/benchmark_on_push.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/benchmark_on_push.yml b/.github/workflows/benchmark_on_push.yml index ad6ad1e708..823dd8305c 100644 --- a/.github/workflows/benchmark_on_push.yml +++ b/.github/workflows/benchmark_on_push.yml @@ -1,8 +1,14 @@ name: Run benchmarks on push on: push: + branches: [main, develop] pull_request: +concurrency: + # Cancel intermediate builds + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + jobs: benchmarks: runs-on: ubuntu-latest From 81fc4fb653b2b0dbab224b249fb6a34112e423ab Mon Sep 17 00:00:00 2001 From: Saransh Chopra Date: Thu, 10 Aug 2023 10:46:11 -0400 Subject: [PATCH 032/129] Fix comment and test changes --- .github/workflows/benchmark_on_push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/benchmark_on_push.yml b/.github/workflows/benchmark_on_push.yml index 823dd8305c..07747af58c 100644 --- a/.github/workflows/benchmark_on_push.yml +++ b/.github/workflows/benchmark_on_push.yml @@ -5,7 +5,7 @@ on: pull_request: concurrency: - # Cancel intermediate builds + # Cancel intermediate builds always group: ${{ github.workflow }}-${{ github.ref }} cancel-in-progress: true From f780af3dc2193afe6508c0dd8b0111387bea495c Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 20:50:03 +0530 Subject: [PATCH 033/129] Refactor jobs' names, steps, and dependents --- .github/workflows/test_on_push.yml | 230 ++++++++++++++++++++++++++--- 1 file changed, 213 insertions(+), 17 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 4b7cf08a6c..f047406787 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -37,7 +37,7 @@ jobs: python -m pip install pre-commit pre-commit run ruff - install_requirements: + run_unit_and_coverage_tests: needs: style runs-on: ${{ matrix.os }} strategy: @@ -45,7 +45,7 @@ jobs: matrix: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.8", "3.9", "3.10", "3.11"] - name: Install dependencies on ${{ matrix.os }} with Python ${{ matrix.python-version }} + name: Run unit and coverage tests on ${{ matrix.os }} with Python ${{ matrix.python-version }} steps: - name: Check out PyBaMM repository @@ -116,14 +116,6 @@ jobs: if: matrix.os == 'ubuntu-latest' run: nox -s pybamm-requires - unit_and_coverage_tests: - needs: install_requirements - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false - name: Run unit and coverage tests on ${{ matrix.os }} with Python ${{ matrix.python-version }} - - steps: - name: Run unit tests for GNU/Linux with Python 3.8, 3.9, and 3.10 and for macOS and Windows with all Python versions if: (matrix.os == 'ubuntu-latest' && matrix.python-version != 3.11) || (matrix.os != 'ubuntu-latest') run: nox -s unit @@ -136,8 +128,8 @@ jobs: if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 uses: codecov/codecov-action@v2.1.0 - integration_tests: - needs: unit_and_coverage_tests + run_integration_tests: + needs: run_unit_and_coverage_tests runs-on: ${{ matrix.os }} strategy: fail-fast: false @@ -147,15 +139,83 @@ jobs: name: Run integration tests on ${{ matrix.os }} with Python ${{ matrix.python-version }} steps: + - name: Check out PyBaMM repository + uses: actions/checkout@v3 + + # Install and cache apt packages + - name: Install Linux system dependencies + uses: awalsh128/cache-apt-pkgs-action@v1.3.0 + if: matrix.os == 'ubuntu-latest' + with: + packages: gfortran gcc graphviz pandoc + execute_install_scripts: true + + # dot -c is for registering graphviz fonts and plugins + - name: Install OpenBLAS and TeXLive for Linux + if: matrix.os == 'ubuntu-latest' + run: | + sudo apt-get update + sudo dot -c + sudo apt-get install libopenblas-dev texlive-latex-extra dvipng + + - name: Install macOS system dependencies + if: matrix.os == 'macos-latest' + env: + # Homebrew environment variables + HOMEBREW_NO_INSTALL_CLEANUP: 1 + HOMEBREW_NO_AUTO_UPDATE: 1 + HOMEBREW_NO_COLOR: 1 + # Speed up CI + NONINTERACTIVE: 1 + run: | + brew analytics off + brew update + brew install graphviz openblas + + - name: Install Windows system dependencies + if: matrix.os == 'windows-latest' + run: choco install graphviz --version=8.0.5 + + - name: Set up Python ${{ matrix.python-version }} + id: setup-python + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + cache: 'pip' + cache-dependency-path: setup.py + + - name: Install PyBaMM dependencies + run: | + pip install --upgrade pip wheel setuptools nox + pip install -e .[all,docs] + + - name: Cache pybamm-requires nox environment for GNU/Linux + uses: actions/cache@v3 + if: matrix.os == 'ubuntu-latest' + with: + path: | + # Repository files + ${{ github.workspace }}/pybind11/ + ${{ github.workspace }}/install_KLU_Sundials/ + # Headers and dynamic library files for SuiteSparse and SUNDIALS + ${{ env.HOME }}/.local/lib/ + ${{ env.HOME }}/.local/include/ + ${{ env.HOME }}/.local/examples/ + key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} + + - name: Install SuiteSparse and SUNDIALS on GNU/Linux + if: matrix.os == 'ubuntu-latest' + run: nox -s pybamm-requires + - name: Run integration tests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s integration - doctests: - needs: install_requirements + run_doctests: + needs: style runs-on: ${{ matrix.os }} strategy: - # THe doctests take the least time to run, so we can fail other jobs quickly if they fail + # The doctests take the least time to run, so we can fail other jobs quickly if they fail fail-fast: true matrix: os: [ubuntu-latest, macos-latest, windows-latest] @@ -163,12 +223,80 @@ jobs: name: Run doctests on ${{ matrix.os }} with Python ${{ matrix.python-version }} steps: + - name: Check out PyBaMM repository + uses: actions/checkout@v3 + + # Install and cache apt packages + - name: Install Linux system dependencies + uses: awalsh128/cache-apt-pkgs-action@v1.3.0 + if: matrix.os == 'ubuntu-latest' + with: + packages: gfortran gcc graphviz pandoc + execute_install_scripts: true + + # dot -c is for registering graphviz fonts and plugins + - name: Install OpenBLAS and TeXLive for Linux + if: matrix.os == 'ubuntu-latest' + run: | + sudo apt-get update + sudo dot -c + sudo apt-get install libopenblas-dev texlive-latex-extra dvipng + + - name: Install macOS system dependencies + if: matrix.os == 'macos-latest' + env: + # Homebrew environment variables + HOMEBREW_NO_INSTALL_CLEANUP: 1 + HOMEBREW_NO_AUTO_UPDATE: 1 + HOMEBREW_NO_COLOR: 1 + # Speed up CI + NONINTERACTIVE: 1 + run: | + brew analytics off + brew update + brew install graphviz openblas + + - name: Install Windows system dependencies + if: matrix.os == 'windows-latest' + run: choco install graphviz --version=8.0.5 + + - name: Set up Python ${{ matrix.python-version }} + id: setup-python + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + cache: 'pip' + cache-dependency-path: setup.py + + - name: Install PyBaMM dependencies + run: | + pip install --upgrade pip wheel setuptools nox + pip install -e .[all,docs] + + - name: Cache pybamm-requires nox environment for GNU/Linux + uses: actions/cache@v3 + if: matrix.os == 'ubuntu-latest' + with: + path: | + # Repository files + ${{ github.workspace }}/pybind11/ + ${{ github.workspace }}/install_KLU_Sundials/ + # Headers and dynamic library files for SuiteSparse and SUNDIALS + ${{ env.HOME }}/.local/lib/ + ${{ env.HOME }}/.local/include/ + ${{ env.HOME }}/.local/examples/ + key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} + + - name: Install SuiteSparse and SUNDIALS on GNU/Linux + if: matrix.os == 'ubuntu-latest' + run: nox -s pybamm-requires + - name: Install docs dependencies and run doctests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s doctests - examples-tests: - needs: install_requirements + run_examples_tests: + needs: style runs-on: ${{ matrix.os }} strategy: fail-fast: false @@ -178,6 +306,74 @@ jobs: name: Run example tests on ${{ matrix.os }} with Python ${{ matrix.python-version }} steps: + - name: Check out PyBaMM repository + uses: actions/checkout@v3 + + # Install and cache apt packages + - name: Install Linux system dependencies + uses: awalsh128/cache-apt-pkgs-action@v1.3.0 + if: matrix.os == 'ubuntu-latest' + with: + packages: gfortran gcc graphviz pandoc + execute_install_scripts: true + + # dot -c is for registering graphviz fonts and plugins + - name: Install OpenBLAS and TeXLive for Linux + if: matrix.os == 'ubuntu-latest' + run: | + sudo apt-get update + sudo dot -c + sudo apt-get install libopenblas-dev texlive-latex-extra dvipng + + - name: Install macOS system dependencies + if: matrix.os == 'macos-latest' + env: + # Homebrew environment variables + HOMEBREW_NO_INSTALL_CLEANUP: 1 + HOMEBREW_NO_AUTO_UPDATE: 1 + HOMEBREW_NO_COLOR: 1 + # Speed up CI + NONINTERACTIVE: 1 + run: | + brew analytics off + brew update + brew install graphviz openblas + + - name: Install Windows system dependencies + if: matrix.os == 'windows-latest' + run: choco install graphviz --version=8.0.5 + + - name: Set up Python ${{ matrix.python-version }} + id: setup-python + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + cache: 'pip' + cache-dependency-path: setup.py + + - name: Install PyBaMM dependencies + run: | + pip install --upgrade pip wheel setuptools nox + pip install -e .[all,docs] + + - name: Cache pybamm-requires nox environment for GNU/Linux + uses: actions/cache@v3 + if: matrix.os == 'ubuntu-latest' + with: + path: | + # Repository files + ${{ github.workspace }}/pybind11/ + ${{ github.workspace }}/install_KLU_Sundials/ + # Headers and dynamic library files for SuiteSparse and SUNDIALS + ${{ env.HOME }}/.local/lib/ + ${{ env.HOME }}/.local/include/ + ${{ env.HOME }}/.local/examples/ + key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} + + - name: Install SuiteSparse and SUNDIALS on GNU/Linux + if: matrix.os == 'ubuntu-latest' + run: nox -s pybamm-requires + - name: Install dev dependencies and run example tests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s examples From 6d037aa82a957e1d83f2ebcc499d8a42160606f9 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 21:00:22 +0530 Subject: [PATCH 034/129] Run all tests on all platforms --- .github/workflows/test_on_push.yml | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index f047406787..f8c7d46455 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -116,12 +116,10 @@ jobs: if: matrix.os == 'ubuntu-latest' run: nox -s pybamm-requires - - name: Run unit tests for GNU/Linux with Python 3.8, 3.9, and 3.10 and for macOS and Windows with all Python versions - if: (matrix.os == 'ubuntu-latest' && matrix.python-version != 3.11) || (matrix.os != 'ubuntu-latest') + - name: Run unit tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} run: nox -s unit - - name: Run unit tests for GNU/Linux with Python 3.11 and generate coverage report - if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 + - name: Run unit tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} and generate coverage report run: nox -s coverage - name: Upload coverage report @@ -207,8 +205,7 @@ jobs: if: matrix.os == 'ubuntu-latest' run: nox -s pybamm-requires - - name: Run integration tests for GNU/Linux with Python 3.11 - if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 + - name: Run integration tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} run: nox -s integration run_doctests: @@ -291,8 +288,7 @@ jobs: if: matrix.os == 'ubuntu-latest' run: nox -s pybamm-requires - - name: Install docs dependencies and run doctests for GNU/Linux with Python 3.11 - if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 + - name: Install docs dependencies and run doctests for ${{ matrix.os }} with Python ${{ matrix.python-version }} run: nox -s doctests run_examples_tests: @@ -374,6 +370,6 @@ jobs: if: matrix.os == 'ubuntu-latest' run: nox -s pybamm-requires - - name: Install dev dependencies and run example tests for GNU/Linux with Python 3.11 + - name: Install dev dependencies and run example tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s examples From 2070932a7b3cafa6c01c0bf3bb4a89ceb2a98150 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 21:08:56 +0530 Subject: [PATCH 035/129] Run examples tests as dependents after doctests --- .github/workflows/test_on_push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index f8c7d46455..cc6b28b9a0 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -292,7 +292,7 @@ jobs: run: nox -s doctests run_examples_tests: - needs: style + needs: run_doctests runs-on: ${{ matrix.os }} strategy: fail-fast: false From 9e5a73340a28502f6a2c0df5539a9204a54b3c78 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 21:16:56 +0530 Subject: [PATCH 036/129] Shorten names for jobs --- .github/workflows/test_on_push.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index cc6b28b9a0..f07613b7d6 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -45,7 +45,7 @@ jobs: matrix: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.8", "3.9", "3.10", "3.11"] - name: Run unit and coverage tests on ${{ matrix.os }} with Python ${{ matrix.python-version }} + name: Unit and coverage tests (${{ matrix.os }} / Python ${{ matrix.python-version }}) steps: - name: Check out PyBaMM repository @@ -134,7 +134,7 @@ jobs: matrix: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.8", "3.9", "3.10", "3.11"] - name: Run integration tests on ${{ matrix.os }} with Python ${{ matrix.python-version }} + name: Integration tests (${{ matrix.os }} / Python ${{ matrix.python-version }}) steps: - name: Check out PyBaMM repository @@ -217,7 +217,7 @@ jobs: matrix: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.8", "3.9", "3.10", "3.11"] - name: Run doctests on ${{ matrix.os }} with Python ${{ matrix.python-version }} + name: Doctests (${{ matrix.os }} / Python ${{ matrix.python-version }}) steps: - name: Check out PyBaMM repository @@ -299,7 +299,7 @@ jobs: matrix: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.8", "3.9", "3.10", "3.11"] - name: Run example tests on ${{ matrix.os }} with Python ${{ matrix.python-version }} + name: Examples tests (${{ matrix.os }} / Python ${{ matrix.python-version }}) steps: - name: Check out PyBaMM repository From e31a9195c777790f907688913f83532c686297cf Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 21:29:34 +0530 Subject: [PATCH 037/129] Install `pandoc` for Windows doctests --- .github/workflows/test_on_push.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index f07613b7d6..5f932b19ed 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -255,7 +255,9 @@ jobs: - name: Install Windows system dependencies if: matrix.os == 'windows-latest' - run: choco install graphviz --version=8.0.5 + run: | + choco install graphviz --version=8.0.5 + choco install pandoc - name: Set up Python ${{ matrix.python-version }} id: setup-python From 305f5a70c8e1229d4cd502e119438f6c34e4feb8 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 22:33:18 +0530 Subject: [PATCH 038/129] Add `pybamm-requires` for macOS --- .github/workflows/test_on_push.yml | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 5f932b19ed..65ae83284c 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -19,8 +19,6 @@ jobs: cancel_others: "true" paths_ignore: '["**/README.md"]' -# TODO: add concurrency syntax for groups and cancelling in-progress jobs - style: needs: pre_job if: ${{ needs.pre_job.outputs.should_skip != 'true' }} @@ -98,9 +96,9 @@ jobs: pip install --upgrade pip wheel setuptools nox pip install -e .[all,docs] - - name: Cache pybamm-requires nox environment for GNU/Linux + - name: Cache pybamm-requires nox environment for GNU/Linux and macOS uses: actions/cache@v3 - if: matrix.os == 'ubuntu-latest' + if: matrix.os != 'windows-latest' with: path: | # Repository files @@ -110,10 +108,10 @@ jobs: ${{ env.HOME }}/.local/lib/ ${{ env.HOME }}/.local/include/ ${{ env.HOME }}/.local/examples/ - key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} + key: nox-${{matrix.os}}-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} - - name: Install SuiteSparse and SUNDIALS on GNU/Linux - if: matrix.os == 'ubuntu-latest' + - name: Install SuiteSparse and SUNDIALS on GNU/Linux and macOS + if: matrix.os != 'windows-latest' run: nox -s pybamm-requires - name: Run unit tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} From ddc0fc587bbf95000ac2d4344f83b80d5ff0f94f Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 22:41:16 +0530 Subject: [PATCH 039/129] Add concurrency syntax to cancel workflow runs and remove the pre_job step since it is not needed anymore. --- .github/workflows/test_on_push.yml | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 65ae83284c..948d7bdcd7 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -4,24 +4,16 @@ on: workflow_dispatch: pull_request: -jobs: - pre_job: - runs-on: ubuntu-latest - # Map a step output to a job output - outputs: - should_skip: ${{ steps.skip_check.outputs.should_skip }} - steps: - - id: skip_check - uses: fkirc/skip-duplicate-actions@master - with: - # All of these options are optional, so you can remove them if you are happy with the defaults - concurrent_skipping: "never" - cancel_others: "true" - paths_ignore: '["**/README.md"]' +concurrency: + # github.workflow: name of the workflow, so that we don't cancel other workflows + # github.event.pull_request.number || github.ref: pull request number or branch name if not a pull request + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + # Cancel in-progress runs when a new workflow with the same group name is triggered + # This avoids workflow runs on both pushes and PRs + cancel-in-progress: true +jobs: style: - needs: pre_job - if: ${{ needs.pre_job.outputs.should_skip != 'true' }} runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 From 7999c14768c98d5e94941b3a87c0a10700a82183 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 22:50:16 +0530 Subject: [PATCH 040/129] Install `pandoc` with brew in doctests job --- .github/workflows/test_on_push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 948d7bdcd7..b8d54a5178 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -241,7 +241,7 @@ jobs: run: | brew analytics off brew update - brew install graphviz openblas + brew install graphviz openblas pandoc - name: Install Windows system dependencies if: matrix.os == 'windows-latest' From 44c3175e511918d0d8027a21d5bdd490de12f26b Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 22:51:11 +0530 Subject: [PATCH 041/129] Bump version for `codecov-action` --- .github/workflows/run_periodic_tests.yml | 2 +- .github/workflows/test_on_push.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/run_periodic_tests.yml b/.github/workflows/run_periodic_tests.yml index 5027d877ac..f70a748800 100644 --- a/.github/workflows/run_periodic_tests.yml +++ b/.github/workflows/run_periodic_tests.yml @@ -102,7 +102,7 @@ jobs: - name: Upload coverage report if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 - uses: codecov/codecov-action@v2.1.0 + uses: codecov/codecov-action@v3.1.4 - name: Run integration tests run: nox -s integration diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index b8d54a5178..5f544e83f6 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -114,7 +114,7 @@ jobs: - name: Upload coverage report if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 - uses: codecov/codecov-action@v2.1.0 + uses: codecov/codecov-action@v3.1.4 run_integration_tests: needs: run_unit_and_coverage_tests From bdcd8ffea9a99e7022669964a78214df2b527e88 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 23:31:38 +0530 Subject: [PATCH 042/129] Remove `pybamm-requires` from coverage job --- .github/workflows/test_on_push.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 5f544e83f6..71a8b99899 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -88,7 +88,7 @@ jobs: pip install --upgrade pip wheel setuptools nox pip install -e .[all,docs] - - name: Cache pybamm-requires nox environment for GNU/Linux and macOS + - name: Cache pybamm-requires nox environment for GNU/Linux uses: actions/cache@v3 if: matrix.os != 'windows-latest' with: @@ -100,9 +100,9 @@ jobs: ${{ env.HOME }}/.local/lib/ ${{ env.HOME }}/.local/include/ ${{ env.HOME }}/.local/examples/ - key: nox-${{matrix.os}}-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} + key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} - - name: Install SuiteSparse and SUNDIALS on GNU/Linux and macOS + - name: Install SuiteSparse and SUNDIALS on GNU/Linux if: matrix.os != 'windows-latest' run: nox -s pybamm-requires From 840a71f60f0a20e270a1428913d671f8470ef6a2 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Thu, 10 Aug 2023 23:49:55 +0530 Subject: [PATCH 043/129] Fix `pybamm-requires` conditional --- .github/workflows/test_on_push.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 71a8b99899..762e68e1b8 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -90,7 +90,7 @@ jobs: - name: Cache pybamm-requires nox environment for GNU/Linux uses: actions/cache@v3 - if: matrix.os != 'windows-latest' + if: matrix.os == 'ubuntu-latest' with: path: | # Repository files @@ -103,7 +103,7 @@ jobs: key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} - name: Install SuiteSparse and SUNDIALS on GNU/Linux - if: matrix.os != 'windows-latest' + if: matrix.os == 'ubuntu-latest' run: nox -s pybamm-requires - name: Run unit tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} From 2153209c11fdd8e9a80cf1e12683ddc29c777408 Mon Sep 17 00:00:00 2001 From: Robert Timms Date: Fri, 11 Aug 2023 09:29:09 +0100 Subject: [PATCH 044/129] #3321 update example --- examples/scripts/pouch_cell_cooling.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/scripts/pouch_cell_cooling.py b/examples/scripts/pouch_cell_cooling.py index 4a2163ad9c..be35f52420 100644 --- a/examples/scripts/pouch_cell_cooling.py +++ b/examples/scripts/pouch_cell_cooling.py @@ -53,4 +53,4 @@ def h_edge(y, z): "X-averaged cell temperature [K]", "Voltage [V]", ] -sim.plot(output_variables, variable_limits="tight", shading="gouraud") +sim.plot(output_variables, variable_limits="tight", shading="auto") From babe98af796d5471344dfa0936d66a9f678af843 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sat, 12 Aug 2023 00:10:31 +0530 Subject: [PATCH 045/129] Run doctests and examples tests sequentially --- .github/workflows/test_on_push.yml | 81 +----------------------------- 1 file changed, 1 insertion(+), 80 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 762e68e1b8..12c7369258 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -198,7 +198,7 @@ jobs: - name: Run integration tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} run: nox -s integration - run_doctests: + run_doctests_and_example_tests: needs: style runs-on: ${{ matrix.os }} strategy: @@ -283,85 +283,6 @@ jobs: - name: Install docs dependencies and run doctests for ${{ matrix.os }} with Python ${{ matrix.python-version }} run: nox -s doctests - run_examples_tests: - needs: run_doctests - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false - matrix: - os: [ubuntu-latest, macos-latest, windows-latest] - python-version: ["3.8", "3.9", "3.10", "3.11"] - name: Examples tests (${{ matrix.os }} / Python ${{ matrix.python-version }}) - - steps: - - name: Check out PyBaMM repository - uses: actions/checkout@v3 - - # Install and cache apt packages - - name: Install Linux system dependencies - uses: awalsh128/cache-apt-pkgs-action@v1.3.0 - if: matrix.os == 'ubuntu-latest' - with: - packages: gfortran gcc graphviz pandoc - execute_install_scripts: true - - # dot -c is for registering graphviz fonts and plugins - - name: Install OpenBLAS and TeXLive for Linux - if: matrix.os == 'ubuntu-latest' - run: | - sudo apt-get update - sudo dot -c - sudo apt-get install libopenblas-dev texlive-latex-extra dvipng - - - name: Install macOS system dependencies - if: matrix.os == 'macos-latest' - env: - # Homebrew environment variables - HOMEBREW_NO_INSTALL_CLEANUP: 1 - HOMEBREW_NO_AUTO_UPDATE: 1 - HOMEBREW_NO_COLOR: 1 - # Speed up CI - NONINTERACTIVE: 1 - run: | - brew analytics off - brew update - brew install graphviz openblas - - - name: Install Windows system dependencies - if: matrix.os == 'windows-latest' - run: choco install graphviz --version=8.0.5 - - - name: Set up Python ${{ matrix.python-version }} - id: setup-python - uses: actions/setup-python@v4 - with: - python-version: ${{ matrix.python-version }} - cache: 'pip' - cache-dependency-path: setup.py - - - name: Install PyBaMM dependencies - run: | - pip install --upgrade pip wheel setuptools nox - pip install -e .[all,docs] - - - name: Cache pybamm-requires nox environment for GNU/Linux - uses: actions/cache@v3 - if: matrix.os == 'ubuntu-latest' - with: - path: | - # Repository files - ${{ github.workspace }}/pybind11/ - ${{ github.workspace }}/install_KLU_Sundials/ - # Headers and dynamic library files for SuiteSparse and SUNDIALS - ${{ env.HOME }}/.local/lib/ - ${{ env.HOME }}/.local/include/ - ${{ env.HOME }}/.local/examples/ - key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} - - - name: Install SuiteSparse and SUNDIALS on GNU/Linux - if: matrix.os == 'ubuntu-latest' - run: nox -s pybamm-requires - - name: Install dev dependencies and run example tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s examples From c9ef880c95257a694aae2b50d01a3c164566be83 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sat, 12 Aug 2023 00:26:20 +0530 Subject: [PATCH 046/129] Split unit and coverage, run coverage only on Ubuntu + Python 3.11 --- .github/workflows/test_on_push.yml | 74 ++++++++++++++++++++++++++---- 1 file changed, 66 insertions(+), 8 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 12c7369258..806a7de873 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -27,7 +27,7 @@ jobs: python -m pip install pre-commit pre-commit run ruff - run_unit_and_coverage_tests: + run_unit_tests: needs: style runs-on: ${{ matrix.os }} strategy: @@ -35,7 +35,7 @@ jobs: matrix: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.8", "3.9", "3.10", "3.11"] - name: Unit and coverage tests (${{ matrix.os }} / Python ${{ matrix.python-version }}) + name: Unit tests (${{ matrix.os }} / Python ${{ matrix.python-version }}) steps: - name: Check out PyBaMM repository @@ -107,17 +107,76 @@ jobs: run: nox -s pybamm-requires - name: Run unit tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} + # check coverage only with Python 3.11 on Ubuntu, so we skip it for other Python versions and platforms + if: matrix.os == 'windows-latest' || matrix.os == 'macos-latest' || (matrix.os == 'ubuntu-latest' && matrix.python-version != '3.11') run: nox -s unit - - name: Run unit tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} and generate coverage report + # Runs only on Ubuntu with Python 3.11 + check_coverage: + needs: style + runs-on: ubuntu-latest + strategy: + fail-fast: false + name: Unit and coverage tests (${{ matrix.os }} / Python ${{ matrix.python-version }}) + + steps: + - name: Check out PyBaMM repository + uses: actions/checkout@v3 + + # Install and cache apt packages + - name: Install Linux system dependencies + uses: awalsh128/cache-apt-pkgs-action@v1.3.0 + with: + packages: gfortran gcc graphviz pandoc + execute_install_scripts: true + + # dot -c is for registering graphviz fonts and plugins + - name: Install OpenBLAS and TeXLive for Linux + if: matrix.os == 'ubuntu-latest' + run: | + sudo apt-get update + sudo dot -c + sudo apt-get install libopenblas-dev texlive-latex-extra dvipng + + - name: Set up Python 3.11 + id: setup-python + uses: actions/setup-python@v4 + with: + python-version: 3.11 + cache: 'pip' + cache-dependency-path: setup.py + + - name: Install PyBaMM dependencies + run: | + pip install --upgrade pip wheel setuptools nox + pip install -e .[all,docs] + + - name: Cache pybamm-requires nox environment for GNU/Linux + uses: actions/cache@v3 + if: matrix.os == 'ubuntu-latest' + with: + path: | + # Repository files + ${{ github.workspace }}/pybind11/ + ${{ github.workspace }}/install_KLU_Sundials/ + # Headers and dynamic library files for SuiteSparse and SUNDIALS + ${{ env.HOME }}/.local/lib/ + ${{ env.HOME }}/.local/include/ + ${{ env.HOME }}/.local/examples/ + key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} + + - name: Install SuiteSparse and SUNDIALS on GNU/Linux + if: matrix.os == 'ubuntu-latest' + run: nox -s pybamm-requires + + - name: Run unit tests for Ubuntu with Python 3.11 and generate coverage report run: nox -s coverage - name: Upload coverage report - if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 uses: codecov/codecov-action@v3.1.4 run_integration_tests: - needs: run_unit_and_coverage_tests + needs: run_unit_tests runs-on: ${{ matrix.os }} strategy: fail-fast: false @@ -202,12 +261,11 @@ jobs: needs: style runs-on: ${{ matrix.os }} strategy: - # The doctests take the least time to run, so we can fail other jobs quickly if they fail - fail-fast: true + fail-fast: false matrix: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.8", "3.9", "3.10", "3.11"] - name: Doctests (${{ matrix.os }} / Python ${{ matrix.python-version }}) + name: Doctests and examples (${{ matrix.os }} / Python ${{ matrix.python-version }}) steps: - name: Check out PyBaMM repository From f3c145a08db0307d57198900c6ebd967ae78cd10 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sat, 12 Aug 2023 00:34:00 +0530 Subject: [PATCH 047/129] Rename coverage job step --- .github/workflows/test_on_push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 806a7de873..ca0e7363c0 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -117,7 +117,7 @@ jobs: runs-on: ubuntu-latest strategy: fail-fast: false - name: Unit and coverage tests (${{ matrix.os }} / Python ${{ matrix.python-version }}) + name: Coverage tests (ubuntu-latest / Python 3.11) steps: - name: Check out PyBaMM repository From 96cc0b17f9fe070cb790f02a0d70520a956cd71a Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 13:29:56 +0530 Subject: [PATCH 048/129] Using python3.9 for IDAKLU --- Dockerfile | 35 ++++++++--------------------------- 1 file changed, 8 insertions(+), 27 deletions(-) diff --git a/Dockerfile b/Dockerfile index 9b82bbc9fd..3442939cbb 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,15 +1,17 @@ -FROM python:3.11-slim +FROM python:3.9-slim # Set the working directory WORKDIR / # Install the necessary dependencies RUN apt-get update && apt-get -y upgrade -RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git make g++ build-essential +RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git make g++ build-essential cmake ENV CMAKE_C_COMPILER=/usr/bin/gcc ENV CMAKE_CXX_COMPILER=/usr/bin/g++ ENV CMAKE_MAKE_PROGRAM=/usr/bin/make +ENV SUNDIALS_INST=root/.local +ENV LD_LIBRARY_PATH=root/.local/lib: # Copy project files into the container RUN git clone https://github.com/pybamm-team/PyBaMM.git @@ -17,30 +19,9 @@ RUN git clone https://github.com/pybamm-team/PyBaMM.git WORKDIR /PyBaMM/ # Install PyBaMM -RUN python -m pip install --upgrade pip -# RUN pip install -e ".[all]" - -ARG ODES -ARG JAX -ARG IDAKLU - - -RUN if [ "$ODES" = "true" ]; then \ - apt-get install -y cmake && \ - pip install wget \ - pip install -e ".[all]" \ - pybamm_install_odes; \ - fi - -RUN if [ "$JAX" = "true" ]; then \ - pip install -e ".[jax,all]";\ - fi - -RUN if [ "$IDAKLU" = "true" ]; then \ - pip install wget \ - python scripts/install_KLU_Sundials.py \ - git clone https://github.com/pybind/pybind11.git pybind11/; \ - pip install -e ".[all]"; \ - fi +RUN python -m pip install --upgrade pip setuptools wheel nox wget +RUN python scripts/install_KLU_Sundials.py +RUN git clone https://github.com/pybind/pybind11.git pybind11/ +RUN python -m pip install -e ".[all]" CMD ["/bin/bash"] From 63337e3469d2aa1e466e10829e6a07602c4c25f3 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 13:30:12 +0530 Subject: [PATCH 049/129] Try using venv --- Dockerfile | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/Dockerfile b/Dockerfile index 3442939cbb..1091c5f792 100644 --- a/Dockerfile +++ b/Dockerfile @@ -18,6 +18,13 @@ RUN git clone https://github.com/pybamm-team/PyBaMM.git WORKDIR /PyBaMM/ +# Install virtualenv +RUN python -m pip install virtualenv + +# Create and activate virtual environment +RUN virtualenv -p python3.9 venv +RUN /bin/bash -c "source venv/bin/activate" + # Install PyBaMM RUN python -m pip install --upgrade pip setuptools wheel nox wget RUN python scripts/install_KLU_Sundials.py From aa4b83f1647b3a80588062ca444a72e29e0cd546 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 13:34:20 +0530 Subject: [PATCH 050/129] Trying python3.11-dev --- Dockerfile | 36 +++++++++++++++++++++++++----------- 1 file changed, 25 insertions(+), 11 deletions(-) diff --git a/Dockerfile b/Dockerfile index 1091c5f792..87d1cbe1f3 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,34 +1,48 @@ -FROM python:3.9-slim +FROM python:3.10-slim # Set the working directory WORKDIR / # Install the necessary dependencies RUN apt-get update && apt-get -y upgrade -RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git make g++ build-essential cmake +RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git make g++ build-essential python3.11-dev python3-pip ENV CMAKE_C_COMPILER=/usr/bin/gcc ENV CMAKE_CXX_COMPILER=/usr/bin/g++ ENV CMAKE_MAKE_PROGRAM=/usr/bin/make -ENV SUNDIALS_INST=root/.local -ENV LD_LIBRARY_PATH=root/.local/lib: # Copy project files into the container RUN git clone https://github.com/pybamm-team/PyBaMM.git WORKDIR /PyBaMM/ -# Install virtualenv -RUN python -m pip install virtualenv - -# Create and activate virtual environment -RUN virtualenv -p python3.9 venv +# RUN python3.11 -m pip install virtualenv +RUN apt-get install -y python3.11-venv +RUN python3.11 -m venv venv RUN /bin/bash -c "source venv/bin/activate" # Install PyBaMM -RUN python -m pip install --upgrade pip setuptools wheel nox wget +RUN python3.11 -m pip install --upgrade pip setuptools wheel nox +# RUN pip install -e ".[all]" + +ARG ODES +ARG JAX +ARG IDAKLU + + +# RUN if [ "$ODES" = "true" ]; then \ +# apt-get install -y cmake && \ +# pip install wget \ +# pybamm_install_odes; \ +# fi + +# RUN if [ "$JAX" = "true" ]; then \ +# pip install -e ".[jax,all]";\ +# fi + +RUN pip install wget cmake RUN python scripts/install_KLU_Sundials.py RUN git clone https://github.com/pybind/pybind11.git pybind11/ -RUN python -m pip install -e ".[all]" +RUN python3.11 -m pip install -e ".[all]" CMD ["/bin/bash"] From 9991cbce0e9837d309a2a082fed5cd77db2695fa Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 13:39:01 +0530 Subject: [PATCH 051/129] Squash previous 3 commits --- Dockerfile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Dockerfile b/Dockerfile index 87d1cbe1f3..c3b39bff9d 100644 --- a/Dockerfile +++ b/Dockerfile @@ -21,7 +21,7 @@ RUN apt-get install -y python3.11-venv RUN python3.11 -m venv venv RUN /bin/bash -c "source venv/bin/activate" -# Install PyBaMM +# Install PyBaMMs RUN python3.11 -m pip install --upgrade pip setuptools wheel nox # RUN pip install -e ".[all]" @@ -40,8 +40,8 @@ ARG IDAKLU # pip install -e ".[jax,all]";\ # fi -RUN pip install wget cmake -RUN python scripts/install_KLU_Sundials.py +RUN pip install wget cmake +RUN python scripts/install_KLU_Sundials.py RUN git clone https://github.com/pybind/pybind11.git pybind11/ RUN python3.11 -m pip install -e ".[all]" From 83c7df01ec378d738214475ed06efa48d5399eb3 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 14:09:53 +0530 Subject: [PATCH 052/129] Using `ubuntu:22.04` as base image --- Dockerfile | 42 +++++++++++++++--------------------------- 1 file changed, 15 insertions(+), 27 deletions(-) diff --git a/Dockerfile b/Dockerfile index c3b39bff9d..1981662917 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,48 +1,36 @@ -FROM python:3.10-slim +FROM ubuntu:22.04 # Set the working directory WORKDIR / # Install the necessary dependencies RUN apt-get update && apt-get -y upgrade -RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git make g++ build-essential python3.11-dev python3-pip +RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git make g++ build-essential python3.9 python3-pip ENV CMAKE_C_COMPILER=/usr/bin/gcc ENV CMAKE_CXX_COMPILER=/usr/bin/g++ ENV CMAKE_MAKE_PROGRAM=/usr/bin/make +ENV SUNDIALS_INST=root/.local +ENV LD_LIBRARY_PATH=root/.local/lib: + +RUN python3.9 -m pip install wget # Copy project files into the container RUN git clone https://github.com/pybamm-team/PyBaMM.git WORKDIR /PyBaMM/ -# RUN python3.11 -m pip install virtualenv -RUN apt-get install -y python3.11-venv -RUN python3.11 -m venv venv -RUN /bin/bash -c "source venv/bin/activate" - -# Install PyBaMMs -RUN python3.11 -m pip install --upgrade pip setuptools wheel nox -# RUN pip install -e ".[all]" - -ARG ODES -ARG JAX -ARG IDAKLU +# Install virtualenv +RUN python3.9 -m pip install virtualenv +# Create and activate virtual environment +RUN virtualenv -p python3.9 venv +RUN /bin/bash -c "source venv/bin/activate" -# RUN if [ "$ODES" = "true" ]; then \ -# apt-get install -y cmake && \ -# pip install wget \ -# pybamm_install_odes; \ -# fi - -# RUN if [ "$JAX" = "true" ]; then \ -# pip install -e ".[jax,all]";\ -# fi - -RUN pip install wget cmake -RUN python scripts/install_KLU_Sundials.py +# Install PyBaMM +RUN python3.9 -m pip install --upgrade pip setuptools wheel nox +RUN python3.9 scripts/install_KLU_Sundials.py RUN git clone https://github.com/pybind/pybind11.git pybind11/ -RUN python3.11 -m pip install -e ".[all]" +RUN python3.9 -m pip install -e ".[all]" CMD ["/bin/bash"] From 89c2ba7ef677e1ffd3be0465d0546153ee28c09a Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 14:16:33 +0530 Subject: [PATCH 053/129] Using `continuumio/miniconda3` as base --- Dockerfile | 40 ++++++++++++++++++---------------------- 1 file changed, 18 insertions(+), 22 deletions(-) diff --git a/Dockerfile b/Dockerfile index 1981662917..5f4b7b5310 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,11 +1,16 @@ -FROM ubuntu:22.04 +FROM continuumio/miniconda3:latest -# Set the working directory WORKDIR / # Install the necessary dependencies RUN apt-get update && apt-get -y upgrade -RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git make g++ build-essential python3.9 python3-pip +RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git make g++ build-essential cmake +RUN rm -rf /var/lib/apt/lists/* + +# Clone project files from Git repository +RUN git clone https://github.com/pybamm-team/PyBaMM.git + +WORKDIR /PyBaMM ENV CMAKE_C_COMPILER=/usr/bin/gcc ENV CMAKE_CXX_COMPILER=/usr/bin/g++ @@ -13,24 +18,15 @@ ENV CMAKE_MAKE_PROGRAM=/usr/bin/make ENV SUNDIALS_INST=root/.local ENV LD_LIBRARY_PATH=root/.local/lib: -RUN python3.9 -m pip install wget - -# Copy project files into the container -RUN git clone https://github.com/pybamm-team/PyBaMM.git - -WORKDIR /PyBaMM/ - -# Install virtualenv -RUN python3.9 -m pip install virtualenv - -# Create and activate virtual environment -RUN virtualenv -p python3.9 venv -RUN /bin/bash -c "source venv/bin/activate" +RUN conda create -n py39 python=3.9 -# Install PyBaMM -RUN python3.9 -m pip install --upgrade pip setuptools wheel nox -RUN python3.9 scripts/install_KLU_Sundials.py -RUN git clone https://github.com/pybind/pybind11.git pybind11/ -RUN python3.9 -m pip install -e ".[all]" +SHELL ["conda", "run", "-n", "py39", "/bin/bash", "-c"] +RUN conda install -y pip +RUN pip install --upgrade pip setuptools wheel nox wget +RUN pip install cmake==3.22 +RUN python scripts/install_KLU_Sundials.py +RUN git clone https://github.com/pybind/pybind11.git +RUN pip install -e ".[all]" +RUN conda init --all -CMD ["/bin/bash"] +ENTRYPOINT ["/bin/bash", "-c", "conda activate py39 && /bin/bash"] From 5d35c8e71b7a8612c3cf7a81013763d4f7f3d6bb Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 14:18:32 +0530 Subject: [PATCH 054/129] Create a non-root user to avoid conflicts --- Dockerfile | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/Dockerfile b/Dockerfile index 5f4b7b5310..779248fa3e 100644 --- a/Dockerfile +++ b/Dockerfile @@ -7,26 +7,31 @@ RUN apt-get update && apt-get -y upgrade RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git make g++ build-essential cmake RUN rm -rf /var/lib/apt/lists/* +RUN useradd -m -s /bin/bash myuser +USER myuser + +WORKDIR /home/myuser/ + # Clone project files from Git repository RUN git clone https://github.com/pybamm-team/PyBaMM.git -WORKDIR /PyBaMM +WORKDIR /home/myuser/PyBaMM ENV CMAKE_C_COMPILER=/usr/bin/gcc ENV CMAKE_CXX_COMPILER=/usr/bin/g++ ENV CMAKE_MAKE_PROGRAM=/usr/bin/make -ENV SUNDIALS_INST=root/.local -ENV LD_LIBRARY_PATH=root/.local/lib: +ENV SUNDIALS_INST=/home/myuser/.local +ENV LD_LIBRARY_PATH=/home/myuser/.local/lib: RUN conda create -n py39 python=3.9 SHELL ["conda", "run", "-n", "py39", "/bin/bash", "-c"] RUN conda install -y pip -RUN pip install --upgrade pip setuptools wheel nox wget +RUN pip install --upgrade --user pip setuptools wheel nox wget RUN pip install cmake==3.22 RUN python scripts/install_KLU_Sundials.py RUN git clone https://github.com/pybind/pybind11.git -RUN pip install -e ".[all]" +RUN pip install --user -e ".[all]" RUN conda init --all -ENTRYPOINT ["/bin/bash", "-c", "conda activate py39 && /bin/bash"] +ENTRYPOINT ["/bin/bash", "-c", "source activate py39 && /bin/bash"] From b520197d6eea642eb6401c9798c90c6cb5628cf5 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 14:52:48 +0530 Subject: [PATCH 055/129] Again add all ARGS --- Dockerfile | 46 +++++++++++++++++++++++++++++++--------------- 1 file changed, 31 insertions(+), 15 deletions(-) diff --git a/Dockerfile b/Dockerfile index 779248fa3e..74dfdbcb8e 100644 --- a/Dockerfile +++ b/Dockerfile @@ -7,31 +7,47 @@ RUN apt-get update && apt-get -y upgrade RUN apt-get install -y libopenblas-dev gcc gfortran graphviz git make g++ build-essential cmake RUN rm -rf /var/lib/apt/lists/* -RUN useradd -m -s /bin/bash myuser -USER myuser +RUN useradd -m -s /bin/bash pybamm +USER pybamm -WORKDIR /home/myuser/ +WORKDIR /home/pybamm/ # Clone project files from Git repository RUN git clone https://github.com/pybamm-team/PyBaMM.git -WORKDIR /home/myuser/PyBaMM +WORKDIR /home/pybamm/PyBaMM ENV CMAKE_C_COMPILER=/usr/bin/gcc ENV CMAKE_CXX_COMPILER=/usr/bin/g++ ENV CMAKE_MAKE_PROGRAM=/usr/bin/make -ENV SUNDIALS_INST=/home/myuser/.local -ENV LD_LIBRARY_PATH=/home/myuser/.local/lib: +ENV SUNDIALS_INST=/home/pybamm/.local +ENV LD_LIBRARY_PATH=/home/pybamm/.local/lib: -RUN conda create -n py39 python=3.9 +ARG IDAKLU +ARG ODES +ARG JAX -SHELL ["conda", "run", "-n", "py39", "/bin/bash", "-c"] -RUN conda install -y pip -RUN pip install --upgrade --user pip setuptools wheel nox wget -RUN pip install cmake==3.22 -RUN python scripts/install_KLU_Sundials.py -RUN git clone https://github.com/pybind/pybind11.git -RUN pip install --user -e ".[all]" +RUN conda create -n pybamm python=3.9 RUN conda init --all +SHELL ["conda", "run", "-n", "pybamm", "/bin/bash", "-c"] +RUN conda install -y pip -ENTRYPOINT ["/bin/bash", "-c", "source activate py39 && /bin/bash"] +RUN if [ "$IDAKLU" = "true" ]; then \ + pip install --upgrade --user pip setuptools wheel wget && \ + pip install cmake==3.22 && \ + python scripts/install_KLU_Sundials.py && \ + git clone https://github.com/pybind/pybind11.git && \ + pip install --user -e ".[all]"; \ + fi + +RUN if [ "$ODES" = "true" ]; then \ + pip install cmake==3.22 && \ + pip install --upgrade --user pip wget && \ + pybamm_install_odes; \ + fi + +RUN if [ "$JAX" = "true" ]; then \ + pip install --user -e ".[jax,all]";\ + fi + +ENTRYPOINT ["/bin/bash", "-c", "conda activate pybamm && /bin/bash"] From 2fda58fd433702126b864b695e0cbc935b6dfb0e Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 16:21:08 +0530 Subject: [PATCH 056/129] edit entrypoint --- Dockerfile | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Dockerfile b/Dockerfile index 74dfdbcb8e..202f40d092 100644 --- a/Dockerfile +++ b/Dockerfile @@ -43,11 +43,12 @@ RUN if [ "$IDAKLU" = "true" ]; then \ RUN if [ "$ODES" = "true" ]; then \ pip install cmake==3.22 && \ pip install --upgrade --user pip wget && \ - pybamm_install_odes; \ + python scripts/install_KLU_Sundials.py && \ + pip install --user -e ".[all,odes]"; \ fi RUN if [ "$JAX" = "true" ]; then \ pip install --user -e ".[jax,all]";\ fi -ENTRYPOINT ["/bin/bash", "-c", "conda activate pybamm && /bin/bash"] +ENTRYPOINT ["/bin/bash"] From 3b0a964049c9e8ace042a2545c300e70062fc3d7 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sat, 12 Aug 2023 16:42:20 +0530 Subject: [PATCH 057/129] Run examples on all platforms and Python versions --- .github/workflows/test_on_push.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index ca0e7363c0..bb5d0db6dd 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -342,5 +342,4 @@ jobs: run: nox -s doctests - name: Install dev dependencies and run example tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} - if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s examples From 135a4469417d938308ab7b945a2c3f9aa8072b97 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sat, 12 Aug 2023 16:50:21 +0530 Subject: [PATCH 058/129] Manually environment variables for coverage --- .github/workflows/test_on_push.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index bb5d0db6dd..a6a855bdfb 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -170,6 +170,9 @@ jobs: run: nox -s pybamm-requires - name: Run unit tests for Ubuntu with Python 3.11 and generate coverage report + env: + SUNDIALS_INST: ${{ env.HOME }}/.local + LD_LIBRARY_PATH: ${{ env.HOME }}/.local/lib run: nox -s coverage - name: Upload coverage report From 701e45fcd8e9b1087e5a096dfe76960f7d89fea2 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 16:52:08 +0530 Subject: [PATCH 059/129] Start documenting Docker --- .../user_guide/installation/install-from-docker.rst | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 docs/source/user_guide/installation/install-from-docker.rst diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst new file mode 100644 index 0000000000..399fa65547 --- /dev/null +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -0,0 +1,9 @@ +Install using Docker (developer install) +========================================= + +.. contents:: + +This page describes the build and installation of PyBaMM from the source code, available on GitHub. Note that this is **not the recommended approach for most users** and should be reserved to people wanting to participate in the development of PyBaMM, or people who really need to use bleeding-edge feature(s) not yet available in the latest released version. If you do not fall in the two previous categories, you would be better off installing PyBaMM using pip or conda. + +Lastly, familiarity with the Python ecosystem is recommended (pip, virtualenvs). +Here is a gentle introduction/refresher: `Python Virtual Environments: A Primer `_. \ No newline at end of file From 3506c5120590630f1cadccd5ea7c450787d57e33 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sat, 12 Aug 2023 16:55:58 +0530 Subject: [PATCH 060/129] Exclude unit test from matrix config itself --- .github/workflows/test_on_push.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index a6a855bdfb..96d55b5aba 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -35,6 +35,10 @@ jobs: matrix: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.8", "3.9", "3.10", "3.11"] + # We check coverage on Ubuntu with Python 3.11, so we skip unit tests for it here + exclude: + - os: ubuntu-latest + python-version: "3.11" name: Unit tests (${{ matrix.os }} / Python ${{ matrix.python-version }}) steps: @@ -107,8 +111,6 @@ jobs: run: nox -s pybamm-requires - name: Run unit tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} - # check coverage only with Python 3.11 on Ubuntu, so we skip it for other Python versions and platforms - if: matrix.os == 'windows-latest' || matrix.os == 'macos-latest' || (matrix.os == 'ubuntu-latest' && matrix.python-version != '3.11') run: nox -s unit # Runs only on Ubuntu with Python 3.11 From 3d5a77a915e7962e63f17c3c117ab1ac16047e2f Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sat, 12 Aug 2023 17:03:00 +0530 Subject: [PATCH 061/129] Fix Linux and Python 3.11 coverage CI job --- .github/workflows/test_on_push.yml | 6 ------ 1 file changed, 6 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 96d55b5aba..41fb8e17b4 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -134,7 +134,6 @@ jobs: # dot -c is for registering graphviz fonts and plugins - name: Install OpenBLAS and TeXLive for Linux - if: matrix.os == 'ubuntu-latest' run: | sudo apt-get update sudo dot -c @@ -155,7 +154,6 @@ jobs: - name: Cache pybamm-requires nox environment for GNU/Linux uses: actions/cache@v3 - if: matrix.os == 'ubuntu-latest' with: path: | # Repository files @@ -168,13 +166,9 @@ jobs: key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} - name: Install SuiteSparse and SUNDIALS on GNU/Linux - if: matrix.os == 'ubuntu-latest' run: nox -s pybamm-requires - name: Run unit tests for Ubuntu with Python 3.11 and generate coverage report - env: - SUNDIALS_INST: ${{ env.HOME }}/.local - LD_LIBRARY_PATH: ${{ env.HOME }}/.local/lib run: nox -s coverage - name: Upload coverage report From a226530e37378dde6e9d781286732e753d5308e9 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 19:01:50 +0530 Subject: [PATCH 062/129] Add initial documentation for docker --- .../installation/install-from-docker.rst | 44 ++++++++++++++++++- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 399fa65547..6104fe27af 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -5,5 +5,45 @@ Install using Docker (developer install) This page describes the build and installation of PyBaMM from the source code, available on GitHub. Note that this is **not the recommended approach for most users** and should be reserved to people wanting to participate in the development of PyBaMM, or people who really need to use bleeding-edge feature(s) not yet available in the latest released version. If you do not fall in the two previous categories, you would be better off installing PyBaMM using pip or conda. -Lastly, familiarity with the Python ecosystem is recommended (pip, virtualenvs). -Here is a gentle introduction/refresher: `Python Virtual Environments: A Primer `_. \ No newline at end of file +Prerequisites +------------- +Before you begin, make sure you have Docker installed on your system. You can download and install Docker from the official `Docker website `_. +Ensure Docker installation by running : + +.. code:: bash + + docker --version + +Pulling the Docker Image +------------------------ +Use the following command to pull the PyBaMM Docker image from Docker Hub: + +.. code:: bash + + docker pull pybamm/pybamm:latest + +Running the Docker Container +---------------------------- + +Once you have pulled the Docker image, you can run a Docker container with the PyBaMM environment: + +1. In your terminal, use the following command to start a Docker container from the pulled image: + +.. code-block:: bash + + docker run -it pybamm/pybamm:latest + +2. You will now be inside the Docker container's shell. You can use PyBaMM and its dependencies as if you were in a virtual environment. + +3. You can execute PyBaMM-related commands, run tests develop & contribute from the container. + +Exiting the Docker Container +--------------------------- + +To exit the Docker container's shell, you can simply type: + +.. code-block:: bash + + exit + +This will return you to your host machine's terminal. From 3eca42de8b3c150c56e21867672b22d1f978042d Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 19:53:14 +0530 Subject: [PATCH 063/129] Add `nox` to `[dev]` --- Dockerfile | 8 +++++--- docs/source/user_guide/installation/index.rst | 3 ++- .../user_guide/installation/install-from-docker.rst | 2 ++ setup.py | 3 ++- 4 files changed, 11 insertions(+), 5 deletions(-) diff --git a/Dockerfile b/Dockerfile index 202f40d092..54bfc828eb 100644 --- a/Dockerfile +++ b/Dockerfile @@ -37,18 +37,20 @@ RUN if [ "$IDAKLU" = "true" ]; then \ pip install cmake==3.22 && \ python scripts/install_KLU_Sundials.py && \ git clone https://github.com/pybind/pybind11.git && \ - pip install --user -e ".[all]"; \ + pip install --user -e ".[all,dev]"; \ fi RUN if [ "$ODES" = "true" ]; then \ pip install cmake==3.22 && \ pip install --upgrade --user pip wget && \ python scripts/install_KLU_Sundials.py && \ - pip install --user -e ".[all,odes]"; \ + pip install --user -e ".[all,odes,dev]"; \ fi RUN if [ "$JAX" = "true" ]; then \ - pip install --user -e ".[jax,all]";\ + pip install --user -e ".[jax,all,dev]";\ fi +RUN pip install --user -e ".[all] + ENTRYPOINT ["/bin/bash"] diff --git a/docs/source/user_guide/installation/index.rst b/docs/source/user_guide/installation/index.rst index 166bef64d7..34cef1fa5a 100644 --- a/docs/source/user_guide/installation/index.rst +++ b/docs/source/user_guide/installation/index.rst @@ -236,4 +236,5 @@ Installing a specific version? Installing from source? Check the advanced instal GNU-linux windows windows-wsl - install-from-source \ No newline at end of file + install-from-source + install-from-docker \ No newline at end of file diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 6104fe27af..fb3596dc20 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -47,3 +47,5 @@ To exit the Docker container's shell, you can simply type: exit This will return you to your host machine's terminal. + + diff --git a/setup.py b/setup.py index a391d42fc8..ef9f6a3a9d 100644 --- a/setup.py +++ b/setup.py @@ -253,7 +253,8 @@ def compile_KLU(): ], "dev": [ "pre-commit", # For code style checking - "ruff", # For code style auto-formatting + "ruff", # For code style auto-formatting + "nox", # For running testing sessions ], "jax": [ "jax==0.4.8", From 6e481b4a9eb38842b3dbebdc287a9f389bdbaf7d Mon Sep 17 00:00:00 2001 From: Arjun Date: Sat, 12 Aug 2023 20:29:23 +0530 Subject: [PATCH 064/129] Update Dockerfile Co-authored-by: Saransh Chopra --- Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Dockerfile b/Dockerfile index 54bfc828eb..999cc77740 100644 --- a/Dockerfile +++ b/Dockerfile @@ -51,6 +51,6 @@ RUN if [ "$JAX" = "true" ]; then \ pip install --user -e ".[jax,all,dev]";\ fi -RUN pip install --user -e ".[all] +RUN pip install --user -e ".[all]" ENTRYPOINT ["/bin/bash"] From 1a3107e8799f801b4563999b42b90ec1d11924c6 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 12 Aug 2023 20:39:02 +0530 Subject: [PATCH 065/129] Squash merge --- .all-contributorsrc | 20 +- .git-blame-ignore-revs | 2 + .github/PULL_REQUEST_TEMPLATE.md | 8 +- .github/workflows/benchmark_on_push.yml | 6 + .github/workflows/lychee_url_checker.yml | 5 +- .github/workflows/need_reply_remove.yml | 4 +- .github/workflows/needs_reply.yml | 4 +- .github/workflows/run_periodic_tests.yml | 8 +- .github/workflows/test_on_push.yml | 71 +-- .pre-commit-config.yaml | 22 +- .readthedocs.yaml | 12 +- CHANGELOG.md | 16 +- CMakeLists.txt | 8 +- FindSuiteSparse.cmake | 3 +- README.md | 13 +- benchmarks/__init__.py | 1 - build_manylinux_wheels/Dockerfile | 2 +- build_manylinux_wheels/install_sundials.sh | 1 - docs/Makefile | 1 - docs/_static/index-images/api.svg | 42 +- docs/_static/index-images/contributor.svg | 2 +- docs/_static/index-images/examples.svg | 2 +- docs/_static/index-images/getting_started.svg | 42 +- docs/_static/pybamm.css | 55 +-- docs/conf.py | 2 +- docs/index.rst | 4 +- docs/requirements.txt | 36 -- docs/source/api/batch_study.rst | 2 +- .../api/experiment/experiment_steps.rst | 2 +- docs/source/api/expression_tree/array.rst | 2 +- docs/source/api/expression_tree/matrix.rst | 1 - .../expression_tree/operations/evaluate.rst | 3 +- docs/source/api/expression_tree/scalar.rst | 1 - docs/source/api/expression_tree/symbol.rst | 1 - docs/source/api/expression_tree/variable.rst | 1 - docs/source/api/geometry/index.rst | 1 - docs/source/api/index.rst | 2 +- docs/source/api/meshes/meshes.rst | 2 +- .../models/base_models/base_battery_model.rst | 2 +- docs/source/api/models/base_models/event.rst | 2 - docs/source/api/models/index.rst | 2 +- docs/source/api/models/lead_acid/full.rst | 2 +- docs/source/api/models/lithium_ion/index.rst | 2 +- .../api/models/lithium_ion/yang2017.rst | 1 - .../active_material/base_active_material.rst | 1 - .../constant_active_material.rst | 2 - .../submodels/active_material/index.rst | 1 - .../active_material/loss_active_material.rst | 2 +- .../api/models/submodels/base_submodel.rst | 1 - .../models/submodels/electrode/ohm/index.rst | 2 +- .../base_electrolyte_conductivity.rst | 1 - .../full_conductivity.rst | 1 - .../leading_order_conductivity.rst | 1 - .../surface_form/index.rst | 2 +- .../leading_surface_form_conductivity.rst | 2 +- .../constant_concentration.rst | 1 - .../electrolyte_diffusion/full_diffusion.rst | 1 - .../leading_order_diffusion.rst | 2 - .../ocv_element.rst | 1 - .../rc_element.rst | 1 - .../resistor_element.rst | 1 - .../equivalent_circuit_elements/thermal.rst | 1 - .../voltage_model.rst | 1 - .../function_control_external_circuit.rst | 2 +- .../interface/kinetics/base_kinetics.rst | 2 +- .../interface/kinetics/butler_volmer.rst | 2 +- .../kinetics/inverse_kinetics/index.rst | 2 +- .../inverse_butler_volmer.rst | 2 +- .../submodels/interface/kinetics/linear.rst | 2 +- .../submodels/interface/kinetics/marcus.rst | 2 +- .../interface/kinetics/no_reaction.rst | 2 +- .../submodels/interface/kinetics/tafel.rst | 2 +- .../kinetics/total_main_kinetics.rst | 2 +- .../interface/lithium_plating/index.rst | 2 +- .../open_circuit_potential/base_ocp.rst | 2 +- .../current_sigmoid_ocp.rst | 1 - .../submodels/interface/sei/base_sei.rst | 2 +- .../submodels/interface/sei/constant_sei.rst | 2 +- .../models/submodels/interface/sei/index.rst | 2 +- .../models/submodels/interface/sei/no_sei.rst | 2 +- .../submodels/interface/sei/total_sei.rst | 2 +- .../api/models/submodels/particle/index.rst | 2 +- .../submodels/porosity/base_porosity.rst | 1 - .../submodels/porosity/constant_porosity.rst | 4 +- .../api/models/submodels/porosity/index.rst | 1 - .../porosity/reaction_driven_porosity.rst | 5 +- .../porosity/reaction_driven_porosity_ode.rst | 3 - .../models/submodels/thermal/base_thermal.rst | 1 - .../base_transport_efficiency.rst | 1 - .../bruggeman_transport_efficiency.rst | 5 +- .../submodels/transport_efficiency/index.rst | 1 - .../api/plotting/plot_summary_variables.rst | 2 +- .../api/plotting/plot_voltage_components.rst | 2 +- docs/source/api/plotting/quick_plot.rst | 2 +- docs/source/api/simulation.rst | 2 +- docs/source/api/solvers/index.rst | 1 - .../api/spatial_methods/finite_volume.rst | 1 - docs/source/examples/index.rst | 2 +- .../notebooks/models/jelly-roll-model.ipynb | 40 +- .../models/loss_of_active_materials.ipynb | 427 +++++++++++++++++ .../notebooks/models/pouch-cell-model.ipynb | 40 +- .../submodel_loss_of_active_materials.ipynb | 438 ------------------ .../notebooks/models/thermal-models.ipynb | 9 +- .../user_guide/installation/GNU-linux.rst | 2 +- docs/source/user_guide/installation/index.rst | 24 +- .../installation/install-from-docker.rst | 2 - .../installation/install-from-source.rst | 5 +- docs/sphinxext/inheritance_diagram.py | 21 +- .../compare_comsol/compare_comsol_DFN.py | 1 + examples/scripts/thermal_lithium_ion.py | 66 +-- noxfile.py | 42 +- pybamm/discretisations/discretisation.py | 10 +- pybamm/expression_tree/binary_operators.py | 32 +- pybamm/expression_tree/symbol.py | 27 +- .../0.1C_discharge_displacement.txt | 2 +- .../0.5C_discharge_displacement.txt | 2 +- .../1C_discharge_displacement.txt | 2 +- .../discharge_data/Enertech_cells/stn_2C.txt | 4 +- .../discharge_data/Enertech_cells/stp_2C.txt | 2 +- .../input/parameters/lead_acid/Sulzer2019.py | 19 +- pybamm/input/parameters/lithium_ion/Ai2020.py | 13 +- .../input/parameters/lithium_ion/Chen2020.py | 19 +- .../lithium_ion/Chen2020_composite.py | 13 +- .../input/parameters/lithium_ion/Ecker2015.py | 39 +- .../parameters/lithium_ion/Marquis2019.py | 80 ++-- .../parameters/lithium_ion/Mohtat2020.py | 31 +- .../parameters/lithium_ion/NCA_Kim2011.py | 41 +- .../input/parameters/lithium_ion/OKane2022.py | 23 +- .../parameters/lithium_ion/ORegan2022.py | 56 ++- .../input/parameters/lithium_ion/Prada2013.py | 15 +- .../parameters/lithium_ion/Ramadass2004.py | 52 +-- pybamm/input/parameters/lithium_ion/Xu2019.py | 5 +- .../data/graphite_LGM50_ocp_Chen2020.csv | 2 +- .../data/graphite_ocp_Enertech_Ai2020.csv | 2 +- .../lithium_ion/data/lico2_ocp_Ai2020.csv | 2 +- .../lithium_ion/data/nca_ocp_Kim2011_data.csv | 2 +- .../data/nmc_LGM50_ocp_Chen2020.csv | 2 +- pybamm/meshes/meshes.py | 11 + pybamm/models/base_model.py | 5 + .../full_battery_models/base_battery_model.py | 30 +- .../active_material/loss_active_material.py | 13 + .../kinetics/inverse_kinetics/__init__.py | 1 - .../models/submodels/thermal/base_thermal.py | 2 + pybamm/models/submodels/thermal/lumped.py | 1 - .../pouch_cell_2D_current_collectors.py | 3 +- pybamm/models/submodels/thermal/x_full.py | 119 +++-- pybamm/parameters/geometric_parameters.py | 3 - pybamm/parameters/lead_acid_parameters.py | 13 +- pybamm/parameters/lithium_ion_parameters.py | 12 +- pybamm/parameters/process_parameter_data.py | 50 +- .../size_distribution_parameters.py | 6 - pybamm/simulation.py | 2 +- .../c_solvers/idaklu/casadi_functions.cpp | 4 +- .../c_solvers/idaklu/casadi_solver.cpp | 16 +- .../c_solvers/idaklu/casadi_solver.hpp | 4 +- .../idaklu/casadi_sundials_functions.cpp | 6 +- pybamm/solvers/c_solvers/idaklu/common.hpp | 4 +- pybamm/solvers/c_solvers/idaklu/options.cpp | 8 +- pybamm/solvers/c_solvers/idaklu/options.hpp | 4 +- pybamm/solvers/c_solvers/idaklu/python.cpp | 43 +- pybamm/solvers/c_solvers/idaklu/python.hpp | 8 +- pybamm/solvers/processed_variable.py | 111 ++--- requirements.txt | 19 - run-tests.py | 11 +- .../sundials-3.1.1/CMakeLists.txt | 34 +- .../sundials-4.1.0/CMakeLists.txt | 1 - .../sundials-5.0.0/CMakeLists.txt | 1 - setup.py | 5 +- tests/__init__.py | 1 + .../test_models/standard_output_tests.py | 3 + .../base_lithium_ion_tests.py | 28 ++ .../test_finite_volume.py | 45 ++ tests/shared.py | 6 + .../test_binary_operators.py | 20 + .../unit/test_expression_tree/test_symbol.py | 4 + tests/unit/test_meshes/test_meshes.py | 6 + .../test_base_battery_model.py | 2 +- .../base_lithium_ion_tests.py | 8 + .../test_lithium_ion/test_mpm.py | 4 +- .../test_lithium_ion/test_mpm_half_cell.py | 4 +- .../test_size_distribution_parameters.py | 3 - .../test_solvers/test_processed_variable.py | 312 +++++++++++-- 182 files changed, 1728 insertions(+), 1399 deletions(-) delete mode 100644 docs/requirements.txt create mode 100644 docs/source/examples/notebooks/models/loss_of_active_materials.ipynb delete mode 100644 docs/source/examples/notebooks/models/submodel_loss_of_active_materials.ipynb delete mode 100644 requirements.txt diff --git a/.all-contributorsrc b/.all-contributorsrc index 3c2d5e6c27..eef8a5aa16 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -331,7 +331,8 @@ "example", "doc", "test", - "tutorial" + "tutorial", + "review" ] }, { @@ -610,7 +611,9 @@ "avatar_url": "https://avatars.githubusercontent.com/u/104268427?v=4", "profile": "https://github.com/arjxn-py", "contributions": [ - "infra" + "infra", + "code", + "doc" ] }, { @@ -629,7 +632,8 @@ "profile": "https://www.aboutenergy.io/", "contributions": [ "code", - "bug" + "bug", + "ideas" ] }, { @@ -660,6 +664,16 @@ "code", "test" ] + }, + { + "login": "ejfdickinson", + "name": "ejfdickinson", + "avatar_url": "https://avatars.githubusercontent.com/u/116663050?v=4", + "profile": "https://github.com/ejfdickinson", + "contributions": [ + "ideas", + "bug" + ] } ], "contributorsPerLine": 7, diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs index e0aa2cf0ab..228a76373e 100644 --- a/.git-blame-ignore-revs +++ b/.git-blame-ignore-revs @@ -2,3 +2,5 @@ 0054efe388d2d17301f7e0554449eac9a7d3b7fc # activated pre-commit for notebooks - https://github.com/pybamm-team/PyBaMM/pull/3110 a63e49ece0f9336d1f5c2562f7459e555c6e6693 +# activated standard pre-commits - https://github.com/pybamm-team/PyBaMM/pull/3192 +5273214b585c5a4286609aed40e0b092d0e05f42 diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md index e0fc7df49b..4c6f9bd6c6 100644 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -14,11 +14,11 @@ Please add a line in the relevant section of [CHANGELOG.md](https://github.com/p # Key checklist: -- [ ] No style issues: `$ pre-commit run` (see [CONTRIBUTING.md](https://github.com/pybamm-team/PyBaMM/blob/develop/CONTRIBUTING.md#installing-and-using-pre-commit) for how to set this up to run automatically when committing locally, in just two lines of code) -- [ ] All tests pass: `$ python run-tests.py --all` -- [ ] The documentation builds: `$ python run-tests.py --doctest` +- [ ] No style issues: `$ pre-commit run` (or `$ nox -s pre-commit`) (see [CONTRIBUTING.md](https://github.com/pybamm-team/PyBaMM/blob/develop/CONTRIBUTING.md#installing-and-using-pre-commit) for how to set this up to run automatically when committing locally, in just two lines of code) +- [ ] All tests pass: `$ python run-tests.py --all` (or `$ nox -s tests`) +- [ ] The documentation builds: `$ python run-tests.py --doctest` (or `$ nox -s doctests`) -You can run unit and doctests together at once, using `$ python run-tests.py --quick`. +You can run integration tests, unit tests, and doctests together at once, using `$ python run-tests.py --quick` (or `$ nox -s quick`). ## Further checks: diff --git a/.github/workflows/benchmark_on_push.yml b/.github/workflows/benchmark_on_push.yml index ad6ad1e708..07747af58c 100644 --- a/.github/workflows/benchmark_on_push.yml +++ b/.github/workflows/benchmark_on_push.yml @@ -1,8 +1,14 @@ name: Run benchmarks on push on: push: + branches: [main, develop] pull_request: +concurrency: + # Cancel intermediate builds always + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + jobs: benchmarks: runs-on: ubuntu-latest diff --git a/.github/workflows/lychee_url_checker.yml b/.github/workflows/lychee_url_checker.yml index e99ba9c290..86a282b57c 100644 --- a/.github/workflows/lychee_url_checker.yml +++ b/.github/workflows/lychee_url_checker.yml @@ -15,7 +15,7 @@ jobs: runs-on: ubuntu-latest steps: - # cache Lychee results to avoid hitting rate limits + # cache Lychee results to avoid hitting rate limits - name: Restore lychee cache uses: actions/cache@v3 with: @@ -41,8 +41,9 @@ jobs: --exclude-loopback --exclude https://twitter.com/pybamm_ --exclude "https://doi\.org|www.sciencedirect\.com/*" + --exclude https://www.rse.ox.ac.uk --accept 200,429 - --exclude-path ./CHANGELOG.md + --exclude-path ./CHANGELOG.md --exclude-path ./scripts/update_version.py './**/*.rst' './**/*.md' diff --git a/.github/workflows/need_reply_remove.yml b/.github/workflows/need_reply_remove.yml index 59f9a839ed..959891aec8 100644 --- a/.github/workflows/need_reply_remove.yml +++ b/.github/workflows/need_reply_remove.yml @@ -11,7 +11,7 @@ jobs: if: | github.event.comment.author_association != 'OWNER' && github.event.comment.author_association != 'COLLABORATOR' && - github.repository-owner == 'pybamm-team' + github.repository_owner == 'pybamm-team' steps: - name: Remove needs-reply label uses: octokit/request-action@v2.x @@ -22,4 +22,4 @@ jobs: issue: ${{ github.event.issue.number }} label: needs-reply env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/needs_reply.yml b/.github/workflows/needs_reply.yml index 8e9269001b..d2c836fc52 100644 --- a/.github/workflows/needs_reply.yml +++ b/.github/workflows/needs_reply.yml @@ -7,10 +7,10 @@ on: jobs: build: runs-on: ubuntu-latest - if: github.repository-owner == 'pybamm-team' + if: github.repository_owner == 'pybamm-team' steps: - name: Close old issues that need reply uses: dwieeb/needs-reply@v2 with: repo-token: ${{ secrets.GITHUB_TOKEN }} - issue-label: needs-reply \ No newline at end of file + issue-label: needs-reply diff --git a/.github/workflows/run_periodic_tests.yml b/.github/workflows/run_periodic_tests.yml index 41e4a9de8a..5027d877ac 100644 --- a/.github/workflows/run_periodic_tests.yml +++ b/.github/workflows/run_periodic_tests.yml @@ -1,11 +1,11 @@ -# Run all unit tests and integration tests for all Python versions +# Run all unit tests and integration tests for all Python versions # and platforms at 3am UTC every day and on PRs to the main branch name: Scheduled on: workflow_dispatch: pull_request: - branches: + branches: - main # Run everyday at 3 am UTC @@ -119,13 +119,13 @@ jobs: build-apple-mseries: needs: style runs-on: [self-hosted, macOS, ARM64] - env: + env: GITHUB_PATH: ${PYENV_ROOT/bin:$PATH} strategy: fail-fast: false matrix: python-version: ["3.8", "3.9", "3.10", "3.11"] - + steps: - uses: actions/checkout@v3 - name: Install python & create virtualenv diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 3a1142c939..8fb1aae588 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -45,12 +45,8 @@ jobs: python-version: ["3.8", "3.9", "3.10", "3.11"] steps: - - uses: actions/checkout@v3 - - id: setup-python - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v4 - with: - python-version: ${{ matrix.python-version }} + - name: Check out PyBaMM repository + uses: actions/checkout@v3 # Install and cache apt packages - name: Install Linux system dependencies @@ -68,24 +64,17 @@ jobs: sudo dot -c sudo apt-get install libopenblas-dev texlive-latex-extra dvipng - # Added fixes to homebrew installs: - # rm -f /usr/local/bin/2to3 - # (see https://github.com/actions/virtual-environments/issues/2322) - name: Install macOS system dependencies if: matrix.os == 'macos-latest' env: # Homebrew environment variables HOMEBREW_NO_INSTALL_CLEANUP: 1 - HOMEBREW_NO_ANALYTICS: 1 - HOMEBREW_NO_GOOGLE_ANALYTICS: 1 HOMEBREW_NO_AUTO_UPDATE: 1 + HOMEBREW_NO_COLOR: 1 # Speed up CI NONINTERACTIVE: 1 run: | - rm -f /usr/local/bin/2to3* - rm -f /usr/local/bin/idle3* - rm -f /usr/local/bin/pydoc3* - rm -f /usr/local/bin/python3* + brew analytics off brew update brew install graphviz openblas @@ -93,10 +82,18 @@ jobs: if: matrix.os == 'windows-latest' run: choco install graphviz --version=8.0.5 - - name: Install standard Python dependencies + - name: Set up Python ${{ matrix.python-version }} + id: setup-python + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + cache: 'pip' + cache-dependency-path: setup.py + + - name: Install PyBaMM dependencies run: | - python -m pip install --upgrade pip wheel setuptools - python -m pip install nox + pip install --upgrade pip wheel setuptools nox + pip install -e .[all,docs] - name: Cache pybamm-requires nox environment for GNU/Linux uses: actions/cache@v3 @@ -104,37 +101,22 @@ jobs: with: path: | # Repository files - ${{ github.workspace }}/.nox/pybamm-requires/ ${{ github.workspace }}/pybind11/ ${{ github.workspace }}/install_KLU_Sundials/ # Headers and dynamic library files for SuiteSparse and SUNDIALS ${{ env.HOME }}/.local/lib/ ${{ env.HOME }}/.local/include/ ${{ env.HOME }}/.local/examples/ - key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/noxfile.py', '**/install_KLU_Sundials.py') }} + key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} - name: Install SuiteSparse and SUNDIALS on GNU/Linux if: matrix.os == 'ubuntu-latest' run: nox -s pybamm-requires - - name: Cache unit tests nox environment for GNU/Linux with Python 3.8, 3.9, and 3.10, and for macOS and Windows with all Python versions - uses: actions/cache@v3 - if: (matrix.os == 'ubuntu-latest' && matrix.python-version != 3.11) || (matrix.os != 'ubuntu-latest') - with: - path: ${{ github.workspace }}/.nox/unit/ - key: ${{ runner.os }}-nox-unit-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/noxfile.py', '**/setup.py') }} - - name: Run unit tests for GNU/Linux with Python 3.8, 3.9, and 3.10 and for macOS and Windows with all Python versions if: (matrix.os == 'ubuntu-latest' && matrix.python-version != 3.11) || (matrix.os != 'ubuntu-latest') run: nox -s unit - - name: Cache coverage nox environment for GNU/Linux with Python 3.11 - uses: actions/cache@v3 - if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 - with: - path: ${{ github.workspace }}/.nox/coverage/ - key: ${{ runner.os }}-nox-coverage-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/noxfile.py', '**/setup.py', '**/.coveragerc') }} - - name: Run unit tests for GNU/Linux with Python 3.11 and generate coverage report if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s coverage @@ -143,35 +125,14 @@ jobs: if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 uses: codecov/codecov-action@v2.1.0 - - name: Cache integration tests nox environment for GNU/Linux with Python 3.11 - uses: actions/cache@v3 - if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 - with: - path: ${{ github.workspace }}/.nox/integration/ - key: ${{ runner.os }}-nox-integration-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/noxfile.py', '**/setup.py') }} - - name: Run integration tests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s integration - - name: Cache doctests nox environment for GNU/Linux with Python 3.11 - uses: actions/cache@v3 - if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 - with: - path: ${{ github.workspace }}/.nox/doctests/ - key: ${{ runner.os }}-nox-doctests-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/noxfile.py', '**/setup.py', '**/docs/requirements.txt') }} - - name: Install docs dependencies and run doctests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s doctests - - name: Cache examples nox environment for GNU/Linux with Python 3.11 - uses: actions/cache@v3 - if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 - with: - path: ${{ github.workspace }}/.nox/examples/ - key: ${{ runner.os }}-nox-examples-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/noxfile.py', '**/setup.py') }} - - name: Install dev dependencies and run example tests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s examples diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index df805f100c..1cde3c7019 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ ci: repos: - repo: https://github.com/astral-sh/ruff-pre-commit - rev: "v0.0.281" + rev: "v0.0.282" hooks: - id: ruff args: [--fix, --ignore=E741, --exclude=__init__.py] @@ -21,3 +21,23 @@ repos: hooks: - id: blacken-docs additional_dependencies: [black==22.12.0] + + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.4.0 + hooks: + - id: check-added-large-files + - id: check-case-conflict + - id: check-merge-conflict + - id: check-yaml + - id: debug-statements + - id: end-of-file-fixer + - id: mixed-line-ending + - id: trailing-whitespace + + - repo: https://github.com/pre-commit/pygrep-hooks + rev: v1.10.0 + hooks: + - id: python-check-blanket-type-ignore + - id: rst-backticks + - id: rst-directive-colons + - id: rst-inline-touching-normal diff --git a/.readthedocs.yaml b/.readthedocs.yaml index 41e4653566..d97966ee38 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -1,4 +1,4 @@ -# .readthedocs.yml +# .readthedocs.yaml # Read the Docs configuration file # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details @@ -34,7 +34,9 @@ build: # Optionally declare the Python requirements required to build your docs python: - install: - - requirements: docs/requirements.txt - - method: pip - path: . + install: + - method: pip + path: . + extra_requirements: + - docs + - all diff --git a/CHANGELOG.md b/CHANGELOG.md index 678ada7911..6488dbef4d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,11 +1,12 @@ # [Unreleased](https://github.com/pybamm-team/PyBaMM/) +## Features +- Spherical and cylindrical shell domains can now be solved with any boundary conditions ([#3237](https://github.com/pybamm-team/PyBaMM/pull/3237)) +- Processed variables now get the spatial variables automatically, allowing plotting of more generic models ([#3234](https://github.com/pybamm-team/PyBaMM/pull/3234)) + ## Breaking changes -- Added option to use an empirical hysteresis model for the diffusivity and exchange-current density ([#3194](https://github.com/pybamm-team/PyBaMM/pull/3194)) -- Double-layer capacity can now be provided as a function of temperature ([#3174](https://github.com/pybamm-team/PyBaMM/pull/3174)) -- `pybamm_install_jax` is deprecated. It is now replaced with `pip install pybamm[jax]` ([#3163](https://github.com/pybamm-team/PyBaMM/pull/3163)) -- PyBaMM now has optional dependencies that can be installed with the pattern `pip install pybamm[option]` e.g. `pybamm[plot]` ([#3044](https://github.com/pybamm-team/PyBaMM/pull/3044)) +- Numpy functions now work with PyBaMM symbols (e.g. `np.exp(pybamm.Symbol("a"))` returns `pybamm.Exp(pybamm.Symbol("a"))`). This means that parameter functions can be specified using numpy functions instead of pybamm functions. Additionally, combining numpy arrays with pybamm objects now works (the numpy array is converted to a pybamm array) ([#3205](https://github.com/pybamm-team/PyBaMM/pull/3205)) ## Bug fixes @@ -17,6 +18,13 @@ - Thevenin() model is now constructed with standard variables: `Time [s], Time [min], Time [h]` ([#3143](https://github.com/pybamm-team/PyBaMM/pull/3143)) - Fix SEI Example Notebook ([#3166](https://github.com/pybamm-team/PyBaMM/pull/3166)) +## Breaking changes + +- Added option to use an empirical hysteresis model for the diffusivity and exchange-current density ([#3194](https://github.com/pybamm-team/PyBaMM/pull/3194)) +- Double-layer capacity can now be provided as a function of temperature ([#3174](https://github.com/pybamm-team/PyBaMM/pull/3174)) +- `pybamm_install_jax` is deprecated. It is now replaced with `pip install pybamm[jax]` ([#3163](https://github.com/pybamm-team/PyBaMM/pull/3163)) +- PyBaMM now has optional dependencies that can be installed with the pattern `pip install pybamm[option]` e.g. `pybamm[plot]` ([#3044](https://github.com/pybamm-team/PyBaMM/pull/3044)) + # [v23.5](https://github.com/pybamm-team/PyBaMM/tree/v23.5) - 2023-06-18 ## Features diff --git a/CMakeLists.txt b/CMakeLists.txt index cc47ba99c0..c3c5141d4f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,7 +34,7 @@ if(NOT PYBIND11_DIR) endif() add_subdirectory(${PYBIND11_DIR}) -pybind11_add_module(idaklu +pybind11_add_module(idaklu pybamm/solvers/c_solvers/idaklu/casadi_functions.cpp pybamm/solvers/c_solvers/idaklu/casadi_functions.hpp pybamm/solvers/c_solvers/idaklu/casadi_solver.cpp @@ -56,7 +56,7 @@ if (NOT DEFINED USE_PYTHON_CASADI) endif() execute_process( - COMMAND "${PYTHON_EXECUTABLE}" -c + COMMAND "${PYTHON_EXECUTABLE}" -c "import casadi as _; print(_.__path__[0])" OUTPUT_VARIABLE CASADI_DIR OUTPUT_STRIP_TRAILING_WHITESPACE) @@ -67,7 +67,7 @@ endif() message("Found python casadi path: ${CASADI_DIR}") if(${USE_PYTHON_CASADI}) - message("Trying to link against python casadi package") + message("Trying to link against python casadi package") find_package(casadi CONFIG PATHS ${CASADI_DIR} REQUIRED) else() message("Trying to link against any casadi package apart from the python one") @@ -78,7 +78,7 @@ endif() set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}) # Sundials find_package(SUNDIALS REQUIRED) -message("sundials ${SUNDIALS_INCLUDE_DIR} ${SUNDIALS_LIBRARIES}") +message("sundials ${SUNDIALS_INCLUDE_DIR} ${SUNDIALS_LIBRARIES}") target_include_directories(idaklu PRIVATE ${SUNDIALS_INCLUDE_DIR}) target_link_libraries(idaklu PRIVATE ${SUNDIALS_LIBRARIES} casadi) diff --git a/FindSuiteSparse.cmake b/FindSuiteSparse.cmake index 532007e7ae..c5275c02c0 100644 --- a/FindSuiteSparse.cmake +++ b/FindSuiteSparse.cmake @@ -1,4 +1,4 @@ -# This CMakeFile is adapted from that in dune-common: +# This CMakeFile is adapted from that in dune-common: # .. cmake_module:: # @@ -239,4 +239,3 @@ endif() #set HAVE_SUITESPARSE for config.h set(HAVE_SUITESPARSE ${SuiteSparse_FOUND}) set(HAVE_UMFPACK ${SuiteSparse_UMFPACK_FOUND}) - diff --git a/README.md b/README.md index 3eff39b8c4..72d39b927d 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ [![code style](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) -[![All Contributors](https://img.shields.io/badge/all_contributors-60-orange.svg)](#-contributors) +[![All Contributors](https://img.shields.io/badge/all_contributors-61-orange.svg)](#-contributors) @@ -41,8 +41,8 @@ pay for developer time, professional services, travel, workshops, and a variety @@ -214,7 +214,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d WEILONG AI
WEILONG AI
💻 💡 ⚠️ lonnbornj
lonnbornj
💻 ⚠️ 💡 Priyanshu Agarwal
Priyanshu Agarwal
⚠️ 💻 🐛 👀 🚧 ✅ - DrSOKane
DrSOKane
💻 💡 📖 ⚠️ ✅ + DrSOKane
DrSOKane
💻 💡 📖 ⚠️ ✅ 👀 Saransh Chopra
Saransh Chopra
💻 ⚠️ 📖 ✅ 👀 🚧 @@ -250,14 +250,15 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d Jerom Palimattom Tom
Jerom Palimattom Tom
📖 💻 ⚠️ Brady Planden
Brady Planden
💡 jsbrittain
jsbrittain
💻 ⚠️ - Arjun
Arjun
🚇 + Arjun
Arjun
🚇 💻 📖 CHEN ZHAO
CHEN ZHAO
🐛 - darryl-ad
darryl-ad
💻 🐛 + darryl-ad
darryl-ad
💻 🐛 🤔 julian-evers
julian-evers
💻 Jason Siegel
Jason Siegel
💻 🤔 Tom Maull
Tom Maull
💻 ⚠️ + ejfdickinson
ejfdickinson
🤔 🐛 diff --git a/benchmarks/__init__.py b/benchmarks/__init__.py index 8b13789179..e69de29bb2 100644 --- a/benchmarks/__init__.py +++ b/benchmarks/__init__.py @@ -1 +0,0 @@ - diff --git a/build_manylinux_wheels/Dockerfile b/build_manylinux_wheels/Dockerfile index efaef13a1f..a6c2dcc41c 100644 --- a/build_manylinux_wheels/Dockerfile +++ b/build_manylinux_wheels/Dockerfile @@ -15,4 +15,4 @@ RUN chmod +x /entrypoint.sh RUN ./install_sundials.sh -ENTRYPOINT ["/entrypoint.sh"] \ No newline at end of file +ENTRYPOINT ["/entrypoint.sh"] diff --git a/build_manylinux_wheels/install_sundials.sh b/build_manylinux_wheels/install_sundials.sh index e97817a367..709d9c13c7 100644 --- a/build_manylinux_wheels/install_sundials.sh +++ b/build_manylinux_wheels/install_sundials.sh @@ -78,4 +78,3 @@ cmake -DENABLE_LAPACK=ON\ -DCMAKE_INSTALL_PREFIX=/usr\ ../$SUNDIALS_DIR make install - diff --git a/docs/Makefile b/docs/Makefile index b454275837..46d9ea6f19 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -17,4 +17,3 @@ help: # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) - diff --git a/docs/_static/index-images/api.svg b/docs/_static/index-images/api.svg index e637525cc0..2cbc9a9403 100644 --- a/docs/_static/index-images/api.svg +++ b/docs/_static/index-images/api.svg @@ -5,27 +5,27 @@ - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/_static/index-images/contributor.svg b/docs/_static/index-images/contributor.svg index 3a689e0e4c..b03a9a2b19 100644 --- a/docs/_static/index-images/contributor.svg +++ b/docs/_static/index-images/contributor.svg @@ -1 +1 @@ - \ No newline at end of file + diff --git a/docs/_static/index-images/examples.svg b/docs/_static/index-images/examples.svg index d61b0937da..a8057b819b 100644 --- a/docs/_static/index-images/examples.svg +++ b/docs/_static/index-images/examples.svg @@ -1 +1 @@ - \ No newline at end of file + diff --git a/docs/_static/index-images/getting_started.svg b/docs/_static/index-images/getting_started.svg index 04db7e6156..463ef73e34 100644 --- a/docs/_static/index-images/getting_started.svg +++ b/docs/_static/index-images/getting_started.svg @@ -5,27 +5,27 @@ - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/_static/pybamm.css b/docs/_static/pybamm.css index 8a6c07887c..a795e50f23 100644 --- a/docs/_static/pybamm.css +++ b/docs/_static/pybamm.css @@ -1,41 +1,11 @@ -@import url("https://fonts.googleapis.com/css2?family=Lato:ital,wght@0,400;0,700;0,900;1,400;1,700;1,900&family=Open+Sans:ital,wght@0,400;0,600;1,400;1,600&display=swap"); - -.navbar-brand img { - height: 50px; -} +/* Font */ -.navbar-brand { - height: 50px; -} +@import url("https://fonts.googleapis.com/css2?family=Lato:ital,wght@0,400;0,700;0,900;1,400;1,700;1,900&family=Open+Sans:ital,wght@0,400;0,600;1,400;1,600&display=swap"); body { font-family: "Open Sans", sans-serif; } -pre, -code { - font-size: 100%; - line-height: 155%; -} - -h1 { - font-family: "Lato", sans-serif; - color: #013243; - /* warm black */ -} - -h2 { - color: #4d77cf; - /* han blue */ - letter-spacing: -0.03em; -} - -h3 { - color: #013243; - /* warm black */ - letter-spacing: -0.03em; -} - /* Main page overview cards */ .sd-card { @@ -81,18 +51,18 @@ h3 { } /* Dark theme tweaking */ + html[data-theme="dark"] .sd-card img[src*=".svg"] { filter: invert(0.82) brightness(0.8) contrast(1.2); } /* Main index page overview cards */ + html[data-theme="dark"] .sd-card { background-color: var(--pst-color-background); } -html[data-theme="dark"] .sd-shadow-sm { - box-shadow: 0 0.1rem 1rem rgba(250, 250, 250, 0.6) !important; -} +/* Inheritance diagram dropdown options */ html[data-theme="dark"] .sd-card .sd-card-header { background-color: var(--pst-color-background); @@ -103,12 +73,12 @@ html[data-theme="dark"] .sd-card .sd-card-footer { background-color: var(--pst-color-background); } -html[data-theme="dark"] h1 { - color: var(--pst-color-primary); +details.sd-dropdown { + box-shadow: none !important; } -html[data-theme="dark"] h3 { - color: #0a6774; +.sd-summary-content blockquote { + border-left: 0 !important; } /* Overrides for sphinx-hoverxref since it does not support a native dark theme, see */ @@ -139,6 +109,12 @@ html[data-theme="dark"] h3 { @import url("https://cdn.jsdelivr.net/npm/@docsearch/css@3"); +/* Remove the default PST search */ + +div.search-button__wrapper.show { + visibility: hidden; +} + .DocSearch-Modal { margin: 150px auto auto; background: var(--pst-color-background); @@ -158,6 +134,7 @@ kbd.DocSearch-Commands-Key { .DocSearch-Button-Key { width: 24px; } + /* Do not add custom padding for keyboard buttons */ kbd:not(.compound) { diff --git a/docs/conf.py b/docs/conf.py index 43f71f704e..336fa15743 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -314,7 +314,7 @@

An interactive online version of this notebook is available, which can be accessed via - Open this notebook in Google Colab diff --git a/docs/index.rst b/docs/index.rst index 21b224a331..3e5d54ecb5 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -28,7 +28,7 @@ PyBaMM documentation PyBaMM (Python Battery Mathematical Modelling) is an open-source battery simulation package written in Python. Our mission is to accelerate battery modelling research by -providing open-source tools for multi-institutional, interdisciplinary collaboration. +providing open-source tools for multi-institutional, interdisciplinary collaboration. Broadly, PyBaMM consists of #. a framework for writing and solving systems of differential equations, @@ -57,7 +57,7 @@ explore the effect of different battery designs and modeling assumptions under a :click-parent: To the user guide - + .. grid-item-card:: :img-top: _static/index-images/examples.svg diff --git a/docs/requirements.txt b/docs/requirements.txt deleted file mode 100644 index 08077d2f88..0000000000 --- a/docs/requirements.txt +++ /dev/null @@ -1,36 +0,0 @@ -# Requirements for readthedocs.io -numpy >= 1.16 -scipy >= 1.3 -pandas >= 0.24 -anytree >= 2.4.3 -autograd >= 1.2 -scikit-fem >= 0.2.0 -casadi >= 3.6.0 -imageio>=2.9.0 -jupyter # For example notebooks -pybtex -sympy >= 1.8 -xarray -tqdm -# Note: Matplotlib is loaded for debug plots but to ensure pybamm runs -# on systems without an attached display it should never be imported -# outside of plot() methods. -# Should not be imported -matplotlib >= 2.0 -# -sphinx>6.0 -sphinx_rtd_theme>=0.5 -pydata-sphinx-theme -sphinx_design -sphinx-copybutton -myst-parser -sphinx-inline-tabs -sphinxcontrib-bibtex -sphinx-last-updated-by-git -nbsphinx -ipython -ipykernel -ipywidgets -sphinx-gallery -sphinx-hoverxref -sphinx-docsearch diff --git a/docs/source/api/batch_study.rst b/docs/source/api/batch_study.rst index f00a2b1657..51e927d856 100644 --- a/docs/source/api/batch_study.rst +++ b/docs/source/api/batch_study.rst @@ -2,4 +2,4 @@ Batch Study =========== .. autoclass:: pybamm.BatchStudy - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/experiment/experiment_steps.rst b/docs/source/api/experiment/experiment_steps.rst index a4637a866b..55de9d17bf 100644 --- a/docs/source/api/experiment/experiment_steps.rst +++ b/docs/source/api/experiment/experiment_steps.rst @@ -17,4 +17,4 @@ These functions return the following step class, which is not intended to be use directly: .. autoclass:: pybamm.step._Step - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/expression_tree/array.rst b/docs/source/api/expression_tree/array.rst index a84a856a19..7b398ea8e7 100644 --- a/docs/source/api/expression_tree/array.rst +++ b/docs/source/api/expression_tree/array.rst @@ -6,4 +6,4 @@ Array .. autofunction:: pybamm.linspace -.. autofunction:: pybamm.meshgrid +.. autofunction:: pybamm.meshgrid diff --git a/docs/source/api/expression_tree/matrix.rst b/docs/source/api/expression_tree/matrix.rst index 71a281bd8a..c07c9c4462 100644 --- a/docs/source/api/expression_tree/matrix.rst +++ b/docs/source/api/expression_tree/matrix.rst @@ -3,4 +3,3 @@ Matrix .. autoclass:: pybamm.Matrix :members: - diff --git a/docs/source/api/expression_tree/operations/evaluate.rst b/docs/source/api/expression_tree/operations/evaluate.rst index ab3e9e14f2..6429c1f370 100644 --- a/docs/source/api/expression_tree/operations/evaluate.rst +++ b/docs/source/api/expression_tree/operations/evaluate.rst @@ -1,6 +1,5 @@ -EvaluatorPython +EvaluatorPython =============== .. autoclass:: pybamm.EvaluatorPython :members: - diff --git a/docs/source/api/expression_tree/scalar.rst b/docs/source/api/expression_tree/scalar.rst index e02ee39bf8..ca5ea1aae3 100644 --- a/docs/source/api/expression_tree/scalar.rst +++ b/docs/source/api/expression_tree/scalar.rst @@ -3,4 +3,3 @@ Scalar .. autoclass:: pybamm.Scalar :members: - diff --git a/docs/source/api/expression_tree/symbol.rst b/docs/source/api/expression_tree/symbol.rst index be252c9b06..41f390e1ac 100644 --- a/docs/source/api/expression_tree/symbol.rst +++ b/docs/source/api/expression_tree/symbol.rst @@ -5,4 +5,3 @@ Symbol .. autoclass:: pybamm.Symbol :special-members: :members: - diff --git a/docs/source/api/expression_tree/variable.rst b/docs/source/api/expression_tree/variable.rst index ab42f76bcf..8028ceaf56 100644 --- a/docs/source/api/expression_tree/variable.rst +++ b/docs/source/api/expression_tree/variable.rst @@ -6,4 +6,3 @@ Variable .. autoclass:: pybamm.VariableDot :members: - diff --git a/docs/source/api/geometry/index.rst b/docs/source/api/geometry/index.rst index b63b5ce82c..0dd5fc294c 100644 --- a/docs/source/api/geometry/index.rst +++ b/docs/source/api/geometry/index.rst @@ -5,4 +5,3 @@ Geometry geometry battery_geometry - diff --git a/docs/source/api/index.rst b/docs/source/api/index.rst index 34c888339d..432461a58e 100644 --- a/docs/source/api/index.rst +++ b/docs/source/api/index.rst @@ -29,4 +29,4 @@ For a high-level introduction to PyBaMM, see the :ref:`user guide ` util callbacks citations - batch_study \ No newline at end of file + batch_study diff --git a/docs/source/api/meshes/meshes.rst b/docs/source/api/meshes/meshes.rst index 671839c278..db96c58f00 100644 --- a/docs/source/api/meshes/meshes.rst +++ b/docs/source/api/meshes/meshes.rst @@ -6,6 +6,6 @@ Meshes .. autoclass:: pybamm.SubMesh :members: - + .. autoclass:: pybamm.MeshGenerator :members: diff --git a/docs/source/api/models/base_models/base_battery_model.rst b/docs/source/api/models/base_models/base_battery_model.rst index 64715ae5d4..1ce24ebdeb 100644 --- a/docs/source/api/models/base_models/base_battery_model.rst +++ b/docs/source/api/models/base_models/base_battery_model.rst @@ -7,4 +7,4 @@ Base Battery Model :members: .. autoclass:: pybamm.BatteryModelOptions - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/base_models/event.rst b/docs/source/api/models/base_models/event.rst index 856fb2b68f..daf873f898 100644 --- a/docs/source/api/models/base_models/event.rst +++ b/docs/source/api/models/base_models/event.rst @@ -6,5 +6,3 @@ Event .. autoclass:: pybamm.EventType :members: - - diff --git a/docs/source/api/models/index.rst b/docs/source/api/models/index.rst index e62d4a2beb..a259e3cb7f 100644 --- a/docs/source/api/models/index.rst +++ b/docs/source/api/models/index.rst @@ -4,7 +4,7 @@ Models Below is an overview of all the battery models included in PyBaMM. Each of the pre-built models contains a reference to the paper in which it is derived. -The models can be customised using the `options` dictionary defined in the :class:`pybamm.BaseBatteryModel` (which also provides information on which options and models are compatible) +The models can be customised using the ``options`` dictionary defined in the :class:`pybamm.BaseBatteryModel` (which also provides information on which options and models are compatible) Visit our `examples page `_ to see how these models can be solved, and compared, using PyBaMM. diff --git a/docs/source/api/models/lead_acid/full.rst b/docs/source/api/models/lead_acid/full.rst index a07a38949f..4cc6af7cc0 100644 --- a/docs/source/api/models/lead_acid/full.rst +++ b/docs/source/api/models/lead_acid/full.rst @@ -7,4 +7,4 @@ Full Model .. autoclass:: pybamm.lead_acid.BasicFull :members: -.. footbibliography:: \ No newline at end of file +.. footbibliography:: diff --git a/docs/source/api/models/lithium_ion/index.rst b/docs/source/api/models/lithium_ion/index.rst index 8148824dd9..f925d2c3d4 100644 --- a/docs/source/api/models/lithium_ion/index.rst +++ b/docs/source/api/models/lithium_ion/index.rst @@ -10,4 +10,4 @@ Lithium-ion Models dfn newman_tobias yang2017 - electrode_soh \ No newline at end of file + electrode_soh diff --git a/docs/source/api/models/lithium_ion/yang2017.rst b/docs/source/api/models/lithium_ion/yang2017.rst index 06134be58d..1ee5bad80d 100644 --- a/docs/source/api/models/lithium_ion/yang2017.rst +++ b/docs/source/api/models/lithium_ion/yang2017.rst @@ -3,4 +3,3 @@ Yang et al 2017 .. autoclass:: pybamm.lithium_ion.Yang2017 :members: - diff --git a/docs/source/api/models/submodels/active_material/base_active_material.rst b/docs/source/api/models/submodels/active_material/base_active_material.rst index 6eab5fe0a0..f94c816d51 100644 --- a/docs/source/api/models/submodels/active_material/base_active_material.rst +++ b/docs/source/api/models/submodels/active_material/base_active_material.rst @@ -3,4 +3,3 @@ Base Model .. autoclass:: pybamm.active_material.BaseModel :members: - diff --git a/docs/source/api/models/submodels/active_material/constant_active_material.rst b/docs/source/api/models/submodels/active_material/constant_active_material.rst index 9102c533d2..2d022563cb 100644 --- a/docs/source/api/models/submodels/active_material/constant_active_material.rst +++ b/docs/source/api/models/submodels/active_material/constant_active_material.rst @@ -3,5 +3,3 @@ Constant Active Material .. autoclass:: pybamm.active_material.Constant :members: - - diff --git a/docs/source/api/models/submodels/active_material/index.rst b/docs/source/api/models/submodels/active_material/index.rst index 1022c9c6c0..ed075940c5 100644 --- a/docs/source/api/models/submodels/active_material/index.rst +++ b/docs/source/api/models/submodels/active_material/index.rst @@ -9,4 +9,3 @@ Submodels for (loss of) active material base_active_material constant_active_material loss_active_material - diff --git a/docs/source/api/models/submodels/active_material/loss_active_material.rst b/docs/source/api/models/submodels/active_material/loss_active_material.rst index 37072847a1..e600806a1c 100644 --- a/docs/source/api/models/submodels/active_material/loss_active_material.rst +++ b/docs/source/api/models/submodels/active_material/loss_active_material.rst @@ -1,4 +1,4 @@ -Loss of Active Material +Loss of Active Material ======================= .. autoclass:: pybamm.active_material.LossActiveMaterial diff --git a/docs/source/api/models/submodels/base_submodel.rst b/docs/source/api/models/submodels/base_submodel.rst index a407963142..41a2c178b0 100644 --- a/docs/source/api/models/submodels/base_submodel.rst +++ b/docs/source/api/models/submodels/base_submodel.rst @@ -3,4 +3,3 @@ Base Submodel .. autoclass:: pybamm.BaseSubModel :members: - diff --git a/docs/source/api/models/submodels/electrode/ohm/index.rst b/docs/source/api/models/submodels/electrode/ohm/index.rst index 63b4727fe0..ad4a16ff2c 100644 --- a/docs/source/api/models/submodels/electrode/ohm/index.rst +++ b/docs/source/api/models/submodels/electrode/ohm/index.rst @@ -8,4 +8,4 @@ Ohmic composite_ohm full_ohm surface_form_ohm - li_metal_explicit \ No newline at end of file + li_metal_explicit diff --git a/docs/source/api/models/submodels/electrolyte_conductivity/base_electrolyte_conductivity.rst b/docs/source/api/models/submodels/electrolyte_conductivity/base_electrolyte_conductivity.rst index 4a2fb4d0b1..ca6cc18095 100644 --- a/docs/source/api/models/submodels/electrolyte_conductivity/base_electrolyte_conductivity.rst +++ b/docs/source/api/models/submodels/electrolyte_conductivity/base_electrolyte_conductivity.rst @@ -3,4 +3,3 @@ Base Electrolyte Conductivity Submodel .. autoclass:: pybamm.electrolyte_conductivity.BaseElectrolyteConductivity :members: - diff --git a/docs/source/api/models/submodels/electrolyte_conductivity/full_conductivity.rst b/docs/source/api/models/submodels/electrolyte_conductivity/full_conductivity.rst index 6882fbb8e2..017811f313 100644 --- a/docs/source/api/models/submodels/electrolyte_conductivity/full_conductivity.rst +++ b/docs/source/api/models/submodels/electrolyte_conductivity/full_conductivity.rst @@ -4,4 +4,3 @@ Full Model .. autoclass:: pybamm.electrolyte_conductivity.Full :members: :inherited-members: - diff --git a/docs/source/api/models/submodels/electrolyte_conductivity/leading_order_conductivity.rst b/docs/source/api/models/submodels/electrolyte_conductivity/leading_order_conductivity.rst index e5e6f0261c..31a91b8498 100644 --- a/docs/source/api/models/submodels/electrolyte_conductivity/leading_order_conductivity.rst +++ b/docs/source/api/models/submodels/electrolyte_conductivity/leading_order_conductivity.rst @@ -3,4 +3,3 @@ Leading Order Model .. autoclass:: pybamm.electrolyte_conductivity.LeadingOrder :members: - diff --git a/docs/source/api/models/submodels/electrolyte_conductivity/surface_form/index.rst b/docs/source/api/models/submodels/electrolyte_conductivity/surface_form/index.rst index de0c5b1fd1..bb49e378e6 100644 --- a/docs/source/api/models/submodels/electrolyte_conductivity/surface_form/index.rst +++ b/docs/source/api/models/submodels/electrolyte_conductivity/surface_form/index.rst @@ -5,4 +5,4 @@ Surface Form full_surface_form_conductivity leading_surface_form_conductivity - explicit_surface_form_conductivity \ No newline at end of file + explicit_surface_form_conductivity diff --git a/docs/source/api/models/submodels/electrolyte_conductivity/surface_form/leading_surface_form_conductivity.rst b/docs/source/api/models/submodels/electrolyte_conductivity/surface_form/leading_surface_form_conductivity.rst index 07154f9aa6..0a5b7c2756 100644 --- a/docs/source/api/models/submodels/electrolyte_conductivity/surface_form/leading_surface_form_conductivity.rst +++ b/docs/source/api/models/submodels/electrolyte_conductivity/surface_form/leading_surface_form_conductivity.rst @@ -3,6 +3,6 @@ Leading Order Model .. autoclass:: pybamm.electrolyte_conductivity.surface_potential_form.LeadingOrderDifferential :members: - + .. autoclass:: pybamm.electrolyte_conductivity.surface_potential_form.LeadingOrderAlgebraic :members: diff --git a/docs/source/api/models/submodels/electrolyte_diffusion/constant_concentration.rst b/docs/source/api/models/submodels/electrolyte_diffusion/constant_concentration.rst index be326a8f6d..7d5109d974 100644 --- a/docs/source/api/models/submodels/electrolyte_diffusion/constant_concentration.rst +++ b/docs/source/api/models/submodels/electrolyte_diffusion/constant_concentration.rst @@ -3,4 +3,3 @@ Constant Concentration .. autoclass:: pybamm.electrolyte_diffusion.ConstantConcentration :members: - diff --git a/docs/source/api/models/submodels/electrolyte_diffusion/full_diffusion.rst b/docs/source/api/models/submodels/electrolyte_diffusion/full_diffusion.rst index 99dd1fee93..cbf6da93d4 100644 --- a/docs/source/api/models/submodels/electrolyte_diffusion/full_diffusion.rst +++ b/docs/source/api/models/submodels/electrolyte_diffusion/full_diffusion.rst @@ -3,4 +3,3 @@ Full Model .. autoclass:: pybamm.electrolyte_diffusion.Full :members: - diff --git a/docs/source/api/models/submodels/electrolyte_diffusion/leading_order_diffusion.rst b/docs/source/api/models/submodels/electrolyte_diffusion/leading_order_diffusion.rst index a4c817c60d..4005165095 100644 --- a/docs/source/api/models/submodels/electrolyte_diffusion/leading_order_diffusion.rst +++ b/docs/source/api/models/submodels/electrolyte_diffusion/leading_order_diffusion.rst @@ -3,5 +3,3 @@ Leading Order Model .. autoclass:: pybamm.electrolyte_diffusion.LeadingOrder :members: - - diff --git a/docs/source/api/models/submodels/equivalent_circuit_elements/ocv_element.rst b/docs/source/api/models/submodels/equivalent_circuit_elements/ocv_element.rst index f34a563edc..025e40eb92 100644 --- a/docs/source/api/models/submodels/equivalent_circuit_elements/ocv_element.rst +++ b/docs/source/api/models/submodels/equivalent_circuit_elements/ocv_element.rst @@ -3,4 +3,3 @@ OCV Element .. autoclass:: pybamm.equivalent_circuit_elements.OCVElement :members: - diff --git a/docs/source/api/models/submodels/equivalent_circuit_elements/rc_element.rst b/docs/source/api/models/submodels/equivalent_circuit_elements/rc_element.rst index e783f4b291..bc938e4619 100644 --- a/docs/source/api/models/submodels/equivalent_circuit_elements/rc_element.rst +++ b/docs/source/api/models/submodels/equivalent_circuit_elements/rc_element.rst @@ -3,4 +3,3 @@ RC Element .. autoclass:: pybamm.equivalent_circuit_elements.RCElement :members: - diff --git a/docs/source/api/models/submodels/equivalent_circuit_elements/resistor_element.rst b/docs/source/api/models/submodels/equivalent_circuit_elements/resistor_element.rst index 91d6e6d2c5..d519db70bf 100644 --- a/docs/source/api/models/submodels/equivalent_circuit_elements/resistor_element.rst +++ b/docs/source/api/models/submodels/equivalent_circuit_elements/resistor_element.rst @@ -3,4 +3,3 @@ Resistor Element .. autoclass:: pybamm.equivalent_circuit_elements.ResistorElement :members: - diff --git a/docs/source/api/models/submodels/equivalent_circuit_elements/thermal.rst b/docs/source/api/models/submodels/equivalent_circuit_elements/thermal.rst index c95ead818f..a3c3ac62a7 100644 --- a/docs/source/api/models/submodels/equivalent_circuit_elements/thermal.rst +++ b/docs/source/api/models/submodels/equivalent_circuit_elements/thermal.rst @@ -3,4 +3,3 @@ Thermal SubModel .. autoclass:: pybamm.equivalent_circuit_elements.ThermalSubModel :members: - diff --git a/docs/source/api/models/submodels/equivalent_circuit_elements/voltage_model.rst b/docs/source/api/models/submodels/equivalent_circuit_elements/voltage_model.rst index bda725dfcb..caa08f188f 100644 --- a/docs/source/api/models/submodels/equivalent_circuit_elements/voltage_model.rst +++ b/docs/source/api/models/submodels/equivalent_circuit_elements/voltage_model.rst @@ -3,4 +3,3 @@ Voltage Model .. autoclass:: pybamm.equivalent_circuit_elements.VoltageModel :members: - diff --git a/docs/source/api/models/submodels/external_circuit/function_control_external_circuit.rst b/docs/source/api/models/submodels/external_circuit/function_control_external_circuit.rst index e977600663..baa9454076 100644 --- a/docs/source/api/models/submodels/external_circuit/function_control_external_circuit.rst +++ b/docs/source/api/models/submodels/external_circuit/function_control_external_circuit.rst @@ -14,4 +14,4 @@ Function control external circuit :members: .. autoclass:: pybamm.external_circuit.CCCVFunctionControl - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/kinetics/base_kinetics.rst b/docs/source/api/models/submodels/interface/kinetics/base_kinetics.rst index 67e4f15cf0..b17fb73a4d 100644 --- a/docs/source/api/models/submodels/interface/kinetics/base_kinetics.rst +++ b/docs/source/api/models/submodels/interface/kinetics/base_kinetics.rst @@ -2,4 +2,4 @@ Base Kinetics ============= .. autoclass:: pybamm.kinetics.BaseKinetics - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/kinetics/butler_volmer.rst b/docs/source/api/models/submodels/interface/kinetics/butler_volmer.rst index 0c46b217c5..abf878e57b 100644 --- a/docs/source/api/models/submodels/interface/kinetics/butler_volmer.rst +++ b/docs/source/api/models/submodels/interface/kinetics/butler_volmer.rst @@ -5,4 +5,4 @@ Butler Volumer :members: .. autoclass:: pybamm.kinetics.AsymmetricButlerVolmer - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/kinetics/inverse_kinetics/index.rst b/docs/source/api/models/submodels/interface/kinetics/inverse_kinetics/index.rst index 260259ad3d..f6d3f495ff 100644 --- a/docs/source/api/models/submodels/interface/kinetics/inverse_kinetics/index.rst +++ b/docs/source/api/models/submodels/interface/kinetics/inverse_kinetics/index.rst @@ -3,4 +3,4 @@ Inverse Kinetics .. toctree:: - inverse_butler_volmer \ No newline at end of file + inverse_butler_volmer diff --git a/docs/source/api/models/submodels/interface/kinetics/inverse_kinetics/inverse_butler_volmer.rst b/docs/source/api/models/submodels/interface/kinetics/inverse_kinetics/inverse_butler_volmer.rst index 3a2f7e3e3b..60bd3c7c0d 100644 --- a/docs/source/api/models/submodels/interface/kinetics/inverse_kinetics/inverse_butler_volmer.rst +++ b/docs/source/api/models/submodels/interface/kinetics/inverse_kinetics/inverse_butler_volmer.rst @@ -2,4 +2,4 @@ Inverse Butler-Volmer ===================== .. autoclass:: pybamm.kinetics.InverseButlerVolmer - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/kinetics/linear.rst b/docs/source/api/models/submodels/interface/kinetics/linear.rst index 57bc5b5437..22c02cbe21 100644 --- a/docs/source/api/models/submodels/interface/kinetics/linear.rst +++ b/docs/source/api/models/submodels/interface/kinetics/linear.rst @@ -2,4 +2,4 @@ Linear ====== .. autoclass:: pybamm.kinetics.Linear - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/kinetics/marcus.rst b/docs/source/api/models/submodels/interface/kinetics/marcus.rst index 2c72b71e5d..6252f22e8b 100644 --- a/docs/source/api/models/submodels/interface/kinetics/marcus.rst +++ b/docs/source/api/models/submodels/interface/kinetics/marcus.rst @@ -2,4 +2,4 @@ Marcus ====== .. autoclass:: pybamm.kinetics.Marcus - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/kinetics/no_reaction.rst b/docs/source/api/models/submodels/interface/kinetics/no_reaction.rst index 4da4e490a9..573b9a2117 100644 --- a/docs/source/api/models/submodels/interface/kinetics/no_reaction.rst +++ b/docs/source/api/models/submodels/interface/kinetics/no_reaction.rst @@ -2,4 +2,4 @@ NoReaction ========== .. autoclass:: pybamm.kinetics.NoReaction - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/kinetics/tafel.rst b/docs/source/api/models/submodels/interface/kinetics/tafel.rst index 23280eea8a..1969ab5b53 100644 --- a/docs/source/api/models/submodels/interface/kinetics/tafel.rst +++ b/docs/source/api/models/submodels/interface/kinetics/tafel.rst @@ -2,4 +2,4 @@ Tafel ===== .. autoclass:: pybamm.kinetics.ForwardTafel - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/kinetics/total_main_kinetics.rst b/docs/source/api/models/submodels/interface/kinetics/total_main_kinetics.rst index b8462437d2..36b17e2564 100644 --- a/docs/source/api/models/submodels/interface/kinetics/total_main_kinetics.rst +++ b/docs/source/api/models/submodels/interface/kinetics/total_main_kinetics.rst @@ -3,4 +3,4 @@ Total Main Kinetics .. autoclass:: pybamm.kinetics.TotalMainKinetics - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/lithium_plating/index.rst b/docs/source/api/models/submodels/interface/lithium_plating/index.rst index 3edc2652d2..29bca51941 100644 --- a/docs/source/api/models/submodels/interface/lithium_plating/index.rst +++ b/docs/source/api/models/submodels/interface/lithium_plating/index.rst @@ -5,4 +5,4 @@ Lithium Plating base_plating no_plating - plating \ No newline at end of file + plating diff --git a/docs/source/api/models/submodels/interface/open_circuit_potential/base_ocp.rst b/docs/source/api/models/submodels/interface/open_circuit_potential/base_ocp.rst index e06196b6a8..41b0fdbb28 100644 --- a/docs/source/api/models/submodels/interface/open_circuit_potential/base_ocp.rst +++ b/docs/source/api/models/submodels/interface/open_circuit_potential/base_ocp.rst @@ -2,4 +2,4 @@ Base Open Circuit Potential =========================== .. autoclass:: pybamm.open_circuit_potential.BaseOpenCircuitPotential - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/open_circuit_potential/current_sigmoid_ocp.rst b/docs/source/api/models/submodels/interface/open_circuit_potential/current_sigmoid_ocp.rst index f71e360495..832cc57603 100644 --- a/docs/source/api/models/submodels/interface/open_circuit_potential/current_sigmoid_ocp.rst +++ b/docs/source/api/models/submodels/interface/open_circuit_potential/current_sigmoid_ocp.rst @@ -3,4 +3,3 @@ Current Sigmoid Open Circuit Potential .. autoclass:: pybamm.open_circuit_potential.CurrentSigmoidOpenCircuitPotential :members: - diff --git a/docs/source/api/models/submodels/interface/sei/base_sei.rst b/docs/source/api/models/submodels/interface/sei/base_sei.rst index bcfad871da..2e42e0eea9 100644 --- a/docs/source/api/models/submodels/interface/sei/base_sei.rst +++ b/docs/source/api/models/submodels/interface/sei/base_sei.rst @@ -2,4 +2,4 @@ SEI Base Model ============== .. autoclass:: pybamm.sei.BaseModel - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/sei/constant_sei.rst b/docs/source/api/models/submodels/interface/sei/constant_sei.rst index e92180d1ca..a38652daa8 100644 --- a/docs/source/api/models/submodels/interface/sei/constant_sei.rst +++ b/docs/source/api/models/submodels/interface/sei/constant_sei.rst @@ -2,4 +2,4 @@ Constant SEI ============ .. autoclass:: pybamm.sei.ConstantSEI - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/sei/index.rst b/docs/source/api/models/submodels/interface/sei/index.rst index 07ecc475e3..3468f2d0ef 100644 --- a/docs/source/api/models/submodels/interface/sei/index.rst +++ b/docs/source/api/models/submodels/interface/sei/index.rst @@ -7,4 +7,4 @@ SEI models constant_sei no_sei sei_growth - total_sei \ No newline at end of file + total_sei diff --git a/docs/source/api/models/submodels/interface/sei/no_sei.rst b/docs/source/api/models/submodels/interface/sei/no_sei.rst index dde5f645fe..69e93f5d2e 100644 --- a/docs/source/api/models/submodels/interface/sei/no_sei.rst +++ b/docs/source/api/models/submodels/interface/sei/no_sei.rst @@ -2,4 +2,4 @@ No SEI ====== .. autoclass:: pybamm.sei.NoSEI - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/interface/sei/total_sei.rst b/docs/source/api/models/submodels/interface/sei/total_sei.rst index 7f65c9cae3..4210bcd47f 100644 --- a/docs/source/api/models/submodels/interface/sei/total_sei.rst +++ b/docs/source/api/models/submodels/interface/sei/total_sei.rst @@ -2,4 +2,4 @@ Total SEI ========= .. autoclass:: pybamm.sei.TotalSEI - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/models/submodels/particle/index.rst b/docs/source/api/models/submodels/particle/index.rst index a701eeec6e..ae020ac3fa 100644 --- a/docs/source/api/models/submodels/particle/index.rst +++ b/docs/source/api/models/submodels/particle/index.rst @@ -7,4 +7,4 @@ Particle base_particle fickian_diffusion polynomial_profile - x_averaged_polynomial_profile \ No newline at end of file + x_averaged_polynomial_profile diff --git a/docs/source/api/models/submodels/porosity/base_porosity.rst b/docs/source/api/models/submodels/porosity/base_porosity.rst index 0886e2502c..a328047f4c 100644 --- a/docs/source/api/models/submodels/porosity/base_porosity.rst +++ b/docs/source/api/models/submodels/porosity/base_porosity.rst @@ -3,4 +3,3 @@ Base Model .. autoclass:: pybamm.porosity.BaseModel :members: - diff --git a/docs/source/api/models/submodels/porosity/constant_porosity.rst b/docs/source/api/models/submodels/porosity/constant_porosity.rst index babb63bd36..7eff146917 100644 --- a/docs/source/api/models/submodels/porosity/constant_porosity.rst +++ b/docs/source/api/models/submodels/porosity/constant_porosity.rst @@ -1,7 +1,5 @@ -Constant Porosity +Constant Porosity ================= .. autoclass:: pybamm.porosity.Constant :members: - - diff --git a/docs/source/api/models/submodels/porosity/index.rst b/docs/source/api/models/submodels/porosity/index.rst index deadc9e5c5..17d0f23fb8 100644 --- a/docs/source/api/models/submodels/porosity/index.rst +++ b/docs/source/api/models/submodels/porosity/index.rst @@ -8,4 +8,3 @@ Porosity constant_porosity reaction_driven_porosity reaction_driven_porosity_ode - diff --git a/docs/source/api/models/submodels/porosity/reaction_driven_porosity.rst b/docs/source/api/models/submodels/porosity/reaction_driven_porosity.rst index dc4dfc8d42..35d77d20d9 100644 --- a/docs/source/api/models/submodels/porosity/reaction_driven_porosity.rst +++ b/docs/source/api/models/submodels/porosity/reaction_driven_porosity.rst @@ -1,8 +1,5 @@ -Reaction-driven Model +Reaction-driven Model ===================== .. autoclass:: pybamm.porosity.ReactionDriven :members: - - - diff --git a/docs/source/api/models/submodels/porosity/reaction_driven_porosity_ode.rst b/docs/source/api/models/submodels/porosity/reaction_driven_porosity_ode.rst index f74f7d5c30..afa0e5f358 100644 --- a/docs/source/api/models/submodels/porosity/reaction_driven_porosity_ode.rst +++ b/docs/source/api/models/submodels/porosity/reaction_driven_porosity_ode.rst @@ -3,6 +3,3 @@ Reaction-driven Model as an ODE .. autoclass:: pybamm.porosity.ReactionDrivenODE :members: - - - diff --git a/docs/source/api/models/submodels/thermal/base_thermal.rst b/docs/source/api/models/submodels/thermal/base_thermal.rst index fd3acc0edf..eb38b4934a 100644 --- a/docs/source/api/models/submodels/thermal/base_thermal.rst +++ b/docs/source/api/models/submodels/thermal/base_thermal.rst @@ -3,4 +3,3 @@ Base Thermal .. autoclass:: pybamm.thermal.BaseThermal :members: - diff --git a/docs/source/api/models/submodels/transport_efficiency/base_transport_efficiency.rst b/docs/source/api/models/submodels/transport_efficiency/base_transport_efficiency.rst index e24f0cba15..fc581a666a 100644 --- a/docs/source/api/models/submodels/transport_efficiency/base_transport_efficiency.rst +++ b/docs/source/api/models/submodels/transport_efficiency/base_transport_efficiency.rst @@ -3,4 +3,3 @@ Base Model .. autoclass:: pybamm.transport_efficiency.BaseModel :members: - diff --git a/docs/source/api/models/submodels/transport_efficiency/bruggeman_transport_efficiency.rst b/docs/source/api/models/submodels/transport_efficiency/bruggeman_transport_efficiency.rst index f50e825b09..f5e5f1c1bc 100644 --- a/docs/source/api/models/submodels/transport_efficiency/bruggeman_transport_efficiency.rst +++ b/docs/source/api/models/submodels/transport_efficiency/bruggeman_transport_efficiency.rst @@ -1,8 +1,5 @@ -Bruggeman Model +Bruggeman Model =============== .. autoclass:: pybamm.transport_efficiency.Bruggeman :members: - - - diff --git a/docs/source/api/models/submodels/transport_efficiency/index.rst b/docs/source/api/models/submodels/transport_efficiency/index.rst index fe7b640f68..fcdec7077f 100644 --- a/docs/source/api/models/submodels/transport_efficiency/index.rst +++ b/docs/source/api/models/submodels/transport_efficiency/index.rst @@ -6,4 +6,3 @@ transport_efficiency base_transport_efficiency bruggeman_transport_efficiency - diff --git a/docs/source/api/plotting/plot_summary_variables.rst b/docs/source/api/plotting/plot_summary_variables.rst index 35baeda605..746c501c5c 100644 --- a/docs/source/api/plotting/plot_summary_variables.rst +++ b/docs/source/api/plotting/plot_summary_variables.rst @@ -1,4 +1,4 @@ Plot Summary Variables ====================== -.. autofunction:: pybamm.plot_summary_variables \ No newline at end of file +.. autofunction:: pybamm.plot_summary_variables diff --git a/docs/source/api/plotting/plot_voltage_components.rst b/docs/source/api/plotting/plot_voltage_components.rst index 04d95e62cc..6954374d0c 100644 --- a/docs/source/api/plotting/plot_voltage_components.rst +++ b/docs/source/api/plotting/plot_voltage_components.rst @@ -3,4 +3,4 @@ Plot Voltage Components ======================= -.. autofunction:: pybamm.plot_voltage_components \ No newline at end of file +.. autofunction:: pybamm.plot_voltage_components diff --git a/docs/source/api/plotting/quick_plot.rst b/docs/source/api/plotting/quick_plot.rst index ef81719056..ff7576a00d 100644 --- a/docs/source/api/plotting/quick_plot.rst +++ b/docs/source/api/plotting/quick_plot.rst @@ -6,4 +6,4 @@ Quick Plot .. autoclass:: pybamm.QuickPlot :members: -.. autofunction:: pybamm.dynamic_plot \ No newline at end of file +.. autofunction:: pybamm.dynamic_plot diff --git a/docs/source/api/simulation.rst b/docs/source/api/simulation.rst index a50a67eb21..203420ad73 100644 --- a/docs/source/api/simulation.rst +++ b/docs/source/api/simulation.rst @@ -2,4 +2,4 @@ Simulation ========== .. autoclass:: pybamm.Simulation - :members: \ No newline at end of file + :members: diff --git a/docs/source/api/solvers/index.rst b/docs/source/api/solvers/index.rst index d87f003309..af2a8893dd 100644 --- a/docs/source/api/solvers/index.rst +++ b/docs/source/api/solvers/index.rst @@ -13,4 +13,3 @@ Solvers algebraic_solvers solution processed_variable - diff --git a/docs/source/api/spatial_methods/finite_volume.rst b/docs/source/api/spatial_methods/finite_volume.rst index f57c5e9e76..3b6122acc8 100644 --- a/docs/source/api/spatial_methods/finite_volume.rst +++ b/docs/source/api/spatial_methods/finite_volume.rst @@ -3,4 +3,3 @@ Finite Volume .. autoclass:: pybamm.FiniteVolume :members: - diff --git a/docs/source/examples/index.rst b/docs/source/examples/index.rst index c7522fc972..4287e28927 100644 --- a/docs/source/examples/index.rst +++ b/docs/source/examples/index.rst @@ -66,7 +66,7 @@ The notebooks are organised into subfolders, and can be viewed in the galleries notebooks/models/SPM.ipynb notebooks/models/SPMe.ipynb notebooks/models/submodel_cracking_DFN_or_SPM.ipynb - notebooks/models/submodel_loss_of_active_materials.ipynb + notebooks/models/loss_of_active_materials.ipynb notebooks/models/thermal-models.ipynb notebooks/models/unsteady-heat-equation.ipynb notebooks/models/using-model-options_thermal-example.ipynb diff --git a/docs/source/examples/notebooks/models/jelly-roll-model.ipynb b/docs/source/examples/notebooks/models/jelly-roll-model.ipynb index 24e32e2525..f03c328abf 100644 --- a/docs/source/examples/notebooks/models/jelly-roll-model.ipynb +++ b/docs/source/examples/notebooks/models/jelly-roll-model.ipynb @@ -46,6 +46,11 @@ "name": "stdout", "output_type": "stream", "text": [ + "\u001b[33mWARNING: pybamm 23.5 does not provide the extra 'cite'\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: pybamm 23.5 does not provide the extra 'plot'\u001b[0m\u001b[33m\n", + "\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", "Note: you may need to restart the kernel to use updated packages.\n" ] } @@ -149,7 +154,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -246,16 +251,7 @@ "execution_count": 8, "id": "affecting-albuquerque", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-11-30 13:46:37,966 - [WARNING] processed_variable.get_spatial_scale(520): No length scale set for cell. Using default of 1 [m].\n", - "2021-11-30 13:46:37,968 - [WARNING] processed_variable.get_spatial_scale(520): No length scale set for cell. Using default of 1 [m].\n" - ] - } - ], + "outputs": [], "source": [ "# post-process homogenised potential \n", "phi_n = solution[\"Negative potential\"]\n", @@ -263,17 +259,17 @@ "\n", "\n", "def alpha(r):\n", - " return 2 * (phi_n(x=r) - phi_p(x=r))\n", + " return 2 * (phi_n(r=r) - phi_p(r=r))\n", "\n", "\n", "def phi_am1(r, theta):\n", " # careful here - phi always returns a column vector so we need to add a new axis to r to get the right shape \n", - " return alpha(r) * (r[:,np.newaxis]/eps - r0/eps - delta - theta / 2 / pi) / (1 - 4*delta) + phi_p(x=r)\n", + " return alpha(r) * (r[:,np.newaxis]/eps - r0/eps - delta - theta / 2 / pi) / (1 - 4*delta) + phi_p(r=r)\n", "\n", "\n", "def phi_am2(r, theta):\n", " # careful here - phi always returns a column vector so we need to add a new axis to r to get the right shape \n", - " return alpha(r) * (r0/eps + 1 - delta + theta / 2 / pi - r[:,np.newaxis]/eps) / (1 - 4*delta) + phi_p(x=r)" + " return alpha(r) * (r0/eps + 1 - delta + theta / 2 / pi - r[:,np.newaxis]/eps) / (1 - 4*delta) + phi_p(r=r)" ] }, { @@ -343,14 +339,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "

" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -358,12 +352,12 @@ "# plot homogenised potential \n", "fig, ax = plt.subplots(1, 1, figsize=(8,6))\n", "\n", - "ax.plot(r_total_mesh, phi_n(x=r_total_mesh), 'b', label=r\"$\\phi^-$\")\n", - "ax.plot(r_total_mesh, phi_p(x=r_total_mesh), 'r', label=r\"$\\phi^+$\")\n", + "ax.plot(r_total_mesh, phi_n(r=r_total_mesh), 'b', label=r\"$\\phi^-$\")\n", + "ax.plot(r_total_mesh, phi_p(r=r_total_mesh), 'r', label=r\"$\\phi^+$\")\n", "for i in range(len(tt)):\n", - " ax.plot(r_mesh_pos[i,:], phi_p(x=r_mesh_pos[i,:]), 'k', label=r\"$\\phi$\" if i ==0 else \"\")\n", + " ax.plot(r_mesh_pos[i,:], phi_p(r=r_mesh_pos[i,:]), 'k', label=r\"$\\phi$\" if i ==0 else \"\")\n", "for i in range(len(tt)-1):\n", - " ax.plot(r_mesh_neg[i,:], phi_n(x=r_mesh_neg[i,:]), 'k')\n", + " ax.plot(r_mesh_neg[i,:], phi_n(r=r_mesh_neg[i,:]), 'k')\n", " ax.plot(r_mesh_am1[i,:], phi_am1(r_mesh_am1[i,:], tt[i]), 'k')\n", " ax.plot(r_mesh_am2[i,:], phi_am2(r_mesh_am2[i,:], tt[i]), 'k')\n", "ax.set_xlabel(r\"$r$\")\n", diff --git a/docs/source/examples/notebooks/models/loss_of_active_materials.ipynb b/docs/source/examples/notebooks/models/loss_of_active_materials.ipynb new file mode 100644 index 0000000000..f1e81796a1 --- /dev/null +++ b/docs/source/examples/notebooks/models/loss_of_active_materials.ipynb @@ -0,0 +1,427 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Loss of active material submodels\n", + "In this notebook we show how to use the loss of active materials (LAM) submodels in PyBaMM. \n", + "\n", + "## Stress-driven LAM\n", + "The first model we consider is the stress-driven submodel, which follows equation (25) from [Reniers et al (2019)](https://iopscience.iop.org/article/10.1149/2.0281914jes/meta), and the stresses are calculated by equations (7)-(9) in [Ai et al (2020)](https://iopscience.iop.org/article/10.1149/2.0122001JES/meta). To see all of the models and submodels available in PyBaMM, please take a look at the [documentation](https://docs.pybamm.org).\n", + "\n", + "As usual, we start by defining the model. We choose a DFN model with stress-driven loss of active material, and we also include SEI growth. We then define the parameters and experiments, and solve the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING: pybamm 23.5 does not provide the extra 'cite'\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: pybamm 23.5 does not provide the extra 'plot'\u001b[0m\u001b[33m\n", + "\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install pybamm[plot,cite] -q # install PyBaMM if it is not installed\n", + "import pybamm\n", + "\n", + "model = pybamm.lithium_ion.DFN(\n", + " options=\n", + " {\n", + " \"SEI\":\"solvent-diffusion limited\", \n", + " \"SEI porosity change\":\"false\", \n", + " \"particle mechanics\":\"swelling only\",\n", + " \"loss of active material\":\"stress-driven\",\n", + " }\n", + ")\n", + "param = pybamm.ParameterValues(\"Ai2020\")\n", + "param.update({\"Negative electrode LAM constant proportional term [s-1]\": 1e-4/3600})\n", + "param.update({\"Positive electrode LAM constant proportional term [s-1]\": 1e-4/3600})\n", + "total_cycles = 2\n", + "experiment = pybamm.Experiment(\n", + " [\n", + " \"Discharge at 1C until 3 V\",\n", + " \"Rest for 600 seconds\",\n", + " \"Charge at 1C until 4.2 V\",\n", + " \"Hold at 4.199 V for 600 seconds\",\n", + " ] * total_cycles\n", + ")\n", + "sim = pybamm.Simulation(\n", + " model, \n", + " experiment = experiment,\n", + " parameter_values = param,\n", + " solver = pybamm.CasadiSolver(\"fast with events\")\n", + ")\n", + "solution = sim.solve(calc_esoh=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now plot the results as usual." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3558ac2f7db145baadec9a28e236483e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.0, description='t', max=4.5113500706445695, step=0.04511350070644569…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim.plot([\n", + " \"Voltage [V]\",\n", + " \"Current [A]\",\n", + " \"Sum of x-averaged positive electrode volumetric interfacial current densities [A.m-3]\",\n", + " \"Sum of x-averaged negative electrode volumetric interfacial current densities [A.m-3]\",\n", + " \"X-averaged positive electrode active material volume fraction\",\n", + " \"X-averaged negative electrode active material volume fraction\",\n", + " \"X-averaged positive particle surface tangential stress [Pa]\",\n", + " \"X-averaged negative particle surface tangential stress [Pa]\",\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To understand the effect of the LAM constant proportional term, let's perform a parameter sweep." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9ff0e45a0c8c47b2b8d21da91b6110c1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.0, description='t', max=4.5113500706445695, step=0.04511350070644569…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ks = [1e-4, 1e-3, 1e-2]\n", + "solutions = []\n", + "\n", + "for k in ks:\n", + " param.update({\"Positive electrode LAM constant proportional term [s-1]\": k/3600})\n", + " param.update({\"Negative electrode LAM constant proportional term [s-1]\": k/3600})\n", + "\n", + " sim = pybamm.Simulation(\n", + " model, \n", + " experiment=experiment,\n", + " parameter_values=param,\n", + " solver=pybamm.CasadiSolver(\"fast with events\"),\n", + " )\n", + " solution = sim.solve(calc_esoh=False)\n", + " solutions.append(solution)\n", + " \n", + "pybamm.dynamic_plot(\n", + " solutions,\n", + " output_variables=[\n", + " \"Voltage [V]\",\n", + " \"Current [A]\",\n", + " \"Sum of x-averaged positive electrode volumetric interfacial current densities [A.m-3]\",\n", + " \"Sum of x-averaged negative electrode volumetric interfacial current densities [A.m-3]\",\n", + " \"X-averaged positive electrode active material volume fraction\",\n", + " \"X-averaged negative electrode active material volume fraction\",\n", + " \"X-averaged positive electrode surface area to volume ratio [m-1]\",\n", + " \"X-averaged negative electrode surface area to volume ratio [m-1]\",\n", + " ],\n", + " labels=[f\"k={k:.0e}\" for k in ks]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reaction-driven LAM\n", + "\n", + "Another option is to use reaction-driven (i.e. SEI) LAM. In this case we need to choose the `\"reaction-driven\"` option in the model, and proceed along the lines of the previous example." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "53f5eacbb94b4ae29acee57db4bf7785", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.0, description='t', max=3.5075529064499813, step=0.03507552906449981…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = pybamm.lithium_ion.DFN(\n", + " options=\n", + " {\n", + " \"SEI\":\"solvent-diffusion limited\", \n", + " \"loss of active material\":\"reaction-driven\",\n", + " }\n", + ")\n", + "param = pybamm.ParameterValues(\"Chen2020\")\n", + "param.update({\"Negative electrode reaction-driven LAM factor [m3.mol-1]\": 1e-3,})\n", + "total_cycles = 2\n", + "experiment = pybamm.Experiment(\n", + " [\n", + " \"Discharge at 1C until 3 V\",\n", + " \"Rest for 600 seconds\",\n", + " \"Charge at 1C until 4.2 V\",\n", + " \"Hold at 4.199 V for 600 seconds\",\n", + " ] * total_cycles\n", + ")\n", + "sim = pybamm.Simulation(\n", + " model, \n", + " experiment = experiment,\n", + " parameter_values = param,\n", + " solver = pybamm.CasadiSolver(\"fast with events\")\n", + ")\n", + "solution = sim.solve(calc_esoh=False)\n", + "\n", + "sim.plot([\n", + " \"Voltage [V]\",\n", + " \"Current [A]\",\n", + " \"Sum of x-averaged negative electrode volumetric interfacial current densities [A.m-3]\",\n", + " \"X-averaged negative electrode active material volume fraction\",\n", + " \"Total SEI thickness [m]\",\n", + " \"X-averaged total SEI thickness [m]\",\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Both stress-driven and reaction-driven can be combined by calling the `\"stress and reaction-driven\"` option." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Current-driven LAM\n", + "\n", + "The final submodel is current-driven LAM, which follows equation (26) from [Reniers et al (2019)](https://iopscience.iop.org/article/10.1149/2.0281914jes/meta). In this case we need to define the RHS of the equation as a function of current density and temperature. The example here is illustrative and does not represent any real scenario." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "15acf6373f874463ba95de522d12fc89", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.0, description='t', max=3.4962610293431426, step=0.03496261029343142…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def current_LAM(i, T):\n", + " return -1e-10 * (abs(i) + 1e3 * abs(i) ** 0.5)\n", + "\n", + "model = pybamm.lithium_ion.DFN(\n", + " options=\n", + " {\n", + " \"loss of active material\":\"current-driven\",\n", + " }\n", + ")\n", + "param = pybamm.ParameterValues(\"Chen2020\")\n", + "param.update({\n", + " \"Positive electrode current-driven LAM rate\": current_LAM,\n", + " \"Negative electrode current-driven LAM rate\": current_LAM,\n", + "}, check_already_exists=False)\n", + "total_cycles = 2\n", + "experiment = pybamm.Experiment(\n", + " [\n", + " \"Discharge at 1C until 3 V\",\n", + " \"Rest for 600 seconds\",\n", + " \"Charge at 1C until 4.2 V\",\n", + " \"Hold at 4.199 V for 600 seconds\",\n", + " ] * total_cycles\n", + ")\n", + "sim = pybamm.Simulation(\n", + " model, \n", + " experiment = experiment,\n", + " parameter_values = param,\n", + " solver = pybamm.CasadiSolver(\"fast with events\")\n", + ")\n", + "solution = sim.solve(calc_esoh=False)\n", + "\n", + "sim.plot([\n", + " \"Voltage [V]\",\n", + " \"Current [A]\",\n", + " \"X-averaged positive electrode active material volume fraction\",\n", + " \"X-averaged negative electrode active material volume fraction\",\n", + "])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "The relevant papers for this notebook are:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1] Weilong Ai, Ludwig Kraft, Johannes Sturm, Andreas Jossen, and Billy Wu. Electrochemical thermal-mechanical modelling of stress inhomogeneity in lithium-ion pouch cells. Journal of The Electrochemical Society, 167(1):013512, 2019. doi:10.1149/2.0122001JES.\n", + "[2] Joel A. E. Andersson, Joris Gillis, Greg Horn, James B. Rawlings, and Moritz Diehl. CasADi – A software framework for nonlinear optimization and optimal control. Mathematical Programming Computation, 11(1):1–36, 2019. doi:10.1007/s12532-018-0139-4.\n", + "[3] Chang-Hui Chen, Ferran Brosa Planella, Kieran O'Regan, Dominika Gastol, W. Dhammika Widanage, and Emma Kendrick. Development of Experimental Techniques for Parameterization of Multi-scale Lithium-ion Battery Models. Journal of The Electrochemical Society, 167(8):080534, 2020. doi:10.1149/1945-7111/ab9050.\n", + "[4] Rutooj Deshpande, Mark Verbrugge, Yang-Tse Cheng, John Wang, and Ping Liu. Battery cycle life prediction with coupled chemical degradation and fatigue mechanics. Journal of the Electrochemical Society, 159(10):A1730, 2012. doi:10.1149/2.049210jes.\n", + "[5] Marc Doyle, Thomas F. Fuller, and John Newman. Modeling of galvanostatic charge and discharge of the lithium/polymer/insertion cell. Journal of the Electrochemical society, 140(6):1526–1533, 1993. doi:10.1149/1.2221597.\n", + "[6] Charles R. Harris, K. Jarrod Millman, Stéfan J. van der Walt, Ralf Gommers, Pauli Virtanen, David Cournapeau, Eric Wieser, Julian Taylor, Sebastian Berg, Nathaniel J. Smith, and others. Array programming with NumPy. Nature, 585(7825):357–362, 2020. doi:10.1038/s41586-020-2649-2.\n", + "[7] Scott G. Marquis. Long-term degradation of lithium-ion batteries. PhD thesis, University of Oxford, 2020.\n", + "[8] Jorn M. Reniers, Grietus Mulder, and David A. Howey. Review and performance comparison of mechanical-chemical degradation models for lithium-ion batteries. Journal of The Electrochemical Society, 166(14):A3189, 2019. doi:10.1149/2.0281914jes.\n", + "[9] Valentin Sulzer, Scott G. Marquis, Robert Timms, Martin Robinson, and S. Jon Chapman. Python Battery Mathematical Modelling (PyBaMM). Journal of Open Research Software, 9(1):14, 2021. doi:10.5334/jors.309.\n", + "\n" + ] + } + ], + "source": [ + "pybamm.print_citations()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pybamm", + "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.9.17" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + }, + "vscode": { + "interpreter": { + "hash": "187972e187ab8dfbecfab9e8e194ae6d08262b2d51a54fa40644e3ddb6b5f74c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/source/examples/notebooks/models/pouch-cell-model.ipynb b/docs/source/examples/notebooks/models/pouch-cell-model.ipynb index 4abae879fb..5cc8c66e7a 100644 --- a/docs/source/examples/notebooks/models/pouch-cell-model.ipynb +++ b/docs/source/examples/notebooks/models/pouch-cell-model.ipynb @@ -49,6 +49,11 @@ "name": "stdout", "output_type": "stream", "text": [ + "\u001b[33mWARNING: pybamm 23.5 does not provide the extra 'cite'\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: pybamm 23.5 does not provide the extra 'plot'\u001b[0m\u001b[33m\n", + "\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", "Note: you may need to restart the kernel to use updated packages.\n" ] } @@ -315,6 +320,7 @@ "outputs": [], "source": [ "comsol_model = pybamm.BaseModel()\n", + "comsol_model._geometry = pybamm.battery_geometry(options={\"dimensionality\": 1})\n", "comsol_model.variables = {\n", " \"Voltage [V]\": comsol_voltage,\n", " \"Negative current collector potential [V]\": comsol_phi_s_cn,\n", @@ -563,14 +569,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -609,14 +613,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -675,14 +677,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -730,14 +730,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -845,7 +843,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.9.17" }, "toc": { "base_numbering": 1, diff --git a/docs/source/examples/notebooks/models/submodel_loss_of_active_materials.ipynb b/docs/source/examples/notebooks/models/submodel_loss_of_active_materials.ipynb deleted file mode 100644 index 066a52d360..0000000000 --- a/docs/source/examples/notebooks/models/submodel_loss_of_active_materials.ipynb +++ /dev/null @@ -1,438 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Using submodel loss of active materials in PyBaMM\n", - "In this notebook we show how to use the loss of active materials (LAM) submodel in pybamm. The LAM model follows the equation (25) from [[6]](#References), and the stresses are calculated by equations (7)-(9) in [[1]](#References). To see all of the models and submodels available in PyBaMM, please take a look at the documentation here." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "%pip install pybamm[plot,cite] -q # install PyBaMM if it is not installed\n", - "import pybamm\n", - "import os\n", - "import matplotlib.pyplot as plt\n", - "os.chdir(pybamm.__path__[0]+'/..')\n", - "# Here the model is applicable to SPM, SPMe and DFN\n", - "model = pybamm.lithium_ion.DFN(\n", - " options=\n", - " {\n", - " \"particle\": \"Fickian diffusion\", \n", - " \"SEI\":\"solvent-diffusion limited\", \n", - " \"SEI film resistance\":\"distributed\", \n", - " \"SEI porosity change\":\"false\", \n", - " \"particle mechanics\":\"swelling only\",\n", - " \"loss of active material\":\"stress-driven\",\n", - " }\n", - ")\n", - "param = pybamm.ParameterValues(\"Ai2020\")\n", - "param.update({\"Negative electrode LAM constant proportional term [s-1]\": 1e-4/3600})\n", - "param.update({\"Positive electrode LAM constant proportional term [s-1]\": 1e-4/3600})\n", - "total_cycles = 2\n", - "experiment = pybamm.Experiment(\n", - " [\n", - " \"Discharge at 1C until 3 V\",\n", - " \"Rest for 600 seconds\",\n", - " \"Charge at 1C until 4.2 V\",\n", - " \"Hold at 4.199 V for 600 seconds\",\n", - " ] * total_cycles\n", - ")\n", - "sim1 = pybamm.Simulation(\n", - " model, \n", - " experiment = experiment,\n", - " parameter_values = param,\n", - " solver = pybamm.CasadiSolver(\"fast with events\")\n", - ")\n", - "solution = sim1.solve(calc_esoh=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "t_all = solution[\"Time [h]\"].entries\n", - "v_all = solution[\"Voltage [V]\"].entries\n", - "I_if_n = solution[\"Sum of x-averaged negative electrode volumetric interfacial current densities [A.m-3]\"].entries\n", - "I_if_p = solution[\"Sum of x-averaged positive electrode volumetric interfacial current densities [A.m-3]\"].entries" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# ploting the results\n", - "f, (ax1, ax2, ax3) = plt.subplots(1, 3 ,figsize=(18,4))\n", - "\n", - "ax1.plot(t_all, v_all, label=\"loss of active material model\")\n", - "ax1.set_xlabel(\"Time [h]\")\n", - "ax1.set_ylabel(\"Voltage [V]\")\n", - "#ax1.legend()\n", - "\n", - "\n", - "ax2.plot(t_all, I_if_p, label=\"loss of active material model\")\n", - "ax2.set_xlabel(\"Time [h]\")\n", - "ax2.set_ylabel(\"Positive electrode interfacial current densities [A.m-3]\")\n", - "#ax2.legend()\n", - "#ax2.set_xlim(6000,7000)\n", - "\n", - "ax3.plot(t_all, I_if_n, label=\"loss of active material model\")\n", - "ax3.set_xlabel(\"Time [h]\")\n", - "ax3.set_ylabel(\"Negative electrode interfacial current densities [A.m-3]\")\n", - "ax3.legend(bbox_to_anchor=(1, 1.2))\n", - "#ax3.set_xlim(10000,15000)\n", - "# f.tight_layout(pad=1.0)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "LAM_n_all = solution[\"X-averaged negative electrode active material volume fraction\"].entries\n", - "LAM_p_all = solution[\"X-averaged positive electrode active material volume fraction\"].entries\n", - "f, (ax1, ax2) = plt.subplots(1, 2 ,figsize=(10,4))\n", - "ax1.plot(t_all, LAM_n_all, label=\"loss of active material model\")\n", - "ax1.set_xlabel(\"Time [h]\")\n", - "ax1.set_ylabel(\"X-averaged negative electrode active material volume fraction\")\n", - "\n", - "ax2.plot(t_all, LAM_p_all, label=\"loss of active material model\")\n", - "ax2.set_xlabel(\"Time [h]\")\n", - "ax2.set_ylabel(\"X-averaged positive electrode active material volume fraction\")\n", - "f.tight_layout(pad=3.0)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "E_n = param[\"Negative electrode Young's modulus [Pa]\"]\n", - "E_p = param[\"Positive electrode Young's modulus [Pa]\"]\n", - "\n", - "S_t_n_all = solution[\"X-averaged negative particle surface tangential stress [Pa]\"].entries / E_n\n", - "S_t_p_all = solution[\"X-averaged positive particle surface tangential stress [Pa]\"].entries / E_p\n", - "f, (ax1, ax2) = plt.subplots(1, 2 ,figsize=(10,4))\n", - "ax1.plot(t_all, S_t_n_all, label=\"loss of active material model\")\n", - "ax1.set_xlabel(\"Time [h]\")\n", - "ax1.set_ylabel(\"X-averaged negative tangential stress/ $E_n$\")\n", - "\n", - "ax2.plot(t_all, S_t_p_all, label=\"loss of active material model\")\n", - "ax2.set_xlabel(\"Time [h]\")\n", - "ax2.set_ylabel(\"X-averaged positive tangential stress/ $E_p$\")\n", - "f.tight_layout(pad=3.0)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "k1 = 1e-4\n", - "k2 = 1e-3\n", - "k3 = 1e-2\n", - "param.update({\"Positive electrode LAM constant proportional term [s-1]\": k2/3600})\n", - "param.update({\"Negative electrode LAM constant proportional term [s-1]\": k2/3600})\n", - "sim2 = pybamm.Simulation(\n", - " model, \n", - " experiment=experiment,\n", - " parameter_values=param,\n", - " solver=pybamm.CasadiSolver(\"fast with events\"),\n", - ")\n", - "solution2 = sim2.solve(calc_esoh=False)\n", - "param.update({\"Positive electrode LAM constant proportional term [s-1]\": k3/3600})\n", - "param.update({\"Negative electrode LAM constant proportional term [s-1]\": k3/3600})\n", - "sim3 = pybamm.Simulation(\n", - " model, \n", - " experiment=experiment,\n", - " parameter_values=param,\n", - " solver=pybamm.CasadiSolver(\"fast with events\"),\n", - ")\n", - "solution3 = sim3.solve(calc_esoh=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "t_all2 = solution2[\"Time [h]\"].entries\n", - "t_all3 = solution3[\"Time [h]\"].entries\n", - "LAM_n_all2 = solution2[\"X-averaged negative electrode active material volume fraction\"].entries\n", - "LAM_p_all2 = solution2[\"X-averaged positive electrode active material volume fraction\"].entries\n", - "LAM_n_all3 = solution3[\"X-averaged negative electrode active material volume fraction\"].entries\n", - "LAM_p_all3 = solution3[\"X-averaged positive electrode active material volume fraction\"].entries\n", - "\n", - "f, (ax1, ax2) = plt.subplots(1, 2 ,figsize=(10,4))\n", - "ax1.plot(t_all, LAM_n_all, label=\"k_LAM = \"+ str(k1))\n", - "ax1.plot(t_all2, LAM_n_all2, label=\"k_LAM = \"+ str(k2))\n", - "ax1.plot(t_all3, LAM_n_all3, label=\"k_LAM = \"+ str(k3))\n", - "ax1.set_xlabel(\"Time [h]\")\n", - "ax1.set_ylabel(\"X-averaged negative electrode active material volume fraction\")\n", - "ax1.legend()\n", - "ax2.plot(t_all, LAM_p_all, label=\"k_LAM = \"+ str(k1))\n", - "ax2.plot(t_all2, LAM_p_all2, label=\"k_LAM = \"+ str(k2))\n", - "ax2.plot(t_all3, LAM_p_all3, label=\"k_LAM = \"+ str(k3))\n", - "ax2.set_xlabel(\"Time [h]\")\n", - "ax2.set_ylabel(\"X-averaged positive electrode active material volume fraction\")\n", - "f.tight_layout(pad=3.0)\n", - "ax2.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "t_all2 = solution2[\"Time [h]\"].entries\n", - "t_all3 = solution3[\"Time [h]\"].entries\n", - "a_n_all = solution[\"X-averaged negative electrode surface area to volume ratio [m-1]\"].entries\n", - "a_p_all = solution[\"X-averaged positive electrode surface area to volume ratio [m-1]\"].entries\n", - "a_n_all2 = solution2[\"X-averaged negative electrode surface area to volume ratio [m-1]\"].entries\n", - "a_p_all2 = solution2[\"X-averaged positive electrode surface area to volume ratio [m-1]\"].entries\n", - "a_n_all3 = solution3[\"Negative electrode surface area to volume ratio [m-1]\"].entries[-1,:]\n", - "a_p_all3 = solution3[\"Positive electrode surface area to volume ratio [m-1]\"].entries[0,:]\n", - "\n", - "f, (ax1, ax2) = plt.subplots(1, 2 ,figsize=(10,4))\n", - "ax1.plot(t_all, a_n_all, label=\"k_LAM = \"+ str(k1))\n", - "ax1.plot(t_all2, a_n_all2, label=\"k_LAM = \"+ str(k2))\n", - "ax1.plot(t_all3, a_n_all3, label=\"k_LAM = \"+ str(k3))\n", - "ax1.set_xlabel(\"Time [h]\")\n", - "ax1.set_ylabel(\"X-averaged negative electrode surface area to volume ratio [m-1]\")\n", - "ax1.legend()\n", - "ax2.plot(t_all, a_p_all, label=\"k_LAM = \"+ str(k1))\n", - "ax2.plot(t_all2, a_p_all2, label=\"k_LAM = \"+ str(k2))\n", - "ax2.plot(t_all3, a_p_all3, label=\"k_LAM = \"+ str(k3))\n", - "ax2.set_xlabel(\"Time [h]\")\n", - "ax2.set_ylabel(\"X-averaged positive electrode surface area to volume ratio [m-1]\")\n", - "f.tight_layout(pad=3.0)\n", - "ax2.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "v_all = solution[\"Voltage [V]\"].entries\n", - "v_all2 = solution2[\"Voltage [V]\"].entries\n", - "v_all3 = solution3[\"Voltage [V]\"].entries\n", - "I_if_n = solution[\"Sum of x-averaged negative electrode volumetric interfacial current densities [A.m-3]\"].entries\n", - "I_if_p = solution[\"Sum of x-averaged positive electrode volumetric interfacial current densities [A.m-3]\"].entries\n", - "I_if_n2 = solution2[\"Sum of x-averaged negative electrode volumetric interfacial current densities [A.m-3]\"].entries\n", - "I_if_p2 = solution2[\"Sum of x-averaged positive electrode volumetric interfacial current densities [A.m-3]\"].entries\n", - "I_if_n3 = solution3[\"Sum of x-averaged negative electrode volumetric interfacial current densities [A.m-3]\"].entries\n", - "I_if_p3 = solution3[\"Sum of x-averaged positive electrode volumetric interfacial current densities [A.m-3]\"].entries\n", - "\n", - "f, (ax1, ax2, ax3) = plt.subplots(1, 3 ,figsize=(18,5))\n", - "ax1.plot(t_all, v_all, label=\"k_LAM = \"+ str(k1))\n", - "ax1.plot(t_all2, v_all2, label=\"k_LAM = \"+ str(k2))\n", - "ax1.plot(t_all3, v_all3, label=\"k_LAM = \"+ str(k3))\n", - "ax1.set_xlabel(\"Time [h]\")\n", - "ax1.set_ylabel(\"Voltage [V]\")\n", - "#ax1.legend()\n", - "#ax1.set_xlim(0.5,0.8)\n", - "\n", - "ax2.plot(t_all, I_if_n, label=\"k_LAM = \"+ str(k1))\n", - "ax2.plot(t_all2, I_if_n2, label=\"k_LAM = \"+ str(k2))\n", - "ax2.plot(t_all3, I_if_n3, label=\"k_LAM = \"+ str(k3))\n", - "ax2.set_xlabel(\"Time [h]\")\n", - "ax2.set_ylabel(\"Negative electrode interfacial current densities\")\n", - "#ax2.legend()\n", - "#ax2.set_xlim(6000,7000)\n", - "ax2.set_ylim(2.2155,2.2165)\n", - "\n", - "ax3.plot(t_all, I_if_p, label=\"k_LAM = \"+ str(k1))\n", - "ax3.plot(t_all2, I_if_p2, label=\"k_LAM = \"+ str(k2))\n", - "ax3.plot(t_all3, I_if_p3, label=\"k_LAM = \"+ str(k3))\n", - "ax3.set_xlabel(\"Time [h]\")\n", - "ax3.set_ylabel(\"Positive electrode interfacial current densities\")\n", - "ax3.legend(bbox_to_anchor=(0.68, 1.3), ncol=2)\n", - "#ax3.set_xlim(2,2.8)\n", - "#ax3.set_ylim(2.492,2.494)\n", - "ax3.set_ylim(-2.494,-2.492)\n", - "plt.tight_layout(pad=1.0)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## References\n", - "\n", - "The relevant papers for this notebook are:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1] Weilong Ai, Ludwig Kraft, Johannes Sturm, Andreas Jossen, and Billy Wu. Electrochemical thermal-mechanical modelling of stress inhomogeneity in lithium-ion pouch cells. Journal of The Electrochemical Society, 167(1):013512, 2019. doi:10.1149/2.0122001JES.\n", - "[2] Joel A. E. Andersson, Joris Gillis, Greg Horn, James B. Rawlings, and Moritz Diehl. CasADi – A software framework for nonlinear optimization and optimal control. Mathematical Programming Computation, 11(1):1–36, 2019. doi:10.1007/s12532-018-0139-4.\n", - "[3] Rutooj Deshpande, Mark Verbrugge, Yang-Tse Cheng, John Wang, and Ping Liu. Battery cycle life prediction with coupled chemical degradation and fatigue mechanics. Journal of the Electrochemical Society, 159(10):A1730, 2012. doi:10.1149/2.049210jes.\n", - "[4] Marc Doyle, Thomas F. Fuller, and John Newman. Modeling of galvanostatic charge and discharge of the lithium/polymer/insertion cell. Journal of the Electrochemical society, 140(6):1526–1533, 1993. doi:10.1149/1.2221597.\n", - "[5] Charles R. Harris, K. Jarrod Millman, Stéfan J. van der Walt, Ralf Gommers, Pauli Virtanen, David Cournapeau, Eric Wieser, Julian Taylor, Sebastian Berg, Nathaniel J. Smith, and others. Array programming with NumPy. Nature, 585(7825):357–362, 2020. doi:10.1038/s41586-020-2649-2.\n", - "[6] Jorn M. Reniers, Grietus Mulder, and David A. Howey. Review and performance comparison of mechanical-chemical degradation models for lithium-ion batteries. Journal of The Electrochemical Society, 166(14):A3189, 2019. doi:10.1149/2.0281914jes.\n", - "[7] Valentin Sulzer, Scott G. Marquis, Robert Timms, Martin Robinson, and S. Jon Chapman. Python Battery Mathematical Modelling (PyBaMM). Journal of Open Research Software, 9(1):14, 2021. doi:10.5334/jors.309.\n", - "\n" - ] - } - ], - "source": [ - "pybamm.print_citations()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "pybamm", - "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.9.16" - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": false, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": true - }, - "vscode": { - "interpreter": { - "hash": "187972e187ab8dfbecfab9e8e194ae6d08262b2d51a54fa40644e3ddb6b5f74c" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/docs/source/examples/notebooks/models/thermal-models.ipynb b/docs/source/examples/notebooks/models/thermal-models.ipynb index 788a02a88f..9ee4c1328a 100644 --- a/docs/source/examples/notebooks/models/thermal-models.ipynb +++ b/docs/source/examples/notebooks/models/thermal-models.ipynb @@ -519,7 +519,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "dev", "language": "python", "name": "python3" }, @@ -533,7 +533,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.0" + "version": "3.9.16" }, "toc": { "base_numbering": 1, @@ -547,6 +547,11 @@ "toc_position": {}, "toc_section_display": true, "toc_window_display": true + }, + "vscode": { + "interpreter": { + "hash": "bca2b99bfac80e18288b793d52fa0653ab9b5fe5d22e7b211c44eb982a41c00c" + } } }, "nbformat": 4, diff --git a/docs/source/user_guide/installation/GNU-linux.rst b/docs/source/user_guide/installation/GNU-linux.rst index 8f1ee50dbc..3bdeda9ad9 100644 --- a/docs/source/user_guide/installation/GNU-linux.rst +++ b/docs/source/user_guide/installation/GNU-linux.rst @@ -185,7 +185,7 @@ Then, to install PyBaMM as a `developer `__ 1.16.0 `SciPy `__ 2.8.2 -`pandas `__ 0.24.0 `CasADi `__ 3.6.0 `Xarray `__ 2023.04.0 ================================================================ ========================== @@ -93,7 +92,20 @@ Dependency Minimum Version p =========================================================== ================== ================== ================================================================== `imageio `__ 2.9.0 plot For generating simulation GIFs. `matplotlib `__ 2.0.0 plot To plot various battery models, and analyzing battery performance. -=========================================================== ================== ================== ================================================================== +=========================================================== ================== ================== ================================================================== + +.. _install.pandas_dependencies: + +Pandas dependencies +^^^^^^^^^^^^^^^^^^^ + +Installable with ``pip install "pybamm[pandas]"`` + +=========================================================== ================== ================== ================================================================== +Dependency Minimum Version pip extra Notes +=========================================================== ================== ================== ================================================================== +`pandas `__ 0.24.0 pandas For data manipulation and analysis. +=========================================================== ================== ================== ================================================================== .. _install.docs_dependencies: @@ -115,7 +127,7 @@ Dependency `sphinx-autobuild `__ \- docs For re-building docs once triggered. ================================================================================================= ================== ================== ======================================================================= -.. _install.examples_dependencies: +.. _install.examples_dependencies: Examples dependencies ^^^^^^^^^^^^^^^^^^^^^ @@ -226,7 +238,7 @@ Dependency Before running ``pip install "pybamm[odes]"``, make sure to install ``scikits.odes`` build-time requirements as described `here `_ . Full installation guide ------------------------ +----------------------- Installing a specific version? Installing from source? Check the advanced installation pages below @@ -237,4 +249,4 @@ Installing a specific version? Installing from source? Check the advanced instal windows windows-wsl install-from-source - install-from-docker \ No newline at end of file + install-from-docker diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index fb3596dc20..6104fe27af 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -47,5 +47,3 @@ To exit the Docker container's shell, you can simply type: exit This will return you to your host machine's terminal. - - diff --git a/docs/source/user_guide/installation/install-from-source.rst b/docs/source/user_guide/installation/install-from-source.rst index c0d49e3858..0e3573cee2 100644 --- a/docs/source/user_guide/installation/install-from-source.rst +++ b/docs/source/user_guide/installation/install-from-source.rst @@ -90,7 +90,7 @@ If you'd rather do things yourself, 2. Compile and install SuiteSparse (PyBaMM only requires the ``KLU`` component). 3. Compile and install SUNDIALS. 4. Clone the pybind11 repository in the ``PyBaMM/`` directory (make sure the directory is named ``pybind11``). - + PyBaMM ships with a Python script that automates points 2. and 3. You can run it with @@ -193,7 +193,7 @@ Finally, to run the unit and the integration suites sequentially, use nox -s tests -Using the test runner +Using the test runner ~~~~~~~~~~~~~~~~~~~~~~ You can run unit tests for PyBaMM using @@ -239,6 +239,7 @@ Doctests, examples, and coverage - ``nox -s examples``: Run the example scripts in ``examples/scripts``. - ``nox -s doctests``: Run doctests. - ``nox -s coverage``: Measure current test coverage and generate a coverage report. +- ``nox -s quick``: Run integration tests, unit tests, and doctests sequentially. Extra tips while using Nox -------------------------- diff --git a/docs/sphinxext/inheritance_diagram.py b/docs/sphinxext/inheritance_diagram.py index 048921bffb..30a61aeba2 100644 --- a/docs/sphinxext/inheritance_diagram.py +++ b/docs/sphinxext/inheritance_diagram.py @@ -20,16 +20,21 @@ def add_diagram(app, what, name, obj, options, lines): # do nothing if it is not a derived class return - # Append the inheritance diagram to the docstring + # Append the inheritance diagram to the docstring. Note: we do this + # for HTML output only because SVG output creates multiple PDFs which + # are not supported by Read the Docs. + # https://github.com/readthedocs/readthedocs.org/issues/2045 lines.append("\n") - lines.append(".. dropdown:: View inheritance diagram for this model") - lines.append(" :animate: fade-in-slide-down") - lines.append(" :icon: eye\n") - lines.append(" :class-title: sd-align-major-center sd-fs-6 \n") - lines.append(" :class-container: sd-text-info \n") + lines.append(".. only:: not latex\n") lines.append("\n") - lines.append(" .. inheritance-diagram:: " + cls_name) - lines.append(" :parts: 2\n") + lines.append(" .. dropdown:: View inheritance diagram for this model") + lines.append(" :animate: fade-in-slide-down") + lines.append(" :icon: eye\n") + lines.append(" :class-title: sd-align-major-center sd-fs-6 \n") + lines.append(" :class-container: sd-text-info \n") + lines.append("\n") + lines.append(" .. inheritance-diagram:: " + cls_name) + lines.append(" :parts: 2\n") lines.append("\n") diff --git a/examples/scripts/compare_comsol/compare_comsol_DFN.py b/examples/scripts/compare_comsol/compare_comsol_DFN.py index f06293d42d..afdb9eacbf 100644 --- a/examples/scripts/compare_comsol/compare_comsol_DFN.py +++ b/examples/scripts/compare_comsol/compare_comsol_DFN.py @@ -102,6 +102,7 @@ def get_interp_fun(variable_name, domain): # Create comsol model with dictionary of Matrix variables comsol_model = pybamm.lithium_ion.BaseModel() +comsol_model._geometry = pybamm_model.default_geometry comsol_model.variables = { "Negative particle surface concentration [mol.m-3]": comsol_c_n_surf, "Electrolyte concentration [mol.m-3]": comsol_c_e, diff --git a/examples/scripts/thermal_lithium_ion.py b/examples/scripts/thermal_lithium_ion.py index 9240c6e895..cd950cd701 100644 --- a/examples/scripts/thermal_lithium_ion.py +++ b/examples/scripts/thermal_lithium_ion.py @@ -3,58 +3,35 @@ # import pybamm -import numpy as np -# load model pybamm.set_logging_level("INFO") -options = {"thermal": "x-full"} -full_thermal_model = pybamm.lithium_ion.SPMe(options) - -options = {"thermal": "x-lumped"} -lumped_thermal_model = pybamm.lithium_ion.SPMe(options) - -models = [full_thermal_model, lumped_thermal_model] - -# load parameter values and process models and geometry -param = models[0].default_parameter_values +# load models +models = [ + pybamm.lithium_ion.SPMe({"thermal": "x-full"}), + pybamm.lithium_ion.SPMe({"thermal": "x-lumped"}), +] -# for x-full, cooling is only implemented on the surfaces -# so set other forms of cooling to zero for comparison. -param.update( +# load parameter values and update cooling coefficients +parameter_values = pybamm.ParameterValues("Marquis2019") +parameter_values.update( { - "Negative current collector" - + " surface heat transfer coefficient [W.m-2.K-1]": 5, - "Positive current collector" - + " surface heat transfer coefficient [W.m-2.K-1]": 5, - "Negative tab heat transfer coefficient [W.m-2.K-1]": 0, - "Positive tab heat transfer coefficient [W.m-2.K-1]": 0, - "Edge heat transfer coefficient [W.m-2.K-1]": 0, + "Negative current collector surface heat transfer coefficient [W.m-2.K-1]" + "": 5, + "Positive current collector surface heat transfer coefficient [W.m-2.K-1]" + "": 5, + "Negative tab heat transfer coefficient [W.m-2.K-1]": 10, + "Positive tab heat transfer coefficient [W.m-2.K-1]": 10, + "Edge heat transfer coefficient [W.m-2.K-1]": 5, } ) +# create and solve simulations +sols = [] for model in models: - param.process_model(model) - -# set mesh -var_pts = {"x_n": 10, "x_s": 10, "x_p": 10, "r_n": 10, "r_p": 10} - -# discretise models -for model in models: - # create geometry - geometry = model.default_geometry - param.process_geometry(geometry) - mesh = pybamm.Mesh(geometry, models[-1].default_submesh_types, var_pts) - disc = pybamm.Discretisation(mesh, model.default_spatial_methods) - disc.process_model(model) - -# solve model -solutions = [None] * len(models) -t_eval = np.linspace(0, 3600, 100) -for i, model in enumerate(models): - solver = pybamm.ScipySolver(atol=1e-8, rtol=1e-8) - solution = solver.solve(model, t_eval) - solutions[i] = solution + sim = pybamm.Simulation(model, parameter_values=parameter_values) + sol = sim.solve([0, 3600]) + sols.append(sol) # plot output_variables = [ @@ -63,5 +40,4 @@ "Cell temperature [K]", ] labels = ["Full thermal model", "Lumped thermal model"] -plot = pybamm.QuickPlot(solutions, output_variables, labels) -plot.dynamic_plot() +pybamm.dynamic_plot(sols, output_variables, labels=labels) diff --git a/noxfile.py b/noxfile.py index 264a22a5f3..2a08865037 100644 --- a/noxfile.py +++ b/noxfile.py @@ -19,6 +19,10 @@ # Do not stdout ANSI colours on GitHub Actions if os.getenv("CI") == "true": os.environ["NO_COLOR"] = "1" + # The setup-python action installs and caches dependencies by default, so we skip + # installing them again in nox environments. The dev and docs sessions will still + # require a virtual environment, but we don't run them in the CI + nox.options.default_venv_backend = "none" def set_environment_variables(env_dict, session): @@ -42,7 +46,7 @@ def run_pybamm_requires(session): """Download, compile, and install the build-time requirements for Linux and macOS: the SuiteSparse and SUNDIALS libraries.""" # noqa: E501 set_environment_variables(PYBAMM_ENV, session=session) if sys.platform != "win32": - session.install("wget", "cmake") + session.run_always("pip", "install", "wget", "cmake") session.run("python", "scripts/install_KLU_Sundials.py") if not os.path.exists("./pybind11"): session.run( @@ -60,11 +64,11 @@ def run_pybamm_requires(session): def run_coverage(session): """Run the coverage tests and generate an XML report.""" set_environment_variables(PYBAMM_ENV, session=session) - session.install("coverage") - session.install("-e", ".[all]") + session.run_always("pip", "install", "coverage") + session.run_always("pip", "install", "-e", ".[all]") if sys.platform != "win32": - session.install("-e", ".[odes]") - session.install("-e", ".[jax]") + session.run_always("pip", "install", "-e", ".[odes]") + session.run_always("pip", "install", "-e", ".[jax]") session.run("coverage", "run", "--rcfile=.coveragerc", "run-tests.py", "--nosub") session.run("coverage", "combine") session.run("coverage", "xml") @@ -74,16 +78,16 @@ def run_coverage(session): def run_integration(session): """Run the integration tests.""" set_environment_variables(PYBAMM_ENV, session=session) - session.install("-e", ".[all]") + session.run_always("pip", "install", "-e", ".[all]") if sys.platform == "linux": - session.install("-e", ".[odes]") + session.run_always("pip", "install", "-e", ".[odes]") session.run("python", "run-tests.py", "--integration") @nox.session(name="doctests") def run_doctests(session): """Run the doctests and generate the output(s) in the docs/build/ directory.""" - session.install("-e", ".[all,docs]") + session.run_always("pip", "install", "-e", ".[all,docs]") session.run("python", "run-tests.py", "--doctest") @@ -91,17 +95,18 @@ def run_doctests(session): def run_unit(session): """Run the unit tests.""" set_environment_variables(PYBAMM_ENV, session=session) - session.install("-e", ".[all]") + session.run_always("pip", "install", "-e", ".[all]") if sys.platform == "linux": - session.install("-e", ".[odes]") - session.install("-e", ".[jax]") + session.run_always("pip", "install", "-e", ".[odes]") + session.run_always("pip", "install", "-e", ".[jax]") session.run("python", "run-tests.py", "--unit") @nox.session(name="examples") def run_examples(session): """Run the examples tests for Jupyter notebooks and Python scripts.""" - session.install("-e", ".[all]") + set_environment_variables(PYBAMM_ENV, session=session) + session.run_always("pip", "install", "-e", ".[all]") session.run("python", "run-tests.py", "--examples") @@ -127,10 +132,10 @@ def set_dev(session): def run_tests(session): """Run the unit tests and integration tests sequentially.""" set_environment_variables(PYBAMM_ENV, session=session) - session.install("-e", ".[all]") + session.run_always("pip", "install", "-e", ".[all]") if sys.platform == "linux" or sys.platform == "darwin": - session.install("-e", ".[odes]") - session.install("-e", ".[jax]") + session.run_always("pip", "install", "-e", ".[odes]") + session.run_always("pip", "install", "-e", ".[jax]") session.run("python", "run-tests.py", "--all") @@ -156,3 +161,10 @@ def lint(session): """Check all files against the defined pre-commit hooks.""" session.install("pre-commit") session.run("pre-commit", "run", "--all-files") + + +@nox.session(name="quick", reuse_venv=True) +def run_quick(session): + """Run integration tests, unit tests, and doctests sequentially""" + run_tests(session) + run_doctests(session) diff --git a/pybamm/discretisations/discretisation.py b/pybamm/discretisations/discretisation.py index 5dfd2405cc..c04b41c888 100644 --- a/pybamm/discretisations/discretisation.py +++ b/pybamm/discretisations/discretisation.py @@ -241,6 +241,10 @@ def process_model( model_disc ) + # Save geometry + pybamm.logger.verbose("Save geometry for {}".format(model.name)) + model_disc._geometry = getattr(self.mesh, "_geometry", None) + # Check that resulting model makes sense if check_model: pybamm.logger.verbose("Performing model checks for {}".format(model.name)) @@ -454,7 +458,11 @@ def process_boundary_conditions(self, model): # check if the boundary condition at the origin for sphere domains is other # than no flux for subdomain in key.domain: - if self.mesh[subdomain].coord_sys == "spherical polar": + if ( + self.mesh[subdomain].coord_sys + in ["spherical polar", "cylindrical polar"] + and list(self.mesh.geometry[subdomain].values())[0]["min"] == 0 + ): if bcs["left"][0].value != 0 or bcs["left"][1] != "Neumann": raise pybamm.ModelError( "Boundary condition at r = 0 must be a homogeneous " diff --git a/pybamm/expression_tree/binary_operators.py b/pybamm/expression_tree/binary_operators.py index 8bd8423c91..6794d201af 100644 --- a/pybamm/expression_tree/binary_operators.py +++ b/pybamm/expression_tree/binary_operators.py @@ -16,6 +16,14 @@ def _preprocess_binary(left, right): left = pybamm.Scalar(left) if isinstance(right, numbers.Number): right = pybamm.Scalar(right) + elif isinstance(left, np.ndarray): + if left.ndim > 1: + raise ValueError("left must be a 1D array") + left = pybamm.Vector(left) + elif isinstance(right, np.ndarray): + if right.ndim > 1: + raise ValueError("right must be a 1D array") + right = pybamm.Vector(right) # Check both left and right are pybamm Symbols if not (isinstance(left, pybamm.Symbol) and isinstance(right, pybamm.Symbol)): @@ -756,7 +764,7 @@ def simplified_power(left, right): return pybamm.simplify_if_constant(pybamm.Power(left, right)) -def simplified_addition(left, right): +def add(left, right): """ Note ---- @@ -771,7 +779,7 @@ def simplified_addition(left, right): left, right = right, left # Check for Concatenations and Broadcasts - out = _simplified_binary_broadcast_concatenation(left, right, simplified_addition) + out = _simplified_binary_broadcast_concatenation(left, right, add) if out is not None: return out @@ -844,7 +852,7 @@ def simplified_addition(left, right): return pybamm.simplify_if_constant(Addition(left, right)) -def simplified_subtraction(left, right): +def subtract(left, right): """ Note ---- @@ -860,9 +868,7 @@ def simplified_subtraction(left, right): return -right + left # Check for Concatenations and Broadcasts - out = _simplified_binary_broadcast_concatenation( - left, right, simplified_subtraction - ) + out = _simplified_binary_broadcast_concatenation(left, right, subtract) if out is not None: return out @@ -873,7 +879,7 @@ def simplified_subtraction(left, right): if pybamm.is_matrix_zero(left): if right.evaluates_to_number(): return -right * pybamm.ones_like(left) - # See comments in simplified_addition + # See comments in add elif all( left_dim_size <= right_dim_size for left_dim_size, right_dim_size in zip( @@ -928,7 +934,7 @@ def simplified_subtraction(left, right): return pybamm.simplify_if_constant(Subtraction(left, right)) -def simplified_multiplication(left, right): +def multiply(left, right): left, right = _simplify_elementwise_binary_broadcasts(left, right) # Move constant to always be on the left @@ -936,9 +942,7 @@ def simplified_multiplication(left, right): left, right = right, left # Check for Concatenations and Broadcasts - out = _simplified_binary_broadcast_concatenation( - left, right, simplified_multiplication - ) + out = _simplified_binary_broadcast_concatenation(left, right, multiply) if out is not None: return out @@ -1055,7 +1059,7 @@ def simplified_multiplication(left, right): return Multiplication(left, right) -def simplified_division(left, right): +def divide(left, right): left, right = _simplify_elementwise_binary_broadcasts(left, right) # anything divided by zero raises error @@ -1068,7 +1072,7 @@ def simplified_division(left, right): return (1 / right) * left # Check for Concatenations and Broadcasts - out = _simplified_binary_broadcast_concatenation(left, right, simplified_division) + out = _simplified_binary_broadcast_concatenation(left, right, divide) if out is not None: return out @@ -1126,7 +1130,7 @@ def simplified_division(left, right): return pybamm.simplify_if_constant(Division(left, right)) -def simplified_matrix_multiplication(left, right): +def matmul(left, right): left, right = _preprocess_binary(left, right) if pybamm.is_matrix_zero(left) or pybamm.is_matrix_zero(right): return pybamm.zeros_like(MatrixMultiplication(left, right)) diff --git a/pybamm/expression_tree/symbol.py b/pybamm/expression_tree/symbol.py index 32c226fe56..5d28884ed5 100644 --- a/pybamm/expression_tree/symbol.py +++ b/pybamm/expression_tree/symbol.py @@ -540,43 +540,43 @@ def __repr__(self): def __add__(self, other): """return an :class:`Addition` object.""" - return pybamm.simplified_addition(self, other) + return pybamm.add(self, other) def __radd__(self, other): """return an :class:`Addition` object.""" - return pybamm.simplified_addition(other, self) + return pybamm.add(other, self) def __sub__(self, other): """return a :class:`Subtraction` object.""" - return pybamm.simplified_subtraction(self, other) + return pybamm.subtract(self, other) def __rsub__(self, other): """return a :class:`Subtraction` object.""" - return pybamm.simplified_subtraction(other, self) + return pybamm.subtract(other, self) def __mul__(self, other): """return a :class:`Multiplication` object.""" - return pybamm.simplified_multiplication(self, other) + return pybamm.multiply(self, other) def __rmul__(self, other): """return a :class:`Multiplication` object.""" - return pybamm.simplified_multiplication(other, self) + return pybamm.multiply(other, self) def __matmul__(self, other): """return a :class:`MatrixMultiplication` object.""" - return pybamm.simplified_matrix_multiplication(self, other) + return pybamm.matmul(self, other) def __rmatmul__(self, other): """return a :class:`MatrixMultiplication` object.""" - return pybamm.simplified_matrix_multiplication(other, self) + return pybamm.matmul(other, self) def __truediv__(self, other): """return a :class:`Division` object.""" - return pybamm.simplified_division(self, other) + return pybamm.divide(self, other) def __rtruediv__(self, other): """return a :class:`Division` object.""" - return pybamm.simplified_division(other, self) + return pybamm.divide(other, self) def __pow__(self, other): """return a :class:`Power` object.""" @@ -648,6 +648,13 @@ def __mod__(self, other): def __bool__(self): raise NotImplementedError("Boolean operator not defined for Symbols.") + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + """ + If a numpy ufunc is applied to a symbol, call the corresponding pybamm function + instead. + """ + return getattr(pybamm, ufunc.__name__)(*inputs, **kwargs) + def diff(self, variable): """ Differentiate a symbol with respect to a variable. For any symbol that can be diff --git a/pybamm/input/discharge_data/Enertech_cells/0.1C_discharge_displacement.txt b/pybamm/input/discharge_data/Enertech_cells/0.1C_discharge_displacement.txt index 1abab6f79c..ec8998b3c4 100644 --- a/pybamm/input/discharge_data/Enertech_cells/0.1C_discharge_displacement.txt +++ b/pybamm/input/discharge_data/Enertech_cells/0.1C_discharge_displacement.txt @@ -3742,4 +3742,4 @@ 36860 4.49083105587186E-7 36870 3.6003394272133456E-7 36880 2.7098410120201244E-7 -36881.8408095558 2.5459165129906363E-7 \ No newline at end of file +36881.8408095558 2.5459165129906363E-7 diff --git a/pybamm/input/discharge_data/Enertech_cells/0.5C_discharge_displacement.txt b/pybamm/input/discharge_data/Enertech_cells/0.5C_discharge_displacement.txt index 8ee457ce77..42103e4d32 100644 --- a/pybamm/input/discharge_data/Enertech_cells/0.5C_discharge_displacement.txt +++ b/pybamm/input/discharge_data/Enertech_cells/0.5C_discharge_displacement.txt @@ -785,4 +785,4 @@ 7290 5.629040101801396E-6 7300 5.185645939982822E-6 7310 4.742039959903541E-6 -7311.673930367749 4.667763172375133E-6 \ No newline at end of file +7311.673930367749 4.667763172375133E-6 diff --git a/pybamm/input/discharge_data/Enertech_cells/1C_discharge_displacement.txt b/pybamm/input/discharge_data/Enertech_cells/1C_discharge_displacement.txt index 69f31d5e6c..c8881d82e0 100644 --- a/pybamm/input/discharge_data/Enertech_cells/1C_discharge_displacement.txt +++ b/pybamm/input/discharge_data/Enertech_cells/1C_discharge_displacement.txt @@ -414,4 +414,4 @@ 3580 1.3950084177824084E-5 3590 1.3086398528538203E-5 3600 1.2219619567992016E-5 -3609.1611221134444 1.1422884433792557E-5 \ No newline at end of file +3609.1611221134444 1.1422884433792557E-5 diff --git a/pybamm/input/discharge_data/Enertech_cells/stn_2C.txt b/pybamm/input/discharge_data/Enertech_cells/stn_2C.txt index 2b924bdb92..1517501646 100755 --- a/pybamm/input/discharge_data/Enertech_cells/stn_2C.txt +++ b/pybamm/input/discharge_data/Enertech_cells/stn_2C.txt @@ -1,5 +1,5 @@ -# Negative particle surface tangetial stress close to the separator -# for the Enertech cells Ai2020 JES +# Negative particle surface tangetial stress close to the separator +# for the Enertech cells Ai2020 JES # time [s] and normalised stress sigma_t_surf_n/E_n 0,-1.0741e-17 2,0.00031276 diff --git a/pybamm/input/discharge_data/Enertech_cells/stp_2C.txt b/pybamm/input/discharge_data/Enertech_cells/stp_2C.txt index 0cf5eb9b13..2190ad2fbf 100755 --- a/pybamm/input/discharge_data/Enertech_cells/stp_2C.txt +++ b/pybamm/input/discharge_data/Enertech_cells/stp_2C.txt @@ -1,4 +1,4 @@ -# Positive particle surface tangetial stress close to the separator +# Positive particle surface tangetial stress close to the separator # for the Enertech cells Ai2020 JES # time [s] and normalised stress sigma_t_surf_p/E_p 0,2.207e-18 diff --git a/pybamm/input/parameters/lead_acid/Sulzer2019.py b/pybamm/input/parameters/lead_acid/Sulzer2019.py index 3aaec4e3de..864eef6749 100644 --- a/pybamm/input/parameters/lead_acid/Sulzer2019.py +++ b/pybamm/input/parameters/lead_acid/Sulzer2019.py @@ -1,4 +1,5 @@ import pybamm +import numpy as np def lead_ocp_Bode1977(m): @@ -13,10 +14,10 @@ def lead_ocp_Bode1977(m): """ U = ( -0.294 - - 0.074 * pybamm.log10(m) - - 0.030 * pybamm.log10(m) ** 2 - - 0.031 * pybamm.log10(m) ** 3 - - 0.012 * pybamm.log10(m) ** 4 + - 0.074 * np.log10(m) + - 0.030 * np.log10(m) ** 2 + - 0.031 * np.log10(m) ** 3 + - 0.012 * np.log10(m) ** 4 ) return U @@ -65,10 +66,10 @@ def lead_dioxide_ocp_Bode1977(m): """ U = ( 1.628 - + 0.074 * pybamm.log10(m) - + 0.033 * pybamm.log10(m) ** 2 - + 0.043 * pybamm.log10(m) ** 3 - + 0.022 * pybamm.log10(m) ** 4 + + 0.074 * np.log10(m) + + 0.033 * np.log10(m) ** 2 + + 0.043 * np.log10(m) ** 3 + + 0.022 * np.log10(m) ** 4 ) return U @@ -161,7 +162,7 @@ def conductivity_Gu1997(c_e): California Univ., Berkeley. Lawrence Radiation Lab., 1968. """ - return c_e * pybamm.exp(6.23 - 1.34e-4 * c_e - 1.61e-8 * c_e**2) * 1e-4 + return c_e * np.exp(6.23 - 1.34e-4 * c_e - 1.61e-8 * c_e**2) * 1e-4 def darken_thermodynamic_factor_Chapman1968(c_e): diff --git a/pybamm/input/parameters/lithium_ion/Ai2020.py b/pybamm/input/parameters/lithium_ion/Ai2020.py index d197452bf1..abae3087ea 100644 --- a/pybamm/input/parameters/lithium_ion/Ai2020.py +++ b/pybamm/input/parameters/lithium_ion/Ai2020.py @@ -1,5 +1,6 @@ import pybamm import os +import numpy as np def graphite_diffusivity_Dualfoil1998(sto, T): @@ -31,7 +32,7 @@ def graphite_diffusivity_Dualfoil1998(sto, T): D_ref = 3.9 * 10 ** (-14) E_D_s = 5000 T_ref = 298.15 - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / T_ref - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / T_ref - 1 / T)) return D_ref * arrhenius @@ -66,7 +67,7 @@ def graphite_electrolyte_exchange_current_density_Dualfoil1998( 1 * 10 ** (-11) * pybamm.constants.F ) # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 5000 # activation energy for Temperature Dependent Reaction Constant [J/mol] - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -209,7 +210,7 @@ def graphite_cracking_rate_Ai2020(T_dim): Eac_cr = pybamm.Parameter( "Negative electrode activation energy for cracking rate [J.mol-1]" ) - arrhenius = pybamm.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / T_ref)) + arrhenius = np.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / T_ref)) return k_cr * arrhenius @@ -237,7 +238,7 @@ def lico2_diffusivity_Dualfoil1998(sto, T): D_ref = 5.387 * 10 ** (-15) E_D_s = 5000 T_ref = 298.15 - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / T_ref - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / T_ref - 1 / T)) return D_ref * arrhenius @@ -269,7 +270,7 @@ def lico2_electrolyte_exchange_current_density_Dualfoil1998(c_e, c_s_surf, c_s_m m_ref = 1 * 10 ** (-11) * pybamm.constants.F # need to match the unit from m/s # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 5000 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -388,7 +389,7 @@ def lico2_cracking_rate_Ai2020(T_dim): Eac_cr = pybamm.Parameter( "Positive electrode activation energy for cracking rate [J.mol-1]" ) - arrhenius = pybamm.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / T_ref)) + arrhenius = np.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / T_ref)) return k_cr * arrhenius diff --git a/pybamm/input/parameters/lithium_ion/Chen2020.py b/pybamm/input/parameters/lithium_ion/Chen2020.py index b53cf9b7e5..e526b480c4 100644 --- a/pybamm/input/parameters/lithium_ion/Chen2020.py +++ b/pybamm/input/parameters/lithium_ion/Chen2020.py @@ -1,4 +1,5 @@ import pybamm +import numpy as np def graphite_LGM50_ocp_Chen2020(sto): @@ -25,11 +26,11 @@ def graphite_LGM50_ocp_Chen2020(sto): """ u_eq = ( - 1.9793 * pybamm.exp(-39.3631 * sto) + 1.9793 * np.exp(-39.3631 * sto) + 0.2482 - - 0.0909 * pybamm.tanh(29.8538 * (sto - 0.1234)) - - 0.04478 * pybamm.tanh(14.9159 * (sto - 0.2769)) - - 0.0205 * pybamm.tanh(30.4444 * (sto - 0.6103)) + - 0.0909 * np.tanh(29.8538 * (sto - 0.1234)) + - 0.04478 * np.tanh(14.9159 * (sto - 0.2769)) + - 0.0205 * np.tanh(30.4444 * (sto - 0.6103)) ) return u_eq @@ -67,7 +68,7 @@ def graphite_LGM50_electrolyte_exchange_current_density_Chen2020( """ m_ref = 6.48e-7 # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 35000 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -100,9 +101,9 @@ def nmc_LGM50_ocp_Chen2020(sto): u_eq = ( -0.8090 * sto + 4.4875 - - 0.0428 * pybamm.tanh(18.5138 * (sto - 0.5542)) - - 17.7326 * pybamm.tanh(15.7890 * (sto - 0.3117)) - + 17.5842 * pybamm.tanh(15.9308 * (sto - 0.3120)) + - 0.0428 * np.tanh(18.5138 * (sto - 0.5542)) + - 17.7326 * np.tanh(15.7890 * (sto - 0.3117)) + + 17.5842 * np.tanh(15.9308 * (sto - 0.3120)) ) return u_eq @@ -138,7 +139,7 @@ def nmc_LGM50_electrolyte_exchange_current_density_Chen2020(c_e, c_s_surf, c_s_m """ m_ref = 3.42e-6 # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 17800 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 diff --git a/pybamm/input/parameters/lithium_ion/Chen2020_composite.py b/pybamm/input/parameters/lithium_ion/Chen2020_composite.py index fa01325dee..bbc7b1990e 100644 --- a/pybamm/input/parameters/lithium_ion/Chen2020_composite.py +++ b/pybamm/input/parameters/lithium_ion/Chen2020_composite.py @@ -1,5 +1,6 @@ import pybamm import os +import numpy as np def graphite_LGM50_electrolyte_exchange_current_density_Chen2020( @@ -34,7 +35,7 @@ def graphite_LGM50_electrolyte_exchange_current_density_Chen2020( """ m_ref = 6.48e-7 # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 35000 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -164,7 +165,7 @@ def silicon_LGM50_electrolyte_exchange_current_density_Chen2020( 6.48e-7 * 28700 / 278000 ) # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 35000 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -197,9 +198,9 @@ def nmc_LGM50_ocp_Chen2020(sto): u_eq = ( -0.8090 * sto + 4.4875 - - 0.0428 * pybamm.tanh(18.5138 * (sto - 0.5542)) - - 17.7326 * pybamm.tanh(15.7890 * (sto - 0.3117)) - + 17.5842 * pybamm.tanh(15.9308 * (sto - 0.3120)) + - 0.0428 * np.tanh(18.5138 * (sto - 0.5542)) + - 17.7326 * np.tanh(15.7890 * (sto - 0.3117)) + + 17.5842 * np.tanh(15.9308 * (sto - 0.3120)) ) return u_eq @@ -235,7 +236,7 @@ def nmc_LGM50_electrolyte_exchange_current_density_Chen2020(c_e, c_s_surf, c_s_m """ m_ref = 3.42e-6 # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 17800 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 diff --git a/pybamm/input/parameters/lithium_ion/Ecker2015.py b/pybamm/input/parameters/lithium_ion/Ecker2015.py index 14a6893736..3f37db6e61 100644 --- a/pybamm/input/parameters/lithium_ion/Ecker2015.py +++ b/pybamm/input/parameters/lithium_ion/Ecker2015.py @@ -1,4 +1,5 @@ import pybamm +import numpy as np def graphite_diffusivity_Ecker2015(sto, T): @@ -30,9 +31,9 @@ def graphite_diffusivity_Ecker2015(sto, T): Solid diffusivity """ - D_ref = 8.4e-13 * pybamm.exp(-11.3 * sto) + 8.2e-15 + D_ref = 8.4e-13 * np.exp(-11.3 * sto) + 8.2e-15 E_D_s = 3.03e4 - arrhenius = pybamm.exp(-E_D_s / (pybamm.constants.R * T)) * pybamm.exp( + arrhenius = np.exp(-E_D_s / (pybamm.constants.R * T)) * np.exp( E_D_s / (pybamm.constants.R * 296) ) @@ -88,12 +89,12 @@ def graphite_ocp_Ecker2015(sto): t = 0.196176 u_eq = ( - a * pybamm.exp(-b * sto) - + c * pybamm.exp(-d * (sto - e)) - - r * pybamm.tanh(s * (sto - t)) - - g * pybamm.tanh(h * (sto - i)) - - j * pybamm.tanh(k * (sto - m)) - - n * pybamm.exp(o * (sto - p)) + a * np.exp(-b * sto) + + c * np.exp(-d * (sto - e)) + - r * np.tanh(s * (sto - t)) + - g * np.tanh(h * (sto - i)) + - j * np.tanh(k * (sto - m)) + - n * np.exp(o * (sto - p)) + q ) @@ -142,7 +143,7 @@ def graphite_electrolyte_exchange_current_density_Ecker2015(c_e, c_s_surf, c_s_m ) # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 53400 - arrhenius = pybamm.exp(-E_r / (pybamm.constants.R * T)) * pybamm.exp( + arrhenius = np.exp(-E_r / (pybamm.constants.R * T)) * np.exp( E_r / (pybamm.constants.R * 296.15) ) @@ -180,9 +181,9 @@ def nco_diffusivity_Ecker2015(sto, T): Solid diffusivity """ - D_ref = 3.7e-13 - 3.4e-13 * pybamm.exp(-12 * (sto - 0.62) * (sto - 0.62)) + D_ref = 3.7e-13 - 3.4e-13 * np.exp(-12 * (sto - 0.62) * (sto - 0.62)) E_D_s = 8.06e4 - arrhenius = pybamm.exp(-E_D_s / (pybamm.constants.R * T)) * pybamm.exp( + arrhenius = np.exp(-E_D_s / (pybamm.constants.R * T)) * np.exp( E_D_s / (pybamm.constants.R * 296.15) ) @@ -235,11 +236,11 @@ def nco_ocp_Ecker2015(sto): u_eq = ( a * sto - - c * pybamm.tanh(d * (sto - e)) - - r * pybamm.tanh(s * (sto - t)) - - g * pybamm.tanh(h * (sto - i)) - - j * pybamm.tanh(k * (sto - m)) - - n * pybamm.tanh(o * (sto - p)) + - c * np.tanh(d * (sto - e)) + - r * np.tanh(s * (sto - t)) + - g * np.tanh(h * (sto - i)) + - j * np.tanh(k * (sto - m)) + - n * np.tanh(o * (sto - p)) + q ) return u_eq @@ -287,7 +288,7 @@ def nco_electrolyte_exchange_current_density_Ecker2015(c_e, c_s_surf, c_s_max, T ) # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 4.36e4 - arrhenius = pybamm.exp(-E_r / (pybamm.constants.R * T)) * pybamm.exp( + arrhenius = np.exp(-E_r / (pybamm.constants.R * T)) * np.exp( E_r / (pybamm.constants.R * 296.15) ) @@ -376,8 +377,8 @@ def electrolyte_conductivity_Ecker2015(c_e, T): # add temperature dependence E_k_e = 1.71e4 - C = 296 * pybamm.exp(E_k_e / (pybamm.constants.R * 296)) - sigma_e = C * sigma_e_296 * pybamm.exp(-E_k_e / (pybamm.constants.R * T)) / T + C = 296 * np.exp(E_k_e / (pybamm.constants.R * 296)) + sigma_e = C * sigma_e_296 * np.exp(-E_k_e / (pybamm.constants.R * T)) / T return sigma_e diff --git a/pybamm/input/parameters/lithium_ion/Marquis2019.py b/pybamm/input/parameters/lithium_ion/Marquis2019.py index 9ac47438b7..d3bddc6e30 100644 --- a/pybamm/input/parameters/lithium_ion/Marquis2019.py +++ b/pybamm/input/parameters/lithium_ion/Marquis2019.py @@ -1,4 +1,5 @@ import pybamm +import numpy as np def graphite_mcmb2528_diffusivity_Dualfoil1998(sto, T): @@ -25,7 +26,7 @@ def graphite_mcmb2528_diffusivity_Dualfoil1998(sto, T): D_ref = 3.9 * 10 ** (-14) E_D_s = 42770 - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -44,15 +45,15 @@ def graphite_mcmb2528_ocp_Dualfoil1998(sto): u_eq = ( 0.194 - + 1.5 * pybamm.exp(-120.0 * sto) - + 0.0351 * pybamm.tanh((sto - 0.286) / 0.083) - - 0.0045 * pybamm.tanh((sto - 0.849) / 0.119) - - 0.035 * pybamm.tanh((sto - 0.9233) / 0.05) - - 0.0147 * pybamm.tanh((sto - 0.5) / 0.034) - - 0.102 * pybamm.tanh((sto - 0.194) / 0.142) - - 0.022 * pybamm.tanh((sto - 0.9) / 0.0164) - - 0.011 * pybamm.tanh((sto - 0.124) / 0.0226) - + 0.0155 * pybamm.tanh((sto - 0.105) / 0.029) + + 1.5 * np.exp(-120.0 * sto) + + 0.0351 * np.tanh((sto - 0.286) / 0.083) + - 0.0045 * np.tanh((sto - 0.849) / 0.119) + - 0.035 * np.tanh((sto - 0.9233) / 0.05) + - 0.0147 * np.tanh((sto - 0.5) / 0.034) + - 0.102 * np.tanh((sto - 0.194) / 0.142) + - 0.022 * np.tanh((sto - 0.9) / 0.0164) + - 0.011 * np.tanh((sto - 0.124) / 0.0226) + + 0.0155 * np.tanh((sto - 0.105) / 0.029) ) return u_eq @@ -87,7 +88,7 @@ def graphite_electrolyte_exchange_current_density_Dualfoil1998( """ m_ref = 2 * 10 ** (-5) # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 37480 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -111,15 +112,15 @@ def graphite_entropic_change_Moura2016(sto, c_s_max): """ du_dT = ( - -1.5 * (120.0 / c_s_max) * pybamm.exp(-120 * sto) - + (0.0351 / (0.083 * c_s_max)) * ((pybamm.cosh((sto - 0.286) / 0.083)) ** (-2)) - - (0.0045 / (0.119 * c_s_max)) * ((pybamm.cosh((sto - 0.849) / 0.119)) ** (-2)) - - (0.035 / (0.05 * c_s_max)) * ((pybamm.cosh((sto - 0.9233) / 0.05)) ** (-2)) - - (0.0147 / (0.034 * c_s_max)) * ((pybamm.cosh((sto - 0.5) / 0.034)) ** (-2)) - - (0.102 / (0.142 * c_s_max)) * ((pybamm.cosh((sto - 0.194) / 0.142)) ** (-2)) - - (0.022 / (0.0164 * c_s_max)) * ((pybamm.cosh((sto - 0.9) / 0.0164)) ** (-2)) - - (0.011 / (0.0226 * c_s_max)) * ((pybamm.cosh((sto - 0.124) / 0.0226)) ** (-2)) - + (0.0155 / (0.029 * c_s_max)) * ((pybamm.cosh((sto - 0.105) / 0.029)) ** (-2)) + -1.5 * (120.0 / c_s_max) * np.exp(-120 * sto) + + (0.0351 / (0.083 * c_s_max)) * ((np.cosh((sto - 0.286) / 0.083)) ** (-2)) + - (0.0045 / (0.119 * c_s_max)) * ((np.cosh((sto - 0.849) / 0.119)) ** (-2)) + - (0.035 / (0.05 * c_s_max)) * ((np.cosh((sto - 0.9233) / 0.05)) ** (-2)) + - (0.0147 / (0.034 * c_s_max)) * ((np.cosh((sto - 0.5) / 0.034)) ** (-2)) + - (0.102 / (0.142 * c_s_max)) * ((np.cosh((sto - 0.194) / 0.142)) ** (-2)) + - (0.022 / (0.0164 * c_s_max)) * ((np.cosh((sto - 0.9) / 0.0164)) ** (-2)) + - (0.011 / (0.0226 * c_s_max)) * ((np.cosh((sto - 0.124) / 0.0226)) ** (-2)) + + (0.0155 / (0.029 * c_s_max)) * ((np.cosh((sto - 0.105) / 0.029)) ** (-2)) ) return du_dT @@ -148,7 +149,7 @@ def lico2_diffusivity_Dualfoil1998(sto, T): """ D_ref = 1 * 10 ** (-13) E_D_s = 18550 - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -180,12 +181,12 @@ def lico2_ocp_Dualfoil1998(sto): u_eq = ( 2.16216 - + 0.07645 * pybamm.tanh(30.834 - 54.4806 * sto) - + 2.1581 * pybamm.tanh(52.294 - 50.294 * sto) - - 0.14169 * pybamm.tanh(11.0923 - 19.8543 * sto) - + 0.2051 * pybamm.tanh(1.4684 - 5.4888 * sto) - + 0.2531 * pybamm.tanh((-sto + 0.56478) / 0.1316) - - 0.02167 * pybamm.tanh((sto - 0.525) / 0.006) + + 0.07645 * np.tanh(30.834 - 54.4806 * sto) + + 2.1581 * np.tanh(52.294 - 50.294 * sto) + - 0.14169 * np.tanh(11.0923 - 19.8543 * sto) + + 0.2051 * np.tanh(1.4684 - 5.4888 * sto) + + 0.2531 * np.tanh((-sto + 0.56478) / 0.1316) + - 0.02167 * np.tanh((sto - 0.525) / 0.006) ) return u_eq @@ -218,7 +219,7 @@ def lico2_electrolyte_exchange_current_density_Dualfoil1998(c_e, c_s_surf, c_s_m """ m_ref = 6 * 10 ** (-7) # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 39570 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -246,17 +247,12 @@ def lico2_entropic_change_Moura2016(sto, c_s_max): sto = stretch * sto du_dT = ( - 0.07645 - * (-54.4806 / c_s_max) - * ((1.0 / pybamm.cosh(30.834 - 54.4806 * sto)) ** 2) - + 2.1581 * (-50.294 / c_s_max) * ((pybamm.cosh(52.294 - 50.294 * sto)) ** (-2)) - + 0.14169 - * (19.854 / c_s_max) - * ((pybamm.cosh(11.0923 - 19.8543 * sto)) ** (-2)) - - 0.2051 * (5.4888 / c_s_max) * ((pybamm.cosh(1.4684 - 5.4888 * sto)) ** (-2)) - - (0.2531 / 0.1316 / c_s_max) - * ((pybamm.cosh((-sto + 0.56478) / 0.1316)) ** (-2)) - - (0.02167 / 0.006 / c_s_max) * ((pybamm.cosh((sto - 0.525) / 0.006)) ** (-2)) + 0.07645 * (-54.4806 / c_s_max) * ((1.0 / np.cosh(30.834 - 54.4806 * sto)) ** 2) + + 2.1581 * (-50.294 / c_s_max) * ((np.cosh(52.294 - 50.294 * sto)) ** (-2)) + + 0.14169 * (19.854 / c_s_max) * ((np.cosh(11.0923 - 19.8543 * sto)) ** (-2)) + - 0.2051 * (5.4888 / c_s_max) * ((np.cosh(1.4684 - 5.4888 * sto)) ** (-2)) + - (0.2531 / 0.1316 / c_s_max) * ((np.cosh((-sto + 0.56478) / 0.1316)) ** (-2)) + - (0.02167 / 0.006 / c_s_max) * ((np.cosh((sto - 0.525) / 0.006)) ** (-2)) ) return du_dT @@ -288,9 +284,9 @@ def electrolyte_diffusivity_Capiglia1999(c_e, T): Solid diffusivity """ - D_c_e = 5.34e-10 * pybamm.exp(-0.65 * c_e / 1000) + D_c_e = 5.34e-10 * np.exp(-0.65 * c_e / 1000) E_D_e = 37040 - arrhenius = pybamm.exp(E_D_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_c_e * arrhenius @@ -329,7 +325,7 @@ def electrolyte_conductivity_Capiglia1999(c_e, T): ) E_k_e = 34700 - arrhenius = pybamm.exp(E_k_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_k_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) return sigma_e * arrhenius diff --git a/pybamm/input/parameters/lithium_ion/Mohtat2020.py b/pybamm/input/parameters/lithium_ion/Mohtat2020.py index 5ee01927da..29535b9f3d 100644 --- a/pybamm/input/parameters/lithium_ion/Mohtat2020.py +++ b/pybamm/input/parameters/lithium_ion/Mohtat2020.py @@ -1,4 +1,5 @@ import pybamm +import numpy as np def graphite_diffusivity_PeymanMPM(sto, T): @@ -25,7 +26,7 @@ def graphite_diffusivity_PeymanMPM(sto, T): D_ref = 5.0 * 10 ** (-15) E_D_s = 42770 - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -42,13 +43,13 @@ def graphite_ocp_PeymanMPM(sto): u_eq = ( 0.063 - + 0.8 * pybamm.exp(-75 * (sto + 0.001)) - - 0.0120 * pybamm.tanh((sto - 0.127) / 0.016) - - 0.0118 * pybamm.tanh((sto - 0.155) / 0.016) - - 0.0035 * pybamm.tanh((sto - 0.220) / 0.020) - - 0.0095 * pybamm.tanh((sto - 0.190) / 0.013) - - 0.0145 * pybamm.tanh((sto - 0.490) / 0.020) - - 0.0800 * pybamm.tanh((sto - 1.030) / 0.055) + + 0.8 * np.exp(-75 * (sto + 0.001)) + - 0.0120 * np.tanh((sto - 0.127) / 0.016) + - 0.0118 * np.tanh((sto - 0.155) / 0.016) + - 0.0035 * np.tanh((sto - 0.220) / 0.020) + - 0.0095 * np.tanh((sto - 0.190) / 0.013) + - 0.0145 * np.tanh((sto - 0.490) / 0.020) + - 0.0800 * np.tanh((sto - 1.030) / 0.055) ) return u_eq @@ -83,7 +84,7 @@ def graphite_electrolyte_exchange_current_density_PeymanMPM(c_e, c_s_surf, c_s_m m_ref = 1.061 * 10 ** (-6) # unit has been converted # units are (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 37480 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -144,7 +145,7 @@ def NMC_diffusivity_PeymanMPM(sto, T): D_ref = 8 * 10 ** (-15) E_D_s = 18550 - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -172,7 +173,7 @@ def NMC_ocp_PeymanMPM(sto): - 2.0843 * (sto**3) + 3.5146 * (sto**4) - 2.2166 * (sto**5) - - 0.5623e-4 * pybamm.exp(109.451 * sto - 100.006) + - 0.5623e-4 * np.exp(109.451 * sto - 100.006) ) return u_eq @@ -205,7 +206,7 @@ def NMC_electrolyte_exchange_current_density_PeymanMPM(c_e, c_s_surf, c_s_max, T """ m_ref = 4.824 * 10 ** (-6) # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 39570 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -240,7 +241,7 @@ def NMC_entropic_change_PeymanMPM(sto, c_s_max): + 1.6225 * sto**2 - 2.0843 * sto**3 + 3.5146 * sto**4 - - 0.5623 * 10 ** (-4) * pybamm.exp(109.451 * sto - 100.006) + - 0.5623 * 10 ** (-4) * np.exp(109.451 * sto - 100.006) ) du_dT = ( @@ -278,7 +279,7 @@ def electrolyte_diffusivity_PeymanMPM(c_e, T): D_c_e = 5.35 * 10 ** (-10) E_D_e = 37040 - arrhenius = pybamm.exp(E_D_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_c_e * arrhenius @@ -310,7 +311,7 @@ def electrolyte_conductivity_PeymanMPM(c_e, T): sigma_e = 1.3 E_k_e = 34700 - arrhenius = pybamm.exp(E_k_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_k_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) return sigma_e * arrhenius diff --git a/pybamm/input/parameters/lithium_ion/NCA_Kim2011.py b/pybamm/input/parameters/lithium_ion/NCA_Kim2011.py index 3d92d71868..b5543ea6c2 100644 --- a/pybamm/input/parameters/lithium_ion/NCA_Kim2011.py +++ b/pybamm/input/parameters/lithium_ion/NCA_Kim2011.py @@ -1,4 +1,5 @@ import pybamm +import numpy as np def graphite_diffusivity_Kim2011(sto, T): @@ -27,7 +28,7 @@ def graphite_diffusivity_Kim2011(sto, T): D_ref = 9 * 10 ** (-14) E_D_s = 4e3 - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -46,15 +47,15 @@ def graphite_ocp_Kim2011(sto): u_eq = ( 0.124 - + 1.5 * pybamm.exp(-70 * sto) - - 0.0351 * pybamm.tanh((sto - 0.286) / 0.083) - - 0.0045 * pybamm.tanh((sto - 0.9) / 0.119) - - 0.035 * pybamm.tanh((sto - 0.99) / 0.05) - - 0.0147 * pybamm.tanh((sto - 0.5) / 0.034) - - 0.102 * pybamm.tanh((sto - 0.194) / 0.142) - - 0.022 * pybamm.tanh((sto - 0.98) / 0.0164) - - 0.011 * pybamm.tanh((sto - 0.124) / 0.0226) - + 0.0155 * pybamm.tanh((sto - 0.105) / 0.029) + + 1.5 * np.exp(-70 * sto) + - 0.0351 * np.tanh((sto - 0.286) / 0.083) + - 0.0045 * np.tanh((sto - 0.9) / 0.119) + - 0.035 * np.tanh((sto - 0.99) / 0.05) + - 0.0147 * np.tanh((sto - 0.5) / 0.034) + - 0.102 * np.tanh((sto - 0.194) / 0.142) + - 0.022 * np.tanh((sto - 0.98) / 0.0164) + - 0.011 * np.tanh((sto - 0.124) / 0.0226) + + 0.0155 * np.tanh((sto - 0.105) / 0.029) ) return u_eq @@ -101,7 +102,7 @@ def graphite_electrolyte_exchange_current_density_Kim2011(c_e, c_s_surf, c_s_max ) E_r = 3e4 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref @@ -137,7 +138,7 @@ def nca_diffusivity_Kim2011(sto, T): """ D_ref = 3 * 10 ** (-15) E_D_s = 2e4 - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -180,7 +181,7 @@ def nca_electrolyte_exchange_current_density_Kim2011(c_e, c_s_surf, c_s_max, T): c_e_ref**alpha * (c_s_max - c_s_ref) ** alpha * c_s_ref**alpha ) E_r = 3e4 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref @@ -217,9 +218,9 @@ def electrolyte_diffusivity_Kim2011(c_e, T): """ D_c_e = ( - 5.84 * 10 ** (-7) * pybamm.exp(-2870 / T) * (c_e / 1000) ** 2 - - 33.9 * 10 ** (-7) * pybamm.exp(-2920 / T) * (c_e / 1000) - + 129 * 10 ** (-7) * pybamm.exp(-3200 / T) + 5.84 * 10 ** (-7) * np.exp(-2870 / T) * (c_e / 1000) ** 2 + - 33.9 * 10 ** (-7) * np.exp(-2920 / T) * (c_e / 1000) + + 129 * 10 ** (-7) * np.exp(-3200 / T) ) return D_c_e @@ -251,9 +252,9 @@ def electrolyte_conductivity_Kim2011(c_e, T): """ sigma_e = ( - 3.45 * pybamm.exp(-798 / T) * (c_e / 1000) ** 3 - - 48.5 * pybamm.exp(-1080 / T) * (c_e / 1000) ** 2 - + 244 * pybamm.exp(-1440 / T) * (c_e / 1000) + 3.45 * np.exp(-798 / T) * (c_e / 1000) ** 3 + - 48.5 * np.exp(-1080 / T) * (c_e / 1000) ** 2 + + 244 * np.exp(-1440 / T) * (c_e / 1000) ) return sigma_e @@ -283,7 +284,7 @@ def nca_ocp_Kim2011(sto): + 264.427 * sto**2 - 66.3691 * sto + 11.8058 - - 0.61386 * pybamm.exp(5.8201 * sto**136.4) + - 0.61386 * np.exp(5.8201 * sto**136.4) ) return U_posi diff --git a/pybamm/input/parameters/lithium_ion/OKane2022.py b/pybamm/input/parameters/lithium_ion/OKane2022.py index 32ad7c169e..e3718fb9ee 100644 --- a/pybamm/input/parameters/lithium_ion/OKane2022.py +++ b/pybamm/input/parameters/lithium_ion/OKane2022.py @@ -1,5 +1,6 @@ import pybamm import os +import numpy as np def plating_exchange_current_density_OKane2020(c_e, c_Li, T): @@ -121,7 +122,7 @@ def graphite_LGM50_diffusivity_Chen2020(sto, T): D_ref = 3.3e-14 E_D_s = 3.03e4 # E_D_s not given by Chen et al (2020), so taken from Ecker et al. (2015) instead - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -159,7 +160,7 @@ def graphite_LGM50_electrolyte_exchange_current_density_Chen2020( m_ref = 6.48e-7 # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 35000 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -242,7 +243,7 @@ def graphite_cracking_rate_Ai2020(T_dim): """ k_cr = 3.9e-20 Eac_cr = 0 # to be implemented - arrhenius = pybamm.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / 298.15)) + arrhenius = np.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / 298.15)) return k_cr * arrhenius @@ -273,7 +274,7 @@ def nmc_LGM50_diffusivity_Chen2020(sto, T): D_ref = 4e-15 E_D_s = 25000 # O'Kane et al. (2022), after Cabanero et al. (2018) - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -304,9 +305,9 @@ def nmc_LGM50_ocp_Chen2020(sto): u_eq = ( -0.8090 * sto + 4.4875 - - 0.0428 * pybamm.tanh(18.5138 * (sto - 0.5542)) - - 17.7326 * pybamm.tanh(15.7890 * (sto - 0.3117)) - + 17.5842 * pybamm.tanh(15.9308 * (sto - 0.3120)) + - 0.0428 * np.tanh(18.5138 * (sto - 0.5542)) + - 17.7326 * np.tanh(15.7890 * (sto - 0.3117)) + + 17.5842 * np.tanh(15.9308 * (sto - 0.3120)) ) return u_eq @@ -340,7 +341,7 @@ def nmc_LGM50_electrolyte_exchange_current_density_Chen2020(c_e, c_s_surf, c_s_m """ m_ref = 3.42e-6 # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 17800 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -403,7 +404,7 @@ def cracking_rate_Ai2020(T_dim): """ k_cr = 3.9e-20 Eac_cr = 0 # to be implemented - arrhenius = pybamm.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / 298.15)) + arrhenius = np.exp(Eac_cr / pybamm.constants.R * (1 / T_dim - 1 / 298.15)) return k_cr * arrhenius @@ -440,7 +441,7 @@ def electrolyte_diffusivity_Nyman2008_arrhenius(c_e, T): # So use temperature dependence from Ecker et al. (2015) instead E_D_c_e = 17000 - arrhenius = pybamm.exp(E_D_c_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_c_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_c_e * arrhenius @@ -480,7 +481,7 @@ def electrolyte_conductivity_Nyman2008_arrhenius(c_e, T): # So use temperature dependence from Ecker et al. (2015) instead E_sigma_e = 17000 - arrhenius = pybamm.exp(E_sigma_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_sigma_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) return sigma_e * arrhenius diff --git a/pybamm/input/parameters/lithium_ion/ORegan2022.py b/pybamm/input/parameters/lithium_ion/ORegan2022.py index bbd23c1ae7..3ea7ab06ce 100644 --- a/pybamm/input/parameters/lithium_ion/ORegan2022.py +++ b/pybamm/input/parameters/lithium_ion/ORegan2022.py @@ -30,8 +30,8 @@ def electrolyte_conductivity_base_Landesfeind2019(c_e, T, coeffs): c = c_e / 1000 # mol.m-3 -> mol.l p1, p2, p3, p4, p5, p6 = coeffs A = p1 * (1 + (T - p2)) - B = 1 + p3 * pybamm.sqrt(c) + p4 * (1 + p5 * pybamm.exp(1000 / T)) * c - C = 1 + c**4 * (p6 * pybamm.exp(1000 / T)) + B = 1 + p3 * pybamm.sqrt(c) + p4 * (1 + p5 * np.exp(1000 / T)) * c + C = 1 + c**4 * (p6 * np.exp(1000 / T)) sigma_e = A * c * B / C # mS.cm-1 return sigma_e / 10 @@ -64,9 +64,9 @@ def electrolyte_diffusivity_base_Landesfeind2019(c_e, T, coeffs): """ c = c_e / 1000 # mol.m-3 -> mol.l p1, p2, p3, p4 = coeffs - A = p1 * pybamm.exp(p2 * c) - B = pybamm.exp(p3 / T) - C = pybamm.exp(p4 * c / T) + A = p1 * np.exp(p2 * c) + B = np.exp(p3 / T) + C = np.exp(p4 * c / T) D_e = A * B * C * 1e-10 # m2/s return D_e @@ -276,16 +276,16 @@ def graphite_LGM50_diffusivity_ORegan2022(sto, T): ** ( a0 * sto + c0 - + a1 * pybamm.exp(-((sto - b1) ** 2) / c1) - + a2 * pybamm.exp(-((sto - b2) ** 2) / c2) - + a3 * pybamm.exp(-((sto - b3) ** 2) / c3) - + a4 * pybamm.exp(-((sto - b4) ** 2) / c4) + + a1 * np.exp(-((sto - b1) ** 2) / c1) + + a2 * np.exp(-((sto - b2) ** 2) / c2) + + a3 * np.exp(-((sto - b3) ** 2) / c3) + + a4 * np.exp(-((sto - b4) ** 2) / c4) ) * 3.0321 # correcting factor (see O'Regan et al 2021) ) E_D_s = d * pybamm.constants.R - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -314,11 +314,11 @@ def graphite_LGM50_ocp_Chen2020(sto): """ U = ( - 1.9793 * pybamm.exp(-39.3631 * sto) + 1.9793 * np.exp(-39.3631 * sto) + 0.2482 - - 0.0909 * pybamm.tanh(29.8538 * (sto - 0.1234)) - - 0.04478 * pybamm.tanh(14.9159 * (sto - 0.2769)) - - 0.0205 * pybamm.tanh(30.4444 * (sto - 0.6103)) + - 0.0909 * np.tanh(29.8538 * (sto - 0.1234)) + - 0.04478 * np.tanh(14.9159 * (sto - 0.2769)) + - 0.0205 * np.tanh(30.4444 * (sto - 0.6103)) ) return U @@ -357,7 +357,7 @@ def graphite_LGM50_electrolyte_exchange_current_density_ORegan2022( i_ref = 2.668 # (A/m2) alpha = 0.792 E_r = 4e4 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) c_e_ref = pybamm.Parameter("Initial concentration in electrolyte [mol.m-3]") @@ -474,9 +474,8 @@ def graphite_LGM50_entropic_change_ORegan2022(sto, c_s_max): dUdT = ( a0 * sto + c0 - + a2 * pybamm.exp(-((sto - b2) ** 2) / c2) - + a1 - * (pybamm.tanh(d1 * (sto - (b1 - c1))) - pybamm.tanh(d1 * (sto - (b1 + c1)))) + + a2 * np.exp(-((sto - b2) ** 2) / c2) + + a1 * (np.tanh(d1 * (sto - (b1 - c1))) - np.tanh(d1 * (sto - (b1 + c1)))) ) / 1000 # fit in mV / K return dUdT @@ -505,7 +504,7 @@ def nmc_LGM50_electronic_conductivity_ORegan2022(T): """ E_r = 3.5e3 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) sigma = 0.8473 * arrhenius @@ -552,15 +551,15 @@ def nmc_LGM50_diffusivity_ORegan2022(sto, T): 10 ** ( c0 - + a1 * pybamm.exp(-((sto - b1) ** 2) / c1) - + a2 * pybamm.exp(-((sto - b2) ** 2) / c2) - + a3 * pybamm.exp(-((sto - b3) ** 2) / c3) + + a1 * np.exp(-((sto - b1) ** 2) / c1) + + a2 * np.exp(-((sto - b2) ** 2) / c2) + + a3 * np.exp(-((sto - b3) ** 2) / c3) ) * 2.7 # correcting factor (see O'Regan et al 2021) ) E_D_s = d * pybamm.constants.R - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -591,9 +590,9 @@ def nmc_LGM50_ocp_Chen2020(sto): U = ( -0.809 * sto + 4.4875 - - 0.0428 * pybamm.tanh(18.5138 * (sto - 0.5542)) - - 17.7326 * pybamm.tanh(15.789 * (sto - 0.3117)) - + 17.5842 * pybamm.tanh(15.9308 * (sto - 0.312)) + - 0.0428 * np.tanh(18.5138 * (sto - 0.5542)) + - 17.7326 * np.tanh(15.789 * (sto - 0.3117)) + + 17.5842 * np.tanh(15.9308 * (sto - 0.312)) ) return U @@ -631,7 +630,7 @@ def nmc_LGM50_electrolyte_exchange_current_density_ORegan2022( i_ref = 5.028 # (A/m2) alpha = 0.43 E_r = 2.401e4 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) c_e_ref = pybamm.Parameter("Initial concentration in electrolyte [mol.m-3]") @@ -742,8 +741,7 @@ def nmc_LGM50_entropic_change_ORegan2022(sto, c_s_max): c2 = 0.02179 dUdT = ( - a1 * pybamm.exp(-((sto - b1) ** 2) / c1) - + a2 * pybamm.exp(-((sto - b2) ** 2) / c2) + a1 * np.exp(-((sto - b1) ** 2) / c1) + a2 * np.exp(-((sto - b2) ** 2) / c2) ) / 1000 # fit in mV / K diff --git a/pybamm/input/parameters/lithium_ion/Prada2013.py b/pybamm/input/parameters/lithium_ion/Prada2013.py index 767aaaa835..2d3d0e7ceb 100644 --- a/pybamm/input/parameters/lithium_ion/Prada2013.py +++ b/pybamm/input/parameters/lithium_ion/Prada2013.py @@ -1,4 +1,5 @@ import pybamm +import numpy as np def graphite_LGM50_ocp_Chen2020(sto): @@ -25,11 +26,11 @@ def graphite_LGM50_ocp_Chen2020(sto): """ u_eq = ( - 1.9793 * pybamm.exp(-39.3631 * sto) + 1.9793 * np.exp(-39.3631 * sto) + 0.2482 - - 0.0909 * pybamm.tanh(29.8538 * (sto - 0.1234)) - - 0.04478 * pybamm.tanh(14.9159 * (sto - 0.2769)) - - 0.0205 * pybamm.tanh(30.4444 * (sto - 0.6103)) + - 0.0909 * np.tanh(29.8538 * (sto - 0.1234)) + - 0.04478 * np.tanh(14.9159 * (sto - 0.2769)) + - 0.0205 * np.tanh(30.4444 * (sto - 0.6103)) ) return u_eq @@ -67,7 +68,7 @@ def graphite_LGM50_electrolyte_exchange_current_density_Chen2020( """ m_ref = 6.48e-7 # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 35000 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -93,7 +94,7 @@ def LFP_ocp_Afshar2017(sto): c1 = -150 * sto c2 = -30 * (1 - sto) - k = 3.4077 - 0.020269 * sto + 0.5 * pybamm.exp(c1) - 0.9 * pybamm.exp(c2) + k = 3.4077 - 0.020269 * sto + 0.5 * np.exp(c1) - 0.9 * np.exp(c2) return k @@ -128,7 +129,7 @@ def LFP_electrolyte_exchange_current_density_kashkooli2017(c_e, c_s_surf, c_s_ma m_ref = 6 * 10 ** (-7) # (A/m2)(m3/mol)**1.5 - includes ref concentrations E_r = 39570 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 diff --git a/pybamm/input/parameters/lithium_ion/Ramadass2004.py b/pybamm/input/parameters/lithium_ion/Ramadass2004.py index 6372e04a28..13aa86fe8e 100644 --- a/pybamm/input/parameters/lithium_ion/Ramadass2004.py +++ b/pybamm/input/parameters/lithium_ion/Ramadass2004.py @@ -1,4 +1,5 @@ import pybamm +import numpy as np def graphite_mcmb2528_diffusivity_Dualfoil1998(sto, T): @@ -25,7 +26,7 @@ def graphite_mcmb2528_diffusivity_Dualfoil1998(sto, T): D_ref = 3.9 * 10 ** (-14) E_D_s = 42770 - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -48,8 +49,8 @@ def graphite_ocp_Ramadass2004(sto): + 0.029 * (sto**0.5) - 0.0172 / sto + 0.0019 / (sto**1.5) - + 0.2808 * pybamm.exp(0.9 - 15 * sto) - - 0.7984 * pybamm.exp(0.4465 * sto - 0.4108) + + 0.2808 * np.exp(0.9 - 15 * sto) + - 0.7984 * np.exp(0.4465 * sto - 0.4108) ) return u_eq @@ -86,7 +87,7 @@ def graphite_electrolyte_exchange_current_density_Ramadass2004( """ m_ref = 4.854 * 10 ** (-6) # (A/m2)(m3/mol)**1.5 E_r = 37480 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -110,15 +111,15 @@ def graphite_entropic_change_Moura2016(sto, c_s_max): """ du_dT = ( - -1.5 * (120.0 / c_s_max) * pybamm.exp(-120 * sto) - + (0.0351 / (0.083 * c_s_max)) * ((pybamm.cosh((sto - 0.286) / 0.083)) ** (-2)) - - (0.0045 / (0.119 * c_s_max)) * ((pybamm.cosh((sto - 0.849) / 0.119)) ** (-2)) - - (0.035 / (0.05 * c_s_max)) * ((pybamm.cosh((sto - 0.9233) / 0.05)) ** (-2)) - - (0.0147 / (0.034 * c_s_max)) * ((pybamm.cosh((sto - 0.5) / 0.034)) ** (-2)) - - (0.102 / (0.142 * c_s_max)) * ((pybamm.cosh((sto - 0.194) / 0.142)) ** (-2)) - - (0.022 / (0.0164 * c_s_max)) * ((pybamm.cosh((sto - 0.9) / 0.0164)) ** (-2)) - - (0.011 / (0.0226 * c_s_max)) * ((pybamm.cosh((sto - 0.124) / 0.0226)) ** (-2)) - + (0.0155 / (0.029 * c_s_max)) * ((pybamm.cosh((sto - 0.105) / 0.029)) ** (-2)) + -1.5 * (120.0 / c_s_max) * np.exp(-120 * sto) + + (0.0351 / (0.083 * c_s_max)) * ((np.cosh((sto - 0.286) / 0.083)) ** (-2)) + - (0.0045 / (0.119 * c_s_max)) * ((np.cosh((sto - 0.849) / 0.119)) ** (-2)) + - (0.035 / (0.05 * c_s_max)) * ((np.cosh((sto - 0.9233) / 0.05)) ** (-2)) + - (0.0147 / (0.034 * c_s_max)) * ((np.cosh((sto - 0.5) / 0.034)) ** (-2)) + - (0.102 / (0.142 * c_s_max)) * ((np.cosh((sto - 0.194) / 0.142)) ** (-2)) + - (0.022 / (0.0164 * c_s_max)) * ((np.cosh((sto - 0.9) / 0.0164)) ** (-2)) + - (0.011 / (0.0226 * c_s_max)) * ((np.cosh((sto - 0.124) / 0.0226)) ** (-2)) + + (0.0155 / (0.029 * c_s_max)) * ((np.cosh((sto - 0.105) / 0.029)) ** (-2)) ) return du_dT @@ -149,7 +150,7 @@ def lico2_diffusivity_Ramadass2004(sto, T): """ D_ref = 1 * 10 ** (-14) E_D_s = 18550 - arrhenius = pybamm.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_s / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_ref * arrhenius @@ -224,7 +225,7 @@ def lico2_electrolyte_exchange_current_density_Ramadass2004(c_e, c_s_surf, c_s_m """ m_ref = 2.252 * 10 ** (-6) # (A/m2)(m3/mol)**1.5 E_r = 39570 - arrhenius = pybamm.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_r / pybamm.constants.R * (1 / 298.15 - 1 / T)) return ( m_ref * arrhenius * c_e**0.5 * c_s_surf**0.5 * (c_s_max - c_s_surf) ** 0.5 @@ -252,17 +253,12 @@ def lico2_entropic_change_Moura2016(sto, c_s_max): sto = stretch * sto du_dT = ( - 0.07645 - * (-54.4806 / c_s_max) - * ((1.0 / pybamm.cosh(30.834 - 54.4806 * sto)) ** 2) - + 2.1581 * (-50.294 / c_s_max) * ((pybamm.cosh(52.294 - 50.294 * sto)) ** (-2)) - + 0.14169 - * (19.854 / c_s_max) - * ((pybamm.cosh(11.0923 - 19.8543 * sto)) ** (-2)) - - 0.2051 * (5.4888 / c_s_max) * ((pybamm.cosh(1.4684 - 5.4888 * sto)) ** (-2)) - - (0.2531 / 0.1316 / c_s_max) - * ((pybamm.cosh((-sto + 0.56478) / 0.1316)) ** (-2)) - - (0.02167 / 0.006 / c_s_max) * ((pybamm.cosh((sto - 0.525) / 0.006)) ** (-2)) + 0.07645 * (-54.4806 / c_s_max) * ((1.0 / np.cosh(30.834 - 54.4806 * sto)) ** 2) + + 2.1581 * (-50.294 / c_s_max) * ((np.cosh(52.294 - 50.294 * sto)) ** (-2)) + + 0.14169 * (19.854 / c_s_max) * ((np.cosh(11.0923 - 19.8543 * sto)) ** (-2)) + - 0.2051 * (5.4888 / c_s_max) * ((np.cosh(1.4684 - 5.4888 * sto)) ** (-2)) + - (0.2531 / 0.1316 / c_s_max) * ((np.cosh((-sto + 0.56478) / 0.1316)) ** (-2)) + - (0.02167 / 0.006 / c_s_max) * ((np.cosh((sto - 0.525) / 0.006)) ** (-2)) ) return du_dT @@ -294,7 +290,7 @@ def electrolyte_diffusivity_Ramadass2004(c_e, T): D_c_e = 7.5e-10 E_D_e = 37040 - arrhenius = pybamm.exp(E_D_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_D_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) return D_c_e * arrhenius @@ -336,7 +332,7 @@ def electrolyte_conductivity_Ramadass2004(c_e, T): ) * 1e3 # and here there should not be an exponent E_k_e = 34700 - arrhenius = pybamm.exp(E_k_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) + arrhenius = np.exp(E_k_e / pybamm.constants.R * (1 / 298.15 - 1 / T)) return sigma_e * arrhenius diff --git a/pybamm/input/parameters/lithium_ion/Xu2019.py b/pybamm/input/parameters/lithium_ion/Xu2019.py index 292ce96385..d6d3383b35 100644 --- a/pybamm/input/parameters/lithium_ion/Xu2019.py +++ b/pybamm/input/parameters/lithium_ion/Xu2019.py @@ -1,4 +1,5 @@ import pybamm +import numpy as np def li_metal_electrolyte_exchange_current_density_Xu2019(c_e, c_Li, T): @@ -59,7 +60,7 @@ def nmc_ocp_Xu2019(sto): - 2.0843 * (sto**3) + 3.5146 * (sto**4) - 2.2166 * (sto**5) - - 0.5623e-4 * pybamm.exp(109.451 * sto - 100.006) + - 0.5623e-4 * np.exp(109.451 * sto - 100.006) ) # # only valid in range ~(0.25,0.95) @@ -74,7 +75,7 @@ def nmc_ocp_Xu2019(sto): # - 9578.599274 * sto ** 2 # + 1409.309503 * sto # - 85.31153081 - # - 0.0003 * pybamm.exp(7.657 * sto ** 115) + # - 0.0003 * np.exp(7.657 * sto ** 115) # ) return u_eq diff --git a/pybamm/input/parameters/lithium_ion/data/graphite_LGM50_ocp_Chen2020.csv b/pybamm/input/parameters/lithium_ion/data/graphite_LGM50_ocp_Chen2020.csv index c43da295d5..15615f5bb2 100644 --- a/pybamm/input/parameters/lithium_ion/data/graphite_LGM50_ocp_Chen2020.csv +++ b/pybamm/input/parameters/lithium_ion/data/graphite_LGM50_ocp_Chen2020.csv @@ -250,4 +250,4 @@ 0.9704444444444444,0.07871961454862104 0.9802222222222222,0.07782495680237907 0.99,0.07693029905613709 -1,0.0760153081792987 \ No newline at end of file +1,0.0760153081792987 diff --git a/pybamm/input/parameters/lithium_ion/data/graphite_ocp_Enertech_Ai2020.csv b/pybamm/input/parameters/lithium_ion/data/graphite_ocp_Enertech_Ai2020.csv index 8a5bce2874..abde62a61c 100644 --- a/pybamm/input/parameters/lithium_ion/data/graphite_ocp_Enertech_Ai2020.csv +++ b/pybamm/input/parameters/lithium_ion/data/graphite_ocp_Enertech_Ai2020.csv @@ -126,4 +126,4 @@ 0.999241066,0.030242658 0.999746961,0.024850768 0.999936448,0.019251502 -1,0.004994678 \ No newline at end of file +1,0.004994678 diff --git a/pybamm/input/parameters/lithium_ion/data/lico2_ocp_Ai2020.csv b/pybamm/input/parameters/lithium_ion/data/lico2_ocp_Ai2020.csv index 2c81422639..b1053f1a39 100644 --- a/pybamm/input/parameters/lithium_ion/data/lico2_ocp_Ai2020.csv +++ b/pybamm/input/parameters/lithium_ion/data/lico2_ocp_Ai2020.csv @@ -1,4 +1,4 @@ -# OCP for lico2 from Rieger 2016 +# OCP for lico2 from Rieger 2016 # stoichiometry , OCP [V] 0.4,4.390781177520233 0.401,4.387755138269558 diff --git a/pybamm/input/parameters/lithium_ion/data/nca_ocp_Kim2011_data.csv b/pybamm/input/parameters/lithium_ion/data/nca_ocp_Kim2011_data.csv index dd00060753..8057f34f56 100644 --- a/pybamm/input/parameters/lithium_ion/data/nca_ocp_Kim2011_data.csv +++ b/pybamm/input/parameters/lithium_ion/data/nca_ocp_Kim2011_data.csv @@ -72,4 +72,4 @@ 0.9896421223593032, 3.204894695680104 0.9905703960976598, 3.1496257442302342 0.9915055751666949, 3.104277451188519 -0.9933828386354436, 3.023501523513243 \ No newline at end of file +0.9933828386354436, 3.023501523513243 diff --git a/pybamm/input/parameters/lithium_ion/data/nmc_LGM50_ocp_Chen2020.csv b/pybamm/input/parameters/lithium_ion/data/nmc_LGM50_ocp_Chen2020.csv index 7dc9adc71c..8a2edc1ab0 100644 --- a/pybamm/input/parameters/lithium_ion/data/nmc_LGM50_ocp_Chen2020.csv +++ b/pybamm/input/parameters/lithium_ion/data/nmc_LGM50_ocp_Chen2020.csv @@ -240,4 +240,4 @@ 0.903203643476430,3.56849220000000 0.905926128940627,3.56721330000000 # extra points to avoid extrapolation -1,3.52302166875714 \ No newline at end of file +1,3.52302166875714 diff --git a/pybamm/meshes/meshes.py b/pybamm/meshes/meshes.py index b68e0a2222..4c86290a2f 100644 --- a/pybamm/meshes/meshes.py +++ b/pybamm/meshes/meshes.py @@ -25,6 +25,9 @@ class Mesh(dict): def __init__(self, geometry, submesh_types, var_pts): super().__init__() + # Save geometry + self.geometry = geometry + # Preprocess var_pts var_pts_input = var_pts var_pts = {} @@ -205,6 +208,14 @@ def add_ghost_meshes(self): rgs_edges, submesh.coord_sys ) + @property + def geometry(self): + return self._geometry + + @geometry.setter + def geometry(self, geometry): + self._geometry = geometry + class SubMesh: """ diff --git a/pybamm/models/base_model.py b/pybamm/models/base_model.py index ff809c7ded..41192dbe1f 100644 --- a/pybamm/models/base_model.py +++ b/pybamm/models/base_model.py @@ -113,6 +113,7 @@ def __init__(self, name="Unnamed model"): self._input_parameters = None self._parameter_info = None self._variables_casadi = {} + self._geometry = pybamm.Geometry({}) # Default behaviour is to use the jacobian self.use_jacobian = True @@ -312,6 +313,10 @@ def length_scales(self, values): "length_scales has been removed since models are now dimensional" ) + @property + def geometry(self): + return self._geometry + @property def default_var_pts(self): return {} diff --git a/pybamm/models/full_battery_models/base_battery_model.py b/pybamm/models/full_battery_models/base_battery_model.py index 7a39874108..de7002a08c 100644 --- a/pybamm/models/full_battery_models/base_battery_model.py +++ b/pybamm/models/full_battery_models/base_battery_model.py @@ -26,8 +26,8 @@ class BatteryModelOptions(pybamm.FuzzyDict): "true" or "false". "false" is the default, since calculating discharge energy can be computationally expensive for simple models like SPM. * "cell geometry" : str - Sets the geometry of the cell. Can be "pouch" (default) or - "arbitrary". The arbitrary geometry option solves a 1D electrochemical + Sets the geometry of the cell. Can be "arbitrary" (default) or + "pouch". The arbitrary geometry option solves a 1D electrochemical model with prescribed cell volume and cross-sectional area, and (if thermal effects are included) solves a lumped thermal model with prescribed surface area for cooling. @@ -44,9 +44,9 @@ class BatteryModelOptions(pybamm.FuzzyDict): Sets the current collector model to use. Can be "uniform" (default), "potential pair" or "potential pair quite conductive". * "diffusivity" : str - Sets the model for the diffusivity. Can be "single" - (default) or "current sigmoid". A 2-tuple can be provided for different - behaviour in negative and positive electrodes. + Sets the model for the diffusivity. Can be "single" + (default) or "current sigmoid". A 2-tuple can be provided for different + behaviour in negative and positive electrodes. * "dimensionality" : int Sets the dimension of the current collector problem. Can be 0 (default), 1 or 2. @@ -54,9 +54,9 @@ class BatteryModelOptions(pybamm.FuzzyDict): Can be "default" (default), "full", "leading order", "composite" or "integrated". * "exchange-current density" : str - Sets the model for the exchange-current density. Can be "single" - (default) or "current sigmoid". A 2-tuple can be provided for different - behaviour in negative and positive electrodes. + Sets the model for the exchange-current density. Can be "single" + (default) or "current sigmoid". A 2-tuple can be provided for different + behaviour in negative and positive electrodes. * "hydrolysis" : str Whether to include hydrolysis in the model. Only implemented for lead-acid models. Can be "false" (default) or "true". If "true", then @@ -77,13 +77,14 @@ class BatteryModelOptions(pybamm.FuzzyDict): "false" (default) or "true". * "loss of active material" : str Sets the model for loss of active material. Can be "none" (default), - "stress-driven", "reaction-driven", or "stress and reaction-driven". + "stress-driven", "reaction-driven", "current-driven", or + "stress and reaction-driven". A 2-tuple can be provided for different behaviour in negative and positive electrodes. * "open-circuit potential" : str - Sets the model for the open circuit potential. Can be "single" - (default) or "current sigmoid". A 2-tuple can be provided for different - behaviour in negative and positive electrodes. + Sets the model for the open circuit potential. Can be "single" + (default) or "current sigmoid". A 2-tuple can be provided for different + behaviour in negative and positive electrodes. * "operating mode" : str Sets the operating mode for the model. This determines how the current is set. Can be: @@ -103,7 +104,7 @@ class BatteryModelOptions(pybamm.FuzzyDict): * "particle" : str Sets the submodel to use to describe behaviour within the particle. Can be "Fickian diffusion" (default), "uniform profile", - "quadratic profile", or "quartic profile". A 2-tuple can be provided + "quadratic profile", or "quartic profile". A 2-tuple can be provided for different behaviour in negative and positive electrodes. * "particle mechanics" : str Sets the model to account for mechanical effects such as particle @@ -233,6 +234,7 @@ def __init__(self, extra_options): "none", "stress-driven", "reaction-driven", + "current-driven", "stress and reaction-driven", ], "open-circuit potential": ["single", "current sigmoid"], @@ -283,9 +285,9 @@ def __init__(self, extra_options): default_options = { name: options[0] for name, options in self.possible_options.items() } + extra_options = extra_options or {} # Change the default for cell geometry based on which thermal option is provided - extra_options = extra_options or {} # return "none" if option not given thermal_option = extra_options.get("thermal", "none") if thermal_option in ["none", "isothermal", "lumped"]: diff --git a/pybamm/models/submodels/active_material/loss_active_material.py b/pybamm/models/submodels/active_material/loss_active_material.py index bc59cb8d31..7dfa4f9049 100644 --- a/pybamm/models/submodels/active_material/loss_active_material.py +++ b/pybamm/models/submodels/active_material/loss_active_material.py @@ -114,6 +114,19 @@ def get_coupled_variables(self, variables): j_stress_reaction = beta_LAM_sei * a_j_sei / self.param.F deps_solid_dt += j_stress_reaction + + if "current" in lam_option: + # obtain the rate of loss of active materials (LAM) driven by current + if self.x_average is True: + T = variables[f"X-averaged {domain} electrode temperature [K]"] + else: + T = variables[f"{Domain} electrode temperature [K]"] + + j_current_LAM = self.domain_param.LAM_rate_current( + self.param.current_density_with_time, T + ) + deps_solid_dt += j_current_LAM + variables.update( self._get_standard_active_material_change_variables(deps_solid_dt) ) diff --git a/pybamm/models/submodels/interface/kinetics/inverse_kinetics/__init__.py b/pybamm/models/submodels/interface/kinetics/inverse_kinetics/__init__.py index 8b13789179..e69de29bb2 100644 --- a/pybamm/models/submodels/interface/kinetics/inverse_kinetics/__init__.py +++ b/pybamm/models/submodels/interface/kinetics/inverse_kinetics/__init__.py @@ -1 +0,0 @@ - diff --git a/pybamm/models/submodels/thermal/base_thermal.py b/pybamm/models/submodels/thermal/base_thermal.py index 54c4a1b467..2ac83f1aef 100644 --- a/pybamm/models/submodels/thermal/base_thermal.py +++ b/pybamm/models/submodels/thermal/base_thermal.py @@ -175,6 +175,8 @@ def _get_standard_coupled_variables(self, variables): "Total heating [W.m-3]": Q, "X-averaged total heating [W.m-3]": Q_av, "Volume-averaged total heating [W.m-3]": Q_vol_av, + "Negative current collector Ohmic heating [W.m-3]": Q_ohm_s_cn, + "Positive current collector Ohmic heating [W.m-3]": Q_ohm_s_cp, } ) return variables diff --git a/pybamm/models/submodels/thermal/lumped.py b/pybamm/models/submodels/thermal/lumped.py index 0b7387390f..18d5d1bea2 100644 --- a/pybamm/models/submodels/thermal/lumped.py +++ b/pybamm/models/submodels/thermal/lumped.py @@ -54,7 +54,6 @@ def set_rhs(self, variables): T_amb = variables["Ambient temperature [K]"] # Account for surface area to volume ratio in cooling coefficient - # The factor 1/delta^2 comes from the choice of non-dimensionalisation. if self.options["cell geometry"] == "pouch": cell_volume = self.param.L * self.param.L_y * self.param.L_z diff --git a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py index 35d226d6e3..4117ae84f1 100644 --- a/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py +++ b/pybamm/models/submodels/thermal/pouch_cell/pouch_cell_2D_current_collectors.py @@ -57,8 +57,7 @@ def set_rhs(self, variables): T_amb = variables["Ambient temperature [K]"] # Account for surface area to volume ratio of pouch cell in cooling - # coefficient. Note: the factor 1/delta^2 comes from the choice of - # non-dimensionalisation + # coefficient. yz_surface_area = self.param.L_y * self.param.L_z cell_volume = self.param.L * self.param.L_y * self.param.L_z yz_surface_cooling_coefficient = ( diff --git a/pybamm/models/submodels/thermal/x_full.py b/pybamm/models/submodels/thermal/x_full.py index 49d83a6f2e..da95e2a46a 100644 --- a/pybamm/models/submodels/thermal/x_full.py +++ b/pybamm/models/submodels/thermal/x_full.py @@ -41,8 +41,16 @@ def get_fundamental_variables(self): T_dict[domain] = T_k T = pybamm.concatenation(*T_dict.values()) - T_cn = pybamm.boundary_value(T_dict["negative electrode"], "left") - T_cp = pybamm.boundary_value(T_dict["positive electrode"], "right") + T_cn = pybamm.Variable( + "Negative current collector temperature [K]", + domain="current collector", + scale=self.param.T_ref, + ) + T_cp = pybamm.Variable( + "Positive current collector temperature [K]", + domain="current collector", + scale=self.param.T_ref, + ) T_x_av = self._x_average(T, T_cn, T_cp) T_vol_av = self._yz_average(T_x_av) T_dict.update( @@ -63,57 +71,110 @@ def get_coupled_variables(self, variables): def set_rhs(self, variables): T = variables["Cell temperature [K]"] + T_cn = variables["Negative current collector temperature [K]"] T_n = variables["Negative electrode temperature [K]"] T_s = variables["Separator temperature [K]"] T_p = variables["Positive electrode temperature [K]"] - + T_cp = variables["Positive current collector temperature [K]"] Q = variables["Total heating [W.m-3]"] + Q_cn = variables["Negative current collector Ohmic heating [W.m-3]"] + Q_cp = variables["Positive current collector Ohmic heating [W.m-3]"] + T_amb = variables["Ambient temperature [K]"] - # Define volumetric heat capacity + # Define volumetric heat capacity for electrode/separator/electrode sandwich rho_c_p = pybamm.concatenation( self.param.n.rho_c_p(T_n), self.param.s.rho_c_p(T_s), self.param.p.rho_c_p(T_p), ) - # Define thermal conductivity + # Define thermal conductivity for electrode/separator/electrode sandwich lambda_ = pybamm.concatenation( self.param.n.lambda_(T_n), self.param.s.lambda_(T_s), self.param.p.lambda_(T_p), ) - # Fourier's law for heat flux - q = -lambda_ * pybamm.grad(T) + # Calculate edge/tab cooling + L_y = self.param.L_y + L_z = self.param.L_z + L_cn = self.param.n.L_cc + L_cp = self.param.p.L_cc + h_cn = self.param.n.h_cc + h_cp = self.param.p.h_cc + lambda_n = self.param.n.lambda_(T_n) + lambda_p = self.param.p.lambda_(T_p) + # Negative current collector + volume_cn = L_cn * L_y * L_z + negative_tab_area = self.param.n.L_tab * self.param.n.L_cc + edge_area_cn = 2 * (L_y + L_z) * L_cn - negative_tab_area + negative_tab_cooling_coefficient = ( + -self.param.n.h_tab * negative_tab_area / volume_cn + ) + edge_cooling_coefficient_cn = -self.param.h_edge * edge_area_cn / volume_cn + cooling_coefficient_cn = ( + negative_tab_cooling_coefficient + edge_cooling_coefficient_cn + ) + # Electrode/separator/electrode sandwich + area_to_volume = ( + 2 * (self.param.L_y + self.param.L_z) / (self.param.L_y * self.param.L_z) + ) + cooling_coefficient = -self.param.h_edge * area_to_volume + # Positive current collector + volume_cp = L_cp * L_y * L_z + positive_tab_area = self.param.p.L_tab * self.param.p.L_cc + edge_area_cp = 2 * (L_y + L_z) * L_cp - positive_tab_area + positive_tab_cooling_coefficient = ( + -self.param.p.h_tab * positive_tab_area / volume_cp + ) + edge_cooling_coefficient_cp = -self.param.h_edge * edge_area_cp / volume_cp + cooling_coefficient_cp = ( + positive_tab_cooling_coefficient + edge_cooling_coefficient_cp + ) - # N.B only y-z surface cooling is implemented for this model - self.rhs = {T: (-pybamm.div(q) + Q) / rho_c_p} + self.rhs = { + T_cn: ( + ( + pybamm.boundary_value(lambda_n, "left") + * pybamm.boundary_gradient(T_n, "left") + - h_cn * (T_cn - T_amb) + ) + / L_cn + + Q_cn + + cooling_coefficient_cn * (T_cn - T_amb) + ) + / self.param.n.rho_c_p_cc(T_cn), + T: ( + pybamm.div(lambda_ * pybamm.grad(T)) + + Q + + cooling_coefficient * (T - T_amb) + ) + / rho_c_p, + T_cp: ( + ( + -pybamm.boundary_value(lambda_p, "right") + * pybamm.boundary_gradient(T_p, "right") + - h_cp * (T_cp - T_amb) + ) + / L_cp + + Q_cp + + cooling_coefficient_cp * (T_cp - T_amb) + ) + / self.param.p.rho_c_p_cc(T_cp), + } def set_boundary_conditions(self, variables): T = variables["Cell temperature [K]"] - T_n_left = pybamm.boundary_value(T, "left") - T_p_right = pybamm.boundary_value(T, "right") - T_amb = variables["Ambient temperature [K]"] + T_cn = variables["Negative current collector temperature [K]"] + T_cp = variables["Positive current collector temperature [K]"] - # N.B only y-z surface cooling is implemented for this thermal model. - # Tab and edge cooling is not accounted for. self.boundary_conditions = { - T: { - "left": ( - self.param.n.h_cc - * (T_n_left - T_amb) - / self.param.n.lambda_(T_n_left), - "Neumann", - ), - "right": ( - -self.param.p.h_cc - * (T_p_right - T_amb) - / self.param.p.lambda_(T_p_right), - "Neumann", - ), - } + T: {"left": (T_cn, "Dirichlet"), "right": (T_cp, "Dirichlet")} } def set_initial_conditions(self, variables): T = variables["Cell temperature [K]"] - self.initial_conditions = {T: self.param.T_init} + T_cn = variables["Negative current collector temperature [K]"] + T_cp = variables["Positive current collector temperature [K]"] + T_init = self.param.T_init + self.initial_conditions = {T_cn: T_init, T: T_init, T_cp: T_init} diff --git a/pybamm/parameters/geometric_parameters.py b/pybamm/parameters/geometric_parameters.py index fcfc058c80..8ef6add863 100644 --- a/pybamm/parameters/geometric_parameters.py +++ b/pybamm/parameters/geometric_parameters.py @@ -112,9 +112,6 @@ def _set_parameters(self): # Particle-size distribution geometry self.R_min = pybamm.Parameter(f"{pref}{Domain} minimum particle radius [m]") self.R_max = pybamm.Parameter(f"{pref}{Domain} maximum particle radius [m]") - self.sd_a = pybamm.Parameter( - f"{pref}{Domain} area-weighted particle-size standard deviation [m]" - ) @property def R_typ(self): diff --git a/pybamm/parameters/lead_acid_parameters.py b/pybamm/parameters/lead_acid_parameters.py index b1302aff05..7da6a19410 100644 --- a/pybamm/parameters/lead_acid_parameters.py +++ b/pybamm/parameters/lead_acid_parameters.py @@ -249,9 +249,6 @@ def _set_parameters(self): # Macroscale geometry self.L = self.geo.L - # In lead-acid the current collector and electrodes are the same (same - # thickness) - self.L_cc = self.L # Thermal self.rho_c_p = self.therm.rho_c_p @@ -265,10 +262,20 @@ def _set_parameters(self): self.b_e = self.geo.b_e self.epsilon_inactive = pybamm.Scalar(0) return + + # In lead-acid the current collector and electrodes are the same (same + # thickness) + self.L_cc = self.L # for lead-acid the electrodes and current collector are the same self.rho_c_p_cc = self.therm.rho_c_p self.lambda_cc = self.therm.lambda_ + # Tab geometry (for pouch cells) + self.L_tab = self.geo.L_tab + self.centre_y_tab = self.geo.centre_y_tab + self.centre_z_tab = self.geo.centre_z_tab + self.A_tab = self.geo.A_tab + # Microstructure self.b_e = self.geo.b_e self.b_s = self.geo.b_s diff --git a/pybamm/parameters/lithium_ion_parameters.py b/pybamm/parameters/lithium_ion_parameters.py index d489ac6684..a8558d55dc 100644 --- a/pybamm/parameters/lithium_ion_parameters.py +++ b/pybamm/parameters/lithium_ion_parameters.py @@ -363,6 +363,17 @@ def k_cr(self, T): f"{Domain} electrode cracking rate", {"Temperature [K]": T} ) + def LAM_rate_current(self, i, T): + """ + Dimensional rate of loss of active material as a function of applied current + density + """ + Domain = self.domain.capitalize() + inputs = {"Total current density [A.m-2]": i, "Temperature [K]": T} + return pybamm.FunctionParameter( + f"{Domain} electrode current-driven LAM rate", inputs + ) + class ParticleLithiumIonParameters(BaseParameters): def __init__(self, phase, domain_param): @@ -489,7 +500,6 @@ def _set_parameters(self): # Particle-size distribution parameters self.R_min = self.geo.R_min self.R_max = self.geo.R_max - self.sd_a = self.geo.sd_a self.f_a_dist = self.geo.f_a_dist self.epsilon_s = pybamm.FunctionParameter( diff --git a/pybamm/parameters/process_parameter_data.py b/pybamm/parameters/process_parameter_data.py index 1373aefea7..8de8f32ba8 100644 --- a/pybamm/parameters/process_parameter_data.py +++ b/pybamm/parameters/process_parameter_data.py @@ -1,8 +1,4 @@ -# -# Functions to process parameter data (for Interpolants) -# import os -import pandas as pd import json import numpy as np @@ -39,11 +35,12 @@ def process_1D_data(name, path=None): """ filename, name = _process_name(name, path, ".csv") - data = pd.read_csv( - filename, comment="#", skip_blank_lines=True, header=None - ).to_numpy() + data = np.genfromtxt(filename, delimiter=',', skip_header=1) + x = data[:, 0] + y = data[:, 1] + # Save name and data - return (name, ([data[:, 0]], data[:, 1])) + return (name, ([x], y)) def process_2D_data(name, path=None): @@ -91,23 +88,16 @@ def process_2D_data_csv(name, path=None): filename, name = _process_name(name, path, ".csv") - df = pd.read_csv(filename) - - x1 = np.array(list(set(df.iloc[:, 0]))) - x2 = np.array(list(set(df.iloc[:, 1]))) + data = np.genfromtxt(filename, delimiter=',',skip_header=1) - value = df.iloc[:, 2].to_numpy() + x1 = np.unique(data[:, 0]) + x2 = np.unique(data[:, 1]) - x1.sort() - x2.sort() + value = data[:, 2] x = (x1, x2) - value_data = np.reshape( - value, - (len(x1), len(x2)), - order="C", # use the C convention - ) + value_data = value.reshape(len(x1), len(x2), order="C") formatted_data = (name, (x, value_data)) @@ -145,25 +135,17 @@ def process_3D_data_csv(name, path=None): filename, name = _process_name(name, path, ".csv") - df = pd.read_csv(filename) - - x1 = np.array(list(set(df.iloc[:, 0]))) - x2 = np.array(list(set(df.iloc[:, 1]))) - x3 = np.array(list(set(df.iloc[:, 2]))) + data = np.genfromtxt(filename, delimiter=',',skip_header=1) - value = df.iloc[:, 3].to_numpy() + x1 = np.unique(data[:, 0]) + x2 = np.unique(data[:, 1]) + x3 = np.unique(data[:, 2]) - x1.sort() - x2.sort() - x3.sort() + value = data[:, 3] x = (x1, x2, x3) - value_data = np.reshape( - value, - (len(x1), len(x2), len(x3)), - order="C", - ) + value_data = value.reshape(len(x1), len(x2), len(x3), order="C") formatted_data = (name, (x, value_data)) diff --git a/pybamm/parameters/size_distribution_parameters.py b/pybamm/parameters/size_distribution_parameters.py index c45bd3b11e..c089be964a 100644 --- a/pybamm/parameters/size_distribution_parameters.py +++ b/pybamm/parameters/size_distribution_parameters.py @@ -79,9 +79,6 @@ def f_a_dist_n(R): param.update( { - "Negative area-weighted mean particle radius [m]": R_n_av, - "Negative area-weighted particle-size " - + "standard deviation [m]": sd_n * R_n_av, "Negative minimum particle radius [m]": R_min_n * R_n_av, "Negative maximum particle radius [m]": R_max_n * R_n_av, "Negative area-weighted " @@ -108,9 +105,6 @@ def f_a_dist_p(R): param.update( { - "Positive area-weighted mean particle radius [m]": R_p_av, - "Positive area-weighted particle-size " - + "standard deviation [m]": sd_p * R_p_av, "Positive minimum particle radius [m]": R_min_p * R_p_av, "Positive maximum particle radius [m]": R_max_p * R_p_av, "Positive area-weighted " diff --git a/pybamm/simulation.py b/pybamm/simulation.py index ae10c02464..52c1922545 100644 --- a/pybamm/simulation.py +++ b/pybamm/simulation.py @@ -1027,7 +1027,7 @@ def geometry(self): @geometry.setter def geometry(self, geometry): - self._geometry = geometry.copy() + self._geometry = geometry @property def parameter_values(self): diff --git a/pybamm/solvers/c_solvers/idaklu/casadi_functions.cpp b/pybamm/solvers/c_solvers/idaklu/casadi_functions.cpp index e56b0902b2..310575742d 100644 --- a/pybamm/solvers/c_solvers/idaklu/casadi_functions.cpp +++ b/pybamm/solvers/c_solvers/idaklu/casadi_functions.cpp @@ -41,7 +41,7 @@ CasadiFunctions::CasadiFunctions( const Function &mass_action, const Function &sens, const Function &events, const int n_s, int n_e, const int n_p, const Options& options) : number_of_states(n_s), number_of_events(n_e), number_of_parameters(n_p), - number_of_nnz(jac_times_cjmass_nnz), + number_of_nnz(jac_times_cjmass_nnz), jac_bandwidth_lower(jac_bandwidth_lower), jac_bandwidth_upper(jac_bandwidth_upper), rhs_alg(rhs_alg), jac_times_cjmass(jac_times_cjmass), jac_action(jac_action), @@ -67,7 +67,7 @@ CasadiFunctions::CasadiFunctions( } inputs.resize(inputs_length); - + } realtype *CasadiFunctions::get_tmp_state_vector() { return tmp_state_vector.data(); } diff --git a/pybamm/solvers/c_solvers/idaklu/casadi_solver.cpp b/pybamm/solvers/c_solvers/idaklu/casadi_solver.cpp index 23a24d5372..67bb2793ae 100644 --- a/pybamm/solvers/c_solvers/idaklu/casadi_solver.cpp +++ b/pybamm/solvers/c_solvers/idaklu/casadi_solver.cpp @@ -10,8 +10,8 @@ create_casadi_solver(int number_of_states, int number_of_parameters, const Function &rhs_alg, const Function &jac_times_cjmass, const np_array_int &jac_times_cjmass_colptrs, const np_array_int &jac_times_cjmass_rowvals, - const int jac_times_cjmass_nnz, - const int jac_bandwidth_lower, const int jac_bandwidth_upper, + const int jac_times_cjmass_nnz, + const int jac_bandwidth_lower, const int jac_bandwidth_upper, const Function &jac_action, const Function &mass_action, const Function &sens, const Function &events, const int number_of_events, @@ -26,7 +26,7 @@ create_casadi_solver(int number_of_states, int number_of_parameters, options_cpp); return new CasadiSolver(atol_np, rel_tol, rhs_alg_id, number_of_parameters, - number_of_events, jac_times_cjmass_nnz, + number_of_events, jac_times_cjmass_nnz, jac_bandwidth_lower, jac_bandwidth_upper, std::move(functions), options_cpp); } @@ -169,7 +169,7 @@ CasadiSolver::CasadiSolver(np_array atol_np, double rel_tol, } else if (options.linear_solver == "SUNLinSol_Band") { - DEBUG("\tsetting SUNLinSol_Band linear solver"); + DEBUG("\tsetting SUNLinSol_Band linear solver"); #if SUNDIALS_VERSION_MAJOR >= 6 LS = SUNLinSol_Band(yy, J, sunctx); #else @@ -302,15 +302,15 @@ Solution CasadiSolver::solve(np_array t_np, np_array y0_np, np_array yp0_np, if (y0.size() != number_of_states + number_of_parameters * number_of_states) { throw std::domain_error( - "y0 has wrong size. Expected " + - std::to_string(number_of_states + number_of_parameters * number_of_states) + + "y0 has wrong size. Expected " + + std::to_string(number_of_states + number_of_parameters * number_of_states) + " but got " + std::to_string(y0.size())); } if (yp0.size() != number_of_states + number_of_parameters * number_of_states) { throw std::domain_error( - "yp0 has wrong size. Expected " + - std::to_string(number_of_states + number_of_parameters * number_of_states) + + "yp0 has wrong size. Expected " + + std::to_string(number_of_states + number_of_parameters * number_of_states) + " but got " + std::to_string(yp0.size())); } diff --git a/pybamm/solvers/c_solvers/idaklu/casadi_solver.hpp b/pybamm/solvers/c_solvers/idaklu/casadi_solver.hpp index 09c4434d5b..75bc73e9d3 100644 --- a/pybamm/solvers/c_solvers/idaklu/casadi_solver.hpp +++ b/pybamm/solvers/c_solvers/idaklu/casadi_solver.hpp @@ -48,8 +48,8 @@ create_casadi_solver(int number_of_states, int number_of_parameters, const Function &rhs_alg, const Function &jac_times_cjmass, const np_array_int &jac_times_cjmass_colptrs, const np_array_int &jac_times_cjmass_rowvals, - const int jac_times_cjmass_nnz, - const int jac_bandwidth_lower, const int jac_bandwidth_upper, + const int jac_times_cjmass_nnz, + const int jac_bandwidth_lower, const int jac_bandwidth_upper, const Function &jac_action, const Function &mass_action, const Function &sens, const Function &event, const int number_of_events, diff --git a/pybamm/solvers/c_solvers/idaklu/casadi_sundials_functions.cpp b/pybamm/solvers/c_solvers/idaklu/casadi_sundials_functions.cpp index eaf383cda4..8a3d96966f 100644 --- a/pybamm/solvers/c_solvers/idaklu/casadi_sundials_functions.cpp +++ b/pybamm/solvers/c_solvers/idaklu/casadi_sundials_functions.cpp @@ -172,7 +172,7 @@ int jacobian_casadi(realtype tt, realtype cj, N_Vector yy, N_Vector yp, p_python_functions->jac_times_cjmass(); - if (p_python_functions->options.using_banded_matrix) + if (p_python_functions->options.using_banded_matrix) { // copy data from temporary matrix to the banded matrix auto jac_colptrs = p_python_functions->jac_times_cjmass_colptrs.data(); @@ -187,7 +187,7 @@ int jacobian_casadi(realtype tt, realtype cj, N_Vector yy, N_Vector yp, SM_COLUMN_ELEMENT_B(banded_col, row_ij, col_ij) = value_ij; } } - } + } else if (p_python_functions->options.using_sparse_matrix) { @@ -279,7 +279,7 @@ int sensitivities_casadi(int Ns, realtype t, N_Vector yy, N_Vector yp, } // resvalsS now has (∂F/∂p i ) p_python_functions->sens(); - + for (int i = 0; i < np; i++) { // put (∂F/∂y)s i (t) in tmp diff --git a/pybamm/solvers/c_solvers/idaklu/common.hpp b/pybamm/solvers/c_solvers/idaklu/common.hpp index 1931f8cb61..d6ddb5c16b 100644 --- a/pybamm/solvers/c_solvers/idaklu/common.hpp +++ b/pybamm/solvers/c_solvers/idaklu/common.hpp @@ -12,7 +12,7 @@ #if SUNDIALS_VERSION_MAJOR >= 6 - #include + #include #endif #include /* access to KLU linear solver */ @@ -37,7 +37,7 @@ using np_array_dense = py::array_t; #ifdef NDEBUG -#define DEBUG(x) +#define DEBUG(x) #else #define DEBUG(x) do { std::cerr << __FILE__ << ':' << __LINE__ << ' ' << x << std::endl; } while (0) #endif diff --git a/pybamm/solvers/c_solvers/idaklu/options.cpp b/pybamm/solvers/c_solvers/idaklu/options.cpp index 2a5ed58d9c..33998470ed 100644 --- a/pybamm/solvers/c_solvers/idaklu/options.cpp +++ b/pybamm/solvers/c_solvers/idaklu/options.cpp @@ -2,7 +2,7 @@ #include #include - + using namespace std::string_literals; Options::Options(py::dict options) @@ -35,7 +35,7 @@ Options::Options(py::dict options) else { throw std::domain_error( - "Unknown jacobian type \""s + jacobian + + "Unknown jacobian type \""s + jacobian + "\". Should be one of \"sparse\", \"banded\", \"dense\", \"matrix-free\" or \"none\"."s ); } @@ -97,7 +97,7 @@ Options::Options(py::dict options) { throw std::domain_error( "Unknown linear solver or incompatible options. " - "jacobian = \"" + jacobian + "\" linear solver = \"" + linear_solver + "\"" + "jacobian = \"" + jacobian + "\" linear solver = \"" + linear_solver + "\"" ); } @@ -106,7 +106,7 @@ Options::Options(py::dict options) if (preconditioner != "none" && preconditioner != "BBDP") { throw std::domain_error( - "Unknown preconditioner \""s + preconditioner + + "Unknown preconditioner \""s + preconditioner + "\", use one of \"BBDP\" or \"none\""s ); } diff --git a/pybamm/solvers/c_solvers/idaklu/options.hpp b/pybamm/solvers/c_solvers/idaklu/options.hpp index 30e6fc634d..db5f136a01 100644 --- a/pybamm/solvers/c_solvers/idaklu/options.hpp +++ b/pybamm/solvers/c_solvers/idaklu/options.hpp @@ -9,8 +9,8 @@ struct Options { bool using_banded_matrix; bool using_iterative_solver; std::string jacobian; - std::string linear_solver; // klu, lapack, spbcg - std::string preconditioner; // spbcg + std::string linear_solver; // klu, lapack, spbcg + std::string preconditioner; // spbcg int linsol_max_iterations; int precon_half_bandwidth; int precon_half_bandwidth_keep; diff --git a/pybamm/solvers/c_solvers/idaklu/python.cpp b/pybamm/solvers/c_solvers/idaklu/python.cpp index a1803988d4..9ec018109e 100644 --- a/pybamm/solvers/c_solvers/idaklu/python.cpp +++ b/pybamm/solvers/c_solvers/idaklu/python.cpp @@ -14,10 +14,10 @@ class PybammFunctions const jac_get_type &get_jac_data_in, const jac_get_type &get_jac_row_vals_in, const jac_get_type &get_jac_col_ptrs_in, - const event_type &event, + const event_type &event, const int n_s, int n_e, const int n_p, const np_array &inputs) - : number_of_states(n_s), number_of_events(n_e), + : number_of_states(n_s), number_of_events(n_e), number_of_parameters(n_p), py_res(res), py_jac(jac), py_sens(sens), @@ -48,11 +48,11 @@ class PybammFunctions void sensitivities( std::vector& resvalS, - const double t, const np_array& y, const np_array& yp, - const std::vector& yS, const std::vector& ypS) + const double t, const np_array& y, const np_array& yp, + const std::vector& yS, const std::vector& ypS) { // this function evaluates the sensitivity equations required by IDAS, - // returning them in resvalS, which is preallocated as a numpy array + // returning them in resvalS, which is preallocated as a numpy array // of size (np, n), where n is the number of states and np is the number // of parameters // @@ -199,11 +199,11 @@ int events(realtype t, N_Vector yy, N_Vector yp, realtype *events_ptr, return (0); } -int sensitivities(int Ns, realtype t, N_Vector yy, N_Vector yp, - N_Vector resval, N_Vector *yS, N_Vector *ypS, N_Vector *resvalS, +int sensitivities(int Ns, realtype t, N_Vector yy, N_Vector yp, + N_Vector resval, N_Vector *yS, N_Vector *ypS, N_Vector *resvalS, void *user_data, N_Vector tmp1, N_Vector tmp2, N_Vector tmp3) { -// This function computes the sensitivity residual for all sensitivity -// equations. It must compute the vectors +// This function computes the sensitivity residual for all sensitivity +// equations. It must compute the vectors // (∂F/∂y)s i (t)+(∂F/∂ ẏ) ṡ i (t)+(∂F/∂p i ) and store them in resvalS[i]. // Ns is the number of sensitivities. // t is the current value of the independent variable. @@ -212,15 +212,15 @@ int sensitivities(int Ns, realtype t, N_Vector yy, N_Vector yp, // resval contains the current value F of the original DAE residual. // yS contains the current values of the sensitivities s i . // ypS contains the current values of the sensitivity derivatives ṡ i . -// resvalS contains the output sensitivity residual vectors. +// resvalS contains the output sensitivity residual vectors. // Memory allocation for resvalS is handled within idas. // user data is a pointer to user data. -// tmp1, tmp2, tmp3 are N Vectors of length N which can be used as +// tmp1, tmp2, tmp3 are N Vectors of length N which can be used as // temporary storage. // -// Return value An IDASensResFn should return 0 if successful, +// Return value An IDASensResFn should return 0 if successful, // a positive value if a recoverable error -// occurred (in which case idas will attempt to correct), +// occurred (in which case idas will attempt to correct), // or a negative value if it failed unrecoverably (in which case the integration is halted and IDA SRES FAIL is returned) // PybammFunctions *python_functions_ptr = @@ -232,7 +232,7 @@ int sensitivities(int Ns, realtype t, N_Vector yy, N_Vector yp, // memory managed by sundials, so pass a destructor that does nothing auto state_vector_shape = std::vector{n, 1}; - np_array y_np = np_array(state_vector_shape, N_VGetArrayPointer(yy), + np_array y_np = np_array(state_vector_shape, N_VGetArrayPointer(yy), py::capsule(&yy, [](void* p) {})); np_array yp_np = np_array(state_vector_shape, N_VGetArrayPointer(yp), py::capsule(&yp, [](void* p) {})); @@ -252,7 +252,7 @@ int sensitivities(int Ns, realtype t, N_Vector yy, N_Vector yp, std::vector resvalS_np(np); for (int i = 0; i < np; i++) { auto capsule = py::capsule(resvalS + i, [](void* p) {}); - resvalS_np[i] = np_array(state_vector_shape, + resvalS_np[i] = np_array(state_vector_shape, N_VGetArrayPointer(resvalS[i]), capsule); } @@ -266,12 +266,12 @@ int sensitivities(int Ns, realtype t, N_Vector yy, N_Vector yp, /* main program */ Solution solve_python(np_array t_np, np_array y0_np, np_array yp0_np, - residual_type res, jacobian_type jac, + residual_type res, jacobian_type jac, sensitivities_type sens, - jac_get_type gjd, jac_get_type gjrv, jac_get_type gjcp, + jac_get_type gjd, jac_get_type gjrv, jac_get_type gjcp, int nnz, event_type event, int number_of_events, int use_jacobian, np_array rhs_alg_id, - np_array atol_np, double rel_tol, np_array inputs, + np_array atol_np, double rel_tol, np_array inputs, int number_of_parameters) { auto t = t_np.unchecked<1>(); @@ -374,7 +374,7 @@ Solution solve_python(np_array t_np, np_array y0_np, np_array yp0_np, if (number_of_parameters > 0) { - IDASensInit(ida_mem, number_of_parameters, + IDASensInit(ida_mem, number_of_parameters, IDA_SIMULTANEOUS, sensitivities, yyS, ypS); IDASensEEtolerances(ida_mem); } @@ -433,7 +433,7 @@ Solution solve_python(np_array t_np, np_array y0_np, np_array yp0_np, y_return[t_i * number_of_states + j] = yval[j]; } for (int j = 0; j < number_of_parameters; j++) { - const int base_index = j * number_of_timesteps * number_of_states + const int base_index = j * number_of_timesteps * number_of_states + t_i * number_of_states; for (int k = 0; k < number_of_states; k++) { yS_return[base_index + k] = ySval[j][k]; @@ -468,11 +468,10 @@ Solution solve_python(np_array t_np, np_array y0_np, np_array yp0_np, np_array y_ret = np_array(t_i * number_of_states, &y_return[0]); np_array yS_ret = np_array( std::vector{number_of_parameters, number_of_timesteps, number_of_states}, - &yS_return[0] + &yS_return[0] ); Solution sol(retval, t_ret, y_ret, yS_ret); return sol; } - diff --git a/pybamm/solvers/c_solvers/idaklu/python.hpp b/pybamm/solvers/c_solvers/idaklu/python.hpp index 8c29bbc496..8ae73f2a90 100644 --- a/pybamm/solvers/c_solvers/idaklu/python.hpp +++ b/pybamm/solvers/c_solvers/idaklu/python.hpp @@ -9,9 +9,9 @@ using residual_type = std::function< np_array(realtype, np_array, np_array, np_array) >; using sensitivities_type = std::function&, realtype, const np_array&, + std::vector&, realtype, const np_array&, const np_array&, - const np_array&, const std::vector&, + const np_array&, const std::vector&, const std::vector& )>; using jacobian_type = std::function; @@ -24,9 +24,9 @@ using jac_get_type = std::function; Solution solve_python(np_array t_np, np_array y0_np, np_array yp0_np, - residual_type res, jacobian_type jac, + residual_type res, jacobian_type jac, sensitivities_type sens, - jac_get_type gjd, jac_get_type gjrv, jac_get_type gjcp, + jac_get_type gjd, jac_get_type gjrv, jac_get_type gjcp, int nnz, event_type event, int number_of_events, int use_jacobian, np_array rhs_alg_id, np_array atol_np, double rel_tol, np_array inputs, diff --git a/pybamm/solvers/processed_variable.py b/pybamm/solvers/processed_variable.py index 75b58e0950..9c404b72a2 100644 --- a/pybamm/solvers/processed_variable.py +++ b/pybamm/solvers/processed_variable.py @@ -56,6 +56,15 @@ def __init__( self.warn = warn self.cumtrapz_ic = cumtrapz_ic + # Process spatial variables + geometry = solution.all_models[0].geometry + self.spatial_variables = {} + for domain_level, domain_names in self.domains.items(): + variables = [] + for domain in domain_names: + variables += list(geometry[domain].keys()) + self.spatial_variables[domain_level] = variables + # Sensitivity starts off uninitialized, only set when called self._sensitivities = None self.solution_sensitivities = solution.sensitivities @@ -172,25 +181,11 @@ def initialise_1D(self, fixed_t=False): # assign attributes for reference (either x_sol or r_sol) self.entries = entries self.dimensions = 1 - if self.domain[0].endswith("particle"): - self.first_dimension = "r" - self.r_sol = space - elif self.domain[0] in [ - "negative electrode", - "separator", - "positive electrode", - ]: - self.first_dimension = "x" - self.x_sol = space - elif self.domain == ["current collector"]: - self.first_dimension = "z" - self.z_sol = space - elif self.domain[0].endswith("particle size"): - self.first_dimension = "R" - self.R_sol = space - else: - self.first_dimension = "x" - self.x_sol = space + self.spatial_variable_names = { + k: self._process_spatial_variable_names(v) + for k, v in self.spatial_variables.items() + } + self.first_dimension = self.spatial_variable_names["primary"] # assign attributes for reference pts_for_interp = space @@ -285,48 +280,13 @@ def initialise_2D(self): axis=1, ) - # Process r-x, x-z, r-R, R-x, or R-z - if self.domain[0].endswith("particle") and self.domains["secondary"][ - 0 - ].endswith("electrode"): - self.first_dimension = "r" - self.second_dimension = "x" - self.r_sol = first_dim_pts - self.x_sol = second_dim_pts - elif self.domain[0] in [ - "negative electrode", - "separator", - "positive electrode", - ] and self.domains["secondary"] == ["current collector"]: - self.first_dimension = "x" - self.second_dimension = "z" - self.x_sol = first_dim_pts - self.z_sol = second_dim_pts - elif self.domain[0].endswith("particle") and self.domains["secondary"][ - 0 - ].endswith("particle size"): - self.first_dimension = "r" - self.second_dimension = "R" - self.r_sol = first_dim_pts - self.R_sol = second_dim_pts - elif self.domain[0].endswith("particle size") and self.domains["secondary"][ - 0 - ].endswith("electrode"): - self.first_dimension = "R" - self.second_dimension = "x" - self.R_sol = first_dim_pts - self.x_sol = second_dim_pts - elif self.domain[0].endswith("particle size") and self.domains["secondary"] == [ - "current collector" - ]: - self.first_dimension = "R" - self.second_dimension = "z" - self.R_sol = first_dim_pts - self.z_sol = second_dim_pts - else: # pragma: no cover - raise pybamm.DomainError( - f"Cannot process 2D object with domains '{self.domains}'." - ) + self.spatial_variable_names = { + k: self._process_spatial_variable_names(v) + for k, v in self.spatial_variables.items() + } + + self.first_dimension = self.spatial_variable_names["primary"] + self.second_dimension = self.spatial_variable_names["secondary"] # assign attributes for reference self.entries = entries @@ -386,6 +346,35 @@ def initialise_2D_scikit_fem(self): coords={"y": y_sol, "z": z_sol, "t": self.t_pts}, ) + def _process_spatial_variable_names(self, spatial_variable): + if len(spatial_variable) == 0: + return None + + # Extract names + raw_names = [] + for var in spatial_variable: + # Ignore tabs in domain names + if var == "tabs": + continue + if isinstance(var, str): + raw_names.append(var) + else: + raw_names.append(var.name) + + # Rename battery variables to match PyBaMM convention + if all([var.startswith("r") for var in raw_names]): + return "r" + elif all([var.startswith("x") for var in raw_names]): + return "x" + elif all([var.startswith("R") for var in raw_names]): + return "R" + elif len(raw_names) == 1: + return raw_names[0] + else: + raise NotImplementedError( + "Spatial variable name not recognized for {}".format(spatial_variable) + ) + def __call__(self, t=None, x=None, r=None, y=None, z=None, R=None, warn=True): """ Evaluate the variable at arbitrary *dimensional* t (and x, r, y, z and/or R), diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index d33b212a2e..0000000000 --- a/requirements.txt +++ /dev/null @@ -1,19 +0,0 @@ -numpy >= 1.16 -scipy >= 1.3 -pandas >= 0.24 -anytree >= 2.4.3 -autograd >= 1.2 -scikit-fem >= 0.2.0 -casadi >= 3.6.0 -imageio>=2.9.0 -pybtex>=0.24.0 -sympy >= 1.8 -xarray -bpx -tqdm -# Note: Matplotlib is loaded for debug plots but to ensure pybamm runs -# on systems without an attached display it should never be imported -# outside of plot() methods. -# Should not be imported -matplotlib >= 2.0 -# diff --git a/run-tests.py b/run-tests.py index 98fc4d1619..5d4bb65b65 100755 --- a/run-tests.py +++ b/run-tests.py @@ -187,7 +187,7 @@ def test_notebook(path, executable="python"): print("Test " + path + " ... ", end="") sys.stdout.flush() - # Make sure the notebook has a + # Make sure the notebook has a # "%pip install pybamm[plot,cite] -q" command, for using Google Colab with open(path, "r") as f: if "%pip install pybamm[plot,cite] -q" not in f.read(): @@ -374,12 +374,6 @@ def export_notebook(ipath, opath): metavar=("in", "out"), help="Export a Jupyter notebook to a Python file for manual testing.", ) - # Flake8 (deprecated) - parser.add_argument( - "--flake8", - action="store_true", - help="Run flake8 to check for style issues (deprecated, use pre-commit)", - ) # Doctests parser.add_argument( "--doctest", @@ -421,9 +415,6 @@ def export_notebook(ipath, opath): if args.nosub: has_run = True run_code_tests(folder="unit", interpreter=interpreter) - # Flake8 - if args.flake8: - raise NotImplementedError("flake8 is no longer used. Use pre-commit instead.") # Doctests if args.doctest: has_run = True diff --git a/scripts/replace-cmake/sundials-3.1.1/CMakeLists.txt b/scripts/replace-cmake/sundials-3.1.1/CMakeLists.txt index 342ddf4f9b..81f4267c22 100644 --- a/scripts/replace-cmake/sundials-3.1.1/CMakeLists.txt +++ b/scripts/replace-cmake/sundials-3.1.1/CMakeLists.txt @@ -36,7 +36,7 @@ SET(PACKAGE_NAME "SUNDIALS") SET(PACKAGE_STRING "SUNDIALS 3.1.1") SET(PACKAGE_TARNAME "sundials") -# set SUNDIALS version numbers +# set SUNDIALS version numbers # (use "" for the version label if none is needed) SET(PACKAGE_VERSION_MAJOR "3") SET(PACKAGE_VERSION_MINOR "1") @@ -387,7 +387,7 @@ OPTION(HYPRE_ENABLE "Enable hypre support" OFF) # Using hypre requres building with MPI enabled IF(HYPRE_ENABLE AND NOT MPI_ENABLE) - PRINT_WARNING("MPI not enabled - Disabling hypre" + PRINT_WARNING("MPI not enabled - Disabling hypre" "Set MPI_ENABLE to ON to use parhyp") FORCE_VARIABLE(HYPRE_ENABLE BOOL "Enable hypre support" OFF) ENDIF() @@ -399,7 +399,7 @@ OPTION(PETSC_ENABLE "Enable PETSc support" OFF) # Using PETSc requires building with MPI enabled IF(PETSC_ENABLE AND NOT MPI_ENABLE) - PRINT_WARNING("MPI not enabled - Disabling PETSc" + PRINT_WARNING("MPI not enabled - Disabling PETSc" "Set MPI_ENABLE to ON to use PETSc") FORCE_VARIABLE(PETSC_ENABLE BOOL "Enable PETSc support" OFF) ENDIF() @@ -456,7 +456,7 @@ ENDIF() SET(DOCSTR "Build ARKode F90 examples") IF(FCMIX_ENABLE AND BUILD_ARKODE) SHOW_VARIABLE(EXAMPLES_ENABLE_F90 BOOL "${DOCSTR}" OFF) - # Fortran90 examples do not support single or extended precision + # Fortran90 examples do not support single or extended precision # NOTE: This check can be removed after Fortran configure file is integrated into examples IF(SUNDIALS_PRECISION MATCHES "EXTENDED" OR SUNDIALS_PRECISION MATCHES "SINGLE") PRINT_WARNING("F90 examples are not compatible with ${SUNDIALS_PRECISION} precision" @@ -540,7 +540,7 @@ IF(EXAMPLES_ENABLED) SET(EXAMPLES_INSTALL_PATH "${CMAKE_INSTALL_PREFIX}/examples" CACHE STRING "Output directory for installing example files" FORCE) ENDIF(NOT EXAMPLES_INSTALL_PATH) - + # create test_install target and directory for running smoke tests after # installation ADD_CUSTOM_TARGET(test_install) @@ -565,7 +565,7 @@ ELSE(EXAMPLES_ENABLED) HIDE_VARIABLE(EXAMPLES_INSTALL) HIDE_VARIABLE(EXAMPLES_INSTALL_PATH) - + ENDIF(EXAMPLES_ENABLED) # --------------------------------------------------------------- @@ -796,7 +796,7 @@ IF(PTHREAD_ENABLE) IF(CMAKE_USE_PTHREADS_INIT) message(STATUS "Using Pthreads") SET(PTHREADS_FOUND TRUE) - # SGS + # SGS ELSE() message(STATUS "Disabling Pthreads support, could not determine compiler flags") endif() @@ -814,7 +814,7 @@ ENDIF() if(CUDA_ENABLE) find_package(CUDA) - + if (CUDA_FOUND) #message("CUDA found!") set(CUDA_NVCC_FLAGS "-lineinfo") @@ -1026,7 +1026,7 @@ IF(HYPRE_ENABLE) PRINT_WARNING("HYPRE not functional - support will not be provided" "Found hypre library, test code does not work") ENDIF(HYPRE_LIBRARIES AND NOT HYPRE_FOUND) - + ELSE() HIDE_VARIABLE(HYPRE_INCLUDE_DIR) @@ -1070,7 +1070,7 @@ ENDIF() # =============================================================== -# Add source and configuration files +# Add source and configuration files # =============================================================== # --------------------------------------------------------------- @@ -1141,11 +1141,11 @@ IF(PETSC_FOUND) ENDIF(PETSC_FOUND) IF(CUDA_FOUND) - ADD_SUBDIRECTORY(src/nvec_cuda) + ADD_SUBDIRECTORY(src/nvec_cuda) ENDIF(CUDA_FOUND) IF(RAJA_FOUND) - ADD_SUBDIRECTORY(src/nvec_raja) + ADD_SUBDIRECTORY(src/nvec_raja) ENDIF(RAJA_FOUND) # ARKODE library @@ -1241,7 +1241,7 @@ IF(EXAMPLES_ENABLED) SET(CFLAGS "${CMAKE_C_FLAGS_RELEASE}") SET(LDFLAGS "${CMAKE_EXE_LINKER_FLAGS_RELEASE}") LIST2STRING(EXTRA_LINK_LIBS LIBS) - + IF(CXX_FOUND) SET(CXX "${CMAKE_CXX_COMPILER}") SET(CXX_LNKR "${CMAKE_CXX_COMPILER}") @@ -1378,7 +1378,7 @@ IF(EXAMPLES_ENABLED) IF(MPIF90_FOUND) ADD_SUBDIRECTORY(examples/arkode/F90_parallel) ENDIF() - ENDIF() + ENDIF() ENDIF(BUILD_ARKODE) # add CVODE examples @@ -1411,7 +1411,7 @@ IF(EXAMPLES_ENABLED) ADD_SUBDIRECTORY(examples/cvode/cuda) ENDIF() ENDIF(EXAMPLES_ENABLE_CUDA) - # raja examples + # raja examples IF(EXAMPLES_ENABLE_RAJA) IF(RAJA_ENABLE AND RAJA_FOUND) ADD_SUBDIRECTORY(examples/cvode/raja) @@ -1568,11 +1568,11 @@ IF(EXAMPLES_ENABLED) IF(CUDA_FOUND) ADD_SUBDIRECTORY(examples/nvector/cuda) ENDIF(CUDA_FOUND) - + IF(RAJA_FOUND) ADD_SUBDIRECTORY(examples/nvector/raja) ENDIF(RAJA_FOUND) - + ENDIF(EXAMPLES_ENABLED) # --------------------------------------------------------------- diff --git a/scripts/replace-cmake/sundials-4.1.0/CMakeLists.txt b/scripts/replace-cmake/sundials-4.1.0/CMakeLists.txt index fdd1bc206e..fc8acbddc9 100644 --- a/scripts/replace-cmake/sundials-4.1.0/CMakeLists.txt +++ b/scripts/replace-cmake/sundials-4.1.0/CMakeLists.txt @@ -1149,4 +1149,3 @@ INSTALL( FILES ${PROJECT_SOURCE_DIR}/NOTICE DESTINATION include/sundials ) - diff --git a/scripts/replace-cmake/sundials-5.0.0/CMakeLists.txt b/scripts/replace-cmake/sundials-5.0.0/CMakeLists.txt index fdd1bc206e..fc8acbddc9 100644 --- a/scripts/replace-cmake/sundials-5.0.0/CMakeLists.txt +++ b/scripts/replace-cmake/sundials-5.0.0/CMakeLists.txt @@ -1149,4 +1149,3 @@ INSTALL( FILES ${PROJECT_SOURCE_DIR}/NOTICE DESTINATION include/sundials ) - diff --git a/setup.py b/setup.py index ef9f6a3a9d..dfdd455a16 100644 --- a/setup.py +++ b/setup.py @@ -205,7 +205,6 @@ def compile_KLU(): install_requires=[ "numpy>=1.16", "scipy>=1.3", - "pandas>=0.24", "casadi>=3.6.0", "xarray", ], @@ -256,6 +255,9 @@ def compile_KLU(): "ruff", # For code style auto-formatting "nox", # For running testing sessions ], + "pandas": [ + "pandas>=0.24", + ], "jax": [ "jax==0.4.8", "jaxlib==0.4.7", @@ -264,6 +266,7 @@ def compile_KLU(): "all": [ "anytree>=2.4.3", "autograd>=1.2", + "pandas>=0.24", "scikit-fem>=0.2.0", "imageio>=2.9.0", "pybtex>=0.24.0", diff --git a/tests/__init__.py b/tests/__init__.py index cbbfd567d6..919605998e 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -36,5 +36,6 @@ get_2p1d_discretisation_for_testing, get_unit_2p1D_mesh_for_testing, get_cylindrical_discretisation_for_testing, + get_base_model_with_battery_geometry, ) from .testcase import TestCase diff --git a/tests/integration/test_models/standard_output_tests.py b/tests/integration/test_models/standard_output_tests.py index a119f84404..05cb86f249 100644 --- a/tests/integration/test_models/standard_output_tests.py +++ b/tests/integration/test_models/standard_output_tests.py @@ -450,6 +450,9 @@ def test_conservation(self): decimal = 12 elif self.model.options["particle phases"] != "1": decimal = 13 + elif "current-driven" in self.model.options["loss of active material"]: + # current driven LAM model doesn't perfectly conserve lithium, not sure why + decimal = 9 else: decimal = 14 np.testing.assert_array_almost_equal(diff, 0, decimal=decimal) diff --git a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py index b5dd46101a..01fb8b8d4d 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py +++ b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py @@ -234,6 +234,34 @@ def test_loss_active_material_stress_and_reaction(self): parameter_values = pybamm.ParameterValues("Ai2020") self.run_basic_processing_test(options, parameter_values=parameter_values) + def test_well_posed_loss_active_material_current_negative(self): + options = {"loss of active material": ("current-driven", "none")} + parameter_values = pybamm.ParameterValues("Chen2020") + + def current_LAM(i, T): + return -1e-10 * abs(i) + + parameter_values.update( + {"Negative electrode current-driven LAM rate": current_LAM}, + check_already_exists=False, + ) + + self.run_basic_processing_test(options, parameter_values=parameter_values) + + def test_well_posed_loss_active_material_current_positive(self): + options = {"loss of active material": ("none", "current-driven")} + parameter_values = pybamm.ParameterValues("Chen2020") + + def current_LAM(i, T): + return -1e-10 * abs(i) + + parameter_values.update( + {"Positive electrode current-driven LAM rate": current_LAM}, + check_already_exists=False, + ) + + self.run_basic_processing_test(options, parameter_values=parameter_values) + def test_negative_cracking(self): options = {"particle mechanics": ("swelling and cracking", "none")} parameter_values = pybamm.ParameterValues("Ai2020") diff --git a/tests/integration/test_spatial_methods/test_finite_volume.py b/tests/integration/test_spatial_methods/test_finite_volume.py index 0060e49091..2f9f6ef1b0 100644 --- a/tests/integration/test_spatial_methods/test_finite_volume.py +++ b/tests/integration/test_spatial_methods/test_finite_volume.py @@ -294,6 +294,51 @@ def get_error(m): np.testing.assert_array_less(1.99 * np.ones_like(rates), rates) +def solve_laplace_equation(coord_sys="cartesian"): + model = pybamm.BaseModel() + r = pybamm.SpatialVariable("r", domain="domain", coord_sys=coord_sys) + u = pybamm.Variable("u", domain="domain") + del_u = pybamm.div(pybamm.grad(u)) + model.boundary_conditions = { + u: { + "left": (pybamm.Scalar(0), "Dirichlet"), + "right": (pybamm.Scalar(1), "Dirichlet"), + } + } + model.algebraic = {u: del_u} + model.initial_conditions = {u: pybamm.Scalar(0)} + model.variables = {"u": u, "r": r} + geometry = {"domain": {r: {"min": pybamm.Scalar(1), "max": pybamm.Scalar(2)}}} + submesh_types = {"domain": pybamm.Uniform1DSubMesh} + var_pts = {r: 500} + mesh = pybamm.Mesh(geometry, submesh_types, var_pts) + spatial_methods = {"domain": pybamm.FiniteVolume()} + disc = pybamm.Discretisation(mesh, spatial_methods) + disc.process_model(model) + solver = pybamm.CasadiAlgebraicSolver() + return solver.solve(model) + + +class TestFiniteVolumeLaplacian(TestCase): + def test_laplacian_cartesian(self): + solution = solve_laplace_equation(coord_sys="cartesian") + np.testing.assert_array_almost_equal( + solution["u"].entries, solution["r"].entries - 1, decimal=10 + ) + + def test_laplacian_cylindrical(self): + solution = solve_laplace_equation(coord_sys="cylindrical polar") + np.testing.assert_array_almost_equal( + solution["u"].entries, np.log(solution["r"].entries) / np.log(2), decimal=5 + ) + + def test_laplacian_spherical(self): + solution = solve_laplace_equation(coord_sys="spherical polar") + np.testing.assert_array_almost_equal( + solution["u"].entries, 2 - 2 / solution["r"].entries, decimal=5 + ) + + if __name__ == "__main__": print("Add -v for more debug output") import sys diff --git a/tests/shared.py b/tests/shared.py index f08d388298..1f0b033582 100644 --- a/tests/shared.py +++ b/tests/shared.py @@ -268,3 +268,9 @@ def get_cylindrical_discretisation_for_testing( mesh=get_cylindrical_mesh_for_testing(xpts, rpts, rcellpts, include_particles), cc_method=pybamm.FiniteVolume, ) + + +def get_base_model_with_battery_geometry(**kwargs): + model = pybamm.BaseModel() + model._geometry = pybamm.battery_geometry(**kwargs) + return model diff --git a/tests/unit/test_expression_tree/test_binary_operators.py b/tests/unit/test_expression_tree/test_binary_operators.py index fdcdf55d9c..4e4bbb80cc 100644 --- a/tests/unit/test_expression_tree/test_binary_operators.py +++ b/tests/unit/test_expression_tree/test_binary_operators.py @@ -54,6 +54,26 @@ def test_addition(self): summ2 = pybamm.Scalar(1) + pybamm.Scalar(3) self.assertEqual(summ2, pybamm.Scalar(4)) + def test_addition_numpy_array(self): + a = pybamm.Symbol("a") + # test adding symbol and numpy array + # converts numpy array to vector + array = np.array([1, 2, 3]) + summ3 = pybamm.Addition(a, array) + self.assertIsInstance(summ3, pybamm.Addition) + self.assertIsInstance(summ3.children[0], pybamm.Symbol) + self.assertIsInstance(summ3.children[1], pybamm.Vector) + + summ4 = array + a + self.assertIsInstance(summ4.children[0], pybamm.Vector) + + # should error if numpy array is not 1D + array = np.array([[1, 2, 3], [4, 5, 6]]) + with self.assertRaisesRegex(ValueError, "left must be a 1D array"): + pybamm.Addition(array, a) + with self.assertRaisesRegex(ValueError, "right must be a 1D array"): + pybamm.Addition(a, array) + def test_power(self): a = pybamm.Symbol("a") b = pybamm.Symbol("b") diff --git a/tests/unit/test_expression_tree/test_symbol.py b/tests/unit/test_expression_tree/test_symbol.py index dba0879a8c..3a74375ce7 100644 --- a/tests/unit/test_expression_tree/test_symbol.py +++ b/tests/unit/test_expression_tree/test_symbol.py @@ -482,6 +482,10 @@ def test_test_shape(self): def test_to_equation(self): self.assertEqual(pybamm.Symbol("test").to_equation(), sympy.Symbol("test")) + def test_numpy_array_ufunc(self): + x = pybamm.Symbol("x") + self.assertEqual(np.exp(x), pybamm.exp(x)) + class TestIsZero(TestCase): def test_is_scalar_zero(self): diff --git a/tests/unit/test_meshes/test_meshes.py b/tests/unit/test_meshes/test_meshes.py index d97422860e..6563ba232d 100644 --- a/tests/unit/test_meshes/test_meshes.py +++ b/tests/unit/test_meshes/test_meshes.py @@ -35,6 +35,9 @@ def test_mesh_creation_no_parameters(self): # create mesh mesh = pybamm.Mesh(geometry, submesh_types, var_pts) + # check geometry + self.assertEqual(mesh.geometry, geometry) + # check boundary locations self.assertEqual(mesh["negative particle"].edges[0], 0) self.assertEqual(mesh["negative particle"].edges[-1], 1) @@ -77,6 +80,9 @@ def test_mesh_creation(self): # create mesh mesh = pybamm.Mesh(geometry, submesh_types, var_pts) + # check geometry + self.assertEqual(mesh.geometry, geometry) + # check boundary locations self.assertEqual(mesh["negative electrode"].edges[0], 0) self.assertAlmostEqual(mesh["positive electrode"].edges[-1], 0.6) diff --git a/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py b/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py index b0dad88cc4..28277af9e2 100644 --- a/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py +++ b/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py @@ -30,7 +30,7 @@ 'interface utilisation': 'full' (possible: ['full', 'constant', 'current-driven']) 'lithium plating': 'none' (possible: ['none', 'reversible', 'partially reversible', 'irreversible']) 'lithium plating porosity change': 'false' (possible: ['false', 'true']) -'loss of active material': 'stress-driven' (possible: ['none', 'stress-driven', 'reaction-driven', 'stress and reaction-driven']) +'loss of active material': 'stress-driven' (possible: ['none', 'stress-driven', 'reaction-driven', 'current-driven', 'stress and reaction-driven']) 'open-circuit potential': 'single' (possible: ['single', 'current sigmoid']) 'operating mode': 'current' (possible: ['current', 'voltage', 'power', 'differential power', 'explicit power', 'resistance', 'differential resistance', 'explicit resistance', 'CCCV']) 'particle': 'Fickian diffusion' (possible: ['Fickian diffusion', 'fast diffusion', 'uniform profile', 'quadratic profile', 'quartic profile']) diff --git a/tests/unit/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py b/tests/unit/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py index d60dcda8b6..b8bd292b74 100644 --- a/tests/unit/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py +++ b/tests/unit/test_models/test_full_battery_models/test_lithium_ion/base_lithium_ion_tests.py @@ -119,6 +119,14 @@ def test_well_posed_loss_active_material_stress_reaction(self): options = {"loss of active material": "stress and reaction-driven"} self.check_well_posedness(options) + def test_well_posed_loss_active_material_current_negative(self): + options = {"loss of active material": ("current-driven", "none")} + self.check_well_posedness(options) + + def test_well_posed_loss_active_material_current_positive(self): + options = {"loss of active material": ("none", "current-driven")} + self.check_well_posedness(options) + def test_well_posed_surface_form_differential(self): options = {"surface form": "differential"} self.check_well_posedness(options) diff --git a/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_mpm.py b/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_mpm.py index 222f587a56..7dac0694a5 100644 --- a/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_mpm.py +++ b/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_mpm.py @@ -22,9 +22,9 @@ def test_default_parameter_values(self): model = pybamm.lithium_ion.MPM() self.assertEqual( model.default_parameter_values[ - "Negative area-weighted mean particle radius [m]" + "Negative minimum particle radius [m]" ], - 1e-05, + 0.0, ) def test_lumped_thermal_model_1D(self): diff --git a/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_mpm_half_cell.py b/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_mpm_half_cell.py index 364120c741..ebd19ba614 100644 --- a/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_mpm_half_cell.py +++ b/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_mpm_half_cell.py @@ -22,9 +22,9 @@ def test_default_parameter_values(self): model = pybamm.lithium_ion.MPM({"working electrode": "positive"}) self.assertEqual( model.default_parameter_values[ - "Positive area-weighted mean particle radius [m]" + "Positive minimum particle radius [m]" ], - 5.3e-06, + 0.0, ) def test_lumped_thermal_model_1D(self): diff --git a/tests/unit/test_parameters/test_size_distribution_parameters.py b/tests/unit/test_parameters/test_size_distribution_parameters.py index 8f8851bfaa..1489d7416c 100644 --- a/tests/unit/test_parameters/test_size_distribution_parameters.py +++ b/tests/unit/test_parameters/test_size_distribution_parameters.py @@ -31,9 +31,6 @@ def test_parameter_values(self): np.testing.assert_almost_equal(values.evaluate(param.n.prim.R_max), 2.5e-5, 3) np.testing.assert_almost_equal(values.evaluate(param.p.prim.R_max), 2.5e-5, 3) - # standard deviations - np.testing.assert_almost_equal(values.evaluate(param.n.prim.sd_a), 3e-6, 3) - np.testing.assert_almost_equal(values.evaluate(param.p.prim.sd_a), 3e-6, 3) # check function parameters (size distributions) evaluate R_test = pybamm.Scalar(1.0) diff --git a/tests/unit/test_solvers/test_processed_variable.py b/tests/unit/test_solvers/test_processed_variable.py index a20fd99bd7..79de9b0368 100644 --- a/tests/unit/test_solvers/test_processed_variable.py +++ b/tests/unit/test_solvers/test_processed_variable.py @@ -28,7 +28,7 @@ def to_casadi(var_pybamm, y, inputs=None): def process_and_check_2D_variable( - var, first_spatial_var, second_spatial_var, disc=None + var, first_spatial_var, second_spatial_var, disc=None, geometry_options={} ): # first_spatial_var should be on the "smaller" domain, i.e "r" for an "r-x" variable if disc is None: @@ -45,10 +45,11 @@ def process_and_check_2D_variable( y_sol = np.ones(len(second_sol) * len(first_sol))[:, np.newaxis] * np.linspace(0, 5) var_casadi = to_casadi(var_sol, y_sol) + model = tests.get_base_model_with_battery_geometry(**geometry_options) processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution(t_sol, y_sol, model, {}), warn=False, ) np.testing.assert_array_equal( @@ -151,7 +152,9 @@ def test_processed_variable_1D(self): processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) np.testing.assert_array_equal(processed_var.entries, y_sol) @@ -160,7 +163,9 @@ def test_processed_variable_1D(self): processed_eqn = pybamm.ProcessedVariable( [eqn_sol], [eqn_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) np.testing.assert_array_almost_equal( @@ -180,7 +185,9 @@ def test_processed_variable_1D(self): processed_x_s_edge = pybamm.ProcessedVariable( [x_s_edge], [x_s_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) np.testing.assert_array_equal( @@ -196,7 +203,9 @@ def test_processed_variable_1D(self): processed_eqn2 = pybamm.ProcessedVariable( [eqn_sol], [eqn_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) np.testing.assert_array_equal( @@ -216,10 +225,12 @@ def test_processed_variable_1D_unknown_domain(self): nt = 100 y_sol = np.zeros((var_pts[x], nt)) + model = tests.get_base_model_with_battery_geometry() + model._geometry = geometry solution = pybamm.Solution( np.linspace(0, 1, nt), y_sol, - pybamm.BaseModel(), + model, {}, np.linspace(0, 1, 1), np.zeros((var_pts[x])), @@ -261,7 +272,13 @@ def test_processed_variable_2D_R_x(self): x = pybamm.SpatialVariable("x", domain=["negative electrode"]) disc = tests.get_size_distribution_disc_for_testing() - process_and_check_2D_variable(var, R, x, disc=disc) + process_and_check_2D_variable( + var, + R, + x, + disc=disc, + geometry_options={"options": {"particle size": "distribution"}}, + ) def test_processed_variable_2D_R_z(self): var = pybamm.Variable( @@ -277,7 +294,13 @@ def test_processed_variable_2D_R_z(self): z = pybamm.SpatialVariable("z", domain=["current collector"]) disc = tests.get_size_distribution_disc_for_testing() - process_and_check_2D_variable(var, R, z, disc=disc) + process_and_check_2D_variable( + var, + R, + z, + disc=disc, + geometry_options={"options": {"particle size": "distribution"}}, + ) def test_processed_variable_2D_r_R(self): var = pybamm.Variable( @@ -293,7 +316,13 @@ def test_processed_variable_2D_r_R(self): R = pybamm.SpatialVariable("R", domain=["negative particle size"]) disc = tests.get_size_distribution_disc_for_testing() - process_and_check_2D_variable(var, r, R, disc=disc) + process_and_check_2D_variable( + var, + r, + R, + disc=disc, + geometry_options={"options": {"particle size": "distribution"}}, + ) def test_processed_variable_2D_x_z(self): var = pybamm.Variable( @@ -324,7 +353,9 @@ def test_processed_variable_2D_x_z(self): processed_x_s_edge = pybamm.ProcessedVariable( [x_s_edge], [x_s_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) np.testing.assert_array_equal( @@ -358,7 +389,9 @@ def test_processed_variable_2D_space_only(self): processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) np.testing.assert_array_equal( @@ -382,7 +415,9 @@ def test_processed_variable_2D_scikit(self): processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, u_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, u_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) np.testing.assert_array_equal( @@ -402,10 +437,13 @@ def test_processed_variable_2D_fixed_t_scikit(self): u_sol = np.ones(var_sol.shape[0])[:, np.newaxis] var_casadi = to_casadi(var_sol, u_sol) + model = tests.get_base_model_with_battery_geometry( + options={"dimensionality": 2} + ) processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, u_sol, pybamm.BaseModel(), {}), + pybamm.Solution(t_sol, u_sol, model, {}), warn=False, ) np.testing.assert_array_equal( @@ -427,7 +465,9 @@ def test_processed_var_0D_interpolation(self): processed_var = pybamm.ProcessedVariable( [var], [var_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) # vector @@ -440,7 +480,9 @@ def test_processed_var_0D_interpolation(self): processed_eqn = pybamm.ProcessedVariable( [eqn], [eqn_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) np.testing.assert_array_equal(processed_eqn(t_sol), t_sol * y_sol[0]) @@ -488,7 +530,9 @@ def test_processed_var_1D_interpolation(self): processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) # 2 vectors @@ -506,7 +550,9 @@ def test_processed_var_1D_interpolation(self): processed_eqn = pybamm.ProcessedVariable( [eqn_sol], [eqn_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) # 2 vectors @@ -526,7 +572,9 @@ def test_processed_var_1D_interpolation(self): processed_x = pybamm.ProcessedVariable( [x_disc], [x_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) np.testing.assert_array_almost_equal(processed_x(t=0, x=x_sol), x_sol) @@ -540,7 +588,9 @@ def test_processed_var_1D_interpolation(self): processed_r_n = pybamm.ProcessedVariable( [r_n], [r_n_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) np.testing.assert_array_equal(r_n.entries[:, 0], processed_r_n.entries[:, 0]) @@ -553,10 +603,13 @@ def test_processed_var_1D_interpolation(self): ) R_n.mesh = disc.mesh["negative particle size"] R_n_casadi = to_casadi(R_n, y_sol) + model = tests.get_base_model_with_battery_geometry( + options={"particle size": "distribution"} + ) processed_R_n = pybamm.ProcessedVariable( [R_n], [R_n_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution(t_sol, y_sol, model, {}), warn=False, ) np.testing.assert_array_equal(R_n.entries[:, 0], processed_R_n.entries[:, 0]) @@ -579,7 +632,9 @@ def test_processed_var_1D_fixed_t_interpolation(self): processed_var = pybamm.ProcessedVariable( [eqn_sol], [eqn_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) @@ -590,6 +645,53 @@ def test_processed_var_1D_fixed_t_interpolation(self): # scalar np.testing.assert_array_almost_equal(processed_var(x=0.5), 1) + def test_processed_var_wrong_spatial_variable_names(self): + var = pybamm.Variable( + "var", + domain=["domain A", "domain B"], + ) + a = pybamm.SpatialVariable("a", domain=["domain A"]) + b = pybamm.SpatialVariable("b", domain=["domain B"]) + geometry = { + "domain A": {a: {"min": 0, "max": 1}}, + "domain B": {b: {"min": 1, "max": 2}}, + } + submesh_types = { + "domain A": pybamm.Uniform1DSubMesh, + "domain B": pybamm.Uniform1DSubMesh, + } + var_pts = {a: 10, b: 20} + mesh = pybamm.Mesh(geometry, submesh_types, var_pts) + + spatial_methods = { + "domain A": pybamm.FiniteVolume(), + "domain B": pybamm.FiniteVolume(), + } + + disc = pybamm.Discretisation(mesh, spatial_methods) + disc.set_variable_slices([var]) + a_sol = disc.process_symbol(a).entries[:, 0] + b_sol = disc.process_symbol(b).entries[:, 0] + var_sol = disc.process_symbol(var) + t_sol = np.linspace(0, 1) + y_sol = np.ones(len(a_sol) * len(b_sol))[:, np.newaxis] * np.linspace(0, 5) + + var_casadi = to_casadi(var_sol, y_sol) + model = pybamm.BaseModel() + model._geometry = pybamm.Geometry( + { + "domain A": {a: {"min": 0, "max": 1}}, + "domain B": {b: {"min": 0, "max": 1}}, + } + ) + with self.assertRaisesRegex(NotImplementedError, "Spatial variable name"): + pybamm.ProcessedVariable( + [var_sol], + [var_casadi], + pybamm.Solution(t_sol, y_sol, model, {}), + warn=False, + ) + def test_processed_var_2D_interpolation(self): var = pybamm.Variable( "var", @@ -617,7 +719,9 @@ def test_processed_var_2D_interpolation(self): processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) # 3 vectors @@ -665,7 +769,9 @@ def test_processed_var_2D_interpolation(self): processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) # 3 vectors @@ -700,7 +806,9 @@ def test_processed_var_2D_fixed_t_interpolation(self): processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) # 2 vectors @@ -731,7 +839,9 @@ def test_processed_var_2D_secondary_broadcast(self): processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) # 3 vectors @@ -770,7 +880,9 @@ def test_processed_var_2D_secondary_broadcast(self): processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, y_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) # 3 vectors @@ -794,7 +906,9 @@ def test_processed_var_2D_scikit_interpolation(self): processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, u_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, u_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) # 3 vectors @@ -838,7 +952,9 @@ def test_processed_var_2D_fixed_t_scikit_interpolation(self): processed_var = pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, u_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, u_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) # 2 vectors @@ -851,6 +967,84 @@ def test_processed_var_2D_fixed_t_scikit_interpolation(self): # 2 scalars np.testing.assert_array_equal(processed_var(t=0, y=0.2, z=0.2).shape, ()) + def test_processed_var_2D_unknown_domain(self): + var = pybamm.Variable( + "var", + domain=["domain B"], + auxiliary_domains={"secondary": ["domain A"]}, + ) + x = pybamm.SpatialVariable("x", domain=["domain A"]) + z = pybamm.SpatialVariable( + "z", + domain=["domain B"], + auxiliary_domains={"secondary": ["domain A"]}, + ) + + geometry = { + "domain A": {x: {"min": 0, "max": 1}}, + "domain B": {z: {"min": 0, "max": 1}}, + } + submesh_types = { + "domain A": pybamm.Uniform1DSubMesh, + "domain B": pybamm.Uniform1DSubMesh, + } + var_pts = {x: 10, z: 20} + mesh = pybamm.Mesh(geometry, submesh_types, var_pts) + + spatial_methods = { + "domain A": pybamm.FiniteVolume(), + "domain B": pybamm.FiniteVolume(), + } + + disc = pybamm.Discretisation(mesh, spatial_methods) + disc.set_variable_slices([var]) + x_sol = disc.process_symbol(x).entries[:, 0] + z_sol = disc.process_symbol(z).entries[:, 0] + # Keep only the first iteration of entries + z_sol = z_sol[: len(z_sol) // len(x_sol)] + var_sol = disc.process_symbol(var) + t_sol = np.linspace(0, 1) + y_sol = np.ones(len(x_sol) * len(z_sol))[:, np.newaxis] * np.linspace(0, 5) + + var_casadi = to_casadi(var_sol, y_sol) + model = pybamm.BaseModel() + model._geometry = pybamm.Geometry( + { + "domain A": {x: {"min": 0, "max": 1}}, + "domain B": {z: {"min": 0, "max": 1}}, + } + ) + processed_var = pybamm.ProcessedVariable( + [var_sol], + [var_casadi], + pybamm.Solution(t_sol, y_sol, model, {}), + warn=False, + ) + # 3 vectors + np.testing.assert_array_equal( + processed_var(t=t_sol, x=x_sol, z=z_sol).shape, (20, 10, 50) + ) + np.testing.assert_array_almost_equal( + processed_var(t_sol, x=x_sol, z=z_sol), + np.reshape(y_sol, [len(z_sol), len(x_sol), len(t_sol)]), + ) + # 2 vectors, 1 scalar + np.testing.assert_array_equal( + processed_var(t=0.5, x=x_sol, z=z_sol).shape, (20, 10) + ) + np.testing.assert_array_equal( + processed_var(t=t_sol, x=0.2, z=z_sol).shape, (20, 50) + ) + np.testing.assert_array_equal( + processed_var(t=t_sol, x=x_sol, z=0.5).shape, (10, 50) + ) + # 1 vectors, 2 scalar + np.testing.assert_array_equal(processed_var(t=0.5, x=0.2, z=z_sol).shape, (20,)) + np.testing.assert_array_equal(processed_var(t=0.5, x=x_sol, z=0.5).shape, (10,)) + np.testing.assert_array_equal(processed_var(t=t_sol, x=0.2, z=0.5).shape, (50,)) + # 3 scalars + np.testing.assert_array_equal(processed_var(t=0.2, x=0.2, z=0.2).shape, ()) + def test_3D_raises_error(self): var = pybamm.Variable( "var", @@ -869,10 +1063,68 @@ def test_3D_raises_error(self): pybamm.ProcessedVariable( [var_sol], [var_casadi], - pybamm.Solution(t_sol, u_sol, pybamm.BaseModel(), {}), + pybamm.Solution( + t_sol, u_sol, tests.get_base_model_with_battery_geometry(), {} + ), warn=False, ) + def test_process_spatial_variable_names(self): + # initialise dummy variable to access method + t = pybamm.t + y = pybamm.StateVector(slice(0, 1)) + var = t * y + var.mesh = None + t_sol = np.linspace(0, 1) + y_sol = np.array([np.linspace(0, 5)]) + var_casadi = to_casadi(var, y_sol) + processed_var = pybamm.ProcessedVariable( + [var], + [var_casadi], + pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + warn=False, + ) + + # Test empty list returns None + self.assertIsNone(processed_var._process_spatial_variable_names([])) + + # Test tabs is ignored + self.assertEqual( + processed_var._process_spatial_variable_names(["tabs", "var"]), + "var", + ) + + # Test strings stay strings + self.assertEqual( + processed_var._process_spatial_variable_names(["y"]), + "y", + ) + + # Test spatial variables are converted to strings + x = pybamm.SpatialVariable("x", domain=["domain"]) + self.assertEqual( + processed_var._process_spatial_variable_names([x]), + "x", + ) + + # Test renaming for PyBaMM convention + self.assertEqual( + processed_var._process_spatial_variable_names(["x_a", "x_b"]), + "x", + ) + self.assertEqual( + processed_var._process_spatial_variable_names(["r_a", "r_b"]), + "r", + ) + self.assertEqual( + processed_var._process_spatial_variable_names(["R_a", "R_b"]), + "R", + ) + + # Test error raised if spatial variable name not recognised + with self.assertRaisesRegex(NotImplementedError, "Spatial variable name"): + processed_var._process_spatial_variable_names(["var1", "var2"]) + if __name__ == "__main__": print("Add -v for more debug output") From a285352234590df92c3398bcedd52acd7df732dd Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 12 Aug 2023 15:10:33 +0000 Subject: [PATCH 066/129] style: pre-commit fixes --- docs/source/user_guide/installation/index.rst | 2 +- setup.py | 3 --- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/docs/source/user_guide/installation/index.rst b/docs/source/user_guide/installation/index.rst index 4170a07621..c5714d5d5d 100644 --- a/docs/source/user_guide/installation/index.rst +++ b/docs/source/user_guide/installation/index.rst @@ -249,4 +249,4 @@ Installing a specific version? Installing from source? Check the advanced instal windows windows-wsl install-from-source - install-from-docker \ No newline at end of file + install-from-docker diff --git a/setup.py b/setup.py index 437a618521..dfdd455a16 100644 --- a/setup.py +++ b/setup.py @@ -258,9 +258,6 @@ def compile_KLU(): "pandas": [ "pandas>=0.24", ], - "pandas": [ - "pandas>=0.24", - ], "jax": [ "jax==0.4.8", "jaxlib==0.4.7", From 4113291faf79cbf13cf0b88d542875af80458592 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sat, 12 Aug 2023 22:32:40 +0530 Subject: [PATCH 067/129] Fix Windows file encoding errors for notebooks --- run-tests.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/run-tests.py b/run-tests.py index 5d4bb65b65..2895f7185f 100755 --- a/run-tests.py +++ b/run-tests.py @@ -189,7 +189,9 @@ def test_notebook(path, executable="python"): # Make sure the notebook has a # "%pip install pybamm[plot,cite] -q" command, for using Google Colab - with open(path, "r") as f: + # specify UTF-8 encoding otherwise Windows chooses CP1252 by default + # attributed to https://stackoverflow.com/a/49562606 + with open(path, "r", encoding="UTF-8") as f: if "%pip install pybamm[plot,cite] -q" not in f.read(): # print error and exit print("\n" + "-" * 70) @@ -203,7 +205,9 @@ def test_notebook(path, executable="python"): return False # Make sure the notebook has "pybamm.print_citations()" to print the relevant papers - with open(path, "r") as f: + # specify UTF-8 encoding otherwise Windows chooses CP1252 by default + # attributed to https://stackoverflow.com/a/49562606 + with open(path, "r", encoding="UTF-8") as f: if "pybamm.print_citations()" not in f.read(): # print error and exit print("\n" + "-" * 70) From 3e92e3b6297378b73e828bef75945d1993a51ecf Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sat, 12 Aug 2023 22:35:42 +0530 Subject: [PATCH 068/129] Install latex distributions on macOS and Windows --- .github/workflows/test_on_push.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 41fb8e17b4..1465d6a6e7 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -297,14 +297,15 @@ jobs: NONINTERACTIVE: 1 run: | brew analytics off - brew update brew install graphviz openblas pandoc + brew install --cask basictex - name: Install Windows system dependencies if: matrix.os == 'windows-latest' run: | choco install graphviz --version=8.0.5 choco install pandoc + choco install miktex - name: Set up Python ${{ matrix.python-version }} id: setup-python From 46c752d9de691ad63c4f905499ad5daf0c571241 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sun, 13 Aug 2023 00:06:08 +0530 Subject: [PATCH 069/129] Run unit and integration tests in parallel --- .github/workflows/test_on_push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 1465d6a6e7..4cbc5a91de 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -175,7 +175,7 @@ jobs: uses: codecov/codecov-action@v3.1.4 run_integration_tests: - needs: run_unit_tests + needs: style runs-on: ${{ matrix.os }} strategy: fail-fast: false From d6fc080eb879bb128b0729cf0105ccaa916c3b25 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sun, 13 Aug 2023 01:14:24 +0530 Subject: [PATCH 070/129] Run examples and doctests on Linux and Python 3.11 --- .github/workflows/test_on_push.yml | 37 ++++-------------------------- 1 file changed, 5 insertions(+), 32 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 4cbc5a91de..e1e2dcd330 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -256,15 +256,13 @@ jobs: - name: Run integration tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} run: nox -s integration + # Runs only on Ubuntu with Python 3.11 run_doctests_and_example_tests: needs: style - runs-on: ${{ matrix.os }} + runs-on: ubuntu-latest strategy: fail-fast: false - matrix: - os: [ubuntu-latest, macos-latest, windows-latest] - python-version: ["3.8", "3.9", "3.10", "3.11"] - name: Doctests and examples (${{ matrix.os }} / Python ${{ matrix.python-version }}) + name: Doctests and examples (ubuntu-latest / Python 3.11) steps: - name: Check out PyBaMM repository @@ -273,45 +271,22 @@ jobs: # Install and cache apt packages - name: Install Linux system dependencies uses: awalsh128/cache-apt-pkgs-action@v1.3.0 - if: matrix.os == 'ubuntu-latest' with: packages: gfortran gcc graphviz pandoc execute_install_scripts: true # dot -c is for registering graphviz fonts and plugins - name: Install OpenBLAS and TeXLive for Linux - if: matrix.os == 'ubuntu-latest' run: | sudo apt-get update sudo dot -c sudo apt-get install libopenblas-dev texlive-latex-extra dvipng - - name: Install macOS system dependencies - if: matrix.os == 'macos-latest' - env: - # Homebrew environment variables - HOMEBREW_NO_INSTALL_CLEANUP: 1 - HOMEBREW_NO_AUTO_UPDATE: 1 - HOMEBREW_NO_COLOR: 1 - # Speed up CI - NONINTERACTIVE: 1 - run: | - brew analytics off - brew install graphviz openblas pandoc - brew install --cask basictex - - - name: Install Windows system dependencies - if: matrix.os == 'windows-latest' - run: | - choco install graphviz --version=8.0.5 - choco install pandoc - choco install miktex - - - name: Set up Python ${{ matrix.python-version }} + - name: Set up Python 3.11 id: setup-python uses: actions/setup-python@v4 with: - python-version: ${{ matrix.python-version }} + python-version: 3.11 cache: 'pip' cache-dependency-path: setup.py @@ -322,7 +297,6 @@ jobs: - name: Cache pybamm-requires nox environment for GNU/Linux uses: actions/cache@v3 - if: matrix.os == 'ubuntu-latest' with: path: | # Repository files @@ -335,7 +309,6 @@ jobs: key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} - name: Install SuiteSparse and SUNDIALS on GNU/Linux - if: matrix.os == 'ubuntu-latest' run: nox -s pybamm-requires - name: Install docs dependencies and run doctests for ${{ matrix.os }} with Python ${{ matrix.python-version }} From 02d7750dd631fe7b37b400d2438068fd863ae4c8 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 15 Aug 2023 03:11:40 +0000 Subject: [PATCH 071/129] chore: update pre-commit hooks MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit updates: - [github.com/astral-sh/ruff-pre-commit: v0.0.282 → v0.0.284](https://github.com/astral-sh/ruff-pre-commit/compare/v0.0.282...v0.0.284) --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 1cde3c7019..dd533e18ae 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ ci: repos: - repo: https://github.com/astral-sh/ruff-pre-commit - rev: "v0.0.282" + rev: "v0.0.284" hooks: - id: ruff args: [--fix, --ignore=E741, --exclude=__init__.py] From 589912f244847f43385183db13c3b0e56ba066a4 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Tue, 15 Aug 2023 19:13:38 +0530 Subject: [PATCH 072/129] Add build image from source instructions --- .../installation/install-from-docker.rst | 31 ++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 6104fe27af..20793b106e 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -44,6 +44,35 @@ To exit the Docker container's shell, you can simply type: .. code-block:: bash - exit + exit This will return you to your host machine's terminal. + +Building Docker Image Locally from Source +------------------------------------------ + +If you want to build the PyBaMM Docker image locally from the PyBaMM source code, follow these steps: + +1. Clone the PyBaMM GitHub repository to your local machine if you haven't already: + +.. code-block:: bash + + git clone https://github.com/pybamm-team/PyBaMM.git + +2. Change into the PyBaMM directory: + +.. code-block:: bash + + cd PyBaMM + +3. Build the Docker image using the following command: + +.. code-block:: bash + + docker build -t pybamm . + +4. Once the image is built, you can run a Docker container using: + +.. code-block:: bash + + docker run -it pybamm From 999baa272b20c4b6d60323dd2fd9a19b416c0355 Mon Sep 17 00:00:00 2001 From: Saransh Chopra Date: Tue, 15 Aug 2023 12:56:44 -0400 Subject: [PATCH 073/129] Update .pre-commit-config.yaml --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index dd533e18ae..6a3891ec28 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -13,7 +13,7 @@ repos: rev: 1.7.0 hooks: - id: nbqa-ruff - additional_dependencies: [ruff==0.0.280] + additional_dependencies: [ruff==0.0.284] args: ["--fix","--ignore=E501,E402"] - repo: https://github.com/adamchainz/blacken-docs From 70e05aaa4241aa30c5640b4d9998c2995eefe9a8 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Wed, 16 Aug 2023 16:11:02 +0530 Subject: [PATCH 074/129] Add optional arg to doc --- .../installation/install-from-docker.rst | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 20793b106e..5e5051026e 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -76,3 +76,54 @@ If you want to build the PyBaMM Docker image locally from the PyBaMM source code .. code-block:: bash docker run -it pybamm + +Building Docker Images with Optional Args +----------------------------------------- + +When building the PyBaMM Docker images locally, you have the option to include specific solvers by using optional arguments. These solvers include: + +- IDAKLU: For IDA solver provided by the SUNDIALS plus KLU. +- ODES: For scikits.odes solver for ODE & DAE problems. +- JAX: For Jax solver. + +To build the Docker images with optional arguments, you can follow these steps for each solver: + +Build Docker Image with IDAKLU Solver +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. + +3. Build the Docker image for IDAKLU using the following command: + +.. code-block:: bash + + docker build -t pybamm:idaklu --build-arg IDAKLU=true . + +Build Docker Image with ODES Solver +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. + +2. Build the Docker image for ODES using the following command: + +.. code-block:: bash + + docker build -t pybamm:odes --build-arg ODES=true . + +Build Docker Image with JAX Solver +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. + +2. Build the Docker image for JAX using the following command: + +.. code-block:: bash + + docker build -t pybamm:jax --build-arg JAX=true . + + +After building the Docker images with the desired solvers, use the ``docker run`` command followed by the desired image name. For example, to run a container from the image built with IDAKLU solver: + +.. code-block:: bash + + docker run -it pybamm:idaklu From 99ea85e5b69318a8f223c46c488b08f096582352 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Wed, 16 Aug 2023 17:54:49 +0530 Subject: [PATCH 075/129] Simplify wsl install doc --- .../user_guide/installation/windows-wsl.rst | 106 ++++-------------- 1 file changed, 20 insertions(+), 86 deletions(-) diff --git a/docs/source/user_guide/installation/windows-wsl.rst b/docs/source/user_guide/installation/windows-wsl.rst index fc9a783b21..5dfa8cc9fa 100644 --- a/docs/source/user_guide/installation/windows-wsl.rst +++ b/docs/source/user_guide/installation/windows-wsl.rst @@ -1,108 +1,42 @@ -Install from source (Windows) -============================= +Windows Subsystem for Linux (WSL) +================================= -We recommend the use of Windows Subsystem for Linux (WSL) to install -PyBaMM, see the instructions below to get PyBaMM working using Windows, -WSL and VSCode. - -.. contents:: +To make it easier to install PyBaMM, we recommend using the Windows Subsystem for Linux (WSL) along with Visual Studio Code. This guide will walk you through the process. Install WSL ----------- -Follow the instructions from Microsoft -`here `__. -When given the option, choose the Ubuntu 18.04 LTS distribution to -install. Best practices for setting up a WSL development environment can be found -`here `__. +Install Ubuntu 22.04 or 20.04 LTS as a distribution for WSL following `Microsoft's guide to install WSL `__. For a seamless development environment, refer to `this guide `__. Install PyBaMM -------------- -Open a terminal window in your installed Ubuntu distribution by -selecting “Ubuntu” from the start menu. This should give you a bash -prompt in your home directory. +Get PyBaMM's Source Code +~~~~~~~~~~~~~~~~~~~~~~~~ -To download the PyBaMM source code, you first need to install git, which -you can do by typing +1. Open a terminal in your Ubuntu distribution by selecting "Ubuntu" from the Start menu. You'll get a bash prompt in your home directory. -.. code:: bash +2. Install Git by typing the following command: - sudo apt install git-core +.. code:: bash + sudo apt install git-core -For easier integration with WSL, we recommend that you install PyBaMM in -your *Windows* Documents folder, for example by first navigating to +3. Clone the PyBaMM repository. To install PyBaMM in your Windows Documents folder, navigate to it using the command:: .. code:: bash + cd /mnt/c/Users/USER_NAME/Documents - $ cd /mnt/c/Users/USER_NAME/Documents - -where USER_NAME is your username. Exact path to Windows documents may -vary. Now use git to clone the PyBaMM repository: + Replace ``USER_NAME`` with your Windows username. Clone the PyBaMM repository using the command: .. code:: bash + git clone https://github.com/pybamm-team/PyBaMM.git - git clone https://github.com/pybamm-team/PyBaMM.git - -This will create a new directly called ``PyBaMM``, you can move to this -directory in bash using the ``cd`` command: +4. Enter the PyBaMM Directory by running:: .. code:: bash + cd PyBaMM + +5. Follow the Installation Steps +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - cd PyBaMM - -If you are unfamiliar with the linux command line, you might find it -useful to work through this -`tutorial `__ -provided by Ubuntu. - -Now head over and follow the installation instructions for PyBaMM for -linux `here `__. - -Use Visual Studio Code to run PyBaMM ------------------------------------- - -You will probably want to use a native Windows IDE such as Visual Studio -Code or the full Microsoft Visual Studio IDE. Both of these packages can -connect to WSL so that you can write Python code in a native windows -environment, while at the same time using WSL to run the code using your -installed Ubuntu distribution. The following instructions assume that -you are using Visual Studio Code. - -First, setup VSCode to run within the ``PyBaMM`` directory that you -created above, using the instructions provided -`here `__. - -Once you have opened the ``PyBaMM`` folder in vscode, use the -``Extensions`` panel to install the ``Python`` extension from Microsoft. -Note that extensions are either installed on the Windows (Local) or on -in WSL (WSL:Ubuntu), so even if you have used VSCode previously with the -Python extension, you probably haven’t installed it in WSL. Make sure to -reload after installing the Python extension so that it is available. - -If you have installed PyBaMM into the virtual environment ``env`` as in -the PyBaMM linux install guide, then VSCode should automatically start -using this environment and you should see something similar to “Python -3.6.8 64-bit (‘env’: venv)” in the bottom bar. - -To test that vscode can run a PyBaMM script, navigate to the -``examples/scripts`` folder and right click on the ``create-model.py`` -script. Select “Run current file in Python Interactive Window”. This -should run the script, which sets up and solves a model of SEI thickness -using PyBaMM. You should see a plot of SEI thickness versus time pop up -in the interactive window. - -The Python Interactive Window in VSCode can be used to view plots, but -is restricted in functionality and cannot, for example, launch separate -windows to show plot. To setup an xserver on windows and use this to -launch windows for plotting, follow these instructions: - -1. Install VcXsrv from - `here `__. -2. Set the display port in the WSL command-line: - ``echo "export DISPLAY=localhost:0.0" >> ~/.bashrc`` -3. Install python3-tk in WSL: ``sudo apt-get install python3-tk`` -4. Set the matplotlib backend to TKAgg in WSL: - ``echo "backend : TKAgg" >> ~/.config/matplotlib/matplotlibrc`` -5. Before running the code, just launch XLaunch (with the default - settings) from within Windows. Then the code works as usual. +Follow the `installation instructions for PyBaMM on Linux `__. From 913ddf73fd25d77fc16e5548e4ba0988082851ba Mon Sep 17 00:00:00 2001 From: Saransh Chopra Date: Fri, 18 Aug 2023 18:58:55 -0400 Subject: [PATCH 076/129] Enable dependabot to update GH Action versions periodically --- .github/dependabot.yml | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 .github/dependabot.yml diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000000..2c7d170839 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,7 @@ +version: 2 +updates: + # Maintain dependencies for GitHub Actions + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "daily" From 2c0f1ccb11625a73767337315a53e19a8981dabc Mon Sep 17 00:00:00 2001 From: Arjun Date: Sat, 19 Aug 2023 20:28:37 +0530 Subject: [PATCH 077/129] Apply suggestions from code review Co-authored-by: Saransh Chopra --- docs/source/user_guide/installation/install-from-docker.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 5e5051026e..ffa7f88505 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -1,4 +1,4 @@ -Install using Docker (developer install) +Install from source (Docker) ========================================= .. contents:: @@ -14,8 +14,8 @@ Ensure Docker installation by running : docker --version -Pulling the Docker Image ------------------------- +Pulling the Docker Image (will be supported soon) +------------------------------------------------- Use the following command to pull the PyBaMM Docker image from Docker Hub: .. code:: bash From fa20e46856164853cff69afe7c33eede807fa9e1 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Sun, 20 Aug 2023 00:58:48 +0530 Subject: [PATCH 078/129] Fix matrix variables for doctests and examples job step names --- .github/workflows/test_on_push.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index e1e2dcd330..06af2fb28b 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -17,7 +17,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - - name: Setup python + - name: Setup Python uses: actions/setup-python@v4 with: python-version: 3.11 @@ -311,8 +311,8 @@ jobs: - name: Install SuiteSparse and SUNDIALS on GNU/Linux run: nox -s pybamm-requires - - name: Install docs dependencies and run doctests for ${{ matrix.os }} with Python ${{ matrix.python-version }} + - name: Install docs dependencies and run doctests for GNU/Linux with Python 3.11 run: nox -s doctests - - name: Install dev dependencies and run example tests for ${{ matrix.os }} with Python ${{ matrix.python-version }} + - name: Install dev dependencies and run example tests for GNU/Linux with Python 3.11 run: nox -s examples From 815a4ae518b15cfafebfa45bf3a39d2a21305000 Mon Sep 17 00:00:00 2001 From: Saransh Chopra Date: Sun, 20 Aug 2023 15:15:51 -0400 Subject: [PATCH 079/129] run weekly --- .github/dependabot.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/dependabot.yml b/.github/dependabot.yml index 2c7d170839..6fddca0d6e 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -4,4 +4,4 @@ updates: - package-ecosystem: "github-actions" directory: "/" schedule: - interval: "daily" + interval: "weekly" From 5425210675fc03781ec76a0613c0b632ab54ab73 Mon Sep 17 00:00:00 2001 From: Arjun Date: Mon, 21 Aug 2023 10:01:07 +0530 Subject: [PATCH 080/129] Update docs/source/user_guide/installation/windows-wsl.rst Co-authored-by: Saransh Chopra --- docs/source/user_guide/installation/windows-wsl.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/user_guide/installation/windows-wsl.rst b/docs/source/user_guide/installation/windows-wsl.rst index 5dfa8cc9fa..c8453a7d2c 100644 --- a/docs/source/user_guide/installation/windows-wsl.rst +++ b/docs/source/user_guide/installation/windows-wsl.rst @@ -1,4 +1,4 @@ -Windows Subsystem for Linux (WSL) +Install from source (Windows Subsystem for Linux) ================================= To make it easier to install PyBaMM, we recommend using the Windows Subsystem for Linux (WSL) along with Visual Studio Code. This guide will walk you through the process. From 271f2d3163d8465056d5e5b1963ce12647947b71 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 21 Aug 2023 10:31:10 +0530 Subject: [PATCH 081/129] Split notebooks and scripts, add extra argument --- run-tests.py | 32 ++++++++++++++++++++++++++------ 1 file changed, 26 insertions(+), 6 deletions(-) diff --git a/run-tests.py b/run-tests.py index 5d4bb65b65..c50c6cc15c 100755 --- a/run-tests.py +++ b/run-tests.py @@ -97,18 +97,27 @@ def run_doc_tests(): shutil.rmtree("docs/build") -def run_notebook_and_scripts(executable="python"): +def run_notebooks(executable="python"): """ - Runs Jupyter notebook and example scripts tests. Exits if they fail. + Runs Jupyter notebook tests. Exits if they fail. """ # Scan and run - print("Testing notebooks and scripts with executable `" + str(executable) + "`") + print("Testing notebooks with executable `" + str(executable) + "`") # Test notebooks in docs/source/examples if not scan_for_notebooks("docs/source/examples", True, executable): print("\nErrors encountered in notebooks") sys.exit(1) + print("\nOK") + +def run_scripts(executable="python"): + """ + Run example scripts tests. Exits if they fail. + """ + + # Scan and run + print("Testing scripts with executable `" + str(executable) + "`") # Test scripts in examples # TODO: add scripts to docs/source/examples @@ -362,11 +371,11 @@ def export_notebook(ipath, opath): action="store_true", help="Run unit tests without starting a subprocess.", ) - # Notebook tests + # Example notebooks tests parser.add_argument( "--examples", action="store_true", - help="Test all Jupyter notebooks and scripts in `examples`.", + help="Test all Jupyter notebooks in `docs/source/examples/`.", ) parser.add_argument( "-debook", @@ -374,6 +383,13 @@ def export_notebook(ipath, opath): metavar=("in", "out"), help="Export a Jupyter notebook to a Python file for manual testing.", ) + # Scripts tests + parser.add_argument( + "--scripts", + action="store_true", + help="Test all example scripts in `examples/`.", + + ) # Doctests parser.add_argument( "--doctest", @@ -422,10 +438,14 @@ def export_notebook(ipath, opath): # Notebook tests elif args.examples: has_run = True - run_notebook_and_scripts(interpreter) + run_notebooks(interpreter) if args.debook: has_run = True export_notebook(*args.debook) + # Scripts tests + elif args.scripts: + has_run = True + run_scripts(interpreter) # Combined test sets if args.quick: has_run = True From 4105c22a7d09db38ba5f89b2f70c48b4c0c2f845 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Mon, 21 Aug 2023 10:40:18 +0530 Subject: [PATCH 082/129] Remove redundant steps --- docs/source/user_guide/installation/windows-wsl.rst | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/docs/source/user_guide/installation/windows-wsl.rst b/docs/source/user_guide/installation/windows-wsl.rst index c8453a7d2c..30f4097107 100644 --- a/docs/source/user_guide/installation/windows-wsl.rst +++ b/docs/source/user_guide/installation/windows-wsl.rst @@ -21,12 +21,7 @@ Get PyBaMM's Source Code .. code:: bash sudo apt install git-core -3. Clone the PyBaMM repository. To install PyBaMM in your Windows Documents folder, navigate to it using the command:: - -.. code:: bash - cd /mnt/c/Users/USER_NAME/Documents - - Replace ``USER_NAME`` with your Windows username. Clone the PyBaMM repository using the command: +3. Clone the PyBaMM repository:: .. code:: bash git clone https://github.com/pybamm-team/PyBaMM.git From 62ba18f16493c72ec271faf3bf5ecaff22dc8ac8 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 21 Aug 2023 11:17:47 +0530 Subject: [PATCH 083/129] Add a `nox` scripts session --- noxfile.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/noxfile.py b/noxfile.py index 2a08865037..ad66485f10 100644 --- a/noxfile.py +++ b/noxfile.py @@ -104,11 +104,17 @@ def run_unit(session): @nox.session(name="examples") def run_examples(session): - """Run the examples tests for Jupyter notebooks and Python scripts.""" + """Run the examples tests for Jupyter notebooks.""" set_environment_variables(PYBAMM_ENV, session=session) session.run_always("pip", "install", "-e", ".[all]") session.run("python", "run-tests.py", "--examples") +@nox.session(name="scripts") +def run_scripts(session): + """Run the scripts tests for Python scripts.""" + set_environment_variables(PYBAMM_ENV, session=session) + session.run_always("pip", "install", "-e", ".[all]") + session.run("python", "run-tests.py", "--scripts") @nox.session(name="dev") def set_dev(session): From 31bc980a0daada6b1a942e2dd3fb91db3e3f389d Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 21 Aug 2023 11:31:04 +0530 Subject: [PATCH 084/129] Update source installation guide for `nox -s scripts` --- docs/source/user_guide/installation/install-from-source.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/source/user_guide/installation/install-from-source.rst b/docs/source/user_guide/installation/install-from-source.rst index 0e3573cee2..37631c95a8 100644 --- a/docs/source/user_guide/installation/install-from-source.rst +++ b/docs/source/user_guide/installation/install-from-source.rst @@ -236,7 +236,8 @@ Doctests, examples, and coverage ``Nox`` can also be used to run doctests, run examples, and generate a coverage report using: -- ``nox -s examples``: Run the example scripts in ``examples/scripts``. +- ``nox -s examples``: Run the Jupyter notebooks in ``docs/source/examples/notebooks/``. +- ``nox -s scripts``: Run the example scripts in ``examples/scripts/``. - ``nox -s doctests``: Run doctests. - ``nox -s coverage``: Measure current test coverage and generate a coverage report. - ``nox -s quick``: Run integration tests, unit tests, and doctests sequentially. From 276d32f4a8c6b9d713e1f409a508c19ca9641652 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 21 Aug 2023 11:31:40 +0530 Subject: [PATCH 085/129] Add example scripts section to the contributing instructions --- CONTRIBUTING.md | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index c64722420a..0084f729dc 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -149,9 +149,9 @@ nox -s tests When you commit anything to PyBaMM, these checks will also be run automatically (see [infrastructure](#infrastructure)). -### Testing notebooks +### Testing the example notebooks -To test all example scripts and notebooks, type +To test all the example notebooks in the `docs/source/examples/` folder, type ```bash nox -s examples @@ -171,6 +171,14 @@ If notebooks fail because of changes to PyBaMM, it can be a bit of a hassle to d python run-tests.py --debook docs/source/examples/notebooks/notebook-name.ipynb script.py ``` +### Testing the example scripts + +To test all the example scripts in the `examples/` folder, type + +```bash +nox -s scripts +``` + ### Debugging Often, the code you write won't pass the tests straight away, at which stage it will become necessary to debug. From 17657f2690f4aae89575c3c36cccea2468f96b68 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Mon, 21 Aug 2023 11:41:33 +0530 Subject: [PATCH 086/129] Fix codeblocks & squash --- docs/source/user_guide/installation/windows-wsl.rst | 3 +++ 1 file changed, 3 insertions(+) diff --git a/docs/source/user_guide/installation/windows-wsl.rst b/docs/source/user_guide/installation/windows-wsl.rst index 30f4097107..7065dbdbc3 100644 --- a/docs/source/user_guide/installation/windows-wsl.rst +++ b/docs/source/user_guide/installation/windows-wsl.rst @@ -19,16 +19,19 @@ Get PyBaMM's Source Code 2. Install Git by typing the following command: .. code:: bash + sudo apt install git-core 3. Clone the PyBaMM repository:: .. code:: bash + git clone https://github.com/pybamm-team/PyBaMM.git 4. Enter the PyBaMM Directory by running:: .. code:: bash + cd PyBaMM 5. Follow the Installation Steps From 8015f6af32241a77e2454abd26b10c8dc7185883 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 21 Aug 2023 12:06:56 +0530 Subject: [PATCH 087/129] Add a scripts job based on #3279 --- .github/workflows/test_on_push.yml | 60 +++++++++++++++++++++++++++++- 1 file changed, 59 insertions(+), 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 06af2fb28b..2fd4c92b2e 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -262,7 +262,7 @@ jobs: runs-on: ubuntu-latest strategy: fail-fast: false - name: Doctests and examples (ubuntu-latest / Python 3.11) + name: Doctests and notebooks (ubuntu-latest / Python 3.11) steps: - name: Check out PyBaMM repository @@ -316,3 +316,61 @@ jobs: - name: Install dev dependencies and run example tests for GNU/Linux with Python 3.11 run: nox -s examples + + # Runs only on Ubuntu with Python 3.11 + run_scripts_tests: + needs: style + runs-on: ubuntu-latest + strategy: + fail-fast: false + name: Example scripts (ubuntu-latest / Python 3.11) + + steps: + - name: Check out PyBaMM repository + uses: actions/checkout@v3 + + # Install and cache apt packages + - name: Install Linux system dependencies + uses: awalsh128/cache-apt-pkgs-action@v1.3.0 + with: + packages: gfortran gcc graphviz + execute_install_scripts: true + + # dot -c is for registering graphviz fonts and plugins + - name: Install OpenBLAS and TeXLive for Linux + run: | + sudo apt-get update + sudo dot -c + sudo apt-get install libopenblas-dev texlive-latex-extra dvipng + + - name: Set up Python 3.11 + id: setup-python + uses: actions/setup-python@v4 + with: + python-version: 3.11 + cache: 'pip' + cache-dependency-path: setup.py + + - name: Install PyBaMM dependencies + run: | + pip install --upgrade pip wheel setuptools nox + pip install -e .[all,docs] + + - name: Cache pybamm-requires nox environment for GNU/Linux + uses: actions/cache@v3 + with: + path: | + # Repository files + ${{ github.workspace }}/pybind11/ + ${{ github.workspace }}/install_KLU_Sundials/ + # Headers and dynamic library files for SuiteSparse and SUNDIALS + ${{ env.HOME }}/.local/lib/ + ${{ env.HOME }}/.local/include/ + ${{ env.HOME }}/.local/examples/ + key: nox-pybamm-requires-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/install_KLU_Sundials.py') }} + + - name: Install SuiteSparse and SUNDIALS on GNU/Linux + run: nox -s pybamm-requires + + - name: Install dev dependencies and run example scripts tests for GNU/Linux with Python 3.11 + run: nox -s scripts From 65df9980deb2cee002ea2c2945a025d3b974c579 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 21 Aug 2023 15:19:42 +0000 Subject: [PATCH 088/129] Bump actions/download-artifact from 2 to 3 Bumps [actions/download-artifact](https://github.com/actions/download-artifact) from 2 to 3. - [Release notes](https://github.com/actions/download-artifact/releases) - [Commits](https://github.com/actions/download-artifact/compare/v2...v3) --- updated-dependencies: - dependency-name: actions/download-artifact dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/periodic_benchmarks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/periodic_benchmarks.yml b/.github/workflows/periodic_benchmarks.yml index 4816cc7661..6d1de72588 100644 --- a/.github/workflows/periodic_benchmarks.yml +++ b/.github/workflows/periodic_benchmarks.yml @@ -63,7 +63,7 @@ jobs: repository: pybamm-team/pybamm-bench token: ${{ secrets.BENCH_PAT }} - name: Download results artifact - uses: actions/download-artifact@v2 + uses: actions/download-artifact@v3 with: name: asv_new_results path: new_results From f7ff52b6db48ec36783d5d334da50bcc23cae150 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 21 Aug 2023 15:19:45 +0000 Subject: [PATCH 089/129] Bump codecov/codecov-action from 2.1.0 to 3.1.4 Bumps [codecov/codecov-action](https://github.com/codecov/codecov-action) from 2.1.0 to 3.1.4. - [Release notes](https://github.com/codecov/codecov-action/releases) - [Changelog](https://github.com/codecov/codecov-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/codecov/codecov-action/compare/v2.1.0...v3.1.4) --- updated-dependencies: - dependency-name: codecov/codecov-action dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/run_periodic_tests.yml | 2 +- .github/workflows/test_on_push.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/run_periodic_tests.yml b/.github/workflows/run_periodic_tests.yml index 5027d877ac..f70a748800 100644 --- a/.github/workflows/run_periodic_tests.yml +++ b/.github/workflows/run_periodic_tests.yml @@ -102,7 +102,7 @@ jobs: - name: Upload coverage report if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 - uses: codecov/codecov-action@v2.1.0 + uses: codecov/codecov-action@v3.1.4 - name: Run integration tests run: nox -s integration diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 8fb1aae588..c1d252841b 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -123,7 +123,7 @@ jobs: - name: Upload coverage report if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 - uses: codecov/codecov-action@v2.1.0 + uses: codecov/codecov-action@v3.1.4 - name: Run integration tests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 From 19419a6ef22c3c6eb60f282521a71e349eb2c029 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 21 Aug 2023 15:19:49 +0000 Subject: [PATCH 090/129] Bump actions/upload-artifact from 2 to 3 Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 2 to 3. - [Release notes](https://github.com/actions/upload-artifact/releases) - [Commits](https://github.com/actions/upload-artifact/compare/v2...v3) --- updated-dependencies: - dependency-name: actions/upload-artifact dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/periodic_benchmarks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/periodic_benchmarks.yml b/.github/workflows/periodic_benchmarks.yml index 4816cc7661..eef7b840ee 100644 --- a/.github/workflows/periodic_benchmarks.yml +++ b/.github/workflows/periodic_benchmarks.yml @@ -41,7 +41,7 @@ jobs: SUNDIALS_INST: $HOME/.local LD_LIBRARY_PATH: $HOME/.local/lib - name: Upload results as artifact - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v3 with: name: asv_new_results path: results From 27f659850a38485e99977c7acd17c302ad0466ea Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 21 Aug 2023 15:19:51 +0000 Subject: [PATCH 091/129] Bump FantasticFiasco/action-update-license-year from 2 to 3 Bumps [FantasticFiasco/action-update-license-year](https://github.com/fantasticfiasco/action-update-license-year) from 2 to 3. - [Release notes](https://github.com/fantasticfiasco/action-update-license-year/releases) - [Changelog](https://github.com/FantasticFiasco/action-update-license-year/blob/master/CHANGELOG.md) - [Commits](https://github.com/fantasticfiasco/action-update-license-year/compare/v2...v3) --- updated-dependencies: - dependency-name: FantasticFiasco/action-update-license-year dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/update_license.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/update_license.yml b/.github/workflows/update_license.yml index 1adab96c64..718b24e6b7 100644 --- a/.github/workflows/update_license.yml +++ b/.github/workflows/update_license.yml @@ -17,7 +17,7 @@ jobs: with: fetch-depth: 0 - name: Update year in license - uses: FantasticFiasco/action-update-license-year@v2 + uses: FantasticFiasco/action-update-license-year@v3 with: token: ${{ secrets.GITHUB_TOKEN }} path: LICENSE.txt @@ -32,7 +32,7 @@ jobs: with: fetch-depth: 0 - name: Update year in docs - uses: FantasticFiasco/action-update-license-year@v2 + uses: FantasticFiasco/action-update-license-year@v3 with: token: ${{ secrets.GITHUB_TOKEN }} path: docs/conf.py From 0abc4c20321506354c7645a604616edef3455c36 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 21 Aug 2023 15:19:54 +0000 Subject: [PATCH 092/129] Bump actions/github-script from 5 to 6 Bumps [actions/github-script](https://github.com/actions/github-script) from 5 to 6. - [Release notes](https://github.com/actions/github-script/releases) - [Commits](https://github.com/actions/github-script/compare/v5...v6) --- updated-dependencies: - dependency-name: actions/github-script dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/create_release.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/create_release.yml b/.github/workflows/create_release.yml index 5a8673fd99..6280387e53 100644 --- a/.github/workflows/create_release.yml +++ b/.github/workflows/create_release.yml @@ -26,7 +26,7 @@ jobs: - name: Fail the job if date < 20 if: env.TODAY < 20 - uses: actions/github-script@v5 + uses: actions/github-script@v6 with: script: core.setFailed('This workflow should be triggered only at the end of the month, or else it will create a release for the wrong month.') From b939a2901141bf1dfec2851bd0272465cd7e7872 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 21 Aug 2023 21:36:16 +0530 Subject: [PATCH 093/129] Add newlines between functions Co-authored-by: Saransh Chopra --- noxfile.py | 2 ++ run-tests.py | 1 + 2 files changed, 3 insertions(+) diff --git a/noxfile.py b/noxfile.py index ad66485f10..d1f119cdf1 100644 --- a/noxfile.py +++ b/noxfile.py @@ -109,6 +109,7 @@ def run_examples(session): session.run_always("pip", "install", "-e", ".[all]") session.run("python", "run-tests.py", "--examples") + @nox.session(name="scripts") def run_scripts(session): """Run the scripts tests for Python scripts.""" @@ -116,6 +117,7 @@ def run_scripts(session): session.run_always("pip", "install", "-e", ".[all]") session.run("python", "run-tests.py", "--scripts") + @nox.session(name="dev") def set_dev(session): """Install PyBaMM in editable mode.""" diff --git a/run-tests.py b/run-tests.py index c50c6cc15c..dddafe99e0 100755 --- a/run-tests.py +++ b/run-tests.py @@ -111,6 +111,7 @@ def run_notebooks(executable="python"): sys.exit(1) print("\nOK") + def run_scripts(executable="python"): """ Run example scripts tests. Exits if they fail. From d8b0b58ba3c471bc3762c297cda909081238d4ef Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 21 Aug 2023 22:47:32 +0530 Subject: [PATCH 094/129] Fix style tests --- .github/workflows/test_on_push.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index ba7d5f2948..2fd4c92b2e 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -195,8 +195,6 @@ jobs: with: packages: gfortran gcc graphviz pandoc execute_install_scripts: true - if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 - uses: codecov/codecov-action@v3.1.4 # dot -c is for registering graphviz fonts and plugins - name: Install OpenBLAS and TeXLive for Linux From 531fe528fd637b20cac3bbc91b3371d29dff6834 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 21 Aug 2023 19:26:57 +0000 Subject: [PATCH 095/129] Bump lycheeverse/lychee-action from 1.6.1 to 1.8.0 Bumps [lycheeverse/lychee-action](https://github.com/lycheeverse/lychee-action) from 1.6.1 to 1.8.0. - [Release notes](https://github.com/lycheeverse/lychee-action/releases) - [Commits](https://github.com/lycheeverse/lychee-action/compare/v1.6.1...v1.8.0) --- updated-dependencies: - dependency-name: lycheeverse/lychee-action dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- .github/workflows/lychee_url_checker.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/lychee_url_checker.yml b/.github/workflows/lychee_url_checker.yml index 86a282b57c..a6735d2806 100644 --- a/.github/workflows/lychee_url_checker.yml +++ b/.github/workflows/lychee_url_checker.yml @@ -28,7 +28,7 @@ jobs: # use stable version for now to avoid breaking changes - name: Lychee URL checker - uses: lycheeverse/lychee-action@v1.6.1 + uses: lycheeverse/lychee-action@v1.8.0 with: # arguments with file types to check args: >- From 3ebcbc5ffdb84291279d9d19c7c102a08ba93dbf Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 21 Aug 2023 19:27:01 +0000 Subject: [PATCH 096/129] Bump peter-evans/create-pull-request from 3 to 5 Bumps [peter-evans/create-pull-request](https://github.com/peter-evans/create-pull-request) from 3 to 5. - [Release notes](https://github.com/peter-evans/create-pull-request/releases) - [Commits](https://github.com/peter-evans/create-pull-request/compare/v3...v5) --- updated-dependencies: - dependency-name: peter-evans/create-pull-request dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/update_version.yml | 2 +- .github/workflows/work_precision_sets.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/update_version.yml b/.github/workflows/update_version.yml index 7f05b6edfb..c205603c88 100644 --- a/.github/workflows/update_version.yml +++ b/.github/workflows/update_version.yml @@ -33,7 +33,7 @@ jobs: - name: Create Pull Request id: version_pr - uses: peter-evans/create-pull-request@v3 + uses: peter-evans/create-pull-request@v5 with: delete-branch: true branch-suffix: short-commit-hash diff --git a/.github/workflows/work_precision_sets.yml b/.github/workflows/work_precision_sets.yml index 6b74dcea1b..5be4d079f8 100644 --- a/.github/workflows/work_precision_sets.yml +++ b/.github/workflows/work_precision_sets.yml @@ -26,7 +26,7 @@ jobs: python benchmarks/work_precision_sets/time_vs_reltols.py python benchmarks/work_precision_sets/time_vs_abstols.py - name: Create Pull Request - uses: peter-evans/create-pull-request@v3 + uses: peter-evans/create-pull-request@v5 with: delete-branch: true branch-suffix: short-commit-hash From 8fd0f3f40d76f1314dd8b1ca58cc12dd0860e783 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Tue, 22 Aug 2023 16:39:56 +0530 Subject: [PATCH 097/129] Move Dockerfile to `scripts/` --- .../user_guide/installation/install-from-docker.rst | 10 +++++----- Dockerfile => scripts/Dockerfile | 0 2 files changed, 5 insertions(+), 5 deletions(-) rename Dockerfile => scripts/Dockerfile (100%) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index ffa7f88505..085f1b482d 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -14,7 +14,7 @@ Ensure Docker installation by running : docker --version -Pulling the Docker Image (will be supported soon) +Pulling the Docker Image ------------------------------------------------- Use the following command to pull the PyBaMM Docker image from Docker Hub: @@ -69,7 +69,7 @@ If you want to build the PyBaMM Docker image locally from the PyBaMM source code .. code-block:: bash - docker build -t pybamm . + docker build -t pybamm -f scripts/Dockerfile . 4. Once the image is built, you can run a Docker container using: @@ -97,7 +97,7 @@ Build Docker Image with IDAKLU Solver .. code-block:: bash - docker build -t pybamm:idaklu --build-arg IDAKLU=true . + docker build -t pybamm:idaklu -f scripts/Dockerfile --build-arg IDAKLU=true . Build Docker Image with ODES Solver ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -108,7 +108,7 @@ Build Docker Image with ODES Solver .. code-block:: bash - docker build -t pybamm:odes --build-arg ODES=true . + docker build -t pybamm:odes -f scripts/Dockerfile --build-arg ODES=true . Build Docker Image with JAX Solver ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -119,7 +119,7 @@ Build Docker Image with JAX Solver .. code-block:: bash - docker build -t pybamm:jax --build-arg JAX=true . + docker build -t pybamm:jax -f scripts/Dockerfile --build-arg JAX=true . After building the Docker images with the desired solvers, use the ``docker run`` command followed by the desired image name. For example, to run a container from the image built with IDAKLU solver: diff --git a/Dockerfile b/scripts/Dockerfile similarity index 100% rename from Dockerfile rename to scripts/Dockerfile From d8a9b4f27f9ce837b769fae11b621d099f21b500 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Tue, 22 Aug 2023 18:02:51 +0530 Subject: [PATCH 098/129] Add instructions to use vscode with wsl --- docs/source/user_guide/installation/windows-wsl.rst | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/docs/source/user_guide/installation/windows-wsl.rst b/docs/source/user_guide/installation/windows-wsl.rst index 7065dbdbc3..e56d0a7fd0 100644 --- a/docs/source/user_guide/installation/windows-wsl.rst +++ b/docs/source/user_guide/installation/windows-wsl.rst @@ -38,3 +38,16 @@ Get PyBaMM's Source Code ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Follow the `installation instructions for PyBaMM on Linux `__. + +Using Visual Studio Code with the WSL +--------------------------------------- + +To use Visual Studio Code with the Windows Subsystem for Linux (WSL), follow these steps: + +1. Open Visual Studio Code. +2. Install the "Remote - WSL" extension if not already installed. +3. Open the PyBaMM directory in Visual Studio Code. +4. In the bottom pane, select the "+" sign and choose "New WSL Window." +5. This opens a WSL terminal in the PyBaMM directory within the WSL. + +Now you can develop and edit PyBaMM code using Visual Studio Code while utilizing the WSL environment. From c1d41e04acec061f2834dbbfd631aee394a01a1e Mon Sep 17 00:00:00 2001 From: Arjun Date: Wed, 23 Aug 2023 11:56:38 +0530 Subject: [PATCH 099/129] Apply suggestions from code review Co-authored-by: Saransh Chopra --- .../user_guide/installation/install-from-docker.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 085f1b482d..0768bb1ab5 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -1,5 +1,5 @@ Install from source (Docker) -========================================= +============================ .. contents:: @@ -15,7 +15,7 @@ Ensure Docker installation by running : docker --version Pulling the Docker Image -------------------------------------------------- +------------------------ Use the following command to pull the PyBaMM Docker image from Docker Hub: .. code:: bash @@ -38,7 +38,7 @@ Once you have pulled the Docker image, you can run a Docker container with the P 3. You can execute PyBaMM-related commands, run tests develop & contribute from the container. Exiting the Docker Container ---------------------------- +---------------------------- To exit the Docker container's shell, you can simply type: @@ -49,7 +49,7 @@ To exit the Docker container's shell, you can simply type: This will return you to your host machine's terminal. Building Docker Image Locally from Source ------------------------------------------- +----------------------------------------- If you want to build the PyBaMM Docker image locally from the PyBaMM source code, follow these steps: From 0e54d8f43ab59f4a0d46e41ab131250cbaef457f Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Wed, 23 Aug 2023 12:16:07 +0530 Subject: [PATCH 100/129] Add instructions to use vscode with docker --- .../user_guide/installation/install-from-docker.rst | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 085f1b482d..20e984053c 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -127,3 +127,15 @@ After building the Docker images with the desired solvers, use the ``docker run` .. code-block:: bash docker run -it pybamm:idaklu + +Using Visual Studio Code Inside a Running Docker Container +---------------------------------------------------------- + +You can easily use Visual Studio Code inside a running Docker container by attaching it directly. This provides a seamless development environment within the container. Here's how: + +1. Install the "Docker" extension from Microsoft in your local Visual Studio Code if it's not already installed. +2. Pull and run the Docker image containing PyBaMM development environment. +3. In your local Visual Studio Code, open the "Docker" extension by clicking on the Docker icon in the sidebar. +4. Under the "Containers" section, you'll see a list of running containers. Right-click the running PyBaMM container. +5. Select "Attach Visual Studio Code" from the context menu. +6. Visual Studio Code will now connect to the container, and a new VS Code window will open up, running inside the container. You can now edit, debug, and work on your code using VS Code as if you were working directly on your local machine. From 4b7ededbadf272c45eee19c176ef841a1a3d099e Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Wed, 23 Aug 2023 16:44:29 +0530 Subject: [PATCH 101/129] Add conditions based on terminal commands to selectively exclude outputs --- docs/conf.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/conf.py b/docs/conf.py index 336fa15743..d0b1683aff 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -203,6 +203,15 @@ # -- Options for LaTeX output ------------------------------------------------ +# Note: we exclude the examples directory from the LaTeX build because it has +# problems with the creation of PDFs on Read the Docs +# https://github.com/readthedocs/readthedocs.org/issues/2045 + +# Detect if we are building LaTeX output through the invocation of the build commands +if any("latex" in arg for arg in sys.argv) or any("latexmk" in arg for arg in sys.argv): + exclude_patterns.append("source/examples/*") + print("Skipping compilation of .ipynb files for LaTeX build.") + latex_elements = { # The paper size ('letterpaper' or 'a4paper'). # From 94c1cfc78f9f36b99ae3463b034246c837f08ab0 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Wed, 23 Aug 2023 16:45:10 +0530 Subject: [PATCH 102/129] Add explainer about notebooks in PDF builds --- docs/source/user_guide/index.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/source/user_guide/index.md b/docs/source/user_guide/index.md index 2ed483a9b2..f7bc57a414 100644 --- a/docs/source/user_guide/index.md +++ b/docs/source/user_guide/index.md @@ -25,9 +25,13 @@ fundamentals/index # Example notebooks -The notebooks below provide a good introduction to PyBaMM and how to use it. For more -examples, see the [Examples](../examples/index.rst) section. +PyBaMM ships with example notebooks that demonstrate how to use it and reveal some of its +functionalities and its inner workings. For more examples, see the [Examples](../examples/index.rst) section. +```{only} latex +The notebooks are not included in PDF formats of the documentation. You may access them on PyBaMM's hosted +documentation available at https://docs.pybamm.org/en/latest/source/examples/index.html +``` ```{nbgallery} --- From 2ec97c14f34f0f39d19e648ec9c99658a43b907a Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Wed, 23 Aug 2023 17:44:12 +0530 Subject: [PATCH 103/129] Remove SVG files from LaTeX builds --- docs/index.rst | 103 +++++++++++++++++++++++++------------------------ 1 file changed, 53 insertions(+), 50 deletions(-) diff --git a/docs/index.rst b/docs/index.rst index 3e5d54ecb5..b2e0073780 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -38,77 +38,80 @@ Broadly, PyBaMM consists of Together, these enable flexible model definitions and fast battery simulations, allowing users to explore the effect of different battery designs and modeling assumptions under a variety of operating scenarios. -.. grid:: 2 +.. SVG images sometimes cause LaTeX build errors +.. only:: not latex - .. grid-item-card:: - :img-top: _static/index-images/getting_started.svg + .. grid:: 2 - User Guide - ^^^^^^^^^^ + .. grid-item-card:: + :img-top: _static/index-images/getting_started.svg - The user guide is the best place to start learning PyBaMM. It contains an installation - guide, an introduction to the main concepts and links to additional tutorials. + User Guide + ^^^^^^^^^^ - +++ + The user guide is the best place to start learning PyBaMM. It contains an installation + guide, an introduction to the main concepts and links to additional tutorials. - .. button-ref:: source/user_guide/index - :expand: - :color: secondary - :click-parent: + +++ - To the user guide + .. button-ref:: source/user_guide/index + :expand: + :color: secondary + :click-parent: - .. grid-item-card:: - :img-top: _static/index-images/examples.svg + To the user guide - Examples - ^^^^^^^^ + .. grid-item-card:: + :img-top: _static/index-images/examples.svg - Examples and tutorials can be viewed on the GitHub examples page, - which also provides a link to run them online through Google Colab. + Examples + ^^^^^^^^ - +++ + Examples and tutorials can be viewed on the GitHub examples page, + which also provides a link to run them online through Google Colab. - .. button-ref:: source/examples/index - :expand: - :color: secondary - :click-parent: + +++ - To the examples + .. button-ref:: source/examples/index + :expand: + :color: secondary + :click-parent: - .. grid-item-card:: - :img-top: _static/index-images/api.svg + To the examples - API Documentation - ^^^^^^^^^^^^^^^^^ + .. grid-item-card:: + :img-top: _static/index-images/api.svg - The reference guide contains a detailed description of the functions, - modules, and objects included in PyBaMM. The reference describes how the - methods work and which parameters can be used. + API Documentation + ^^^^^^^^^^^^^^^^^ - +++ + The reference guide contains a detailed description of the functions, + modules, and objects included in PyBaMM. The reference describes how the + methods work and which parameters can be used. - .. button-ref:: source/api/index - :expand: - :color: secondary - :click-parent: + +++ - To the API documentation + .. button-ref:: source/api/index + :expand: + :color: secondary + :click-parent: - .. grid-item-card:: - :img-top: _static/index-images/contributor.svg + To the API documentation - Contributor's Guide - ^^^^^^^^^^^^^^^^^^^ + .. grid-item-card:: + :img-top: _static/index-images/contributor.svg - Contributions to PyBaMM and its development are welcome! If you have ideas for - features, bug fixes, models, spatial methods, or solvers, we would love to hear from you. + Contributor's Guide + ^^^^^^^^^^^^^^^^^^^ - +++ + Contributions to PyBaMM and its development are welcome! If you have ideas for + features, bug fixes, models, spatial methods, or solvers, we would love to hear from you. - .. button-link:: https://github.com/pybamm-team/PyBaMM/blob/develop/CONTRIBUTING.md - :expand: - :color: secondary - :click-parent: + +++ - To the contributor's guide + .. button-link:: https://github.com/pybamm-team/PyBaMM/blob/develop/CONTRIBUTING.md + :expand: + :color: secondary + :click-parent: + + To the contributor's guide From d885cbe19f81deb562bbf54ce4f3426b3243f7dd Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Wed, 23 Aug 2023 18:17:15 +0530 Subject: [PATCH 104/129] Make tabs for different solvers --- .../installation/install-from-docker.rst | 60 +++++++++++++++++-- 1 file changed, 56 insertions(+), 4 deletions(-) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 83b9f488cd..79954b0af6 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -18,9 +18,35 @@ Pulling the Docker Image ------------------------ Use the following command to pull the PyBaMM Docker image from Docker Hub: -.. code:: bash +.. tab:: Basic + + .. code:: bash + + docker pull pybamm/pybamm:latest + +.. tab:: ODES Solver + + .. code:: bash + + docker pull pybamm/pybamm:odes + +.. tab:: JAX Solver + + .. code:: bash + + docker pull pybamm/pybamm:jax + +.. tab:: IDAKLU Solver + + .. code:: bash + + docker pull pybamm/pybamm:idaklu + +.. tab:: All Solver + + .. code:: bash - docker pull pybamm/pybamm:latest + docker pull pybamm/pybamm:all Running the Docker Container ---------------------------- @@ -29,9 +55,35 @@ Once you have pulled the Docker image, you can run a Docker container with the P 1. In your terminal, use the following command to start a Docker container from the pulled image: -.. code-block:: bash +.. tab:: Basic + + .. code:: bash + + docker run -it pybamm/pybamm:latest + +.. tab:: ODES Solver + + .. code:: bash + + docker run -it pybamm/pybamm:odes + +.. tab:: JAX Solver + + .. code:: bash + + docker run -it pybamm/pybamm:jax + +.. tab:: IDAKLU Solver + + .. code:: bash + + docker run -it pybamm/pybamm:idaklu + +.. tab:: All Solver + + .. code:: bash - docker run -it pybamm/pybamm:latest + docker run -it pybamm/pybamm:all 2. You will now be inside the Docker container's shell. You can use PyBaMM and its dependencies as if you were in a virtual environment. From 0caa9732ad6ceca270fb6f076f985c3ee9b8746b Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Wed, 23 Aug 2023 22:54:12 +0530 Subject: [PATCH 105/129] Remove LaTeX output from `Extends:` labels --- docs/sphinxext/extend_parent.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/sphinxext/extend_parent.py b/docs/sphinxext/extend_parent.py index 25978fe804..00752e1483 100644 --- a/docs/sphinxext/extend_parent.py +++ b/docs/sphinxext/extend_parent.py @@ -20,7 +20,8 @@ def process_docstring(app, what, name, obj, options, lines): # get the base class name base_cls_name = f"{getmro(obj)[1].__module__}.{getmro(obj)[1].__name__}" # add the extends keyword to the docstring - lines.append(f"**Extends:** :class:`{base_cls_name}`") + lines.append(".. only:: not latex\n") + lines.append(f" **Extends:** :class:`{base_cls_name}`") def setup(app): From 265cd4abf1120b992e48cffb69ce30ff822f33d6 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Wed, 23 Aug 2023 23:09:17 +0530 Subject: [PATCH 106/129] Add temporary CI docs build job --- .github/workflows/test_on_push.yml | 51 ++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index c1d252841b..df2f9a7bc1 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -136,3 +136,54 @@ jobs: - name: Install dev dependencies and run example tests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s examples + + # temporary job to test building docs on push, besides building locally + build_docs: + needs: style + runs-on: ubuntu-latest + strategy: + fail-fast: false + + steps: + - name: Check out PyBaMM repository + uses: actions/checkout@v3 + + # dot -c is for registering graphviz fonts and plugins + - name: Install Linux system dependencies + run: | + sudo apt-get update + sudo dot -c + sudo apt-get install gfortran gcc graphviz pandoc libopenblas-dev texlive-full latexmk dvipng + + - name: Set up Python 3.11 + id: setup-python + uses: actions/setup-python@v4 + with: + python-version: 3.11 + cache: 'pip' + cache-dependency-path: setup.py + + - name: Install PyBaMM dependencies + run: | + pip install --upgrade pip wheel setuptools nox + pip install -e .[all,docs] + + - name: Install SuiteSparse and SUNDIALS on GNU/Linux + run: nox -s pybamm-requires + + - name: Install docs dependencies and run doctests for GNU/Linux with Python 3.11 + run: | + nox -s doctests + rm -rf docs/build/ + + - name: Check if HTML docs can be built + run: | + sphinx-build -j auto docs docs/build/ + rm -rf docs/build/ + + - name: Check if PDF docs can be built + run: | + sphinx-build -M latexpdf docs/ docs/build/ + cd docs/build/latex/ + make clean + latexmk -r latexmkrc -pdf -f -dvi- -ps- -jobname=pybamm -interaction=nonstopmode From cf1b276ab44cb08f890e602f495c7719b9c8ccf4 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Wed, 23 Aug 2023 23:09:35 +0530 Subject: [PATCH 107/129] Fix undefined module LaTeX warning --- docs/source/api/index.rst | 2 -- 1 file changed, 2 deletions(-) diff --git a/docs/source/api/index.rst b/docs/source/api/index.rst index 432461a58e..5c385ee2e5 100644 --- a/docs/source/api/index.rst +++ b/docs/source/api/index.rst @@ -1,5 +1,3 @@ -.. module:: pybamm - .. _api_docs: ################# From 27a4a560e62089c49cd6ec6bca9b2dfaa2233473 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Wed, 23 Aug 2023 23:11:37 +0530 Subject: [PATCH 108/129] Install Linux system dependencies --- .github/workflows/test_on_push.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index df2f9a7bc1..ae24c87a61 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -152,7 +152,6 @@ jobs: - name: Install Linux system dependencies run: | sudo apt-get update - sudo dot -c sudo apt-get install gfortran gcc graphviz pandoc libopenblas-dev texlive-full latexmk dvipng - name: Set up Python 3.11 From 74cb7cdb16ddddbd82dab594368dfb0c7cf23271 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Wed, 23 Aug 2023 23:34:14 +0530 Subject: [PATCH 109/129] Fix HTML build warnings --- .github/workflows/test_on_push.yml | 2 +- docs/sphinxext/extend_parent.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index ae24c87a61..9fe1f56afd 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -152,7 +152,7 @@ jobs: - name: Install Linux system dependencies run: | sudo apt-get update - sudo apt-get install gfortran gcc graphviz pandoc libopenblas-dev texlive-full latexmk dvipng + sudo apt-get install gfortran gcc graphviz pandoc libopenblas-dev texlive-latex-extra latexmk dvipng - name: Set up Python 3.11 id: setup-python diff --git a/docs/sphinxext/extend_parent.py b/docs/sphinxext/extend_parent.py index 00752e1483..54985109cb 100644 --- a/docs/sphinxext/extend_parent.py +++ b/docs/sphinxext/extend_parent.py @@ -21,6 +21,7 @@ def process_docstring(app, what, name, obj, options, lines): base_cls_name = f"{getmro(obj)[1].__module__}.{getmro(obj)[1].__name__}" # add the extends keyword to the docstring lines.append(".. only:: not latex\n") + lines.append("\n") lines.append(f" **Extends:** :class:`{base_cls_name}`") From 5ea9b8a424ee43c96c8fc91a1496a0e689af623e Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Thu, 24 Aug 2023 00:29:48 +0530 Subject: [PATCH 110/129] Trigger docs build --- docs/source/user_guide/installation/install-from-docker.rst | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 79954b0af6..875c8465b1 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -180,6 +180,12 @@ After building the Docker images with the desired solvers, use the ``docker run` docker run -it pybamm:idaklu +If you want to exit the Docker container's shell, you can simply type: + +.. code-block:: bash + + exit + Using Visual Studio Code Inside a Running Docker Container ---------------------------------------------------------- From 3b0d4fa4981a88f1a3b7d2a86ad9377c9ca98f66 Mon Sep 17 00:00:00 2001 From: Saransh Chopra Date: Wed, 23 Aug 2023 19:05:56 -0400 Subject: [PATCH 111/129] Formatting --- .../installation/install-from-docker.rst | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 875c8465b1..c90f9cdf18 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -48,7 +48,7 @@ Use the following command to pull the PyBaMM Docker image from Docker Hub: docker pull pybamm/pybamm:all -Running the Docker Container +Running the Docker container ---------------------------- Once you have pulled the Docker image, you can run a Docker container with the PyBaMM environment: @@ -89,7 +89,7 @@ Once you have pulled the Docker image, you can run a Docker container with the P 3. You can execute PyBaMM-related commands, run tests develop & contribute from the container. -Exiting the Docker Container +Exiting the Docker container ---------------------------- To exit the Docker container's shell, you can simply type: @@ -100,7 +100,7 @@ To exit the Docker container's shell, you can simply type: This will return you to your host machine's terminal. -Building Docker Image Locally from Source +Building Docker image locally from source ----------------------------------------- If you want to build the PyBaMM Docker image locally from the PyBaMM source code, follow these steps: @@ -129,18 +129,18 @@ If you want to build the PyBaMM Docker image locally from the PyBaMM source code docker run -it pybamm -Building Docker Images with Optional Args +Building Docker images with optional args ----------------------------------------- When building the PyBaMM Docker images locally, you have the option to include specific solvers by using optional arguments. These solvers include: -- IDAKLU: For IDA solver provided by the SUNDIALS plus KLU. -- ODES: For scikits.odes solver for ODE & DAE problems. -- JAX: For Jax solver. +- ``IDAKLU``: For IDA solver provided by the SUNDIALS plus KLU. +- ``ODES``: For scikits.odes solver for ODE & DAE problems. +- ``JAX``: For Jax solver. To build the Docker images with optional arguments, you can follow these steps for each solver: -Build Docker Image with IDAKLU Solver +Build Docker image with IDAKLU solver ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. @@ -151,8 +151,8 @@ Build Docker Image with IDAKLU Solver docker build -t pybamm:idaklu -f scripts/Dockerfile --build-arg IDAKLU=true . -Build Docker Image with ODES Solver -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Build Docker image with Scikits.odes solvers +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. @@ -162,7 +162,7 @@ Build Docker Image with ODES Solver docker build -t pybamm:odes -f scripts/Dockerfile --build-arg ODES=true . -Build Docker Image with JAX Solver +Build Docker image with JAX solver ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. From 37e6f38116d81cfb6211380cb0fa947495e6668c Mon Sep 17 00:00:00 2001 From: Saransh Chopra Date: Wed, 23 Aug 2023 19:06:14 -0400 Subject: [PATCH 112/129] Format again --- docs/source/user_guide/installation/install-from-docker.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index c90f9cdf18..eaf4252e07 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -14,7 +14,7 @@ Ensure Docker installation by running : docker --version -Pulling the Docker Image +Pulling the Docker image ------------------------ Use the following command to pull the PyBaMM Docker image from Docker Hub: From 8cdecf1074859c1056c4c841d47708353d263cc6 Mon Sep 17 00:00:00 2001 From: Saransh Chopra Date: Thu, 24 Aug 2023 17:13:30 -0400 Subject: [PATCH 113/129] Fix formatting --- .../user_guide/installation/GNU-linux.rst | 24 ++++++++----------- .../user_guide/installation/windows-wsl.rst | 2 +- .../user_guide/installation/windows.rst | 2 +- 3 files changed, 12 insertions(+), 16 deletions(-) diff --git a/docs/source/user_guide/installation/GNU-linux.rst b/docs/source/user_guide/installation/GNU-linux.rst index 1baab24e38..e66c3c2291 100644 --- a/docs/source/user_guide/installation/GNU-linux.rst +++ b/docs/source/user_guide/installation/GNU-linux.rst @@ -1,11 +1,10 @@ -=================== - GNU-Linux & MacOS -=================== +GNU-Linux & MacOS +================= .. contents:: Prerequisites -============= +------------- To use and/or contribute to PyBaMM, you must have Python 3.8, 3.9, 3.10, or 3.11 installed. @@ -42,12 +41,12 @@ To use and/or contribute to PyBaMM, you must have Python 3.8, 3.9, 3.10, or 3.11 brew install python3 Install PyBaMM -============== +-------------- .. _user-install-label: User install ------------- +~~~~~~~~~~~~ We recommend to install PyBaMM within a virtual environment, in order not to alter any distribution Python files. @@ -75,7 +74,7 @@ the environment and go back to your original system, just type: PyBaMM can be installed via pip. On macOS, it is necessary to install the `SUNDIALS `__ library beforehand. -.. tab:: GNU/Linux and Windows +.. tab:: GNU/Linux In a terminal, run the following command: @@ -92,7 +91,7 @@ library beforehand. brew install sundials pip install pybamm -PyBaMM’s dependencies (such as ``numpy``, ``scipy``, etc) will be +PyBaMM’s required dependencies (such as ``numpy``, ``casadi``, etc) will be installed automatically when you install PyBaMM using ``pip``. For an introduction to virtual environments, see @@ -101,7 +100,7 @@ For an introduction to virtual environments, see .. _scikits.odes-label: Optional - scikits.odes solver ------------------------------- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Users can install `scikits.odes `__ in order to use the wrapped SUNDIALS ODE and DAE @@ -131,14 +130,11 @@ Currently, only GNU/Linux and macOS are supported. Assuming that SUNDIALS was installed as described :ref:`above`. Optional - JaxSolver --------------------- +~~~~~~~~~~~~~~~~~~~~ Users can install ``jax`` and ``jaxlib`` to use the Jax solver. Currently, only GNU/Linux and macOS are supported. -GNU/Linux and macOS -~~~~~~~~~~~~~~~~~~~ - .. code:: bash pip install "pybamm[jax]" @@ -146,7 +142,7 @@ GNU/Linux and macOS The ``pip install "pybamm[jax]"`` command automatically downloads and installs ``pybamm`` and the compatible versions of ``jax`` and ``jaxlib`` on your system. (``pybamm_install_jax`` is deprecated.) Uninstall PyBaMM -================ +---------------- PyBaMM can be uninstalled by running diff --git a/docs/source/user_guide/installation/windows-wsl.rst b/docs/source/user_guide/installation/windows-wsl.rst index e56d0a7fd0..d08545edc0 100644 --- a/docs/source/user_guide/installation/windows-wsl.rst +++ b/docs/source/user_guide/installation/windows-wsl.rst @@ -1,5 +1,5 @@ Install from source (Windows Subsystem for Linux) -================================= +================================================= To make it easier to install PyBaMM, we recommend using the Windows Subsystem for Linux (WSL) along with Visual Studio Code. This guide will walk you through the process. diff --git a/docs/source/user_guide/installation/windows.rst b/docs/source/user_guide/installation/windows.rst index 1d7396ee19..20e4129709 100644 --- a/docs/source/user_guide/installation/windows.rst +++ b/docs/source/user_guide/installation/windows.rst @@ -1,5 +1,5 @@ Windows -========== +======= .. contents:: From 0d2a61a5076d6cb50c2b040c5f69d175e3935643 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Fri, 25 Aug 2023 02:46:53 +0530 Subject: [PATCH 114/129] Make `ALL` arg --- scripts/Dockerfile | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/scripts/Dockerfile b/scripts/Dockerfile index 999cc77740..3cfbeaa11c 100644 --- a/scripts/Dockerfile +++ b/scripts/Dockerfile @@ -26,6 +26,7 @@ ENV LD_LIBRARY_PATH=/home/pybamm/.local/lib: ARG IDAKLU ARG ODES ARG JAX +ARG ALL RUN conda create -n pybamm python=3.9 RUN conda init --all @@ -51,6 +52,14 @@ RUN if [ "$JAX" = "true" ]; then \ pip install --user -e ".[jax,all,dev]";\ fi -RUN pip install --user -e ".[all]" +RUN if [ "$ALL" = "true" ]; then \ + pip install cmake==3.22 && \ + pip install --upgrade --user pip setuptools wheel wget && \ + python scripts/install_KLU_Sundials.py && \ + git clone https://github.com/pybind/pybind11.git && \ + pip install --user -e ".[all,dev,jax,odes]"; \ + fi + +RUN pip install --user -e ".[all,dev]" ENTRYPOINT ["/bin/bash"] From abb51e5cfe8bcb17796985d0673e4695fd097f31 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Fri, 25 Aug 2023 02:53:10 +0530 Subject: [PATCH 115/129] Modify docs for `ALL` arg --- .../installation/install-from-docker.rst | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index eaf4252e07..417591581f 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -129,6 +129,12 @@ If you want to build the PyBaMM Docker image locally from the PyBaMM source code docker run -it pybamm +5. Activate PyBaMM development environment inside docker container using: + +.. code-block:: bash + + conda activate pybamm + Building Docker images with optional args ----------------------------------------- @@ -173,6 +179,16 @@ Build Docker image with JAX solver docker build -t pybamm:jax -f scripts/Dockerfile --build-arg JAX=true . +Build Docker image with All solver +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. + +2. Build the Docker image with all solvers pre-installed using the following command: + +.. code-block:: bash + + docker build -t pybamm:all -f scripts/Dockerfile --build-arg ALL=true . After building the Docker images with the desired solvers, use the ``docker run`` command followed by the desired image name. For example, to run a container from the image built with IDAKLU solver: @@ -180,6 +196,12 @@ After building the Docker images with the desired solvers, use the ``docker run` docker run -it pybamm:idaklu +Activate PyBaMM development environment inside docker container using: + +.. code-block:: bash + + conda activate pybamm + If you want to exit the Docker container's shell, you can simply type: .. code-block:: bash From ba883084454e0e1379da1b259d03f36d6902f1f6 Mon Sep 17 00:00:00 2001 From: Arjun Date: Fri, 25 Aug 2023 04:14:05 +0530 Subject: [PATCH 116/129] Apply suggestions from code review Co-authored-by: Saransh Chopra --- .../user_guide/installation/install-from-docker.rst | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 417591581f..4f8665d426 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -42,7 +42,7 @@ Use the following command to pull the PyBaMM Docker image from Docker Hub: docker pull pybamm/pybamm:idaklu -.. tab:: All Solver +.. tab:: All Solvers .. code:: bash @@ -79,7 +79,7 @@ Once you have pulled the Docker image, you can run a Docker container with the P docker run -it pybamm/pybamm:idaklu -.. tab:: All Solver +.. tab:: All Solvers .. code:: bash @@ -143,6 +143,7 @@ When building the PyBaMM Docker images locally, you have the option to include s - ``IDAKLU``: For IDA solver provided by the SUNDIALS plus KLU. - ``ODES``: For scikits.odes solver for ODE & DAE problems. - ``JAX``: For Jax solver. +- ``ALL``: For all the optional solvers. To build the Docker images with optional arguments, you can follow these steps for each solver: @@ -179,8 +180,8 @@ Build Docker image with JAX solver docker build -t pybamm:jax -f scripts/Dockerfile --build-arg JAX=true . -Build Docker image with All solver -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Build Docker image with all solvers +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. @@ -194,7 +195,7 @@ After building the Docker images with the desired solvers, use the ``docker run` .. code-block:: bash - docker run -it pybamm:idaklu + docker run -it pybamm:all Activate PyBaMM development environment inside docker container using: From a058467cef9bb3722ca1e789e9b32be9e5a8fae2 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Fri, 25 Aug 2023 04:45:39 +0530 Subject: [PATCH 117/129] Arrange local build of solvers into tabs & Squash --- .../installation/install-from-docker.rst | 50 ++++++------------- 1 file changed, 15 insertions(+), 35 deletions(-) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index 4f8665d426..f959c0e0a8 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -79,7 +79,7 @@ Once you have pulled the Docker image, you can run a Docker container with the P docker run -it pybamm/pybamm:idaklu -.. tab:: All Solvers +.. tab:: All Solver .. code:: bash @@ -143,55 +143,35 @@ When building the PyBaMM Docker images locally, you have the option to include s - ``IDAKLU``: For IDA solver provided by the SUNDIALS plus KLU. - ``ODES``: For scikits.odes solver for ODE & DAE problems. - ``JAX``: For Jax solver. -- ``ALL``: For all the optional solvers. +- ``ALL``: For all the above solvers. To build the Docker images with optional arguments, you can follow these steps for each solver: -Build Docker image with IDAKLU solver -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. - -3. Build the Docker image for IDAKLU using the following command: - -.. code-block:: bash - - docker build -t pybamm:idaklu -f scripts/Dockerfile --build-arg IDAKLU=true . - -Build Docker image with Scikits.odes solvers -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. - -2. Build the Docker image for ODES using the following command: - -.. code-block:: bash +.. tab:: ODES Solver - docker build -t pybamm:odes -f scripts/Dockerfile --build-arg ODES=true . + .. code-block:: bash -Build Docker image with JAX solver -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + docker build -t pybamm:odes -f scripts/Dockerfile --build-arg ODES=true . -1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. +.. tab:: JAX Solver -2. Build the Docker image for JAX using the following command: + .. code-block:: bash -.. code-block:: bash + docker build -t pybamm:jax -f scripts/Dockerfile --build-arg JAX=true . - docker build -t pybamm:jax -f scripts/Dockerfile --build-arg JAX=true . +.. tab:: IDAKLU Solver -Build Docker image with all solvers -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + .. code-block:: bash -1. Follow the same steps as above to clone the PyBaMM repository and navigate to the source code directory. + docker build -t pybamm:idaklu -f scripts/Dockerfile --build-arg IDAKLU=true . -2. Build the Docker image with all solvers pre-installed using the following command: +.. tab:: ALL Solver -.. code-block:: bash + .. code-block:: bash - docker build -t pybamm:all -f scripts/Dockerfile --build-arg ALL=true . + docker build -t pybamm:all -f scripts/Dockerfile --build-arg ALL=true . -After building the Docker images with the desired solvers, use the ``docker run`` command followed by the desired image name. For example, to run a container from the image built with IDAKLU solver: +After building the Docker images with the desired solvers, use the ``docker run`` command followed by the desired image name. For example, to run a container from the image built with ALL solver: .. code-block:: bash From c0d7abfa6d3d9ba92b3d06dd4c715eb1dfb22380 Mon Sep 17 00:00:00 2001 From: Saransh Chopra Date: Thu, 24 Aug 2023 20:15:07 -0400 Subject: [PATCH 118/129] Apply suggestions from code review --- .../installation/install-from-docker.rst | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/docs/source/user_guide/installation/install-from-docker.rst b/docs/source/user_guide/installation/install-from-docker.rst index f959c0e0a8..f25a57d713 100644 --- a/docs/source/user_guide/installation/install-from-docker.rst +++ b/docs/source/user_guide/installation/install-from-docker.rst @@ -18,31 +18,31 @@ Pulling the Docker image ------------------------ Use the following command to pull the PyBaMM Docker image from Docker Hub: -.. tab:: Basic +.. tab:: No optional solver .. code:: bash docker pull pybamm/pybamm:latest -.. tab:: ODES Solver +.. tab:: Scikits.odes solver .. code:: bash docker pull pybamm/pybamm:odes -.. tab:: JAX Solver +.. tab:: JAX solver .. code:: bash docker pull pybamm/pybamm:jax -.. tab:: IDAKLU Solver +.. tab:: IDAKLU solver .. code:: bash docker pull pybamm/pybamm:idaklu -.. tab:: All Solvers +.. tab:: All solvers .. code:: bash @@ -147,31 +147,31 @@ When building the PyBaMM Docker images locally, you have the option to include s To build the Docker images with optional arguments, you can follow these steps for each solver: -.. tab:: ODES Solver +.. tab:: Scikits.odes solver .. code-block:: bash docker build -t pybamm:odes -f scripts/Dockerfile --build-arg ODES=true . -.. tab:: JAX Solver +.. tab:: JAX solver .. code-block:: bash docker build -t pybamm:jax -f scripts/Dockerfile --build-arg JAX=true . -.. tab:: IDAKLU Solver +.. tab:: IDAKLU solver .. code-block:: bash docker build -t pybamm:idaklu -f scripts/Dockerfile --build-arg IDAKLU=true . -.. tab:: ALL Solver +.. tab:: All solvers .. code-block:: bash docker build -t pybamm:all -f scripts/Dockerfile --build-arg ALL=true . -After building the Docker images with the desired solvers, use the ``docker run`` command followed by the desired image name. For example, to run a container from the image built with ALL solver: +After building the Docker images with the desired solvers, use the ``docker run`` command followed by the desired image name. For example, to run a container from the image built with all optional solvers: .. code-block:: bash From f8f3f3eeb88091c0f54394d711410cc6eaf474bc Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 28 Aug 2023 21:17:46 +0530 Subject: [PATCH 119/129] Try custom PDF build job and upload artifact --- .github/workflows/test_on_push.yml | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 9fe1f56afd..532b84eb97 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -183,6 +183,13 @@ jobs: - name: Check if PDF docs can be built run: | sphinx-build -M latexpdf docs/ docs/build/ - cd docs/build/latex/ - make clean - latexmk -r latexmkrc -pdf -f -dvi- -ps- -jobname=pybamm -interaction=nonstopmode + cd docs/build/ + rm -f *.log *.ind *.aux *.toc *.syn *.idx *.out *.ilg *.pla *.ps *.tar *.tar.gz *.tar.bz2 *.tar.xz PyBaMM.pdf PyBaMM.dvi *.fls *.fdb_latexmk + latexmk -r latexmkrc -pdf -f -dvi- -ps- -jobname=pybamm -interaction=nonstopmode || true + test -f pybamm.pdf && echo "pybamm.pdf exists. Copying source file." + + - name: Upload PDF docs + uses: actions/upload-artifact@v2 + with: + name: pybamm-docs + path: docs/build/pybamm.pdf From a5d3da813a631e72668b8848147514ddaef036e8 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 28 Aug 2023 21:35:36 +0530 Subject: [PATCH 120/129] Modify PDF build workflow --- .github/workflows/test_on_push.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 532b84eb97..0094fb3427 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -182,7 +182,7 @@ jobs: - name: Check if PDF docs can be built run: | - sphinx-build -M latexpdf docs/ docs/build/ + sphinx-build -T -E -b latex -D language=en docs docs/build cd docs/build/ rm -f *.log *.ind *.aux *.toc *.syn *.idx *.out *.ilg *.pla *.ps *.tar *.tar.gz *.tar.bz2 *.tar.xz PyBaMM.pdf PyBaMM.dvi *.fls *.fdb_latexmk latexmk -r latexmkrc -pdf -f -dvi- -ps- -jobname=pybamm -interaction=nonstopmode || true From bfe7dd489a4248022e8f31566c12d01924854ef1 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 28 Aug 2023 22:38:43 +0530 Subject: [PATCH 121/129] Add custom `post_build` job for PDFs on RTD --- .readthedocs.yaml | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/.readthedocs.yaml b/.readthedocs.yaml index d97966ee38..48a5b24743 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -11,8 +11,9 @@ sphinx: configuration: docs/conf.py fail_on_warning: false +# PDF builds are disabled here because they are built in a custom fashion +# by extending the RTD build process, see below formats: - - pdf - epub - htmlzip @@ -31,6 +32,19 @@ build: jobs: post_checkout: - git fetch --unshallow + # Altered PDF build and upload job, attributed to + # https://stackoverflow.com/a/76992101/14001839 + post_build: + - mkdir --parents $READTHEDOCS_OUTPUT/pdf/ + # Generate LaTeX files in docs/build/ and doctrees in docs/_build/doctrees, skipping notebooks + - python -m sphinx -T -E -b latex -d docs/_build/doctrees -D language=en docs docs/build/ + - cd docs/build/ + - cat latexmkrc + # Map non-zero exit codes to zero + - latexmk -r latexmkrc -pdf -f -dvi- -ps- -jobname=pybamm -interaction=nonstopmode || true + # Check if pybamm.pdf exists + - test -f pybamm.pdf && echo "pybamm.pdf exists. Copying source file to $READTHEDOCS_OUTPUT/pdf/." + - cd ../../ && cp "docs/build/pybamm.pdf" $READTHEDOCS_OUTPUT/pdf/ # Optionally declare the Python requirements required to build your docs python: From e3933c05aca77958d31c2ec9fd99b69139505982 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 28 Aug 2023 22:38:57 +0530 Subject: [PATCH 122/129] Revert "Fix undefined module LaTeX warning" This reverts commit cf1b276ab44cb08f890e602f495c7719b9c8ccf4. --- docs/source/api/index.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/source/api/index.rst b/docs/source/api/index.rst index 5c385ee2e5..432461a58e 100644 --- a/docs/source/api/index.rst +++ b/docs/source/api/index.rst @@ -1,3 +1,5 @@ +.. module:: pybamm + .. _api_docs: ################# From b5d3cc29e94c3f120c6b5fc3bf796a2fe5a9ae84 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 28 Aug 2023 22:41:29 +0530 Subject: [PATCH 123/129] Revert latex changes for extensions --- docs/sphinxext/extend_parent.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/docs/sphinxext/extend_parent.py b/docs/sphinxext/extend_parent.py index 54985109cb..25978fe804 100644 --- a/docs/sphinxext/extend_parent.py +++ b/docs/sphinxext/extend_parent.py @@ -20,9 +20,7 @@ def process_docstring(app, what, name, obj, options, lines): # get the base class name base_cls_name = f"{getmro(obj)[1].__module__}.{getmro(obj)[1].__name__}" # add the extends keyword to the docstring - lines.append(".. only:: not latex\n") - lines.append("\n") - lines.append(f" **Extends:** :class:`{base_cls_name}`") + lines.append(f"**Extends:** :class:`{base_cls_name}`") def setup(app): From 84a503dfe979826d66aaaa08452b115fbb5256f2 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 28 Aug 2023 22:41:59 +0530 Subject: [PATCH 124/129] Revert "Remove SVG files from LaTeX builds" This reverts commit 2ec97c14f34f0f39d19e648ec9c99658a43b907a. --- docs/index.rst | 103 ++++++++++++++++++++++++------------------------- 1 file changed, 50 insertions(+), 53 deletions(-) diff --git a/docs/index.rst b/docs/index.rst index b2e0073780..3e5d54ecb5 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -38,80 +38,77 @@ Broadly, PyBaMM consists of Together, these enable flexible model definitions and fast battery simulations, allowing users to explore the effect of different battery designs and modeling assumptions under a variety of operating scenarios. -.. SVG images sometimes cause LaTeX build errors -.. only:: not latex +.. grid:: 2 - .. grid:: 2 + .. grid-item-card:: + :img-top: _static/index-images/getting_started.svg - .. grid-item-card:: - :img-top: _static/index-images/getting_started.svg + User Guide + ^^^^^^^^^^ - User Guide - ^^^^^^^^^^ + The user guide is the best place to start learning PyBaMM. It contains an installation + guide, an introduction to the main concepts and links to additional tutorials. - The user guide is the best place to start learning PyBaMM. It contains an installation - guide, an introduction to the main concepts and links to additional tutorials. + +++ - +++ + .. button-ref:: source/user_guide/index + :expand: + :color: secondary + :click-parent: - .. button-ref:: source/user_guide/index - :expand: - :color: secondary - :click-parent: + To the user guide - To the user guide + .. grid-item-card:: + :img-top: _static/index-images/examples.svg - .. grid-item-card:: - :img-top: _static/index-images/examples.svg + Examples + ^^^^^^^^ - Examples - ^^^^^^^^ + Examples and tutorials can be viewed on the GitHub examples page, + which also provides a link to run them online through Google Colab. - Examples and tutorials can be viewed on the GitHub examples page, - which also provides a link to run them online through Google Colab. + +++ - +++ + .. button-ref:: source/examples/index + :expand: + :color: secondary + :click-parent: - .. button-ref:: source/examples/index - :expand: - :color: secondary - :click-parent: + To the examples - To the examples + .. grid-item-card:: + :img-top: _static/index-images/api.svg - .. grid-item-card:: - :img-top: _static/index-images/api.svg + API Documentation + ^^^^^^^^^^^^^^^^^ - API Documentation - ^^^^^^^^^^^^^^^^^ + The reference guide contains a detailed description of the functions, + modules, and objects included in PyBaMM. The reference describes how the + methods work and which parameters can be used. - The reference guide contains a detailed description of the functions, - modules, and objects included in PyBaMM. The reference describes how the - methods work and which parameters can be used. + +++ - +++ + .. button-ref:: source/api/index + :expand: + :color: secondary + :click-parent: - .. button-ref:: source/api/index - :expand: - :color: secondary - :click-parent: + To the API documentation - To the API documentation + .. grid-item-card:: + :img-top: _static/index-images/contributor.svg - .. grid-item-card:: - :img-top: _static/index-images/contributor.svg + Contributor's Guide + ^^^^^^^^^^^^^^^^^^^ - Contributor's Guide - ^^^^^^^^^^^^^^^^^^^ + Contributions to PyBaMM and its development are welcome! If you have ideas for + features, bug fixes, models, spatial methods, or solvers, we would love to hear from you. - Contributions to PyBaMM and its development are welcome! If you have ideas for - features, bug fixes, models, spatial methods, or solvers, we would love to hear from you. + +++ - +++ + .. button-link:: https://github.com/pybamm-team/PyBaMM/blob/develop/CONTRIBUTING.md + :expand: + :color: secondary + :click-parent: - .. button-link:: https://github.com/pybamm-team/PyBaMM/blob/develop/CONTRIBUTING.md - :expand: - :color: secondary - :click-parent: - - To the contributor's guide + To the contributor's guide From ea5ac0c9aebd8a0e8985a95993662075630d8433 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Mon, 28 Aug 2023 22:48:15 +0530 Subject: [PATCH 125/129] Cleanup unneeded docs build job --- .github/workflows/test_on_push.yml | 57 ------------------------------ 1 file changed, 57 deletions(-) diff --git a/.github/workflows/test_on_push.yml b/.github/workflows/test_on_push.yml index 0094fb3427..c1d252841b 100644 --- a/.github/workflows/test_on_push.yml +++ b/.github/workflows/test_on_push.yml @@ -136,60 +136,3 @@ jobs: - name: Install dev dependencies and run example tests for GNU/Linux with Python 3.11 if: matrix.os == 'ubuntu-latest' && matrix.python-version == 3.11 run: nox -s examples - - # temporary job to test building docs on push, besides building locally - build_docs: - needs: style - runs-on: ubuntu-latest - strategy: - fail-fast: false - - steps: - - name: Check out PyBaMM repository - uses: actions/checkout@v3 - - # dot -c is for registering graphviz fonts and plugins - - name: Install Linux system dependencies - run: | - sudo apt-get update - sudo apt-get install gfortran gcc graphviz pandoc libopenblas-dev texlive-latex-extra latexmk dvipng - - - name: Set up Python 3.11 - id: setup-python - uses: actions/setup-python@v4 - with: - python-version: 3.11 - cache: 'pip' - cache-dependency-path: setup.py - - - name: Install PyBaMM dependencies - run: | - pip install --upgrade pip wheel setuptools nox - pip install -e .[all,docs] - - - name: Install SuiteSparse and SUNDIALS on GNU/Linux - run: nox -s pybamm-requires - - - name: Install docs dependencies and run doctests for GNU/Linux with Python 3.11 - run: | - nox -s doctests - rm -rf docs/build/ - - - name: Check if HTML docs can be built - run: | - sphinx-build -j auto docs docs/build/ - rm -rf docs/build/ - - - name: Check if PDF docs can be built - run: | - sphinx-build -T -E -b latex -D language=en docs docs/build - cd docs/build/ - rm -f *.log *.ind *.aux *.toc *.syn *.idx *.out *.ilg *.pla *.ps *.tar *.tar.gz *.tar.bz2 *.tar.xz PyBaMM.pdf PyBaMM.dvi *.fls *.fdb_latexmk - latexmk -r latexmkrc -pdf -f -dvi- -ps- -jobname=pybamm -interaction=nonstopmode || true - test -f pybamm.pdf && echo "pybamm.pdf exists. Copying source file." - - - name: Upload PDF docs - uses: actions/upload-artifact@v2 - with: - name: pybamm-docs - path: docs/build/pybamm.pdf From 737924337b3fda55e4fc356c25d728bbdc16dd0c Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Tue, 29 Aug 2023 14:18:04 +0530 Subject: [PATCH 126/129] Debug file locations --- .readthedocs.yaml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.readthedocs.yaml b/.readthedocs.yaml index 48a5b24743..bf5fe91119 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -35,16 +35,25 @@ build: # Altered PDF build and upload job, attributed to # https://stackoverflow.com/a/76992101/14001839 post_build: + - pwd - mkdir --parents $READTHEDOCS_OUTPUT/pdf/ # Generate LaTeX files in docs/build/ and doctrees in docs/_build/doctrees, skipping notebooks - python -m sphinx -T -E -b latex -d docs/_build/doctrees -D language=en docs docs/build/ + - pwd - cd docs/build/ + - ls - cat latexmkrc + - pwd # Map non-zero exit codes to zero - latexmk -r latexmkrc -pdf -f -dvi- -ps- -jobname=pybamm -interaction=nonstopmode || true + - pwd # Check if pybamm.pdf exists + - pwd - test -f pybamm.pdf && echo "pybamm.pdf exists. Copying source file to $READTHEDOCS_OUTPUT/pdf/." + - pwd - cd ../../ && cp "docs/build/pybamm.pdf" $READTHEDOCS_OUTPUT/pdf/ + - pwd + - ls $READTHEDOCS_OUTPUT/pdf/ # Optionally declare the Python requirements required to build your docs python: From c26fc9fb0e249d76ff5137a64c858913b4829ddc Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Tue, 29 Aug 2023 14:30:40 +0530 Subject: [PATCH 127/129] More debug --- .readthedocs.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.readthedocs.yaml b/.readthedocs.yaml index bf5fe91119..3b6acdb947 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -36,13 +36,13 @@ build: # https://stackoverflow.com/a/76992101/14001839 post_build: - pwd + - ls - mkdir --parents $READTHEDOCS_OUTPUT/pdf/ # Generate LaTeX files in docs/build/ and doctrees in docs/_build/doctrees, skipping notebooks - python -m sphinx -T -E -b latex -d docs/_build/doctrees -D language=en docs docs/build/ - pwd - - cd docs/build/ - ls - - cat latexmkrc + - cd docs/build/ && cat latexmkrc - pwd # Map non-zero exit codes to zero - latexmk -r latexmkrc -pdf -f -dvi- -ps- -jobname=pybamm -interaction=nonstopmode || true From 279cf4af452e5670956f269bce7f2f4601137ba3 Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Tue, 29 Aug 2023 15:02:51 +0530 Subject: [PATCH 128/129] Further debug and copy source files --- .readthedocs.yaml | 17 +++++------------ 1 file changed, 5 insertions(+), 12 deletions(-) diff --git a/.readthedocs.yaml b/.readthedocs.yaml index 3b6acdb947..4fafb6e7aa 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -30,29 +30,22 @@ build: # rust: "1.64" # golang: "1.19" jobs: + # Unshallow the git clone otherwise this may cause issues with Sphinx extensions post_checkout: - git fetch --unshallow # Altered PDF build and upload job, attributed to # https://stackoverflow.com/a/76992101/14001839 post_build: - - pwd - - ls - mkdir --parents $READTHEDOCS_OUTPUT/pdf/ # Generate LaTeX files in docs/build/ and doctrees in docs/_build/doctrees, skipping notebooks - python -m sphinx -T -E -b latex -d docs/_build/doctrees -D language=en docs docs/build/ - - pwd - - ls - cd docs/build/ && cat latexmkrc - - pwd # Map non-zero exit codes to zero - - latexmk -r latexmkrc -pdf -f -dvi- -ps- -jobname=pybamm -interaction=nonstopmode || true - - pwd + - cd docs/build/ && latexmk -r latexmkrc -pdf -f -dvi- -ps- -jobname=pybamm -interaction=nonstopmode || true # Check if pybamm.pdf exists - - pwd - - test -f pybamm.pdf && echo "pybamm.pdf exists. Copying source file to $READTHEDOCS_OUTPUT/pdf/." - - pwd - - cd ../../ && cp "docs/build/pybamm.pdf" $READTHEDOCS_OUTPUT/pdf/ - - pwd + - test -f docs/build/pybamm.pdf && echo "pybamm.pdf exists. Copying source file to $READTHEDOCS_OUTPUT/pdf/." + - ls $READTHEDOCS_OUTPUT/pdf/ + - cp "docs/build/pybamm.pdf" $READTHEDOCS_OUTPUT/pdf/ - ls $READTHEDOCS_OUTPUT/pdf/ # Optionally declare the Python requirements required to build your docs From f5004e6e6257df703808d134b4300b8094b1899a Mon Sep 17 00:00:00 2001 From: Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com> Date: Tue, 29 Aug 2023 15:47:24 +0530 Subject: [PATCH 129/129] Cleanup PDF build job on Read the Docs --- .readthedocs.yaml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/.readthedocs.yaml b/.readthedocs.yaml index 4fafb6e7aa..f907ac23d5 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -35,6 +35,7 @@ build: - git fetch --unshallow # Altered PDF build and upload job, attributed to # https://stackoverflow.com/a/76992101/14001839 + # This also runs on PR builds, but does not upload the PDF post_build: - mkdir --parents $READTHEDOCS_OUTPUT/pdf/ # Generate LaTeX files in docs/build/ and doctrees in docs/_build/doctrees, skipping notebooks @@ -42,11 +43,8 @@ build: - cd docs/build/ && cat latexmkrc # Map non-zero exit codes to zero - cd docs/build/ && latexmk -r latexmkrc -pdf -f -dvi- -ps- -jobname=pybamm -interaction=nonstopmode || true - # Check if pybamm.pdf exists - test -f docs/build/pybamm.pdf && echo "pybamm.pdf exists. Copying source file to $READTHEDOCS_OUTPUT/pdf/." - - ls $READTHEDOCS_OUTPUT/pdf/ - cp "docs/build/pybamm.pdf" $READTHEDOCS_OUTPUT/pdf/ - - ls $READTHEDOCS_OUTPUT/pdf/ # Optionally declare the Python requirements required to build your docs python: