From 3caaa017b681faba25d098ccef590c1aa10b40ad Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Thu, 24 Dec 2020 14:55:53 +0100 Subject: [PATCH 01/13] #1193 update concatenated_initial_conditions when setting new initial conditions --- pybamm/models/base_model.py | 34 +++ tests/unit/test_models/test_base_model.py | 324 ++++++++++++++-------- 2 files changed, 236 insertions(+), 122 deletions(-) diff --git a/pybamm/models/base_model.py b/pybamm/models/base_model.py index f65b74bc43..fa37dbb12f 100644 --- a/pybamm/models/base_model.py +++ b/pybamm/models/base_model.py @@ -117,6 +117,7 @@ def __init__(self, name="Unnamed model"): # Model is not initially discretised self.is_discretised = False + self.y_slices = None # Default timescale is 1 second self.timescale = pybamm.Scalar(1) @@ -327,6 +328,14 @@ def new_empty_copy(self): new_model.convert_to_format = self.convert_to_format new_model.timescale = self.timescale new_model.length_scales = self.length_scales + + # Variables from discretisation + new_model.is_discretised = self.is_discretised + new_model.y_slices = self.y_slices + new_model.concatenated_rhs = self.concatenated_rhs + new_model.concatenated_algebraic = self.concatenated_algebraic + new_model.concatenated_initial_conditions = self.concatenated_initial_conditions + return new_model def new_copy(self): @@ -412,6 +421,31 @@ def set_initial_conditions_from(self, solution, inplace=True): "Variable must have type 'Variable' or 'Concatenation'" ) + # Also update the concatenated initial conditions if the model is already + # discretised + if model.is_discretised: + # Unpack slices for sorting + y_slices = {var.id: slce for var, slce in model.y_slices.items()} + slices = [] + for symbol in model.initial_conditions.keys(): + if isinstance(symbol, pybamm.Concatenation): + # must append the slice for the whole concatenation, so that equations + # get sorted correctly + slices.append( + slice( + y_slices[symbol.children[0].id][0].start, + y_slices[symbol.children[-1].id][0].stop, + ) + ) + else: + slices.append(y_slices[symbol.id][0]) + equations = list(model.initial_conditions.values()) + # sort equations according to slices + sorted_equations = [eq for _, eq in sorted(zip(slices, equations))] + model.concatenated_initial_conditions = pybamm.NumpyConcatenation( + *sorted_equations + ) + return model def check_and_combine_dict(self, dict1, dict2): diff --git a/tests/unit/test_models/test_base_model.py b/tests/unit/test_models/test_base_model.py index 9763b1dc87..6503d6d045 100644 --- a/tests/unit/test_models/test_base_model.py +++ b/tests/unit/test_models/test_base_model.py @@ -8,6 +8,7 @@ import os import subprocess # nosec import platform +from tests import get_discretisation_for_testing class TestBaseModel(unittest.TestCase): @@ -506,123 +507,123 @@ def test_check_well_posedness_output_variables(self): model.initial_conditions[d] = 1 model.check_well_posedness() - def test_export_casadi(self): - model = pybamm.BaseModel() - t = pybamm.t - a = pybamm.Variable("a") - b = pybamm.Variable("b") - p = pybamm.InputParameter("p") - q = pybamm.InputParameter("q") - model.rhs = {a: -a * p} - model.algebraic = {b: a - b} - model.initial_conditions = {a: q, b: 1} - model.variables = {"a+b": a + b - t} - - out = model.export_casadi_objects(["a+b"]) - - # Try making a function from the outputs - t, x, z, p = out["t"], out["x"], out["z"], out["inputs"] - x0, z0 = out["x0"], out["z0"] - rhs, alg = out["rhs"], out["algebraic"] - var = out["variables"]["a+b"] - jac_rhs, jac_alg = out["jac_rhs"], out["jac_algebraic"] - x0_fn = casadi.Function("x0", [p], [x0]) - z0_fn = casadi.Function("x0", [p], [z0]) - rhs_fn = casadi.Function("rhs", [t, x, z, p], [rhs]) - alg_fn = casadi.Function("alg", [t, x, z, p], [alg]) - jac_rhs_fn = casadi.Function("jac_rhs", [t, x, z, p], [jac_rhs]) - jac_alg_fn = casadi.Function("jac_alg", [t, x, z, p], [jac_alg]) - var_fn = casadi.Function("var", [t, x, z, p], [var]) - - # Test that function values are as expected - self.assertEqual(x0_fn([0, 5]), 5) - self.assertEqual(z0_fn([0, 0]), 1) - self.assertEqual(rhs_fn(0, 3, 2, [7, 2]), -21) - self.assertEqual(alg_fn(0, 3, 2, [7, 2]), 1) - np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [8, 9])), [[-8, 0]]) - np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [8, 9])), [[1, -1]]) - self.assertEqual(var_fn(6, 3, 2, [7, 2]), -1) - - # Now change the order of input parameters - out = model.export_casadi_objects(["a+b"], input_parameter_order=["q", "p"]) - - # Try making a function from the outputs - t, x, z, p = out["t"], out["x"], out["z"], out["inputs"] - x0, z0 = out["x0"], out["z0"] - rhs, alg = out["rhs"], out["algebraic"] - var = out["variables"]["a+b"] - jac_rhs, jac_alg = out["jac_rhs"], out["jac_algebraic"] - x0_fn = casadi.Function("x0", [p], [x0]) - z0_fn = casadi.Function("x0", [p], [z0]) - rhs_fn = casadi.Function("rhs", [t, x, z, p], [rhs]) - alg_fn = casadi.Function("alg", [t, x, z, p], [alg]) - jac_rhs_fn = casadi.Function("jac_rhs", [t, x, z, p], [jac_rhs]) - jac_alg_fn = casadi.Function("jac_alg", [t, x, z, p], [jac_alg]) - var_fn = casadi.Function("var", [t, x, z, p], [var]) - - # Test that function values are as expected - self.assertEqual(x0_fn([5, 0]), 5) - self.assertEqual(z0_fn([0, 0]), 1) - self.assertEqual(rhs_fn(0, 3, 2, [2, 7]), -21) - self.assertEqual(alg_fn(0, 3, 2, [2, 7]), 1) - np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [9, 8])), [[-8, 0]]) - np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [9, 8])), [[1, -1]]) - self.assertEqual(var_fn(6, 3, 2, [2, 7]), -1) - - # Test model with external variable runs - model_options = {"thermal": "lumped", "external submodels": ["thermal"]} - model = pybamm.lithium_ion.SPMe(model_options) - sim = pybamm.Simulation(model) - sim.build() - variable_names = ["Volume-averaged cell temperature"] - out = sim.built_model.export_casadi_objects(variable_names) - - # Test fails if not discretised - with self.assertRaisesRegex( - pybamm.DiscretisationError, "Cannot automatically discretise model" - ): - model.export_casadi_objects(["Electrolyte concentration"]) - - @unittest.skipIf(platform.system() == "Windows", "Skipped for Windows") - def test_generate_casadi(self): - model = pybamm.BaseModel() - t = pybamm.t - a = pybamm.Variable("a") - b = pybamm.Variable("b") - p = pybamm.InputParameter("p") - q = pybamm.InputParameter("q") - model.rhs = {a: -a * p} - model.algebraic = {b: a - b} - model.initial_conditions = {a: q, b: 1} - model.variables = {"a+b": a + b - t} - - # Generate C code - model.generate("test.c", ["a+b"]) - - # Compile - subprocess.run(["gcc", "-fPIC", "-shared", "-o", "test.so", "test.c"]) # nosec - - # Read the generated functions - x0_fn = casadi.external("x0", "./test.so") - z0_fn = casadi.external("z0", "./test.so") - rhs_fn = casadi.external("rhs_", "./test.so") - alg_fn = casadi.external("alg_", "./test.so") - jac_rhs_fn = casadi.external("jac_rhs", "./test.so") - jac_alg_fn = casadi.external("jac_alg", "./test.so") - var_fn = casadi.external("variables", "./test.so") - - # Test that function values are as expected - self.assertEqual(x0_fn([0, 5]), 5) - self.assertEqual(z0_fn([0, 0]), 1) - self.assertEqual(rhs_fn(0, 3, 2, [7, 2]), -21) - self.assertEqual(alg_fn(0, 3, 2, [7, 2]), 1) - np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [8, 9])), [[-8, 0]]) - np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [8, 9])), [[1, -1]]) - self.assertEqual(var_fn(6, 3, 2, [7, 2]), -1) - - # Remove generated files. - os.remove("test.c") - os.remove("test.so") + # def test_export_casadi(self): + # model = pybamm.BaseModel() + # t = pybamm.t + # a = pybamm.Variable("a") + # b = pybamm.Variable("b") + # p = pybamm.InputParameter("p") + # q = pybamm.InputParameter("q") + # model.rhs = {a: -a * p} + # model.algebraic = {b: a - b} + # model.initial_conditions = {a: q, b: 1} + # model.variables = {"a+b": a + b - t} + + # out = model.export_casadi_objects(["a+b"]) + + # # Try making a function from the outputs + # t, x, z, p = out["t"], out["x"], out["z"], out["inputs"] + # x0, z0 = out["x0"], out["z0"] + # rhs, alg = out["rhs"], out["algebraic"] + # var = out["variables"]["a+b"] + # jac_rhs, jac_alg = out["jac_rhs"], out["jac_algebraic"] + # x0_fn = casadi.Function("x0", [p], [x0]) + # z0_fn = casadi.Function("x0", [p], [z0]) + # rhs_fn = casadi.Function("rhs", [t, x, z, p], [rhs]) + # alg_fn = casadi.Function("alg", [t, x, z, p], [alg]) + # jac_rhs_fn = casadi.Function("jac_rhs", [t, x, z, p], [jac_rhs]) + # jac_alg_fn = casadi.Function("jac_alg", [t, x, z, p], [jac_alg]) + # var_fn = casadi.Function("var", [t, x, z, p], [var]) + + # # Test that function values are as expected + # self.assertEqual(x0_fn([0, 5]), 5) + # self.assertEqual(z0_fn([0, 0]), 1) + # self.assertEqual(rhs_fn(0, 3, 2, [7, 2]), -21) + # self.assertEqual(alg_fn(0, 3, 2, [7, 2]), 1) + # np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [8, 9])), [[-8, 0]]) + # np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [8, 9])), [[1, -1]]) + # self.assertEqual(var_fn(6, 3, 2, [7, 2]), -1) + + # # Now change the order of input parameters + # out = model.export_casadi_objects(["a+b"], input_parameter_order=["q", "p"]) + + # # Try making a function from the outputs + # t, x, z, p = out["t"], out["x"], out["z"], out["inputs"] + # x0, z0 = out["x0"], out["z0"] + # rhs, alg = out["rhs"], out["algebraic"] + # var = out["variables"]["a+b"] + # jac_rhs, jac_alg = out["jac_rhs"], out["jac_algebraic"] + # x0_fn = casadi.Function("x0", [p], [x0]) + # z0_fn = casadi.Function("x0", [p], [z0]) + # rhs_fn = casadi.Function("rhs", [t, x, z, p], [rhs]) + # alg_fn = casadi.Function("alg", [t, x, z, p], [alg]) + # jac_rhs_fn = casadi.Function("jac_rhs", [t, x, z, p], [jac_rhs]) + # jac_alg_fn = casadi.Function("jac_alg", [t, x, z, p], [jac_alg]) + # var_fn = casadi.Function("var", [t, x, z, p], [var]) + + # # Test that function values are as expected + # self.assertEqual(x0_fn([5, 0]), 5) + # self.assertEqual(z0_fn([0, 0]), 1) + # self.assertEqual(rhs_fn(0, 3, 2, [2, 7]), -21) + # self.assertEqual(alg_fn(0, 3, 2, [2, 7]), 1) + # np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [9, 8])), [[-8, 0]]) + # np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [9, 8])), [[1, -1]]) + # self.assertEqual(var_fn(6, 3, 2, [2, 7]), -1) + + # # Test model with external variable runs + # model_options = {"thermal": "lumped", "external submodels": ["thermal"]} + # model = pybamm.lithium_ion.SPMe(model_options) + # sim = pybamm.Simulation(model) + # sim.build() + # variable_names = ["Volume-averaged cell temperature"] + # out = sim.built_model.export_casadi_objects(variable_names) + + # # Test fails if not discretised + # with self.assertRaisesRegex( + # pybamm.DiscretisationError, "Cannot automatically discretise model" + # ): + # model.export_casadi_objects(["Electrolyte concentration"]) + + # @unittest.skipIf(platform.system() == "Windows", "Skipped for Windows") + # def test_generate_casadi(self): + # model = pybamm.BaseModel() + # t = pybamm.t + # a = pybamm.Variable("a") + # b = pybamm.Variable("b") + # p = pybamm.InputParameter("p") + # q = pybamm.InputParameter("q") + # model.rhs = {a: -a * p} + # model.algebraic = {b: a - b} + # model.initial_conditions = {a: q, b: 1} + # model.variables = {"a+b": a + b - t} + + # # Generate C code + # model.generate("test.c", ["a+b"]) + + # # Compile + # subprocess.run(["gcc", "-fPIC", "-shared", "-o", "test.so", "test.c"]) # nosec + + # # Read the generated functions + # x0_fn = casadi.external("x0", "./test.so") + # z0_fn = casadi.external("z0", "./test.so") + # rhs_fn = casadi.external("rhs_", "./test.so") + # alg_fn = casadi.external("alg_", "./test.so") + # jac_rhs_fn = casadi.external("jac_rhs", "./test.so") + # jac_alg_fn = casadi.external("jac_alg", "./test.so") + # var_fn = casadi.external("variables", "./test.so") + + # # Test that function values are as expected + # self.assertEqual(x0_fn([0, 5]), 5) + # self.assertEqual(z0_fn([0, 0]), 1) + # self.assertEqual(rhs_fn(0, 3, 2, [7, 2]), -21) + # self.assertEqual(alg_fn(0, 3, 2, [7, 2]), 1) + # np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [8, 9])), [[-8, 0]]) + # np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [8, 9])), [[1, -1]]) + # self.assertEqual(var_fn(6, 3, 2, [7, 2]), -1) + + # # Remove generated files. + # os.remove("test.c") + # os.remove("test.so") def test_set_initial_conditions(self): # Set up model @@ -660,7 +661,7 @@ def test_set_initial_conditions(self): self.assertEqual(model.initial_conditions[var_2D].value, 1) self.assertEqual(model.initial_conditions[var_concat].value, 1) - # Update initial conditions + # Discretise var = pybamm.standard_spatial_vars geometry = { "negative electrode": {var.x_n: {"min": 0, "max": 1}}, @@ -690,10 +691,14 @@ def test_set_initial_conditions(self): # model new_model = model.set_initial_conditions_from(sol, inplace=False) # Make sure original model is unchanged - self.assertEqual(model.initial_conditions[var_scalar].value, 1) - self.assertEqual(model.initial_conditions[var_1D].value, 1) - self.assertEqual(model.initial_conditions[var_2D].value, 1) - self.assertEqual(model.initial_conditions[var_concat].value, 1) + np.testing.assert_array_equal( + model.initial_conditions[var_scalar].evaluate(), 1 + ) + np.testing.assert_array_equal(model.initial_conditions[var_1D].evaluate(), 1) + np.testing.assert_array_equal(model.initial_conditions[var_2D].evaluate(), 1) + np.testing.assert_array_equal( + model.initial_conditions[var_concat].evaluate(), 1 + ) # Now update inplace model.set_initial_conditions_from(sol) @@ -719,6 +724,43 @@ def test_set_initial_conditions(self): self.assertEqual(mdl.initial_conditions[var_concat].shape, (20, 1)) np.testing.assert_array_equal(mdl.initial_conditions[var_concat].entries, 3) + # Test updating a discretised model (out-of-place) + new_model_disc = model_disc.set_initial_conditions_from(sol, inplace=False) + + # Test new initial conditions + var_scalar = list(new_model_disc.initial_conditions.keys())[0] + self.assertIsInstance( + new_model_disc.initial_conditions[var_scalar], pybamm.Vector + ) + self.assertEqual(new_model_disc.initial_conditions[var_scalar].entries, 3) + + var_1D = list(new_model_disc.initial_conditions.keys())[1] + self.assertIsInstance(new_model_disc.initial_conditions[var_1D], pybamm.Vector) + self.assertEqual(new_model_disc.initial_conditions[var_1D].shape, (10, 1)) + np.testing.assert_array_equal( + new_model_disc.initial_conditions[var_1D].entries, 3 + ) + + var_2D = list(new_model_disc.initial_conditions.keys())[2] + self.assertIsInstance(new_model_disc.initial_conditions[var_2D], pybamm.Vector) + self.assertEqual(new_model_disc.initial_conditions[var_2D].shape, (50, 1)) + np.testing.assert_array_equal( + new_model_disc.initial_conditions[var_2D].entries, 3 + ) + + var_concat = list(new_model_disc.initial_conditions.keys())[3] + self.assertIsInstance( + new_model_disc.initial_conditions[var_concat], pybamm.Vector + ) + self.assertEqual(new_model_disc.initial_conditions[var_concat].shape, (20, 1)) + np.testing.assert_array_equal( + new_model_disc.initial_conditions[var_concat].entries, 3 + ) + + np.testing.assert_array_equal( + new_model_disc.concatenated_initial_conditions.evaluate(), 3 + ) + # Test updating a new model with a different model new_model = pybamm.BaseModel() new_var_scalar = pybamm.Variable("var_scalar") @@ -818,6 +860,44 @@ def test_set_initial_conditions(self): new_model.initial_conditions[var_concat].entries, 5 ) + # Test updating a discretised model (out-of-place) + model_disc = disc.process_model(model, inplace=False) + new_model_disc = model_disc.set_initial_conditions_from(sol_dict, inplace=False) + + # Test new initial conditions + var_scalar = list(new_model_disc.initial_conditions.keys())[0] + self.assertIsInstance( + new_model_disc.initial_conditions[var_scalar], pybamm.Vector + ) + self.assertEqual(new_model_disc.initial_conditions[var_scalar].entries, 5) + + var_1D = list(new_model_disc.initial_conditions.keys())[1] + self.assertIsInstance(new_model_disc.initial_conditions[var_1D], pybamm.Vector) + self.assertEqual(new_model_disc.initial_conditions[var_1D].shape, (10, 1)) + np.testing.assert_array_equal( + new_model_disc.initial_conditions[var_1D].entries, 5 + ) + + var_2D = list(new_model_disc.initial_conditions.keys())[2] + self.assertIsInstance(new_model_disc.initial_conditions[var_2D], pybamm.Vector) + self.assertEqual(new_model_disc.initial_conditions[var_2D].shape, (50, 1)) + np.testing.assert_array_equal( + new_model_disc.initial_conditions[var_2D].entries, 5 + ) + + var_concat = list(new_model_disc.initial_conditions.keys())[3] + self.assertIsInstance( + new_model_disc.initial_conditions[var_concat], pybamm.Vector + ) + self.assertEqual(new_model_disc.initial_conditions[var_concat].shape, (20, 1)) + np.testing.assert_array_equal( + new_model_disc.initial_conditions[var_concat].entries, 5 + ) + + np.testing.assert_array_equal( + new_model_disc.concatenated_initial_conditions.evaluate(), 5 + ) + def test_set_initial_condition_errors(self): model = pybamm.BaseModel() var = pybamm.Scalar(1) From 1f1f7d6058a28c69bd601a3cd509c192134b2791 Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Sun, 27 Dec 2020 18:01:39 +0100 Subject: [PATCH 02/13] #1221 convert variables to casadi --- examples/scripts/DFN.py | 6 +- .../scripts/experimental_protocols/cccv.py | 6 +- pybamm/models/base_model.py | 5 +- pybamm/solvers/processed_variable.py | 104 +++----- pybamm/solvers/solution.py | 16 +- .../test_function_control.py | 1 - tests/unit/test_models/test_base_model.py | 234 +++++++++--------- 7 files changed, 164 insertions(+), 208 deletions(-) diff --git a/examples/scripts/DFN.py b/examples/scripts/DFN.py index 9c50dbc7ef..5b26d7ab42 100644 --- a/examples/scripts/DFN.py +++ b/examples/scripts/DFN.py @@ -5,11 +5,11 @@ import pybamm import numpy as np -pybamm.set_logging_level("INFO") +pybamm.set_logging_level("DEBUG") # load model -model = pybamm.lithium_ion.DFN() +model = pybamm.lithium_ion.SPMe() # create geometry geometry = model.default_geometry @@ -43,8 +43,8 @@ "Current [A]", "Negative electrode potential [V]", "Electrolyte potential [V]", - "Positive electrode potential [V]", "Terminal voltage [V]", + "Positive electrode potential [V]", ], time_unit="seconds", spatial_unit="um", diff --git a/examples/scripts/experimental_protocols/cccv.py b/examples/scripts/experimental_protocols/cccv.py index f6b98dcb21..26b2327544 100644 --- a/examples/scripts/experimental_protocols/cccv.py +++ b/examples/scripts/experimental_protocols/cccv.py @@ -4,10 +4,10 @@ import pybamm import matplotlib.pyplot as plt -pybamm.set_logging_level("INFO") +pybamm.set_logging_level("DEBUG") experiment = pybamm.Experiment( [ - "Discharge at C/10 for 10 hours or until 3.3 V", + "Discharge at C/1 for 1 hours or until 3.3 V", "Rest for 1 hour", "Charge at 1 A until 4.1 V", "Hold at 4.1 V until 50 mA", @@ -15,7 +15,7 @@ ] * 3 ) -model = pybamm.lithium_ion.DFN() +model = pybamm.lithium_ion.SPM() sim = pybamm.Simulation(model, experiment=experiment, solver=pybamm.CasadiSolver()) sim.solve() diff --git a/pybamm/models/base_model.py b/pybamm/models/base_model.py index fa37dbb12f..8d67b68bb0 100644 --- a/pybamm/models/base_model.py +++ b/pybamm/models/base_model.py @@ -922,10 +922,7 @@ def default_spatial_methods(self): @property def default_solver(self): "Return default solver based on whether model is ODE model or DAE model" - if len(self.algebraic) == 0: - return pybamm.ScipySolver() - else: - return pybamm.CasadiSolver(mode="safe") + return pybamm.CasadiSolver(mode="safe") # helper functions for finding symbols diff --git a/pybamm/solvers/processed_variable.py b/pybamm/solvers/processed_variable.py index ca447f3195..6a4fdbece7 100644 --- a/pybamm/solvers/processed_variable.py +++ b/pybamm/solvers/processed_variable.py @@ -1,6 +1,7 @@ # # Processed Variable class # +import casadi import numbers import numpy as np import pybamm @@ -41,14 +42,12 @@ class ProcessedVariable(object): When evaluated, returns an array of size (m,n) solution : :class:`pybamm.Solution` The solution object to be used to create the processed variables - known_evals : dict - Dictionary of known evaluations, to be used to speed up finding the solution warn : bool, optional Whether to raise warnings when trying to evaluate time and length scales. Default is True. """ - def __init__(self, base_variable, solution, known_evals=None, warn=True): + def __init__(self, base_variable, solution, warn=True): self.base_variable = base_variable self.t_sol = solution.t self.u_sol = solution.y @@ -56,9 +55,24 @@ def __init__(self, base_variable, solution, known_evals=None, warn=True): self.inputs = solution.inputs self.domain = base_variable.domain self.auxiliary_domains = base_variable.auxiliary_domains - self.known_evals = known_evals self.warn = warn + # Convert variable to casadi + t_MX = casadi.MX.sym("t") + y_MX = casadi.MX.sym("y", solution.y.shape[0]) + # Make all inputs symbolic first for converting to casadi + all_inputs_as_MX_dict = {} + for key, value in solution.inputs.items(): + all_inputs_as_MX_dict[key] = casadi.MX.sym("input") + + all_inputs_as_MX = casadi.vertcat(*[p for p in all_inputs_as_MX_dict.values()]) + all_inputs = casadi.vertcat(*[p for p in solution.inputs.values()]) + var = base_variable.to_casadi(t_MX, y_MX, inputs=all_inputs_as_MX_dict) + + self.base_variable_casadi = casadi.Function( + "variable", [t_MX, y_MX, all_inputs_as_MX], [var] + ) + # Set timescale self.timescale = solution.timescale_eval self.t_pts = self.t_sol * self.timescale @@ -68,19 +82,11 @@ def __init__(self, base_variable, solution, known_evals=None, warn=True): self.length_scales = solution.length_scales_eval # Evaluate base variable at initial time - if self.known_evals: - self.base_eval, self.known_evals[solution.t[0]] = base_variable.evaluate( - solution.t[0], - solution.y[:, 0], - inputs={name: inp[:, 0] for name, inp in solution.inputs.items()}, - known_evals=self.known_evals[solution.t[0]], - ) - else: - self.base_eval = base_variable.evaluate( - solution.t[0], - solution.y[:, 0], - inputs={name: inp[:, 0] for name, inp in solution.inputs.items()}, - ) + self.base_eval = self.base_variable_casadi( + solution.t[0], + solution.y[:, 0], + all_inputs, + ).full() # handle 2D (in space) finite element variables differently if ( @@ -128,13 +134,8 @@ def initialise_0D(self): for idx in range(len(self.t_sol)): t = self.t_sol[idx] u = self.u_sol[:, idx] - inputs = {name: inp[:, idx] for name, inp in self.inputs.items()} - if self.known_evals: - entries[idx], self.known_evals[t] = self.base_variable.evaluate( - t, u, inputs=inputs, known_evals=self.known_evals[t] - ) - else: - entries[idx] = self.base_variable.evaluate(t, u, inputs=inputs) + inputs = casadi.vertcat(*[inp[:, idx] for inp in self.inputs.values()]) + entries[idx] = self.base_variable_casadi(t, u, inputs).full()[0, 0] # set up interpolation if len(self.t_sol) == 1: @@ -164,15 +165,8 @@ def initialise_1D(self, fixed_t=False): for idx in range(len(self.t_sol)): t = self.t_sol[idx] u = self.u_sol[:, idx] - inputs = {name: inp[:, idx] for name, inp in self.inputs.items()} - if self.known_evals: - eval_and_known_evals = self.base_variable.evaluate( - t, u, inputs=inputs, known_evals=self.known_evals[t] - ) - entries[:, idx] = eval_and_known_evals[0][:, 0] - self.known_evals[t] = eval_and_known_evals[1] - else: - entries[:, idx] = self.base_variable.evaluate(t, u, inputs=inputs)[:, 0] + inputs = casadi.vertcat(*[inp[:, idx] for inp in self.inputs.values()]) + entries[:, idx] = self.base_variable_casadi(t, u, inputs).full()[:, 0] # Get node and edge values nodes = self.mesh.nodes @@ -274,23 +268,12 @@ def initialise_2D(self): for idx in range(len(self.t_sol)): t = self.t_sol[idx] u = self.u_sol[:, idx] - inputs = {name: inp[:, idx] for name, inp in self.inputs.items()} - if self.known_evals: - eval_and_known_evals = self.base_variable.evaluate( - t, u, inputs=inputs, known_evals=self.known_evals[t] - ) - entries[:, :, idx] = np.reshape( - eval_and_known_evals[0], - [first_dim_size, second_dim_size], - order="F", - ) - self.known_evals[t] = eval_and_known_evals[1] - else: - entries[:, :, idx] = np.reshape( - self.base_variable.evaluate(t, u, inputs=inputs), - [first_dim_size, second_dim_size], - order="F", - ) + inputs = casadi.vertcat(*[inp[:, idx] for inp in self.inputs.values()]) + entries[:, :, idx] = np.reshape( + self.base_variable_casadi(t, u, inputs).full(), + [first_dim_size, second_dim_size], + order="F", + ) # add points outside first dimension domain for extrapolation to # boundaries @@ -427,22 +410,13 @@ def initialise_2D_scikit_fem(self): for idx in range(len(self.t_sol)): t = self.t_sol[idx] u = self.u_sol[:, idx] - inputs = {name: inp[:, idx] for name, inp in self.inputs.items()} + inputs = casadi.vertcat(*[inp[:, idx] for inp in self.inputs.values()]) - if self.known_evals: - eval_and_known_evals = self.base_variable.evaluate( - t, u, inputs=inputs, known_evals=self.known_evals[t] - ) - entries[:, :, idx] = np.reshape( - eval_and_known_evals[0], [len_y, len_z], order="F" - ) - self.known_evals[t] = eval_and_known_evals[1] - else: - entries[:, :, idx] = np.reshape( - self.base_variable.evaluate(t, u, inputs=inputs), - [len_y, len_z], - order="F", - ) + entries[:, :, idx] = np.reshape( + self.base_variable_casadi(t, u, inputs).full(), + [len_y, len_z], + order="F", + ) # assign attributes for reference self.entries = entries diff --git a/pybamm/solvers/solution.py b/pybamm/solvers/solution.py index 3ddbf5514e..84a52e0dbe 100644 --- a/pybamm/solvers/solution.py +++ b/pybamm/solvers/solution.py @@ -67,11 +67,6 @@ def __init__( self._variables = pybamm.FuzzyDict() self.data = pybamm.FuzzyDict() - # initialize empty known evals - self._known_evals = defaultdict(dict) - for time in t: - self._known_evals[time] = {} - @property def t(self): "Times at which the solution is evaluated" @@ -181,13 +176,7 @@ def update(self, variables): # Otherwise a standard ProcessedVariable is ok else: - var = pybamm.ProcessedVariable( - self.model.variables[key], self, self._known_evals - ) - - # Update known_evals in order to process any other variables faster - for t in var.known_evals: - self._known_evals[t].update(var.known_evals[t]) + var = pybamm.ProcessedVariable(self.model.variables[key], self) # Save variable and data self._variables[key] = var @@ -404,9 +393,6 @@ def append(self, solution, start_index=1, create_sub_solutions=False): self._t_event = solution._t_event self._y_event = solution._y_event - # Update known_evals - for t, evals in solution._known_evals.items(): - self._known_evals[t].update(evals) # Recompute existing variables for var in self._variables.keys(): self.update(var) diff --git a/tests/integration/test_models/test_submodels/test_external_circuit/test_function_control.py b/tests/integration/test_models/test_submodels/test_external_circuit/test_function_control.py index 3bc73e97ac..29d388a3c4 100644 --- a/tests/integration/test_models/test_submodels/test_external_circuit/test_function_control.py +++ b/tests/integration/test_models/test_submodels/test_external_circuit/test_function_control.py @@ -23,7 +23,6 @@ def constant_current(variables): # First model: 1A charge params[0]["Current function [A]"] = -1 - params[1]["Current function [A]"] = -1 # set parameters and discretise models for i, model in enumerate(models): diff --git a/tests/unit/test_models/test_base_model.py b/tests/unit/test_models/test_base_model.py index 6503d6d045..ccd729a774 100644 --- a/tests/unit/test_models/test_base_model.py +++ b/tests/unit/test_models/test_base_model.py @@ -507,123 +507,123 @@ def test_check_well_posedness_output_variables(self): model.initial_conditions[d] = 1 model.check_well_posedness() - # def test_export_casadi(self): - # model = pybamm.BaseModel() - # t = pybamm.t - # a = pybamm.Variable("a") - # b = pybamm.Variable("b") - # p = pybamm.InputParameter("p") - # q = pybamm.InputParameter("q") - # model.rhs = {a: -a * p} - # model.algebraic = {b: a - b} - # model.initial_conditions = {a: q, b: 1} - # model.variables = {"a+b": a + b - t} - - # out = model.export_casadi_objects(["a+b"]) - - # # Try making a function from the outputs - # t, x, z, p = out["t"], out["x"], out["z"], out["inputs"] - # x0, z0 = out["x0"], out["z0"] - # rhs, alg = out["rhs"], out["algebraic"] - # var = out["variables"]["a+b"] - # jac_rhs, jac_alg = out["jac_rhs"], out["jac_algebraic"] - # x0_fn = casadi.Function("x0", [p], [x0]) - # z0_fn = casadi.Function("x0", [p], [z0]) - # rhs_fn = casadi.Function("rhs", [t, x, z, p], [rhs]) - # alg_fn = casadi.Function("alg", [t, x, z, p], [alg]) - # jac_rhs_fn = casadi.Function("jac_rhs", [t, x, z, p], [jac_rhs]) - # jac_alg_fn = casadi.Function("jac_alg", [t, x, z, p], [jac_alg]) - # var_fn = casadi.Function("var", [t, x, z, p], [var]) - - # # Test that function values are as expected - # self.assertEqual(x0_fn([0, 5]), 5) - # self.assertEqual(z0_fn([0, 0]), 1) - # self.assertEqual(rhs_fn(0, 3, 2, [7, 2]), -21) - # self.assertEqual(alg_fn(0, 3, 2, [7, 2]), 1) - # np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [8, 9])), [[-8, 0]]) - # np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [8, 9])), [[1, -1]]) - # self.assertEqual(var_fn(6, 3, 2, [7, 2]), -1) - - # # Now change the order of input parameters - # out = model.export_casadi_objects(["a+b"], input_parameter_order=["q", "p"]) - - # # Try making a function from the outputs - # t, x, z, p = out["t"], out["x"], out["z"], out["inputs"] - # x0, z0 = out["x0"], out["z0"] - # rhs, alg = out["rhs"], out["algebraic"] - # var = out["variables"]["a+b"] - # jac_rhs, jac_alg = out["jac_rhs"], out["jac_algebraic"] - # x0_fn = casadi.Function("x0", [p], [x0]) - # z0_fn = casadi.Function("x0", [p], [z0]) - # rhs_fn = casadi.Function("rhs", [t, x, z, p], [rhs]) - # alg_fn = casadi.Function("alg", [t, x, z, p], [alg]) - # jac_rhs_fn = casadi.Function("jac_rhs", [t, x, z, p], [jac_rhs]) - # jac_alg_fn = casadi.Function("jac_alg", [t, x, z, p], [jac_alg]) - # var_fn = casadi.Function("var", [t, x, z, p], [var]) - - # # Test that function values are as expected - # self.assertEqual(x0_fn([5, 0]), 5) - # self.assertEqual(z0_fn([0, 0]), 1) - # self.assertEqual(rhs_fn(0, 3, 2, [2, 7]), -21) - # self.assertEqual(alg_fn(0, 3, 2, [2, 7]), 1) - # np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [9, 8])), [[-8, 0]]) - # np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [9, 8])), [[1, -1]]) - # self.assertEqual(var_fn(6, 3, 2, [2, 7]), -1) - - # # Test model with external variable runs - # model_options = {"thermal": "lumped", "external submodels": ["thermal"]} - # model = pybamm.lithium_ion.SPMe(model_options) - # sim = pybamm.Simulation(model) - # sim.build() - # variable_names = ["Volume-averaged cell temperature"] - # out = sim.built_model.export_casadi_objects(variable_names) - - # # Test fails if not discretised - # with self.assertRaisesRegex( - # pybamm.DiscretisationError, "Cannot automatically discretise model" - # ): - # model.export_casadi_objects(["Electrolyte concentration"]) - - # @unittest.skipIf(platform.system() == "Windows", "Skipped for Windows") - # def test_generate_casadi(self): - # model = pybamm.BaseModel() - # t = pybamm.t - # a = pybamm.Variable("a") - # b = pybamm.Variable("b") - # p = pybamm.InputParameter("p") - # q = pybamm.InputParameter("q") - # model.rhs = {a: -a * p} - # model.algebraic = {b: a - b} - # model.initial_conditions = {a: q, b: 1} - # model.variables = {"a+b": a + b - t} - - # # Generate C code - # model.generate("test.c", ["a+b"]) - - # # Compile - # subprocess.run(["gcc", "-fPIC", "-shared", "-o", "test.so", "test.c"]) # nosec - - # # Read the generated functions - # x0_fn = casadi.external("x0", "./test.so") - # z0_fn = casadi.external("z0", "./test.so") - # rhs_fn = casadi.external("rhs_", "./test.so") - # alg_fn = casadi.external("alg_", "./test.so") - # jac_rhs_fn = casadi.external("jac_rhs", "./test.so") - # jac_alg_fn = casadi.external("jac_alg", "./test.so") - # var_fn = casadi.external("variables", "./test.so") - - # # Test that function values are as expected - # self.assertEqual(x0_fn([0, 5]), 5) - # self.assertEqual(z0_fn([0, 0]), 1) - # self.assertEqual(rhs_fn(0, 3, 2, [7, 2]), -21) - # self.assertEqual(alg_fn(0, 3, 2, [7, 2]), 1) - # np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [8, 9])), [[-8, 0]]) - # np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [8, 9])), [[1, -1]]) - # self.assertEqual(var_fn(6, 3, 2, [7, 2]), -1) - - # # Remove generated files. - # os.remove("test.c") - # os.remove("test.so") + def test_export_casadi(self): + model = pybamm.BaseModel() + t = pybamm.t + a = pybamm.Variable("a") + b = pybamm.Variable("b") + p = pybamm.InputParameter("p") + q = pybamm.InputParameter("q") + model.rhs = {a: -a * p} + model.algebraic = {b: a - b} + model.initial_conditions = {a: q, b: 1} + model.variables = {"a+b": a + b - t} + + out = model.export_casadi_objects(["a+b"]) + + # Try making a function from the outputs + t, x, z, p = out["t"], out["x"], out["z"], out["inputs"] + x0, z0 = out["x0"], out["z0"] + rhs, alg = out["rhs"], out["algebraic"] + var = out["variables"]["a+b"] + jac_rhs, jac_alg = out["jac_rhs"], out["jac_algebraic"] + x0_fn = casadi.Function("x0", [p], [x0]) + z0_fn = casadi.Function("x0", [p], [z0]) + rhs_fn = casadi.Function("rhs", [t, x, z, p], [rhs]) + alg_fn = casadi.Function("alg", [t, x, z, p], [alg]) + jac_rhs_fn = casadi.Function("jac_rhs", [t, x, z, p], [jac_rhs]) + jac_alg_fn = casadi.Function("jac_alg", [t, x, z, p], [jac_alg]) + var_fn = casadi.Function("var", [t, x, z, p], [var]) + + # Test that function values are as expected + self.assertEqual(x0_fn([0, 5]), 5) + self.assertEqual(z0_fn([0, 0]), 1) + self.assertEqual(rhs_fn(0, 3, 2, [7, 2]), -21) + self.assertEqual(alg_fn(0, 3, 2, [7, 2]), 1) + np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [8, 9])), [[-8, 0]]) + np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [8, 9])), [[1, -1]]) + self.assertEqual(var_fn(6, 3, 2, [7, 2]), -1) + + # Now change the order of input parameters + out = model.export_casadi_objects(["a+b"], input_parameter_order=["q", "p"]) + + # Try making a function from the outputs + t, x, z, p = out["t"], out["x"], out["z"], out["inputs"] + x0, z0 = out["x0"], out["z0"] + rhs, alg = out["rhs"], out["algebraic"] + var = out["variables"]["a+b"] + jac_rhs, jac_alg = out["jac_rhs"], out["jac_algebraic"] + x0_fn = casadi.Function("x0", [p], [x0]) + z0_fn = casadi.Function("x0", [p], [z0]) + rhs_fn = casadi.Function("rhs", [t, x, z, p], [rhs]) + alg_fn = casadi.Function("alg", [t, x, z, p], [alg]) + jac_rhs_fn = casadi.Function("jac_rhs", [t, x, z, p], [jac_rhs]) + jac_alg_fn = casadi.Function("jac_alg", [t, x, z, p], [jac_alg]) + var_fn = casadi.Function("var", [t, x, z, p], [var]) + + # Test that function values are as expected + self.assertEqual(x0_fn([5, 0]), 5) + self.assertEqual(z0_fn([0, 0]), 1) + self.assertEqual(rhs_fn(0, 3, 2, [2, 7]), -21) + self.assertEqual(alg_fn(0, 3, 2, [2, 7]), 1) + np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [9, 8])), [[-8, 0]]) + np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [9, 8])), [[1, -1]]) + self.assertEqual(var_fn(6, 3, 2, [2, 7]), -1) + + # Test model with external variable runs + model_options = {"thermal": "lumped", "external submodels": ["thermal"]} + model = pybamm.lithium_ion.SPMe(model_options) + sim = pybamm.Simulation(model) + sim.build() + variable_names = ["Volume-averaged cell temperature"] + out = sim.built_model.export_casadi_objects(variable_names) + + # Test fails if not discretised + with self.assertRaisesRegex( + pybamm.DiscretisationError, "Cannot automatically discretise model" + ): + model.export_casadi_objects(["Electrolyte concentration"]) + + @unittest.skipIf(platform.system() == "Windows", "Skipped for Windows") + def test_generate_casadi(self): + model = pybamm.BaseModel() + t = pybamm.t + a = pybamm.Variable("a") + b = pybamm.Variable("b") + p = pybamm.InputParameter("p") + q = pybamm.InputParameter("q") + model.rhs = {a: -a * p} + model.algebraic = {b: a - b} + model.initial_conditions = {a: q, b: 1} + model.variables = {"a+b": a + b - t} + + # Generate C code + model.generate("test.c", ["a+b"]) + + # Compile + subprocess.run(["gcc", "-fPIC", "-shared", "-o", "test.so", "test.c"]) # nosec + + # Read the generated functions + x0_fn = casadi.external("x0", "./test.so") + z0_fn = casadi.external("z0", "./test.so") + rhs_fn = casadi.external("rhs_", "./test.so") + alg_fn = casadi.external("alg_", "./test.so") + jac_rhs_fn = casadi.external("jac_rhs", "./test.so") + jac_alg_fn = casadi.external("jac_alg", "./test.so") + var_fn = casadi.external("variables", "./test.so") + + # Test that function values are as expected + self.assertEqual(x0_fn([0, 5]), 5) + self.assertEqual(z0_fn([0, 0]), 1) + self.assertEqual(rhs_fn(0, 3, 2, [7, 2]), -21) + self.assertEqual(alg_fn(0, 3, 2, [7, 2]), 1) + np.testing.assert_array_equal(np.array(jac_rhs_fn(5, 6, 7, [8, 9])), [[-8, 0]]) + np.testing.assert_array_equal(np.array(jac_alg_fn(5, 6, 7, [8, 9])), [[1, -1]]) + self.assertEqual(var_fn(6, 3, 2, [7, 2]), -1) + + # Remove generated files. + os.remove("test.c") + os.remove("test.so") def test_set_initial_conditions(self): # Set up model From 65ce7ae96c9abeeab34e88a33da4e64cd6708201 Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Sun, 27 Dec 2020 19:40:07 +0100 Subject: [PATCH 03/13] #1221 convert to casadi inside Solution class --- pybamm/models/base_model.py | 1 + pybamm/solvers/processed_variable.py | 27 +++------- pybamm/solvers/solution.py | 50 +++++++++++++++++-- .../integration/test_solvers/test_solution.py | 9 ---- tests/unit/test_solvers/test_solution.py | 2 +- 5 files changed, 55 insertions(+), 34 deletions(-) diff --git a/pybamm/models/base_model.py b/pybamm/models/base_model.py index 8d67b68bb0..ea297dd4d6 100644 --- a/pybamm/models/base_model.py +++ b/pybamm/models/base_model.py @@ -109,6 +109,7 @@ def __init__(self, name="Unnamed model"): self.external_variables = [] self._parameters = None self._input_parameters = None + self._variables_casadi = {} # Default behaviour is to use the jacobian and simplify self.use_jacobian = True diff --git a/pybamm/solvers/processed_variable.py b/pybamm/solvers/processed_variable.py index 6a4fdbece7..5b7a86aee9 100644 --- a/pybamm/solvers/processed_variable.py +++ b/pybamm/solvers/processed_variable.py @@ -40,6 +40,9 @@ class ProcessedVariable(object): variable. Note that this can be any kind of node in the expression tree, not just a :class:`pybamm.Variable`. When evaluated, returns an array of size (m,n) + base_variable_casadi : :class:`casadi.Function` + A casadi function. When evaluated, returns the same thing as + `base_Variable.evaluate` (but more efficiently). solution : :class:`pybamm.Solution` The solution object to be used to create the processed variables warn : bool, optional @@ -47,8 +50,9 @@ class ProcessedVariable(object): Default is True. """ - def __init__(self, base_variable, solution, warn=True): + def __init__(self, base_variable, base_variable_casadi, solution, warn=True): self.base_variable = base_variable + self.base_variable_casadi = base_variable_casadi self.t_sol = solution.t self.u_sol = solution.y self.mesh = base_variable.mesh @@ -57,22 +61,6 @@ def __init__(self, base_variable, solution, warn=True): self.auxiliary_domains = base_variable.auxiliary_domains self.warn = warn - # Convert variable to casadi - t_MX = casadi.MX.sym("t") - y_MX = casadi.MX.sym("y", solution.y.shape[0]) - # Make all inputs symbolic first for converting to casadi - all_inputs_as_MX_dict = {} - for key, value in solution.inputs.items(): - all_inputs_as_MX_dict[key] = casadi.MX.sym("input") - - all_inputs_as_MX = casadi.vertcat(*[p for p in all_inputs_as_MX_dict.values()]) - all_inputs = casadi.vertcat(*[p for p in solution.inputs.values()]) - var = base_variable.to_casadi(t_MX, y_MX, inputs=all_inputs_as_MX_dict) - - self.base_variable_casadi = casadi.Function( - "variable", [t_MX, y_MX, all_inputs_as_MX], [var] - ) - # Set timescale self.timescale = solution.timescale_eval self.t_pts = self.t_sol * self.timescale @@ -82,10 +70,9 @@ def __init__(self, base_variable, solution, warn=True): self.length_scales = solution.length_scales_eval # Evaluate base variable at initial time + inputs = casadi.vertcat(*[inp[:, 0] for inp in self.inputs.values()]) self.base_eval = self.base_variable_casadi( - solution.t[0], - solution.y[:, 0], - all_inputs, + solution.t[0], solution.y[:, 0], inputs ).full() # handle 2D (in space) finite element variables differently diff --git a/pybamm/solvers/solution.py b/pybamm/solvers/solution.py index 84a52e0dbe..200b58d6b8 100644 --- a/pybamm/solvers/solution.py +++ b/pybamm/solvers/solution.py @@ -40,10 +40,10 @@ class _BaseSolution(object): def __init__( self, t, y, t_event=None, y_event=None, termination="final time", copy_this=None ): - self._t = t + self.t = t if isinstance(y, casadi.DM): - y = y.full() - self._y = y + yå = y.full() + self.y = y self._t_event = t_event self._y_event = y_event self._termination = termination @@ -72,11 +72,21 @@ def t(self): "Times at which the solution is evaluated" return self._t + @t.setter + def t(self, t): + self._t = t + self._t_MX = casadi.MX.sym("t") + @property def y(self): "Values of the solution" return self._y + @y.setter + def y(self, y): + self._y = y + self._y_MX = casadi.MX.sym("y", y.shape[0]) + @property def model(self): "Model used for solution" @@ -126,6 +136,13 @@ def inputs(self, inputs): else: inp = np.tile(inp, len(self.t)) self._inputs[name] = inp + self._all_inputs_as_MX_dict = {} + for key, value in self._inputs.items(): + self._all_inputs_as_MX_dict[key] = casadi.MX.sym("input", value.shape[0]) + + self._all_inputs_as_MX = casadi.vertcat( + *[p for p in self._all_inputs_as_MX_dict.values()] + ) @property def t_event(self): @@ -176,7 +193,25 @@ def update(self, variables): # Otherwise a standard ProcessedVariable is ok else: - var = pybamm.ProcessedVariable(self.model.variables[key], self) + var_pybamm = self.model.variables[key] + + if key in self.model._variables_casadi: + var_casadi = self.model._variables_casadi[key] + else: + # Convert variable to casadi + # Make all inputs symbolic first for converting to casadi + var_sym = var_pybamm.to_casadi( + self._t_MX, self._y_MX, inputs=self._all_inputs_as_MX_dict + ) + + var_casadi = casadi.Function( + "variable", + [self._t_MX, self._y_MX, self._all_inputs_as_MX], + [var_sym], + ) + self.model._variables_casadi[key] = var_casadi + + var = pybamm.ProcessedVariable(var_pybamm, var_casadi, self) # Save variable and data self._variables[key] = var @@ -227,6 +262,13 @@ def save(self, filename): """Save the whole solution using pickle""" # No warning here if len(self.data)==0 as solution can be loaded # and used to process new variables + + # Remove casadi objects for pickling, will be computed again automatically + self._t_MX = None + self._y_MX = None + self._all_inputs_as_MX = None + self._all_inputs_as_MX_dict = None + # Pickle with open(filename, "wb") as f: pickle.dump(self, f, pickle.HIGHEST_PROTOCOL) diff --git a/tests/integration/test_solvers/test_solution.py b/tests/integration/test_solvers/test_solution.py index aa3c3caf62..fc92bab4f3 100644 --- a/tests/integration/test_solvers/test_solution.py +++ b/tests/integration/test_solvers/test_solution.py @@ -43,15 +43,6 @@ def test_append(self): step_solution.update("Terminal voltage") old_t = t - # Step solution should have been updated as we go along so be quicker to - # calculate - timer = pybamm.Timer() - step_solution.update("Terminal voltage") - step_sol_time = timer.time() - timer.reset() - solution.update("Terminal voltage") - sol_time = timer.time() - self.assertLess(step_sol_time.value, sol_time.value) # Check both give the same answer np.testing.assert_array_almost_equal( solution["Terminal voltage"](solution.t[:-1] * model.timescale_eval), diff --git a/tests/unit/test_solvers/test_solution.py b/tests/unit/test_solvers/test_solution.py index 2bc57f14c0..a1dc258cd3 100644 --- a/tests/unit/test_solvers/test_solution.py +++ b/tests/unit/test_solvers/test_solution.py @@ -70,7 +70,7 @@ def test_append(self): ) def test_total_time(self): - sol = pybamm.Solution([], None) + sol = pybamm.Solution(np.array([0]), np.array([[1, 2]])) sol.set_up_time = 0.5 sol.solve_time = 1.2 self.assertEqual(sol.total_time, 1.7) From 0d6184b6050aaca8a394c98749657d35e3d70e5c Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Mon, 28 Dec 2020 13:24:59 +0100 Subject: [PATCH 04/13] #1221 fixing tests --- examples/scripts/DFN.py | 8 +- pybamm/simulation.py | 23 ++-- pybamm/solvers/base_solver.py | 2 +- pybamm/solvers/casadi_solver.py | 6 +- pybamm/solvers/processed_symbolic_variable.py | 8 +- pybamm/solvers/solution.py | 28 ++-- .../test_external_current_collector.py | 6 +- tests/unit/test_models/test_base_model.py | 9 +- .../test_lead_acid/test_full.py | 2 +- tests/unit/test_simulation.py | 18 +-- tests/unit/test_solvers/test_base_solver.py | 2 +- .../test_casadi_algebraic_solver.py | 14 +- tests/unit/test_solvers/test_casadi_solver.py | 82 +++++++----- .../test_solvers/test_processed_variable.py | 124 +++++++++++++----- .../unit/test_solvers/test_scikits_solvers.py | 2 +- 15 files changed, 199 insertions(+), 135 deletions(-) diff --git a/examples/scripts/DFN.py b/examples/scripts/DFN.py index 5b26d7ab42..8acb88e1dc 100644 --- a/examples/scripts/DFN.py +++ b/examples/scripts/DFN.py @@ -5,11 +5,11 @@ import pybamm import numpy as np -pybamm.set_logging_level("DEBUG") +pybamm.set_logging_level("INFO") # load model -model = pybamm.lithium_ion.SPMe() +model = pybamm.lithium_ion.DFN() # create geometry geometry = model.default_geometry @@ -30,7 +30,7 @@ # solve model t_eval = np.linspace(0, 3600, 100) -solver = pybamm.CasadiSolver(mode="fast", atol=1e-6, rtol=1e-3) +solver = pybamm.CasadiSolver(mode="safe", atol=1e-6, rtol=1e-3) solution = solver.solve(model, t_eval) # plot @@ -43,8 +43,8 @@ "Current [A]", "Negative electrode potential [V]", "Electrolyte potential [V]", - "Terminal voltage [V]", "Positive electrode potential [V]", + "Terminal voltage [V]", ], time_unit="seconds", spatial_unit="um", diff --git a/pybamm/simulation.py b/pybamm/simulation.py index c821b44e80..36d3be5ed9 100644 --- a/pybamm/simulation.py +++ b/pybamm/simulation.py @@ -532,17 +532,16 @@ def get_variable_array(self, *variables): arrays. """ - variable_arrays = [ - self.built_model.variables[var].evaluate( - self.solution.t[-1], self.solution.y[:, -1] - ) - for var in variables - ] - - if len(variable_arrays) == 1: - return variable_arrays[0] - else: - return tuple(variable_arrays) + variable_arrays = {} + for var in variables: + processed_var = self.solution[var].data + if processed_var.ndim == 1: + variable_arrays[var] = processed_var[-1] + elif processed_var.ndim == 2: + variable_arrays[var] = processed_var[:, -1] + elif processed_var.ndim == 3: + variable_arrays[var] = processed_var[:, :, -1] + return variable_arrays def plot(self, output_variables=None, quick_plot_vars=None, **kwargs): """ @@ -693,6 +692,8 @@ def save(self, filename): and self._solver.integrator_specs != {} ): self._solver.integrator_specs = {} + if self.solution is not None: + self.solution.clear_casadi_attributes() with open(filename, "wb") as f: pickle.dump(self, f, pickle.HIGHEST_PROTOCOL) diff --git a/pybamm/solvers/base_solver.py b/pybamm/solvers/base_solver.py index 60533452f3..3a6d8175a5 100644 --- a/pybamm/solvers/base_solver.py +++ b/pybamm/solvers/base_solver.py @@ -942,7 +942,7 @@ def __init__(self, function, name, model): self.timescale = self.model.timescale_eval def __call__(self, t, y, inputs): - y = y.reshape(-1, 1) + # y = y.reshape(-1, 1) if self.name in ["RHS", "algebraic", "residuals"]: pybamm.logger.debug( "Evaluating {} for {} at t={}".format( diff --git a/pybamm/solvers/casadi_solver.py b/pybamm/solvers/casadi_solver.py index d05e6283f9..ba185cab88 100644 --- a/pybamm/solvers/casadi_solver.py +++ b/pybamm/solvers/casadi_solver.py @@ -133,8 +133,6 @@ def _integrate(self, model, t_eval, inputs=None): return solution elif self.mode in ["safe", "safe without grid"]: y0 = model.y0 - if isinstance(y0, casadi.DM): - y0 = y0.full().flatten() # Step-and-check t = t_eval[0] t_f = t_eval[-1] @@ -151,7 +149,7 @@ def _integrate(self, model, t_eval, inputs=None): # to avoid having to create several times self.create_integrator(model, inputs) # Initialize solution - solution = pybamm.Solution(np.array([t]), y0[:, np.newaxis]) + solution = pybamm.Solution(np.array([t]), y0) solution.solve_time = 0 solution.integration_time = 0 else: @@ -402,7 +400,7 @@ def _run_integrator(self, model, y0, inputs, t_eval): x0=y0_diff, z0=y0_alg, p=inputs, **self.extra_options_call ) integration_time = timer.time() - y_sol = np.concatenate([sol["xf"].full(), sol["zf"].full()]) + y_sol = casadi.vertcat(sol["xf"], sol["zf"]) sol = pybamm.Solution(t_eval, y_sol) sol.integration_time = integration_time return sol diff --git a/pybamm/solvers/processed_symbolic_variable.py b/pybamm/solvers/processed_symbolic_variable.py index f3a18e9ee7..443e39ec0a 100644 --- a/pybamm/solvers/processed_symbolic_variable.py +++ b/pybamm/solvers/processed_symbolic_variable.py @@ -38,7 +38,6 @@ def __init__(self, base_variable, solution): symbolic_inputs_dict[key] = value all_inputs_as_MX = casadi.vertcat(*[p for p in all_inputs_as_MX_dict.values()]) - all_inputs = casadi.vertcat(*[p for p in solution.inputs.values()]) # The symbolic_inputs dictionary will be used for sensitivity symbolic_inputs = casadi.vertcat(*[p for p in symbolic_inputs_dict.values()]) var = base_variable.to_casadi(t_MX, y_MX, inputs=all_inputs_as_MX_dict) @@ -52,10 +51,13 @@ def __init__(self, base_variable, solution): self.mesh = base_variable.mesh self.symbolic_inputs_dict = symbolic_inputs_dict self.symbolic_inputs_total_shape = symbolic_inputs.shape[0] - self.inputs = all_inputs + self.inputs = solution.inputs self.domain = base_variable.domain - self.base_eval = self.base_variable(solution.t[0], solution.y[:, 0], all_inputs) + self.inputs = casadi.vertcat(*[p for p in solution.inputs.values()]) + self.base_eval = self.base_variable( + solution.t[0], solution.y[:, 0], self.inputs + ) if ( isinstance(self.base_eval, numbers.Number) diff --git a/pybamm/solvers/solution.py b/pybamm/solvers/solution.py index 200b58d6b8..e478af0c1a 100644 --- a/pybamm/solvers/solution.py +++ b/pybamm/solvers/solution.py @@ -41,8 +41,6 @@ def __init__( self, t, y, t_event=None, y_event=None, termination="final time", copy_this=None ): self.t = t - if isinstance(y, casadi.DM): - yå = y.full() self.y = y self._t_event = t_event self._y_event = y_event @@ -123,7 +121,13 @@ def inputs(self, inputs): # If there are symbolic inputs, just store them as given if any(isinstance(v, casadi.MX) for v in inputs.values()): self.has_symbolic_inputs = True - self._inputs = inputs + self._inputs = {} + for name, inp in inputs.items(): + if isinstance(inp, numbers.Number): + self._inputs[name] = casadi.DM([inp]) + else: + self._inputs[name] = inp + # Otherwise, make them the same size as the time vector else: self.has_symbolic_inputs = False @@ -258,16 +262,19 @@ def plot(self, output_variables=None, **kwargs): """ return pybamm.dynamic_plot(self, output_variables=output_variables, **kwargs) + def clear_casadi_attributes(self): + "Remove casadi objects for pickling, will be computed again automatically" + self._t_MX = None + self._y_MX = None + self._all_inputs_as_MX = None + self._all_inputs_as_MX_dict = None + def save(self, filename): """Save the whole solution using pickle""" # No warning here if len(self.data)==0 as solution can be loaded # and used to process new variables - # Remove casadi objects for pickling, will be computed again automatically - self._t_MX = None - self._y_MX = None - self._all_inputs_as_MX = None - self._all_inputs_as_MX_dict = None + self.clear_casadi_attributes() # Pickle with open(filename, "wb") as f: pickle.dump(self, f, pickle.HIGHEST_PROTOCOL) @@ -423,7 +430,10 @@ def append(self, solution, start_index=1, create_sub_solutions=False): # Update t, y and inputs self._t = np.concatenate((self._t, solution.t[start_index:])) - self._y = np.concatenate((self._y, solution.y[:, start_index:]), axis=1) + if isinstance(self.y, casadi.DM) and isinstance(solution.y, casadi.DM): + self._y = casadi.horzcat(self.y, solution.y[:, start_index:]) + else: + self._y = np.hstack((self._y, solution.y[:, start_index:])) for name, inp in self.inputs.items(): solution_inp = solution.inputs[name] self.inputs[name] = np.c_[inp, solution_inp[:, start_index:]] diff --git a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_current_collector.py b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_current_collector.py index 08798ca215..577b2bbd15 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_current_collector.py +++ b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_current_collector.py @@ -7,7 +7,6 @@ class TestExternalCC(unittest.TestCase): - @unittest.skipIf(not pybamm.have_idaklu(), "idaklu solver is not installed") def test_2p1d(self): model_options = { "current collector": "potential pair", @@ -25,8 +24,7 @@ def test_2p1d(self): pybamm.standard_spatial_vars.y: yz_pts, pybamm.standard_spatial_vars.z: yz_pts, } - solver = pybamm.IDAKLUSolver() - sim = pybamm.Simulation(model, var_pts=var_pts, solver=solver) + sim = pybamm.Simulation(model, var_pts=var_pts) # Simulate 100 seconds t_eval = np.linspace(0, 100, 3) @@ -45,7 +43,7 @@ def test_2p1d(self): sim.step(dt, external_variables=external_variables) # obtain phi_s_n from the pybamm solution at the current time - phi_s_p = sim.get_variable_array("Positive current collector potential") + phi_s_p = sim.solution["Positive current collector potential"].data[:, -1] self.assertTrue(phi_s_p.shape, (yz_pts ** 2, 1)) diff --git a/tests/unit/test_models/test_base_model.py b/tests/unit/test_models/test_base_model.py index ccd729a774..146caf372f 100644 --- a/tests/unit/test_models/test_base_model.py +++ b/tests/unit/test_models/test_base_model.py @@ -686,6 +686,7 @@ def test_set_initial_conditions(self): y = np.tile(3 * t, (1 + 30 + 50, 1)) sol = pybamm.Solution(t, y) sol.model = model_disc + sol.inputs = {} # Update out-of-place first, since otherwise we'll have already modified the # model @@ -935,16 +936,12 @@ def test_set_initial_condition_errors(self): class TestStandardBatteryBaseModel(unittest.TestCase): def test_default_solver(self): model = pybamm.BaseBatteryModel() - self.assertIsInstance( - model.default_solver, (pybamm.ScipySolver, pybamm.ScikitsOdeSolver) - ) + self.assertIsInstance(model.default_solver, pybamm.CasadiSolver) # check that default_solver gives you a new solver, not an internal object solver = model.default_solver solver = pybamm.BaseModel() - self.assertIsInstance( - model.default_solver, (pybamm.ScipySolver, pybamm.ScikitsOdeSolver) - ) + self.assertIsInstance(model.default_solver, pybamm.CasadiSolver) self.assertIsInstance(solver, pybamm.BaseModel) # check that adding algebraic variables gives DAE solver diff --git a/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_full.py b/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_full.py index dba32e8355..6dae15249a 100644 --- a/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_full.py +++ b/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_full.py @@ -47,7 +47,7 @@ def test_well_posed_surface_form_differential(self): options = {"side reactions": ["oxygen"], "surface form": "differential"} model = pybamm.lead_acid.Full(options) model.check_well_posedness() - self.assertIsInstance(model.default_solver, pybamm.ScipySolver) + self.assertIsInstance(model.default_solver, pybamm.CasadiSolver) def test_well_posed_surface_form_algebraic(self): options = {"side reactions": ["oxygen"], "surface form": "algebraic"} diff --git a/tests/unit/test_simulation.py b/tests/unit/test_simulation.py index a30c27f3cf..418c5c562b 100644 --- a/tests/unit/test_simulation.py +++ b/tests/unit/test_simulation.py @@ -15,7 +15,7 @@ def test_simple_model(self): param = pybamm.ParameterValues({"a": 1}) sim = pybamm.Simulation(model, parameter_values=param) sol = sim.solve([0, 1]) - np.testing.assert_array_almost_equal(sol.y[0], np.exp(-sol.t), decimal=5) + np.testing.assert_array_almost_equal(sol.y.full()[0], np.exp(-sol.t), decimal=5) def test_basic_ops(self): @@ -145,13 +145,15 @@ def test_get_variable_array(self): sim = pybamm.Simulation(pybamm.lithium_ion.SPM()) sim.solve([0, 600]) - phi_s_n = sim.get_variable_array("Negative electrode potential") + phi_s_n = sim.get_variable_array("Negative electrode potential")[ + "Negative electrode potential" + ] self.assertIsInstance(phi_s_n, np.ndarray) c_s_n_surf, c_e = sim.get_variable_array( "Negative particle surface concentration", "Electrolyte concentration" - ) + ).values() self.assertIsInstance(c_s_n_surf, np.ndarray) self.assertIsInstance(c_e, np.ndarray) @@ -193,18 +195,18 @@ def test_step(self): sim.step(dt) # 1 step stores first two points tau = sim.model.timescale.evaluate() self.assertEqual(sim.solution.t.size, 2) - self.assertEqual(sim.solution.y[0, :].size, 2) + self.assertEqual(sim.solution.y.full()[0, :].size, 2) self.assertEqual(sim.solution.t[0], 0) self.assertEqual(sim.solution.t[1], dt / tau) sim.step(dt) # automatically append the next step self.assertEqual(sim.solution.t.size, 3) - self.assertEqual(sim.solution.y[0, :].size, 3) + self.assertEqual(sim.solution.y.full()[0, :].size, 3) self.assertEqual(sim.solution.t[0], 0) self.assertEqual(sim.solution.t[1], dt / tau) self.assertEqual(sim.solution.t[2], 2 * dt / tau) sim.step(dt, save=False) # now only store the two end step points self.assertEqual(sim.solution.t.size, 2) - self.assertEqual(sim.solution.y[0, :].size, 2) + self.assertEqual(sim.solution.y.full()[0, :].size, 2) self.assertEqual(sim.solution.t[0], 2 * dt / tau) self.assertEqual(sim.solution.t[1], 3 * dt / tau) @@ -227,7 +229,7 @@ def test_step_with_inputs(self): ) # 1 step stores first two points tau = sim.model.timescale.evaluate() self.assertEqual(sim.solution.t.size, 2) - self.assertEqual(sim.solution.y[0, :].size, 2) + self.assertEqual(sim.solution.y.full()[0, :].size, 2) self.assertEqual(sim.solution.t[0], 0) self.assertEqual(sim.solution.t[1], dt / tau) np.testing.assert_array_equal(sim.solution.inputs["Current function [A]"], 1) @@ -235,7 +237,7 @@ def test_step_with_inputs(self): dt, inputs={"Current function [A]": 2} ) # automatically append the next step self.assertEqual(sim.solution.t.size, 3) - self.assertEqual(sim.solution.y[0, :].size, 3) + self.assertEqual(sim.solution.y.full()[0, :].size, 3) self.assertEqual(sim.solution.t[0], 0) self.assertEqual(sim.solution.t[1], dt / tau) self.assertEqual(sim.solution.t[2], 2 * dt / tau) diff --git a/tests/unit/test_solvers/test_base_solver.py b/tests/unit/test_solvers/test_base_solver.py index c12f7bf6c3..123337ee74 100644 --- a/tests/unit/test_solvers/test_base_solver.py +++ b/tests/unit/test_solvers/test_base_solver.py @@ -166,7 +166,7 @@ def algebraic_eval(self, t, y, inputs): np.testing.assert_array_almost_equal(init_cond, vec) # with casadi init_cond = solver_with_casadi.calculate_consistent_state(model) - np.testing.assert_array_almost_equal(init_cond, vec) + np.testing.assert_array_almost_equal(init_cond.full().flatten(), vec) # With jacobian def jac_dense(t, y, inputs): diff --git a/tests/unit/test_solvers/test_casadi_algebraic_solver.py b/tests/unit/test_solvers/test_casadi_algebraic_solver.py index 862ea298ca..9d60a8d164 100644 --- a/tests/unit/test_solvers/test_casadi_algebraic_solver.py +++ b/tests/unit/test_solvers/test_casadi_algebraic_solver.py @@ -96,14 +96,8 @@ def test_model_solver_with_time(self): sol = np.vstack((3 * t_eval, 6 * t_eval)) np.testing.assert_array_almost_equal(solution.y, sol) - np.testing.assert_array_almost_equal( - model.variables["var1"].evaluate(t=t_eval, y=solution.y).flatten(), - sol[0, :], - ) - np.testing.assert_array_almost_equal( - model.variables["var2"].evaluate(t=t_eval, y=solution.y).flatten(), - sol[1, :], - ) + np.testing.assert_array_almost_equal(solution["var1"].data.flatten(), sol[0, :]) + np.testing.assert_array_almost_equal(solution["var2"].data.flatten(), sol[1, :]) def test_model_solver_with_time_not_changing(self): # Create model @@ -137,9 +131,7 @@ def test_model_solver_with_bounds(self): # Solve solver = pybamm.CasadiAlgebraicSolver(tol=1e-12) solution = solver.solve(model) - np.testing.assert_array_almost_equal( - model.variables["var1"].evaluate(t=None, y=solution.y), 3 * np.pi / 2 - ) + np.testing.assert_array_almost_equal(solution["var1"].data, 3 * np.pi / 2) def test_solve_with_input(self): # Simple system: a single algebraic equation diff --git a/tests/unit/test_solvers/test_casadi_solver.py b/tests/unit/test_solvers/test_casadi_solver.py index 7b3dd4ced3..5548ac3f8e 100644 --- a/tests/unit/test_solvers/test_casadi_solver.py +++ b/tests/unit/test_solvers/test_casadi_solver.py @@ -31,7 +31,7 @@ def test_model_solver(self): solution = solver.solve(model_disc, t_eval) np.testing.assert_array_equal(solution.t, t_eval) np.testing.assert_array_almost_equal( - solution.y[0], np.exp(0.1 * solution.t), decimal=5 + solution.y.full()[0], np.exp(0.1 * solution.t), decimal=5 ) # Safe mode (enforce events that won't be triggered) @@ -41,7 +41,7 @@ def test_model_solver(self): solution = solver.solve(model, t_eval) np.testing.assert_array_equal(solution.t, t_eval) np.testing.assert_array_almost_equal( - solution.y[0], np.exp(0.1 * solution.t), decimal=5 + solution.y.full()[0], np.exp(0.1 * solution.t), decimal=5 ) # Safe mode, without grid (enforce events that won't be triggered) @@ -49,7 +49,7 @@ def test_model_solver(self): solution = solver.solve(model, t_eval) np.testing.assert_array_equal(solution.t, t_eval) np.testing.assert_array_almost_equal( - solution.y[0], np.exp(0.1 * solution.t), decimal=5 + solution.y.full()[0], np.exp(0.1 * solution.t), decimal=5 ) def test_model_solver_python(self): @@ -71,7 +71,7 @@ def test_model_solver_python(self): solution = solver.solve(model, t_eval) np.testing.assert_array_equal(solution.t, t_eval) np.testing.assert_array_almost_equal( - solution.y[0], np.exp(0.1 * solution.t), decimal=5 + solution.y.full()[0], np.exp(0.1 * solution.t), decimal=5 ) pybamm.set_logging_level("WARNING") @@ -121,13 +121,13 @@ def test_model_solver_events(self): solver = pybamm.CasadiSolver(mode="safe", rtol=1e-8, atol=1e-8) t_eval = np.linspace(0, 5, 100) solution = solver.solve(model, t_eval) - np.testing.assert_array_less(solution.y[0], 1.5) - np.testing.assert_array_less(solution.y[-1], 2.5 + 1e-10) + np.testing.assert_array_less(solution.y.full()[0], 1.5) + np.testing.assert_array_less(solution.y.full()[-1], 2.5 + 1e-10) np.testing.assert_array_almost_equal( - solution.y[0], np.exp(0.1 * solution.t), decimal=5 + solution.y.full()[0], np.exp(0.1 * solution.t), decimal=5 ) np.testing.assert_array_almost_equal( - solution.y[-1], 2 * np.exp(0.1 * solution.t), decimal=5 + solution.y.full()[-1], 2 * np.exp(0.1 * solution.t), decimal=5 ) # Solve using "safe" mode with debug off @@ -135,15 +135,15 @@ def test_model_solver_events(self): solver = pybamm.CasadiSolver(mode="safe", rtol=1e-8, atol=1e-8, dt_max=1) t_eval = np.linspace(0, 5, 100) solution = solver.solve(model, t_eval) - np.testing.assert_array_less(solution.y[0], 1.5) - np.testing.assert_array_less(solution.y[-1], 2.5 + 1e-10) + np.testing.assert_array_less(solution.y.full()[0], 1.5) + np.testing.assert_array_less(solution.y.full()[-1], 2.5 + 1e-10) # test the last entry is exactly 2.5 np.testing.assert_array_almost_equal(solution.y[-1, -1], 2.5, decimal=2) np.testing.assert_array_almost_equal( - solution.y[0], np.exp(0.1 * solution.t), decimal=5 + solution.y.full()[0], np.exp(0.1 * solution.t), decimal=5 ) np.testing.assert_array_almost_equal( - solution.y[-1], 2 * np.exp(0.1 * solution.t), decimal=5 + solution.y.full()[-1], 2 * np.exp(0.1 * solution.t), decimal=5 ) pybamm.settings.debug_mode = True @@ -151,13 +151,13 @@ def test_model_solver_events(self): solver = pybamm.CasadiSolver(dt_max=0, rtol=1e-8, atol=1e-8) t_eval = np.linspace(0, 5, 100) solution = solver.solve(model, t_eval) - np.testing.assert_array_less(solution.y[0], 1.5) - np.testing.assert_array_less(solution.y[-1], 2.5) + np.testing.assert_array_less(solution.y.full()[0], 1.5) + np.testing.assert_array_less(solution.y.full()[-1], 2.5) np.testing.assert_array_almost_equal( - solution.y[0], np.exp(0.1 * solution.t), decimal=5 + solution.y.full()[0], np.exp(0.1 * solution.t), decimal=5 ) np.testing.assert_array_almost_equal( - solution.y[-1], 2 * np.exp(0.1 * solution.t), decimal=5 + solution.y.full()[-1], 2 * np.exp(0.1 * solution.t), decimal=5 ) # Test when an event returns nan @@ -173,7 +173,7 @@ def test_model_solver_events(self): disc.process_model(model) solver = pybamm.CasadiSolver(rtol=1e-8, atol=1e-8) solution = solver.solve(model, t_eval) - np.testing.assert_array_less(solution.y[0], 1.02 + 1e-10) + np.testing.assert_array_less(solution.y.full()[0], 1.02 + 1e-10) np.testing.assert_array_almost_equal(solution.y[0, -1], 1.02, decimal=2) def test_model_step(self): @@ -197,7 +197,9 @@ def test_model_step(self): dt = 1 step_sol = solver.step(None, model, dt) np.testing.assert_array_equal(step_sol.t, [0, dt]) - np.testing.assert_array_almost_equal(step_sol.y[0], np.exp(0.1 * step_sol.t)) + np.testing.assert_array_almost_equal( + step_sol.y.full()[0], np.exp(0.1 * step_sol.t) + ) # Step again (return 5 points) step_sol_2 = solver.step(step_sol, model, dt, npts=5) @@ -205,13 +207,13 @@ def test_model_step(self): step_sol_2.t, np.concatenate([np.array([0]), np.linspace(dt, 2 * dt, 5)]) ) np.testing.assert_array_almost_equal( - step_sol_2.y[0], np.exp(0.1 * step_sol_2.t) + step_sol_2.y.full()[0], np.exp(0.1 * step_sol_2.t) ) # Check steps give same solution as solve t_eval = step_sol.t solution = solver.solve(model, t_eval) - np.testing.assert_array_almost_equal(solution.y[0], step_sol.y[0]) + np.testing.assert_array_almost_equal(solution.y.full()[0], step_sol.y.full()[0]) def test_model_step_with_input(self): # Create model @@ -233,7 +235,7 @@ def test_model_step_with_input(self): dt = 0.1 step_sol = solver.step(None, model, dt, npts=5, inputs={"a": 0.1}) np.testing.assert_array_equal(step_sol.t, np.linspace(0, dt, 5)) - np.testing.assert_allclose(step_sol.y[0], np.exp(0.1 * step_sol.t)) + np.testing.assert_allclose(step_sol.y.full()[0], np.exp(0.1 * step_sol.t)) # Step again with different inputs step_sol_2 = solver.step(step_sol, model, dt, npts=5, inputs={"a": -1}) @@ -242,7 +244,7 @@ def test_model_step_with_input(self): step_sol_2["a"].entries, np.array([0.1, 0.1, 0.1, 0.1, 0.1, -1, -1, -1, -1]) ) np.testing.assert_allclose( - step_sol_2.y[0], + step_sol_2.y.full()[0], np.concatenate( [ np.exp(0.1 * step_sol.t[:5]), @@ -275,13 +277,13 @@ def test_model_step_events(self): while time < end_time: step_solution = step_solver.step(step_solution, model, dt=dt, npts=10) time += dt - np.testing.assert_array_less(step_solution.y[0], 1.5) - np.testing.assert_array_less(step_solution.y[-1], 2.5001) + np.testing.assert_array_less(step_solution.y.full()[0], 1.5) + np.testing.assert_array_less(step_solution.y.full()[-1], 2.5001) np.testing.assert_array_almost_equal( - step_solution.y[0], np.exp(0.1 * step_solution.t), decimal=5 + step_solution.y.full()[0], np.exp(0.1 * step_solution.t), decimal=5 ) np.testing.assert_array_almost_equal( - step_solution.y[-1], 2 * np.exp(0.1 * step_solution.t), decimal=4 + step_solution.y.full()[-1], 2 * np.exp(0.1 * step_solution.t), decimal=4 ) def test_model_solver_with_inputs(self): @@ -305,17 +307,23 @@ def test_model_solver_with_inputs(self): t_eval = np.linspace(0, 10, 100) solution = solver.solve(model, t_eval, inputs={"rate": 0.1}) self.assertLess(len(solution.t), len(t_eval)) - np.testing.assert_allclose(solution.y[0], np.exp(-0.1 * solution.t), rtol=1e-04) + np.testing.assert_allclose( + solution.y.full()[0], np.exp(-0.1 * solution.t), rtol=1e-04 + ) # Without grid solver = pybamm.CasadiSolver(mode="safe without grid", rtol=1e-8, atol=1e-8) t_eval = np.linspace(0, 10, 100) solution = solver.solve(model, t_eval, inputs={"rate": 0.1}) self.assertLess(len(solution.t), len(t_eval)) - np.testing.assert_allclose(solution.y[0], np.exp(-0.1 * solution.t), rtol=1e-04) + np.testing.assert_allclose( + solution.y.full()[0], np.exp(-0.1 * solution.t), rtol=1e-04 + ) solution = solver.solve(model, t_eval, inputs={"rate": 1.1}) self.assertLess(len(solution.t), len(t_eval)) - np.testing.assert_allclose(solution.y[0], np.exp(-1.1 * solution.t), rtol=1e-04) + np.testing.assert_allclose( + solution.y.full()[0], np.exp(-1.1 * solution.t), rtol=1e-04 + ) def test_model_solver_dae_inputs_in_initial_conditions(self): # Create model @@ -336,10 +344,10 @@ def test_model_solver_dae_inputs_in_initial_conditions(self): model, t_eval, inputs={"rate": -1, "ic 1": 0.1, "ic 2": 2} ) np.testing.assert_array_almost_equal( - solution.y[0], 0.1 * np.exp(-solution.t), decimal=5 + solution.y.full()[0], 0.1 * np.exp(-solution.t), decimal=5 ) np.testing.assert_array_almost_equal( - solution.y[-1], 0.1 * np.exp(-solution.t), decimal=5 + solution.y.full()[-1], 0.1 * np.exp(-solution.t), decimal=5 ) # Solve again with different initial conditions @@ -347,10 +355,10 @@ def test_model_solver_dae_inputs_in_initial_conditions(self): model, t_eval, inputs={"rate": -0.1, "ic 1": 1, "ic 2": 3} ) np.testing.assert_array_almost_equal( - solution.y[0], 1 * np.exp(-0.1 * solution.t), decimal=5 + solution.y.full()[0], 1 * np.exp(-0.1 * solution.t), decimal=5 ) np.testing.assert_array_almost_equal( - solution.y[-1], 1 * np.exp(-0.1 * solution.t), decimal=5 + solution.y.full()[-1], 1 * np.exp(-0.1 * solution.t), decimal=5 ) def test_model_solver_with_external(self): @@ -375,7 +383,9 @@ def test_model_solver_with_external(self): solver = pybamm.CasadiSolver(rtol=1e-8, atol=1e-8) t_eval = np.linspace(0, 10, 100) solution = solver.solve(model, t_eval, external_variables={"var2": 0.5}) - np.testing.assert_allclose(solution.y[0], 1 - 0.5 * solution.t, rtol=1e-06) + np.testing.assert_allclose( + solution.y.full()[0], 1 - 0.5 * solution.t, rtol=1e-06 + ) def test_model_solver_with_non_identity_mass(self): model = pybamm.BaseModel() @@ -403,8 +413,8 @@ def test_model_solver_with_non_identity_mass(self): t_eval = np.linspace(0, 1, 100) solution = solver.solve(model, t_eval) np.testing.assert_array_equal(solution.t, t_eval) - np.testing.assert_allclose(solution.y[0], np.exp(0.1 * solution.t)) - np.testing.assert_allclose(solution.y[-1], 2 * np.exp(0.1 * solution.t)) + np.testing.assert_allclose(solution.y.full()[0], np.exp(0.1 * solution.t)) + np.testing.assert_allclose(solution.y.full()[-1], 2 * np.exp(0.1 * solution.t)) def test_dae_solver_algebraic_model(self): model = pybamm.BaseModel() diff --git a/tests/unit/test_solvers/test_processed_variable.py b/tests/unit/test_solvers/test_processed_variable.py index 951168b8e6..153d8a092f 100644 --- a/tests/unit/test_solvers/test_processed_variable.py +++ b/tests/unit/test_solvers/test_processed_variable.py @@ -1,6 +1,7 @@ # # Tests for the Processed Variable class # +import casadi import pybamm import tests @@ -8,6 +9,23 @@ import unittest +def to_casadi(var_pybamm, y, inputs=None): + t_MX = casadi.MX.sym("t") + y_MX = casadi.MX.sym("y", y.shape[0]) + + all_inputs_as_MX_dict = {} + inputs = inputs or {} + for key, value in inputs.items(): + all_inputs_as_MX_dict[key] = casadi.MX.sym("input", value.shape[0]) + + all_inputs_as_MX = casadi.vertcat(*[p for p in all_inputs_as_MX_dict.values()]) + + var_sym = var_pybamm.to_casadi(t_MX, y_MX, inputs=all_inputs_as_MX_dict) + + var_casadi = casadi.Function("variable", [t_MX, y_MX, all_inputs_as_MX], [var_sym]) + return var_casadi + + class TestProcessedVariable(unittest.TestCase): def test_processed_variable_0D(self): # without space @@ -17,8 +35,9 @@ def test_processed_variable_0D(self): 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, pybamm.Solution(t_sol, y_sol), warn=False + var, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal(processed_var.entries, t_sol * y_sol[0]) @@ -27,8 +46,9 @@ def test_processed_variable_0D(self): var.mesh = None t_sol = np.array([0]) y_sol = np.array([1])[:, np.newaxis] + var_casadi = to_casadi(var, y_sol) processed_var = pybamm.ProcessedVariable( - var, pybamm.Solution(t_sol, y_sol), warn=False + var, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal(processed_var.entries, y_sol[0]) @@ -47,13 +67,15 @@ def test_processed_variable_1D(self): t_sol = np.linspace(0, 1) y_sol = np.ones_like(x_sol)[:, np.newaxis] * np.linspace(0, 5) + var_casadi = to_casadi(var_sol, y_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal(processed_var.entries, y_sol) np.testing.assert_array_equal(processed_var(t_sol, x_sol), y_sol) + eqn_casadi = to_casadi(eqn_sol, y_sol) processed_eqn = pybamm.ProcessedVariable( - eqn_sol, pybamm.Solution(t_sol, y_sol), warn=False + eqn_sol, eqn_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal( processed_eqn(t_sol, x_sol), t_sol * y_sol + x_sol[:, np.newaxis] @@ -68,8 +90,9 @@ def test_processed_variable_1D(self): # On edges x_s_edge = pybamm.Matrix(disc.mesh["separator"].edges, domain="separator") x_s_edge.mesh = disc.mesh["separator"] + x_s_casadi = to_casadi(x_s_edge, y_sol) processed_x_s_edge = pybamm.ProcessedVariable( - x_s_edge, pybamm.Solution(t_sol, y_sol), warn=False + x_s_edge, x_s_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal( x_s_edge.entries[:, 0], processed_x_s_edge.entries[:, 0] @@ -80,8 +103,9 @@ def test_processed_variable_1D(self): eqn_sol = disc.process_symbol(eqn) t_sol = np.array([0]) y_sol = np.ones_like(x_sol)[:, np.newaxis] + eqn_casadi = to_casadi(eqn_sol, y_sol) processed_eqn2 = pybamm.ProcessedVariable( - eqn_sol, pybamm.Solution(t_sol, y_sol), warn=False + eqn_sol, eqn_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal( processed_eqn2.entries, y_sol + x_sol[:, np.newaxis] @@ -99,9 +123,10 @@ def test_processed_variable_1D_unknown_domain(self): nt = 100 + y_sol = np.zeros((var_pts[x], nt)) solution = pybamm.Solution( np.linspace(0, 1, nt), - np.zeros((var_pts[x], nt)), + y_sol, np.linspace(0, 1, 1), np.zeros((var_pts[x])), "test", @@ -109,7 +134,8 @@ def test_processed_variable_1D_unknown_domain(self): c = pybamm.StateVector(slice(0, var_pts[x]), domain=["SEI layer"]) c.mesh = mesh["SEI layer"] - pybamm.ProcessedVariable(c, solution, warn=False) + c_casadi = to_casadi(c, y_sol) + pybamm.ProcessedVariable(c, c_casadi, solution, warn=False) def test_processed_variable_2D_x_r(self): var = pybamm.Variable( @@ -134,8 +160,9 @@ def test_processed_variable_2D_x_r(self): t_sol = np.linspace(0, 1) y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] * np.linspace(0, 5) + var_casadi = to_casadi(var_sol, y_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal( processed_var.entries, @@ -165,8 +192,9 @@ def test_processed_variable_2D_x_z(self): 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) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal( processed_var.entries, @@ -181,8 +209,9 @@ def test_processed_variable_2D_x_z(self): ) x_s_edge.mesh = disc.mesh["separator"] x_s_edge.secondary_mesh = disc.mesh["current collector"] + x_s_casadi = to_casadi(x_s_edge, y_sol) processed_x_s_edge = pybamm.ProcessedVariable( - x_s_edge, pybamm.Solution(t_sol, y_sol), warn=False + x_s_edge, x_s_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal( x_s_edge.entries.flatten(), processed_x_s_edge.entries[:, :, 0].T.flatten() @@ -211,8 +240,9 @@ def test_processed_variable_2D_space_only(self): t_sol = np.array([0]) y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] + var_casadi = to_casadi(var_sol, y_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal( processed_var.entries, @@ -231,8 +261,9 @@ def test_processed_variable_2D_scikit(self): t_sol = np.linspace(0, 1) u_sol = np.ones(var_sol.shape[0])[:, np.newaxis] * np.linspace(0, 5) + var_casadi = to_casadi(var_sol, u_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, u_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, u_sol), warn=False ) np.testing.assert_array_equal( processed_var.entries, np.reshape(u_sol, [len(y), len(z), len(t_sol)]) @@ -250,8 +281,9 @@ def test_processed_variable_2D_fixed_t_scikit(self): t_sol = np.array([0]) u_sol = np.ones(var_sol.shape[0])[:, np.newaxis] + var_casadi = to_casadi(var_sol, u_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, u_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, u_sol), warn=False ) np.testing.assert_array_equal( processed_var.entries, np.reshape(u_sol, [len(y), len(z), len(t_sol)]) @@ -268,8 +300,9 @@ def test_processed_var_0D_interpolation(self): t_sol = np.linspace(0, 1, 1000) y_sol = np.array([np.linspace(0, 5, 1000)]) + var_casadi = to_casadi(var, y_sol) processed_var = pybamm.ProcessedVariable( - var, pybamm.Solution(t_sol, y_sol), warn=False + var, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) # vector np.testing.assert_array_equal(processed_var(t_sol), y_sol[0]) @@ -277,8 +310,9 @@ def test_processed_var_0D_interpolation(self): np.testing.assert_array_equal(processed_var(0.5), 2.5) np.testing.assert_array_equal(processed_var(0.7), 3.5) + eqn_casadi = to_casadi(eqn, y_sol) processed_eqn = pybamm.ProcessedVariable( - eqn, pybamm.Solution(t_sol, y_sol), warn=False + eqn, eqn_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal(processed_eqn(t_sol), t_sol * y_sol[0]) np.testing.assert_array_almost_equal(processed_eqn(0.5), 0.5 * 2.5) @@ -297,8 +331,9 @@ def test_processed_var_0D_fixed_t_interpolation(self): t_sol = np.array([10]) y_sol = np.array([[100]]) + eqn_casadi = to_casadi(eqn, y_sol) processed_var = pybamm.ProcessedVariable( - eqn, pybamm.Solution(t_sol, y_sol), warn=False + eqn, eqn_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal(processed_var(), 200) @@ -317,8 +352,9 @@ def test_processed_var_1D_interpolation(self): t_sol = np.linspace(0, 1) y_sol = x_sol[:, np.newaxis] * np.linspace(0, 5) + var_casadi = to_casadi(var_sol, y_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) # 2 vectors np.testing.assert_array_almost_equal(processed_var(t_sol, x_sol), y_sol) @@ -333,8 +369,9 @@ def test_processed_var_1D_interpolation(self): np.testing.assert_array_almost_equal( processed_var(0.5, x_sol[-1]), 2.5 * x_sol[-1] ) + eqn_casadi = to_casadi(eqn_sol, y_sol) processed_eqn = pybamm.ProcessedVariable( - eqn_sol, pybamm.Solution(t_sol, y_sol), warn=False + eqn_sol, eqn_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) # 2 vectors np.testing.assert_array_almost_equal( @@ -347,8 +384,11 @@ def test_processed_var_1D_interpolation(self): self.assertEqual(processed_eqn(0.5, x_sol[-1]).shape, (1,)) # test x + x_disc = disc.process_symbol(x) + x_casadi = to_casadi(x_disc, y_sol) + processed_x = pybamm.ProcessedVariable( - disc.process_symbol(x), pybamm.Solution(t_sol, y_sol), warn=False + x_disc, x_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_almost_equal(processed_x(x=x_sol), x_sol[:, np.newaxis]) @@ -357,13 +397,14 @@ def test_processed_var_1D_interpolation(self): disc.mesh["negative particle"].nodes, domain="negative particle" ) r_n.mesh = disc.mesh["negative particle"] + r_n_casadi = to_casadi(r_n, y_sol) processed_r_n = pybamm.ProcessedVariable( - r_n, pybamm.Solution(t_sol, y_sol), warn=False + r_n, r_n_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) np.testing.assert_array_equal(r_n.entries[:, 0], processed_r_n.entries[:, 0]) - # np.testing.assert_array_almost_equal( - # processed_r_n(0, r=np.linspace(0, 1))[:, 0], np.linspace(0, 1) - # ) + np.testing.assert_array_almost_equal( + processed_r_n(0, r=np.linspace(0, 1))[:, 0], np.linspace(0, 1) + ) def test_processed_var_1D_fixed_t_interpolation(self): var = pybamm.Variable("var", domain=["negative electrode", "separator"]) @@ -377,8 +418,9 @@ def test_processed_var_1D_fixed_t_interpolation(self): t_sol = np.array([1]) y_sol = x_sol[:, np.newaxis] + eqn_casadi = to_casadi(eqn_sol, y_sol) processed_var = pybamm.ProcessedVariable( - eqn_sol, pybamm.Solution(t_sol, y_sol), warn=False + eqn_sol, eqn_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) # vector @@ -411,8 +453,9 @@ def test_processed_var_2D_interpolation(self): t_sol = np.linspace(0, 1) y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] * np.linspace(0, 5) + var_casadi = to_casadi(var_sol, y_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) # 3 vectors np.testing.assert_array_equal( @@ -455,8 +498,9 @@ def test_processed_var_2D_interpolation(self): t_sol = np.linspace(0, 1) y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] * np.linspace(0, 5) + var_casadi = to_casadi(var_sol, y_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) # 3 vectors np.testing.assert_array_equal( @@ -486,8 +530,9 @@ def test_processed_var_2D_fixed_t_interpolation(self): t_sol = np.array([0]) y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] + var_casadi = to_casadi(var_sol, y_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) # 2 vectors np.testing.assert_array_equal(processed_var(x=x_sol, r=r_sol).shape, (10, 40)) @@ -511,8 +556,9 @@ def test_processed_var_2D_secondary_broadcast(self): t_sol = np.linspace(0, 1) y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] * np.linspace(0, 5) + var_casadi = to_casadi(var_sol, y_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) # 3 vectors np.testing.assert_array_equal( @@ -546,8 +592,9 @@ def test_processed_var_2D_secondary_broadcast(self): t_sol = np.linspace(0, 1) y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] * np.linspace(0, 5) + var_casadi = to_casadi(var_sol, y_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) # 3 vectors np.testing.assert_array_equal( @@ -566,8 +613,9 @@ def test_processed_var_2D_scikit_interpolation(self): t_sol = np.linspace(0, 1) u_sol = np.ones(var_sol.shape[0])[:, np.newaxis] * np.linspace(0, 5) + var_casadi = to_casadi(var_sol, u_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, u_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, u_sol), warn=False ) # 3 vectors np.testing.assert_array_equal( @@ -606,8 +654,9 @@ def test_processed_var_2D_fixed_t_scikit_interpolation(self): t_sol = np.array([0]) u_sol = np.ones(var_sol.shape[0])[:, np.newaxis] + var_casadi = to_casadi(var_sol, u_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, u_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, u_sol), warn=False ) # 2 vectors np.testing.assert_array_equal(processed_var(y=y_sol, z=z_sol).shape, (15, 15)) @@ -674,8 +723,9 @@ def test_call_failure(self): t_sol = np.linspace(0, 1) y_sol = x_sol[:, np.newaxis] * np.linspace(0, 5) + var_casadi = to_casadi(var_sol, y_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) with self.assertRaisesRegex(ValueError, "x cannot be None"): processed_var(0) @@ -693,8 +743,9 @@ def test_call_failure(self): var_sol = disc.process_symbol(var) y_sol = r_sol[:, np.newaxis] * np.linspace(0, 5) + var_casadi = to_casadi(var_sol, y_sol) processed_var = pybamm.ProcessedVariable( - var_sol, pybamm.Solution(t_sol, y_sol), warn=False + var_sol, var_casadi, pybamm.Solution(t_sol, y_sol), warn=False ) with self.assertRaisesRegex(ValueError, "r cannot be None"): processed_var(0) @@ -717,9 +768,12 @@ def test_3D_raises_error(self): var_sol = disc.process_symbol(var) t_sol = np.array([0, 1, 2]) u_sol = np.ones(var_sol.shape[0] * 3)[:, np.newaxis] + var_casadi = to_casadi(var_sol, u_sol) with self.assertRaisesRegex(NotImplementedError, "Shape not recognized"): - pybamm.ProcessedVariable(var_sol, pybamm.Solution(t_sol, u_sol), warn=False) + pybamm.ProcessedVariable( + var_sol, var_casadi, pybamm.Solution(t_sol, u_sol), warn=False + ) if __name__ == "__main__": diff --git a/tests/unit/test_solvers/test_scikits_solvers.py b/tests/unit/test_solvers/test_scikits_solvers.py index 050805029a..0dd4d95434 100644 --- a/tests/unit/test_solvers/test_scikits_solvers.py +++ b/tests/unit/test_solvers/test_scikits_solvers.py @@ -79,7 +79,7 @@ def test_dae_integrate_bad_ics(self): solver.set_up(model) solver._set_initial_conditions(model, {}, True) # check y0 - np.testing.assert_array_equal(model.y0, [0, 0]) + np.testing.assert_array_equal(model.y0.full().flatten(), [0, 0]) # check dae solutions solution = solver.solve(model, t_eval) np.testing.assert_array_equal(solution.t, t_eval) From 761162bc5130bb508a10dd9610efcdd7ef0630a0 Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Mon, 28 Dec 2020 13:59:03 +0100 Subject: [PATCH 05/13] #1221 flake8 --- pybamm/models/base_model.py | 4 ++-- pybamm/solvers/solution.py | 1 - tests/unit/test_models/test_base_model.py | 1 - 3 files changed, 2 insertions(+), 4 deletions(-) diff --git a/pybamm/models/base_model.py b/pybamm/models/base_model.py index ea297dd4d6..984047ee53 100644 --- a/pybamm/models/base_model.py +++ b/pybamm/models/base_model.py @@ -430,8 +430,8 @@ def set_initial_conditions_from(self, solution, inplace=True): slices = [] for symbol in model.initial_conditions.keys(): if isinstance(symbol, pybamm.Concatenation): - # must append the slice for the whole concatenation, so that equations - # get sorted correctly + # must append the slice for the whole concatenation, so that + # equations get sorted correctly slices.append( slice( y_slices[symbol.children[0].id][0].start, diff --git a/pybamm/solvers/solution.py b/pybamm/solvers/solution.py index e478af0c1a..bdad8a833b 100644 --- a/pybamm/solvers/solution.py +++ b/pybamm/solvers/solution.py @@ -8,7 +8,6 @@ import pickle import pybamm import pandas as pd -from collections import defaultdict from scipy.io import savemat diff --git a/tests/unit/test_models/test_base_model.py b/tests/unit/test_models/test_base_model.py index 146caf372f..3635e8f8ad 100644 --- a/tests/unit/test_models/test_base_model.py +++ b/tests/unit/test_models/test_base_model.py @@ -8,7 +8,6 @@ import os import subprocess # nosec import platform -from tests import get_discretisation_for_testing class TestBaseModel(unittest.TestCase): From 2cf467f934acda6572698f39d477365f5453f9ba Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Mon, 28 Dec 2020 15:08:29 +0100 Subject: [PATCH 06/13] #1221 fix test --- tests/integration/test_solvers/test_external_variables.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tests/integration/test_solvers/test_external_variables.py b/tests/integration/test_solvers/test_external_variables.py index 29ef229f6b..1e301bd1fc 100644 --- a/tests/integration/test_solvers/test_external_variables.py +++ b/tests/integration/test_solvers/test_external_variables.py @@ -46,9 +46,7 @@ def test_external_variables_SPMe(self): sim.step(dt, external_variables=external_variables) var = "Terminal voltage [V]" t = sim.solution.t[-1] - y = sim.solution.y[:, -1] - inputs = external_variables - sim.built_model.variables[var].evaluate(t, y, inputs=inputs) + sim.solution[var].data sim.solution[var](t) # test generate with external variable sim.built_model.generate("test.c", ["Volume-averaged cell temperature"]) From 3cff7354bc9be4a641fe18c60b4c76b8b5365ff6 Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Mon, 28 Dec 2020 18:24:46 +0100 Subject: [PATCH 07/13] #1221 debugging examples --- ...rial 6 - Managing simulation outputs.ipynb | 101 +++++++----- .../notebooks/models/pouch-cell-model.ipynb | 146 +++++++++++------- .../compare_comsol/compare_comsol_DFN.py | 36 +++-- .../scripts/experimental_protocols/cccv.py | 6 +- pybamm/solvers/processed_symbolic_variable.py | 12 +- pybamm/solvers/solution.py | 27 ++-- .../test_solvers/test_processed_variable.py | 10 +- 7 files changed, 194 insertions(+), 144 deletions(-) diff --git a/examples/notebooks/Getting Started/Tutorial 6 - Managing simulation outputs.ipynb b/examples/notebooks/Getting Started/Tutorial 6 - Managing simulation outputs.ipynb index a343548e53..9bb1039b41 100644 --- a/examples/notebooks/Getting Started/Tutorial 6 - Managing simulation outputs.ipynb +++ b/examples/notebooks/Getting Started/Tutorial 6 - Managing simulation outputs.ipynb @@ -22,23 +22,23 @@ "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "\u001b[33mWARNING: You are using pip version 20.2.1; however, version 20.2.4 is available.\n", + "\u001b[33mWARNING: You are using pip version 20.2.4; however, version 20.3.3 is available.\n", "You should consider upgrading via the '/Users/vsulzer/Documents/Energy_storage/PyBaMM/.tox/dev/bin/python -m pip install --upgrade pip' command.\u001b[0m\n", "Note: you may need to restart the kernel to use updated packages.\n" ] }, { - "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ] }, + "execution_count": 1, "metadata": {}, - "execution_count": 1 + "output_type": "execute_result" } ], "source": [ @@ -102,33 +102,33 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ - "array([3.77047806, 3.75305163, 3.74567013, 3.74038819, 3.73581198,\n", - " 3.73153388, 3.72742394, 3.72343938, 3.71956644, 3.71580196,\n", - " 3.71214617, 3.70860034, 3.70516557, 3.70184247, 3.69863116,\n", - " 3.69553115, 3.69254136, 3.6896602 , 3.68688564, 3.68421527,\n", + "array([3.77047806, 3.75305182, 3.74567027, 3.74038822, 3.73581196,\n", + " 3.73153391, 3.72742393, 3.72343929, 3.71956623, 3.71580184,\n", + " 3.71214621, 3.7086004 , 3.70516561, 3.70184253, 3.69863121,\n", + " 3.69553118, 3.69254137, 3.68966018, 3.68688562, 3.68421526,\n", " 3.68164637, 3.67917591, 3.6768006 , 3.67451688, 3.67232094,\n", - " 3.6702087 , 3.66817572, 3.66621717, 3.66432763, 3.66250091,\n", - " 3.66072975, 3.65900537, 3.65731692, 3.65565067, 3.65398896,\n", - " 3.65230898, 3.65058136, 3.6487688 , 3.64682545, 3.64469796,\n", - " 3.64232964, 3.63966968, 3.63668791, 3.63339298, 3.62984705,\n", - " 3.62616685, 3.62250444, 3.61901236, 3.61580864, 3.61295718,\n", - " 3.61046845, 3.60831404, 3.60644483, 3.60480596, 3.60334607,\n", + " 3.67020869, 3.66817572, 3.66621717, 3.66432762, 3.6625009 ,\n", + " 3.66072974, 3.65900536, 3.65731692, 3.65565066, 3.65398895,\n", + " 3.65230898, 3.65058135, 3.6487688 , 3.64682546, 3.64469798,\n", + " 3.64232968, 3.63966973, 3.63668796, 3.63339303, 3.62984711,\n", + " 3.62616692, 3.6225045 , 3.61901241, 3.61580868, 3.6129572 ,\n", + " 3.61046847, 3.60831405, 3.60644483, 3.60480596, 3.60334607,\n", " 3.60202167, 3.60079822, 3.5996495 , 3.59855637, 3.59750531,\n", " 3.59648723, 3.59549638, 3.59452954, 3.59358541, 3.59266405,\n", " 3.59176646, 3.59089417, 3.59004885, 3.58923192, 3.58844407,\n", " 3.58768477, 3.58695179, 3.58624057, 3.58554372, 3.58485045,\n", " 3.58414611, 3.58341187, 3.58262441, 3.58175587, 3.58077378,\n", " 3.57964098, 3.57831538, 3.5767492 , 3.57488745, 3.57266504,\n", - " 3.5700019 , 3.56679523, 3.56290767, 3.5581495 , 3.55225276,\n", - " 3.54483362, 3.53533853, 3.52296795, 3.50656968, 3.48449277,\n", - " 3.45439366, 3.41299183, 3.35578872, 3.27680073, 3.16842637])" + " 3.5700019 , 3.56679523, 3.56290766, 3.5581495 , 3.55225276,\n", + " 3.54483361, 3.53533853, 3.52296795, 3.50656968, 3.48449277,\n", + " 3.45439366, 3.41299182, 3.35578871, 3.27680072, 3.16842636])" ] }, + "execution_count": 4, "metadata": {}, - "execution_count": 4 + "output_type": "execute_result" } ], "source": [ @@ -148,7 +148,6 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "array([ 0. , 36.36363636, 72.72727273, 109.09090909,\n", @@ -178,8 +177,9 @@ " 3490.90909091, 3527.27272727, 3563.63636364, 3600. ])" ] }, + "execution_count": 5, "metadata": {}, - "execution_count": 5 + "output_type": "execute_result" } ], "source": [ @@ -199,14 +199,14 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ - "array([3.72947891, 3.70860034, 3.67810702, 3.65400558])" + "array([3.72947892, 3.7086004 , 3.67810702, 3.65400557])" ] }, + "execution_count": 6, "metadata": {}, - "execution_count": 6 + "output_type": "execute_result" } ], "source": [ @@ -265,16 +265,18 @@ "metadata": {}, "outputs": [ { - "output_type": "display_data", "data": { - "text/plain": "interactive(children=(FloatSlider(value=0.0, description='t', max=1.0, step=0.01), Output()), _dom_classes=('w…", "application/vnd.jupyter.widget-view+json": { + "model_id": "8ceaea70446149079f0194450d7828dc", "version_major": 2, - "version_minor": 0, - "model_id": "0b4ebac3fdd947218f9444b2b381cf04" - } + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.0, description='t', max=1.0, step=0.01), Output()), _dom_classes=('w…" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -311,26 +313,28 @@ "metadata": {}, "outputs": [ { - "output_type": "display_data", "data": { - "text/plain": "interactive(children=(FloatSlider(value=0.0, description='t', max=1.0, step=0.01), Output()), _dom_classes=('w…", "application/vnd.jupyter.widget-view+json": { + "model_id": "9c9e516a7aef46688f03aaea77505636", "version_major": 2, - "version_minor": 0, - "model_id": "f4a1b65b2bf945099197135c5598084b" - } + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.0, description='t', max=1.0, step=0.01), Output()), _dom_classes=('w…" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ] }, + "execution_count": 11, "metadata": {}, - "execution_count": 11 + "output_type": "execute_result" } ], "source": [ @@ -425,9 +429,22 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5-final" + "version": "3.8.6" + }, + "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 } }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} diff --git a/examples/notebooks/models/pouch-cell-model.ipynb b/examples/notebooks/models/pouch-cell-model.ipynb index bd86489183..b0ab318965 100644 --- a/examples/notebooks/models/pouch-cell-model.ipynb +++ b/examples/notebooks/models/pouch-cell-model.ipynb @@ -56,6 +56,8 @@ "name": "stdout", "output_type": "stream", "text": [ + "\u001b[33mWARNING: You are using pip version 20.2.4; however, version 20.3.3 is available.\n", + "You should consider upgrading via the '/Users/vsulzer/Documents/Energy_storage/PyBaMM/.tox/dev/bin/python -m pip install --upgrade pip' command.\u001b[0m\n", "Note: you may need to restart the kernel to use updated packages.\n" ] } @@ -91,8 +93,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/user/Documents/PyBaMM/pybamm/models/full_battery_models/base_battery_model.py:375: UserWarning: 1+1D Thermal models are only valid if both tabs are placed at the top of the cell.\n", - " \"1+1D Thermal models are only valid if both tabs are \"\n" + "/Users/vsulzer/Documents/Energy_storage/PyBaMM/pybamm/models/full_battery_models/base_battery_model.py:434: UserWarning: 1+1D Thermal models are only valid if both tabs are placed at the top of the cell.\n", + " warnings.warn(\n" ] } ], @@ -351,7 +353,8 @@ "comsol_solution = pybamm.Solution(solutions[\"1+1D DFN\"].t, solutions[\"1+1D DFN\"].y)\n", "comsol_model.timescale = simulations[\"1+1D DFN\"].model.timescale\n", "comsol_model.length_scales = simulations[\"1+1D DFN\"].model.length_scales\n", - "comsol_solution.model = comsol_model" + "comsol_solution.model = comsol_model\n", + "comsol_solution.inputs = {}" ] }, { @@ -562,22 +565,73 @@ "and plot the negative current collector potential" ] }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'interp1d' object has no attribute '__name__'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/operations/convert_to_casadi.py\u001b[0m in \u001b[0;36mconvert\u001b[0;34m(self, symbol, t, y, y_dot, inputs)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_casadi_symbols\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 42\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 3707944294786099166", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m comsol_model.variables[\"Terminal voltage [V]\"].to_casadi(\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mcomsol_solution\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_t_MX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcomsol_solution\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_y_MX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m )\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/symbol.py\u001b[0m in \u001b[0;36mto_casadi\u001b[0;34m(self, t, y, y_dot, inputs, casadi_symbols)\u001b[0m\n\u001b[1;32m 994\u001b[0m \u001b[0mSee\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;32mclass\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0mpybamm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCasadiConverter\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 995\u001b[0m \"\"\"\n\u001b[0;32m--> 996\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mpybamm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCasadiConverter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasadi_symbols\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconvert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_dot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 997\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 998\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mnew_copy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/operations/convert_to_casadi.py\u001b[0m in \u001b[0;36mconvert\u001b[0;34m(self, symbol, t, y, y_dot, inputs)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[0;31m# Change inputs to empty dictionary if it's None\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0minputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minputs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m \u001b[0mcasadi_symbol\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_convert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_dot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 46\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_casadi_symbols\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcasadi_symbol\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/operations/convert_to_casadi.py\u001b[0m in \u001b[0;36m_convert\u001b[0;34m(self, symbol, t, y, y_dot, inputs)\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mconverted_children\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 138\u001b[0m )\n\u001b[0;32m--> 139\u001b[0;31m \u001b[0;32melif\u001b[0m \u001b[0msymbol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"elementwise_grad_of_\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 140\u001b[0m \u001b[0mdifferentiating_child_idx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 141\u001b[0m \u001b[0;31m# Create dummy symbolic variables in order to differentiate using CasADi\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'interp1d' object has no attribute '__name__'" + ] + } + ], + "source": [ + "comsol_model.variables[\"Terminal voltage [V]\"].to_casadi(\n", + " comsol_solution._t_MX, comsol_solution._y_MX\n", + ")" + ] + }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "ename": "Exception", + "evalue": "Implicit conversion of symbolic CasADi type to numeric matrix not supported.\nThis may occur when you pass a CasADi object to a numpy function.\nUse an equivalent CasADi function instead of that numpy function.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/operations/convert_to_casadi.py\u001b[0m in \u001b[0;36mconvert\u001b[0;34m(self, symbol, t, y, y_dot, inputs)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_casadi_symbols\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 42\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 2414869232381412254", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/.tox/dev/lib/python3.8/site-packages/casadi/casadi.py\u001b[0m in \u001b[0;36m__array__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 10926\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m> 10927\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10928\u001b[0m \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/.tox/dev/lib/python3.8/site-packages/casadi/casadi.py\u001b[0m in \u001b[0;36m\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 9553\u001b[0m \u001b[0m__swig_getmethods__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_s\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'__swig_getmethods__'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 9554\u001b[0;31m \u001b[0m__getattr__\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0m_swig_getattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mMX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9555\u001b[0m \u001b[0m__repr__\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_swig_repr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/.tox/dev/lib/python3.8/site-packages/casadi/casadi.py\u001b[0m in \u001b[0;36m_swig_getattr\u001b[0;34m(self, class_type, name)\u001b[0m\n\u001b[1;32m 82\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 83\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"'%s' object has no attribute '%s'\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mclass_type\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 84\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'MX' object has no attribute 'full'", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mException\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mvar\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Negative current collector potential [V]\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mcomsol_var_fun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcomsol_solution\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mdfn_var_fun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msolutions\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"1+1D DFN\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mdfncc_var_fun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdfncc_vars\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/solvers/solution.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 243\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 244\u001b[0m \u001b[0;31m# otherwise create it, save it and then return it\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 245\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 246\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_variables\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 247\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/solvers/solution.py\u001b[0m in \u001b[0;36mupdate\u001b[0;34m(self, variables)\u001b[0m\n\u001b[1;32m 205\u001b[0m \u001b[0;31m# Convert variable to casadi\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 206\u001b[0m \u001b[0;31m# Make all inputs symbolic first for converting to casadi\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 207\u001b[0;31m var_sym = var_pybamm.to_casadi(\n\u001b[0m\u001b[1;32m 208\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_t_MX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_y_MX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_symbolic_inputs_dict\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 209\u001b[0m )\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/symbol.py\u001b[0m in \u001b[0;36mto_casadi\u001b[0;34m(self, t, y, y_dot, inputs, casadi_symbols)\u001b[0m\n\u001b[1;32m 994\u001b[0m \u001b[0mSee\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;32mclass\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0mpybamm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCasadiConverter\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 995\u001b[0m \"\"\"\n\u001b[0;32m--> 996\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mpybamm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCasadiConverter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasadi_symbols\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconvert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_dot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 997\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 998\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mnew_copy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/operations/convert_to_casadi.py\u001b[0m in \u001b[0;36mconvert\u001b[0;34m(self, symbol, t, y, y_dot, inputs)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[0;31m# Change inputs to empty dictionary if it's None\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0minputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minputs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m \u001b[0mcasadi_symbol\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_convert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_dot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 46\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_casadi_symbols\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcasadi_symbol\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/operations/convert_to_casadi.py\u001b[0m in \u001b[0;36m_convert\u001b[0;34m(self, symbol, t, y, y_dot, inputs)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0;31m# Other functions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 153\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 154\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0msymbol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_function_evaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconverted_children\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 155\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpybamm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mConcatenation\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 156\u001b[0m converted_children = [\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/functions.py\u001b[0m in \u001b[0;36m_function_evaluate\u001b[0;34m(self, evaluated_children)\u001b[0m\n\u001b[1;32m 196\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 197\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_function_evaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mevaluated_children\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 198\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mevaluated_children\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 199\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 200\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mnew_copy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mmyinterp\u001b[0;34m(t)\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmyinterp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0minterp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minterp1d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcomsol_t\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvariable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkind\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"linear\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnewaxis\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[0;31m# Make sure to use dimensional time\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/.tox/dev/lib/python3.8/site-packages/scipy/interpolate/polyint.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 71\u001b[0m \"\"\"\n\u001b[0;32m---> 72\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_shape\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_prepare_x\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 73\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_evaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_finish_y\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_shape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/.tox/dev/lib/python3.8/site-packages/scipy/interpolate/polyint.py\u001b[0m in \u001b[0;36m_prepare_x\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 82\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_prepare_x\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0;34m\"\"\"Reshape input x array to 1-D\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 84\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_asarray_validated\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcheck_finite\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mas_inexact\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 85\u001b[0m \u001b[0mx_shape\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 86\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_shape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/.tox/dev/lib/python3.8/site-packages/scipy/_lib/_util.py\u001b[0m in \u001b[0;36m_asarray_validated\u001b[0;34m(a, check_finite, sparse_ok, objects_ok, mask_ok, as_inexact)\u001b[0m\n\u001b[1;32m 270\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'masked arrays are not supported'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 271\u001b[0m \u001b[0mtoarray\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray_chkfinite\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcheck_finite\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 272\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtoarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 273\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mobjects_ok\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 274\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'O'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/.tox/dev/lib/python3.8/site-packages/numpy/core/_asarray.py\u001b[0m in \u001b[0;36masarray\u001b[0;34m(a, dtype, order)\u001b[0m\n\u001b[1;32m 81\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 82\u001b[0m \"\"\"\n\u001b[0;32m---> 83\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morder\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morder\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 84\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 85\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/.tox/dev/lib/python3.8/site-packages/casadi/casadi.py\u001b[0m in \u001b[0;36m__array__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 10927\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10928\u001b[0m \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m> 10929\u001b[0;31m raise Exception(\"Implicit conversion of symbolic CasADi type to numeric matrix not supported.\\n\"\n\u001b[0m\u001b[1;32m 10930\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"This may occur when you pass a CasADi object to a numpy function.\\n\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10931\u001b[0m + \"Use an equivalent CasADi function instead of that numpy function.\")\n", + "\u001b[0;31mException\u001b[0m: Implicit conversion of symbolic CasADi type to numeric matrix not supported.\nThis may occur when you pass a CasADi object to a numpy function.\nUse an equivalent CasADi function instead of that numpy function." + ] } ], "source": [ @@ -609,22 +663,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "var = \"Positive current collector potential [V]\"\n", "comsol_var = comsol_solution[var]\n", @@ -673,22 +714,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "var = \"Current collector current density [A.m-2]\"\n", "comsol_var_fun = comsol_solution[var]\n", @@ -725,24 +753,11 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAy8AAAHbCAYAAADCsaUWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeXwU9f348dd7k3CHIwQCAkk4whUkKohorRfWYhVvxaOtSj0qUu+z/tR6tVqvolWKRaz223pUrSJeeNYDUQEFORW5EZD7CoQk+/79MbNhstkku8lsdjd5P32suzPzmfd8dmbCft4zn5kRVcUYY4wxxhhjkl0g0RUwxhhjjDHGmGhY8mKMMcYYY4xJCZa8GGOMMcYYY1KCJS/GGGOMMcaYlGDJizHGGGOMMSYlWPJijDHGGGOMSQnpia6AMcYYY2I3a9aszunp6ZOAQdjBSGNM4xAE5pWVlV00ZMiQHyMVSFjyIiItgbeAY1S1PML0ZsC77vSyhq6fafxEpAPQDjgKeFVVtzTm5Rpj4sfzm3YncLWqnhihzLvAmX79zaenp0/q0qXLgE6dOm0JBAL20DZjTMoLBoOyYcOGgevWrZsEnBSpTCKP1IwBXo6UuACo6l7gPWB0g9bKNCoi8pqI7HRf74dNHgL8DhgFnNEYlmuMSZgxwMtAxN801z+BsT4uc1CnTp22W+JijGksAoGAdurUaRvOGeXIZRqwPuHOA14VkTYi8p6IzBaRb0TkZE+ZV9xyxtSJqo5S1Tbu65hUW66IqIjsEpF7oiz/vojsEZFP6rpMY0ydnAe86n5uKyKvi8hiEfmbiIR+a6cA5/i4zIAlLsaYxsb9d63aHCUhyYvbJayXqi4H9gCnqupBwNHAgyIibtF5wMGJqKNJbSJyvufMxx4RKfcMbxWR5sAs4FHgNeDFJF5ukare4sZfLiLHepZ3tohsEZEjAdxE6bd+fBdjTHTCftMAhuGcXR0I9AZOA3C7izUXkY6JqKcxxjQGiTrzkg1sdT8L8EcRmYtzjUs3IAfA7VK2V0QyE1JLk7JU9enQmQ/gj8BUz5mQ9qpaoqpbVHW5qv7Drz7oDblcETkfeAw4QVX/50f9jTF14v1NA/hCVZe6v2HPAod7pv0I7NeQlTPGmMYkUcnLbqCF+/k8oBMwRFUPANZ7pgE0xzk7Y0xdHQDMaUzLFZFLgQeBn6vq9HgswxgTNe9vGkB4Vy7vcAu3fKOwcuXK9BNPPLFXjx49BhUWFg448sgj+8ydO7f5zJkzWwwfPrxvfn7+oLy8vEHXX39912AwCMAjjzzSUUSGvPLKKxUHJv/5z3+2F5EhTz31VAeAZ599tt2AAQMG9uvXb2Dv3r0L77///uxQ2QceeCC7Z8+ehT179izcf//9B7z99tttQtOGDRvW76OPPmrVgKugSTrzzDPzs7KyigoKCgrjFSctLW1I//79B/bp06ewX79+A2+//fac8vKaLikzdVHTep46dWpmZmbmAf379x/Yv3//gYcddlhfgGuuuWa/li1bHrhmzZqKG3+1atXqwNDn6v5dAJg7d27zI488sk9eXt6ggQMHDvjFL37Ra9WqVTHdQCwhyYt7tDlNRFrg3HXpR1UtFZGjgbxQOffU+kZVLU1EPU2jcQDwdSNa7mU4dzQaoaoz4xDfGBODsN80gGEi0tO91mU08AmA2yW6C7A8IRX1WTAY5KSTTupzxBFH7Fi1atW8+fPnL7z33nvX/PDDDxmnnnpqnxtuuGHd8uXL582bN2/B559/3ua+++7rFJq3oKBg97PPPpsVGn7uueey+vXrtxugpKRErrzyyrypU6d+t3jx4gXz5s1bcNxxx+0AJ6l56qmnOk2fPn3xsmXL5k+YMGHFBRdc0HPlypX26IcGNGbMmI1Tpkz5rrZyU6dOzTz99NPz6xKnefPmwUWLFi1YsmTJ/Pfff//bd955p911111nZy19Vtt6Hjp06M5FixYtWLRo0YLp06d/Gxrfvn37srvvvjsnPF5N/y4UFxfLqFGjCi699NINK1asmLdgwYKFY8eO3bBu3brkT15c03BOpf8LGCoi3wC/BhZ5yhwNvJ6AuplGQkTaAvk0cPIS5+X+DJgBfBOH2MaYugn9pgF8CfwVWAgsA/7rjh8CzEjU7f8nTpyYVVBQUJiWljakoKCgcOLEiVm1z1W9qVOnZqanp+sNN9ywITTu0EMP3b1w4cIWQ4cO3XnaaadtB8jMzAxOmDBh5fjx47uGyh1yyCE7v/rqq9YlJSWybdu2wPLly5sXFhYWA2zdujVQVlYmOTk5ZQAtW7bUoqKiEoAHHnigy5/+9KfVXbt2LQM4/PDDi88666xNDz74YOf6fBcTm+OPP35np06d6r0fRxunW7duZZMmTVr+1FNPdQ6dwTP+i2U9n3POOZumTJmStX79+jTv+Or+XRg5cuTOJ554Iuuggw7aee65524LTTvxxBN3HHzwwTH1sEpk8vIYcL6qblTVQ1V1f1W9UFUHeC56PBeYmLgqmkagCNiB04CImYh86N7xK9Krpjt61Wu5tbgM6AtM8tzcwhiTWKHftA9V9QhVPUFV+6nqb1U11Ar4FfB4Iio3ceLErLvuuqvbQw89tLK4uHj2Qw89tPKuu+7qVp8EZu7cuS2LioqKw8fPnz+/xUEHHVRpfGFhYUlxcXFg8+bNAQAR4Ygjjtj+8ssvt/33v//dfuTIkRXXDOXk5JT/7Gc/25qbmzt41KhRPSdMmJAV6sayZMmSlj/5yU8qxT744IOLFy5c2LKu38OkhoEDB+4tLy/H21XJ+C98Pc+cObNNqNvYjTfe2CVUrk2bNuXnnHPOxnvvvbfS2Zfq/l0AmDdvXsvwfxvqImE7gKrOFpEPRCSthodUvqKq30aY3ZhoHQDMVdU63U5UVY/yc7kich9wGE63kTF17BK5HhgB/A+nIXRZHetojPFJbb9prnmq+l6DVsz1wAMPdJ0wYcLyUaNG7QBw35dfc801uZdeeunmRNTpvPPO2/yXv/wlZ8eOHWl/+ctfVt1xxx0VZ2aef/75FV988cWPb775ZuYjjzzS5d1332370ksvLU9EPZPVmDFjesybN8/X63sGDRpUPHny5FX1jTN48OD+e/fuDRQXFwe2bduW3r9//4EA99xzz+rTTz99e/1r2jgNGzas3y9/+cuNV1xxxaaSkhL56U9/2veCCy7YMHbs2M07duwIjBgxouDiiy/+8eKLL96yadOmtOOPP77P5Zdfvv7888/funbt2vSTTz6591VXXbXu3HPP3bZy5cr03Nzcep8dGzp06M4PPvhgSaRpN910049FRUUDb7vttnX1XU4sEnnmBVWdXNNDKlX1mYauk2l0kuZ6FxEpArqp6k9xukfW+QGVqvoDTgIzUkQerk9FjTH+qOk3zZ3+94asj9fSpUtbHHfccTu944477ridS5cubVHdPLXZf//9d8+ZM6dK43ngwIF7Zs+eXWn8ggULmrVq1SqYlZVV0Rfl6KOPLl60aFHLzZs3pw8ePLgkPM6wYcN233777T++//7737711lsdAPr06bP7008/rRR75syZrQYMGNBoboLQGMydO3fRokWLFjz++OMrjj322K2haybqk7gsWLCgWVpaGt26dUtIt8umIpb1nJ2dXX7qqaduvv/++yu6bVb37wJAYWFhlX8b6sJOvZnGrgiYkCTLPQynXzzAW8CFOLdRrRNVXSkixwAficgeVb25rrGMMY1br1699kybNq1N6MwLwLRp09r06tWrznfzHDVq1I5bb71VHnjggezrrrtuI8Dnn3/ecuDAgXseeuihrq+88krmKaecsmPnzp1y+eWX5/7ud7+rcnT2rrvuWt2yZctKZ6i3bdsW+Pjjj1ufeOKJO0Ix99tvv70A11xzzbrf//733YcNG/Ztly5dyqdPn97y+eef7zhjxoxF4bEbOz/OkKSKH374If3iiy/Ou/DCC38MBBJ63D2uvvjii8Whz82bN1fvcGZmZtA73LFjx3LvcNeuXcu8w3U561KX9XzLLbesHzp06IDy8nKB6v9d2LJlS9rFF1+86eGHH+7y3HPPtTv77LO3Abz55pttsrOzy2K57sWSF9OoqerQJFpuB2Ct+3kbEE1f8xJglog8oqq3qmp+2HKWAT1CwyLyDjAc+KIu9TbGNE7XXXfd2ssuuywfWH7cccftnDZtWpvLLrss/9Zbb11T15iBQIApU6Z8P3bs2B7jx4/v0rx5c+3evXvJo48+uurll19eMm7cuNyrrroqIxgMcuaZZ266+eabfwyPcdZZZ1U5Eh8MBrn//vtzxo0bl9eiRYtgq1atgk8++eQygPPOO2/b6tWrmw0fPnyAiGjr1q2DkydPXpaXl1fRBffUU08tSE9PV4CDDjpo55tvvrm0rt/RRDZq1KieM2bMyNyyZUt6Tk7O4JtuuumHq6++eqOfcUpKSgL9+/cfWFZWJmlpaTp69OhNt99++3r/v03TVt/13LVr17Ljjz9+y5NPPpkDNf+70KZNG3311VeXXHHFFT1uvPHGHunp6TpgwIDdEyZMWBlLnaWOlwIYY2IkImOBnar6jIgMAS5U1XGJrpcxJjXNmTNneVFRUdQNxokTJ2Y98MADXZcuXdqiV69ee6677rq1ibrexRhjajJnzpzsoqKi/EjT7MyLMQ1nOnAN8Azwc+DTxFbHGNOUXHrppZstWTHGpLrG23HQmCSjql8D60XkY6AQeCnBVTLGGGOMSSl25sWYBqSq1ye6DsYYY4wxqcrOvBhjjDGpKRgMBu1BtcaYRsX9dy1Y3XRLXowxxpjUNG/Dhg3tLIExxjQWwWBQNmzY0A6YV10Z6zZmjDHGpKCysrKL1q1bN2ndunWDsIORxpjGIQjMKysru6i6AnarZGOMMcYYY0xKsCM1xhhjjDHGmJRgyYsxxhhjjDEmJVjyYowxxhhjjEkJlrwYY4wxxhhjUoIlL8YYY4wxxpiUYMlLnInISBFZLCJLROSmCNOvEZEFIjJXRN4TkTzPtHIR+dp9TUlA3S4QkQ2eOlzkmXa+iHznvs5v4Ho97KnTtyKy1TMtbutMRCaLyI8iEvHe4+J4xK33XBE5yDMtnuurtnqd59bnGxGZLiJFnmnL3fFfi8hMP+sVZd2OEpFtnm12m2dajftBnOt1vadO89z9KsudFrd1JiI9ROQD99+E+SJyZYQyCdnPjDHGmKSgqvaK0wtIA74HegHNgDnAwLAyRwOt3M+XAc97pu1McN0uAP4aYd4sYKn73sH93KGh6hVW/nfA5AZaZ0cABwHzqpn+C+BNQIDhwOfxXl9R1uuw0PKA40P1coeXA9kJXGdHAVPrux/4Xa+wsqOA9xtinQFdgYPcz5nAtxH+LhOyn9nLXvayl73slQwvO/MSX8OAJaq6VFX3As8BJ3sLqOoHqlrsDs4AuidL3Wrwc+AdVd2sqluAd4CRCarXOcCzPi27Rqr6EbC5hiInA8+oYwbQXkS6Et/1VWu9VHW6u1xo2H0smnVWnfrsn37XqyH3sbWqOtv9vANYCHQLK5aQ/cwYY4xJBpa8xFc3YJVneDVVGyJev8E5ohrSQkRmisgMETklQXU73e2a8qKI9Ihx3njWC7eLXU/gfc/oeK6z2lRX93iur1iF72MKTBORWSJySYLqdKiIzBGRN0Wk0B2XFOtMRFrhJAAveUY3yDoTkXzgQODzsEmpsJ8ZY4wxcZGe6AoYh4j8EhgKHOkZnaeqa0SkF/C+iHyjqt83YLVeA55V1RIRuRR4GjimAZdfm7OBF1W13DMu0essaYnI0TjJy+Ge0Ye766sz8I6ILHLPSjSU2TjbbKeI/AJ4BShowOXXZhTwqap6z9LEfZ2JSBuchOkqVd3uZ2xjjDEmldmZl/haA/TwDHd3x1UiIscCtwAnqWpJaLyqrnHflwIf4hyFbbC6qeomT30mAUOinTee9fI4m7DuPHFeZ7Wpru7xXF9REZHBONvwZFXdFBrvWV8/Av/F6a7VYFR1u6rudD+/AWSISDZJsM5cNe1jcVlnIpKBk7j8S1VfjlAkafczY4wxJt4seYmvL4ECEekpIs1wGkKV7oAlIgcCE3ESlx894zuISHP3czbwE2BBA9etq2fwJJz+9wBvA8e5dewAHOeOa5B6uXXrj3NR8meecfFeZ7WZAvzavRvUcGCbqq4lvuurViKSC7wM/EpVv/WMby0imaHPbr0i3n0rjnXrIiLifh6G82/SJqLcD+Jct3Y4Z0Jf9YyL6zpz18WTwEJVfaiaYkm5nxljjDENwbqNxZGqlonIOJwGRBrOXbHmi8idwExVnQLcD7QB/uO24Vaq6knAAGCiiARxGnT3qqpvDfEo63aFiJwElOFc3HyBO+9mEbkLp4EJcGdYt5p41wucxuxzqqqe2eO6zkTkWZy7Y2WLyGrgdiDDrfffgDdw7gS1BCgGLnSnxW19RVmv24COwOPuPlamqkOBHOC/7rh04N+q+pZf9YqybmcAl4lIGbAbONvdphH3gwasF8CpwDRV3eWZNd7r7CfAr4BvRORrd9zvgVxP3RKynxljjDHJQCq3/YwxxhhjjDEmOdmZF2OMMSYFzZo1q3N6evokYBDWDdwY0zgEgXllZWUXDRky5MdIBSx5McYYY1JQenr6pC5dugzo1KnTlkAgYN0ojDEpLxgMyoYNGwauW7duEs711lXYkRpjjDEmNQ3q1KnTdktcjDGNRSAQ0E6dOm3DOaMcuUwD1scYY4wx/glY4mKMaWzcf9eqzVEseTHGGGNMzJYsWZJxyCGH9O3du3dhnz59Cu+6667OoWnr169PO+ywwwry8vIGHXbYYQUbNmxIAwgGg1xwwQU9cnNzB/Xt23fgJ5980ipx38BEY+PGjWkjR47s1bNnz8JevXoVvvvuu63BtnFjcuaZZ+ZnZWUVFRQUFHrH12UbP/roox3z8vIG5eXlDXr00Uc7xqO+lrwkCRG5JNF1iMTqFbtkrVuy1guSt27JWi9I7rqZpiEjI4MHH3xw9ffffz//yy+/XPjkk092njVrVguA22+/vetRRx21Y8WKFfOOOuqoHbfddlsXgP/85z/tli5d2mL58uXzJkyYsGLs2LG5if0WpjaXXHJJj+OOO277smXL5i9YsGDBAQccsAdsGzcmY8aM2ThlypTvwsfHuo3Xr1+fdt999+33xRdfLJw5c+bC++67b79QwuMnS16SR7I2RKxesUvWuiVrvSB565as9YLkrptpAvLy8koPP/zwYoAOHToEe/fuvXvlypXNAN566632l1566SaASy+9dNObb77ZAeDVV19tf955520KBAKMGDFi1/bt29NXrFiR4Y27ffv2wFFHHdWnX79+AwsKCgr//ve/d2jo72YcmzZtSvv8888zr7rqqo0ALVq00Ozs7HKwbdyYHH/88Ts7depUFj4+1m38yiuvtDviiCO25+TklHfq1Kn8iCOO2P7yyy+3C487duzYbr179y7s27fvwEsuuaR7rPW1u40ZY4wxpl4WL17cbMGCBa2OPPLInQCbNm1Kz8vLKwXo0aNH6aZNm9IB1q5dm5Gfn783NF/Xrl33rlixIiNUFuDll19u26VLl9IPP/xwiRvL9yO3JjqLFy9ulpWVVXbmmWfmL1iwoNXgwYN3/f3vf1/Vtm3boG3jxi/WbbxmzZqM7t27V4zv1q3b3jVr1lRKXNetW5f2xhtvdFi6dOm8QCDAxo0bY972TSp5EQm/sFHCS1T6LKFxQuTxYfNJpbKRy0ml8vvGp0kLWqS11+rLVq5rpWGNFHHfh6rzUu2wN4IItJJMstJzNHyeKnHCV1N1cSWGOgiARizfPq0N3Zt3rlhf4ilQuaxWXVa0ZSN+J61hujN/52at6Ns6S/ctq/JuJ27ZSPFBK9Wv0nIlfBwgEWJXM65bq2YMzmpdsUKFyH8OkZbl2ck82yd8fq2ynSu+e6V4Vb9jj/bCkO5pWuN81ew0UqVM+AauUvGKzxr2Nxs+f25OOkP6t9QqC6kUd980FQlbvreMZ1rF/FJRRgkvC1JlvlBsoUduFkOG5Fda6aG/9Vmzlr2tqiMxTcaYMRf3mDdvnq/XFgwaNKh48uS/r6qt3LZt2wKnnXZa73vvvXdVVlZWMHx6IBBw9+XoHHTQQbtvueWWHpdddlm3k08+edvIkSN3xlj1Rum93z/TY9O3a3zdxh37dise8cdfV7uNy8rKZOHCha3Gjx+/8phjjtl14YUX9rj11lu7jB8//gdvOdvG/gjO+G0P3brA120s7QcWB4b/rda/49rEuo2r07Fjx/LmzZsHR48enX/iiSduHT169LZYYzSp5MVpHmS4DYAAEuo1J4GKYZFQT7oAImmVxoU+Vx2fhkiAgDtPqGxAAs40dzkBd74Aofd98wfc/4Q0d+kBAhqoKBcqG1CnlLilK4+TfeNCwyLeb+oZR8VOGPocAALiLec0mULlwVl1+8bjmb/28bjTKsZXiqkV81Ya7zZ098XUinnFbTw79d43v3e8iFZMd76XW7bG8RpWL923/IrhfTEILafK/J5x7ruzrMrjQ2WrlPMMRyorASUgwcrj3PEVdZVgxThvXGc4WFHWO2/4eCKVDSgEgvtieoZDn6srSyDyOALuMtxl7ourEKBi+c7Gqtjw7PuTlX2v0MiAQCDgvkIbMVDx0kAAAmkRxoePS0MrYqY5w6HxFWXdzxHHpbuf0/eNl3R3vDNOA+kQNk4kHQIZzrukI57xIukEJH3fvzmSTsBdbrr8MhtjGkBJSYmccMIJvc8888zN559//tbQ+I4dO5aFjravWLEiIysrqwyga9eupcuXL28WKrd27dpm3iPyAIMHDy6ZPXv2gpdeeqndrbfe2u3dd9/d/sADD6xtuG9lQvLz8/fm5OTsPeaYY3YBjB49esu9997bBWwbNwWxbuNu3bqV/u9//8sMjV+zZk2zI488coc3ZkZGBl9//fXCKVOmtH3xxRc7TJgwofOMGTO+jaVeTSx5McYYYxqfaM6Q+C0YDHL22Wfn9e3bd88f/vCH9d5pP//5z7dOnDix4x//+Md1EydO7Dhy5MitACeddNLWxx9/vPPFF1+8+YMPPmidmZlZHt6wXb58eUbnzp3Lxo4du7lDhw7lTz75pCXjQE1nSOIlNze3rEuXLnvnzJnTvKioqGTatGlt+/XrtwdsG8eDH2dI/BTrNj7llFO23Xnnnd1CF+n/73//a/vwww+v9sbctm1bYOfOnYHRo0dvO/bYY3f27t17/1jrZcmLMcYYY2L2zjvvtHnllVc6FhQU7O7fv/9AgDvuuGPN6NGjt91xxx1rTz311N55eXnZ3bp12/vf//73e4Czzjpr2+uvv94uLy9vUMuWLYOTJk1aHh531qxZLW+++ebugUCA9PR0ffzxx1c08FczHo8++ujK8847r9fevXslNze35Nlnn10OYNu48Rg1alTPGTNmZG7ZsiU9Jydn8E033fTD1VdfvTHWbZyTk1N+/fXX/zBkyJABADfccMMPOTk55d5lbd26Ne3EE0/sU1JSIgB33XVXzAmbqDad51uJiFq3Mes2Zt3GrNtYE+g2NktVh2IatTlz5iwvKiramOh6GGOM3+bMmZNdVFSUH2ma3SrZGGOMMcYYkxIseTHGGGOMMcakBEtejDHGGGOMMSnBkhdjjDHGGGNMSrDkxRhjjDHGGJMSLHkxxhhjjDHGpARLXowxxhhTZ2VlZQwYMGDg0Ucf3Sc0btGiRc0GDx7cPzc3d9AJJ5zQa8+ePQKwe/duOeGEE3rl5uYOGjx4cP/Fixc3qz6ySQZ33HFH5z59+hQWFBQUjho1qmdxcbGAbWOTOJa8GGOMMabO7r777pw+ffrs9o675ppruo8bN279ypUr57Vr165s/Pjx2QDjx4/PbteuXdnKlSvnjRs3bv0111zTPTG1NtFYtmxZxhNPPJHz9ddfL/juu+/ml5eXy6RJk7LAtrFJHEtejDHGGFMn33//fcbbb7/d7uKLL654WGYwGOSzzz7LvPDCC7cAjBkzZtNrr73WHmDq1Kntx4wZswngwgsv3DJ9+vTMYDBYKeaKFSsyhg4d2q9///4DCwoKCt966602DfiVTJjy8nLZtWtXoLS0lN27dwe6d+9eatvYJJIlL8YYY4ypk8svv7zHn//859WBwL7mxPr169MzMzPLMzIyAMjPz9+7fv36Zu60Zj179twLkJGRQZs2bcrXr1+f7o05efLkrBEjRmxbtGjRgoULF84/5JBDihvuGxmvnj17ll5++eXrevbsObhz585FmZmZ5aeddtp228YmkdJrL2KMMcaYZHb/b5/psWzBD638jNlz4H7F1//t16uqm/7ss8+2y87OLvvpT39aPHXq1Ey/ljt8+PBdl156aX5paWngjDPO2HLYYYftrn2uxm/DX//YY+/Kpb5u42a5vYo7jft9tdt4w4YNaa+//nr7JUuWfNOxY8fyE044odfjjz+edeqpp26vz3JtG5v6aGrJy9tKaTbqDGhorFZX3BhjUtLG2osYUz+ffPJJm3feead9t27d2pWUlAR27doVOPnkk3v+97//XbZjx4600tJSMjIyWL58ebOcnJy9ADk5OXuXLVvWrHfv3qWlpaXs3LkzLScnp8wb9/jjj9/50UcfLX7ppZfajRkzpue4cePWjxs3blNivmXT9tprr7XNzc0t2W+//coATjnllK3Tp09v89vf/nazbWOTKE0qeVHVkYmugzHGGOO3ms6QxMtjjz225rHHHlsDMHXq1MwHH3ww59VXX10GMHz48B1PPfVUh0suuWTL5MmTO5544olbAU444YStkydP7njsscfueuqppzoceuihO7xdzgC+/fbbZr169dp77bXXbiwpKZHZs2e3App8w7amMyTxkp+fv3f27NltduzYEWjdunXw/fffzxwyZEhxIBCwbWwSpkklL8YYY4yJvwcffHD16NGje999993dCgsLi6+88sqNAFdeeeXG008/vWdubu6gdu3alT///PPfh8/79ttvZz7yyCNd0tPTtVWrVuX/+te/ljX8NzAAxxxzzK5Ro0ZtGTx48ID09HQKCwuLr/nJncIAACAASURBVLnmmg1g29gkjqhanyljjDEm1cyZM2d5UVGRdRE0xjQ6c+bMyS4qKsqPNM3uNmaMMcYYY4xJCZa8GGOMMcYYY1KCJS/GGGOMMcaYlGDJizHGGJOagsFgUBJdCWOM8ZP771qwuumWvBhjjDGpad6GDRvaWQJjjGksgsGgbNiwoR0wr7oydqtkY4wxJgWVlZVdtG7duknr1q0bhB2MNMY0DkFgXllZ2UXVFbBbJRtjjDHGGGNSgh2pMcYYY4wxxqQES16MMcYYY4wxKcGSF2OMMcYYY0xKsOTFGGOMMcYYkxIseTHGGGOMMcakBEtejDHGGGOMMSnBkhdjjDHGGGNMSmjw5EVEJovIjyIyzzPufhFZJCJzReS/ItLeM+1mEVkiIotF5Oee8SPdcUtE5KaG/h7GGGOMMcaYhpWIMy//AEaGjXsHGKSqg4FvgZsBRGQgcDZQ6M7zuIikiUga8BhwPDAQOMcta4wxxhhjjGmkGjx5UdWPgM1h46apapk7OAPo7n4+GXhOVUtUdRmwBBjmvpao6lJV3Qs855Y1xhhjjDHGNFLpia5ABGOA593P3XCSmZDV7jiAVWHjD4kUTEQuAS4BaN26+ZB+/brUXgOp+F/NVKMq5gmamJhotAETGDOWeFHG1BhiRr3NgzHEjObYgMZQTwGJcl0mMqYINa7Lijgx7kM1VVNDbxr9n0+8YtZCUaL/7hL1smfPXrlRVTtFWdw0AtnZ2Zqfn5/oahhjjO9mzZpV7W9aUiUvInILUAb8y6+YqvoE8ATAgQd21Q/eOze0NCo1IDQ0LJ7poTfv+NBwALQcAgHPOC+J0D7xxJBIjReBYBkE0qKMGWokqqeeEWJquachHU3Mmurorg1VT6M3rJxKWGFP3BpjEuF7uN/PGzO8OVftugx972qmVywqtGDPdhZvA9P7fYIRGvuh+cTTMA+rb6V4YfWoNmZoetgyQtMkrJz7WQEJhraPt2wotGe7acCz4r3zVP77UASpSNw0rL5unCq7VtjfWEU13fhax+1TsbOEvptnH/Z5XVbUk9B6Co8r+9anQqW/CalcLLRvOOvSe5AifLne74NnuRJWz8raZT+0IuIE02jl5+czc+bMRFfDGGN8JyLV/qYlTfIiIhcAJwIjVCtagGuAHp5i3d1x1DC+WoHiLTSf/R/PGG/DJTw5CR+uqKlntFZuOFWKWV0DNxRGPfN5xgcVAt6YYXUMbw9WamdVEzO8QVTt93br7T3CXm09w2et5ntXSnLCylY5phyepCRq+2jYeo5h+1SrhpixbJ9KQWqqJ9U0tt1yoaJB7/aJ0CjW0JF/dfeF8KTCU89QnokiEuH7hNfRu85r3d9j3D4R6xges9IXrWX7hH8MW5fCvr+JiuWG7afeZXqTlyqrx1NHDToHM2o8WyURtrUxxhjTOCVF8iIiI4EbgCNVtdgzaQrwbxF5CNgPKAC+wPlpLxCRnjhJy9nAudRm916YvzLKSlHdAc66iyZmkOivRKqhzRm1SMlQNDHD84fallFrTLdhHEvMZN8+UcaMZVVWmTHScKghXV09w7dHddtHPW9SSy3Dcir1Y9+saRnVqcP2qdQbLtb6iuctPBerx/apcoLFW89q8heTeO5v2XggDZikqveGTc8Fngbau2VuUtU3RCQfWAgsdovOUNXfNlS9TdMUXP4COv/PsH0xtO2HFN5AIP8si2WxfIkVTw2evIjIs8BRQLaIrAZux7m7WHPgHXGOAs9Q1d+q6nwReQFYgNOd7HJVLXfjjAPexvkBmKyq82tbdrAknd3LOoZqUnlipQOpWvkAa8Qj/4CWgqR7pkWIWdG4iSKmujEDGbXGcyZX09IKOzqslCEVmzpCK6eioek5Ch/xCLR3QhlUF7NO65KwBnICtk+kI+DewgpomRszbLq3Ye1dn7WdjQGClBOoaftUqHK6K8Kwu821DIlUz5hjejMSJdTirnIVSKWTIkG0yhmvSDHLcP58q9k+3rnFvfKk2uTCnRAsg0Dt+6UzHLZ9qize2eYxbR/v309oH6pU5yj/Jr0x9537ilDeG7zWk88mjjx3wfwZznWYX4rIFFVd4Cn2/4AXVHWCe4fMN4B8d9r3qnpAQ9a5MUrWhpxfsXyNM+cOAsMfh06HwYbpBGeMdY6rxBjPYlmsauPFKRFq8ORFVc+JMPrJGsrfA9wTYfwbOP/wR628LJ2d6zqGjY3UcKiuhaRhQ4pIhL7+1cWMeDQ6LKa6MauIlHR4D41HjhdbzOjq6IxRpMqh47p/74pDzRplTHda5UtMwusZdOsYTePcM6aGmKpBApIWPgtVurt5ewtVSooiLS+IeGJWzFqPmM61H+H19Dakozm1VnnWqnWqVNuIISrnwGEx1e1eViXJqOZ7R9rdI/xNBiLt6zXErCleKKZ3X5cIn2qrVWWhTLeWdelN6Gupp5MzWfKSYBV3wQQQkdBdML3JiwJt3c/tgB8atIY+StqGfRI25PyK5WeddP6fCQx/HMk50hmRcySB4Y8TnHktWCyLVc9YfidC4ZKi21hDCZYF2LHN+d2o2kSRGobq2vel9qPuVcZ6Tn7EFrP6OjZ8zNi/d+2qxlTvJ0/YKge/Q0euqyRPNdezyokYQt+7pvnCG7SVW97hB/8BgqoEoooZXufqY9Z3+0SKWbPY12WVUlEdBPDEjLTNw7ZP1e9Ry/bRyvEAgkHPfTlqjVm5jtXFjHiSk8r7a3Ux1TNTVDeKMw2lG7XfBfMPwDQR+R3QGjjWM62niHwFbAf+n6p+7HcFG3uSkKwNOb9i+Vknti921rdXp8Oc8bGyWBYrjK/7agRNKnkpDwbYsat1FCW9fYD8EPHUQ+3FqakZE13MSDe/qm/MqkeBaxLjd486ZmK2T+3JS+xqTy5D4rUunZg1RY1tyVFuH/d7134H5uTcPtUfAKn976dS8RrFY5ubBDoH+IeqPigihwL/FJFBwFogV1U3icgQ4BURKVTV7eEBvLf/z83NjXrBTSFJSNaGnG+x/KxT236wYTqE1js4w237WSyLVf9Yfu6rETSp5CWoAXbvbeljxNRoUNR2jqHuooka+zH8pBaHlVlb8lKXvSz6hCjR/N2HKp3R8OnPMx7rMnW2j4lBTXfHDPkNMBJAVT8TkRZAtqr+CJS442eJyPdAX6DKfZC9t/8fOnRo1Ht5k0gSkrUh51csH+skhTcQnDG2SjIrRbfHHIuB1xP87DLkkL9C9iGwYTr6xRWw/+/R0p04RzyDtbyr897nNwSnX4IceCdkHQSbZqFf3wb9x6Hbv6tctrbPeWcR/PQ3yP43QvvBsHUu+s19UHARujH0p+X9E/J8Dr+TS49TCX46Bim8DjrsD1u+Qec/AAW/QTd+EVqrVPxOVfwDHz4M5I126jX499DhAKdec++Bfpej27/FuTW/5xUaRpw43nH9xhH87LfIwQ8723HTF+jnVyAH/CHmzejrPuHn30+kuqpfv/ApoG/rLH104IjoCke6xMTf6kQUr4ZSwO+Y/oZrUPWqe6wzx94jr2HjNTLxSNSdVevz2RzfI8LxM/8zS1WH+hzWREmcO2R8C4zASVq+BM713kxGRN4EnlfVf4jIAOA9nO5m2cBmVS0XkV7Ax8D+qrq5pmUOHTpUo33OS/mzmQRGb0YqbggDGiwl+HwWaefsiOWrUv76UAJDH9yXCAG6/n8EZ15L2gmxPXfGz1jB5S+gX/8BGf5X6DgMNnyKfnEVFF5PoMeJzrO/tBy0zLm5R+izljmNaM+44Np34ftnkH5joW1f2DYfXTwR8s5Asoe55UKvYNiw5xUsR7fMgXUfQLeR0LIbFK+ENdOg03AkszdOYztSrGDFu2oQdq2AbQudxnNGOyjZDFvnQ2YvaJ4NBCvN4yQG4cO6b7h0O5RsoeLmNhltINDcnSeUBATDYkX6bD9AyUec614D6c62lXTntvuS5g57p6W509KdfWL3OijfDemtoU1vaJOHBJpBoBmkue+BDPe9mbPPpHmHm6Gbv4JVryJ9L4XcM5A9aysSoWjP9IpItb9pTSp5KWidpQ/3Py7R1WhwdpQ3ucVv+0QOWqe/+HhlBfHJNKJX2/I1xmrGciLJr5huvJO+es6SlwQTkV8Af2HfXTDvEZE7gZmqOsW9w9jfgTY4W+4GVZ0mIqcDdwKlOLeYu11VX6tteTElLzEmCRosh2CJ8yp3X+7n4OrX4bu/IwN+B5kFsPUbdPHfIPdUpONBECx1X3vdV5nnc2ml6br9O9gyF7KKIKMt7NnoNMjb5EGzDk45LXPfyz3DZU6jO1geVqYsqvWRWLKv8SehBmXoSHua5z0NCOxrdCJQugP2bIDgHkhrAa26QYvOTjlJ23dkPjRveFwCzg18wo/qe+tA2NF9Eao9G1Dls3t2oCJGLe8Vsb3vnhhRfJYYykbeHN7x1XyO9Aw758O+9yrtafWU1WrG7Tv7pNUmilrNZ08ZLXeGqyTobkJekZhXTd41WB5Wrizsb7bE+dsq3xv2d+z+u1Drj5pAu/4xX2NXU/LSpLqNqQplwQh3imrkFOwZdkksZbZPHOro97ETJ9GIISOqbfmh5CXakNF8n1h7UqbCvmEAIt4FU1Vv83xeAPwkwnwvAS/Fs26hLiFkHww/vA1pLWHvZmjWkfLnspyGsKRB+R4oL649IKBf3VJ5xHdPoN/VMEOgmXN0N7gXMjIhvZXbfiuDjTOdZCTUoE9rBektoTQIO5dBh8FI845oyRbYNg86HeYM79kAm2bCfj93hotXO91Tck93hncsgfUfQe/zkWYd0G0LYO170G8s0qwDbJ6Nrn0HKbwRychEN3yG/vA2csBdSEYbdO376Jo3kIPHI2nN0TVvoKtfJ3DYZAikoSteQn94i8Dh/wRJQ5f+C137HoEjnnWGv5uErv+IwJH/QUQILvwLuvEL0n76bwCC8x+ALd8QOPxpZ/ibe2HHt058IDj3LiheTWD4RGf469ugZDOBQ/7qDM++Gcr3EDj4YWd41vXOqh5yvzP85dWQ1oLAQX9yhj8fB82zCBxwpzM841Jo1Z3A4Fud4eljILMvgf1vcoY/OR867E+g8DoAyj8+F8keRmDAVc7w/85Eco4i0P9yZ/iDU5BuvyDQ9xJn+L0TkLwzCPS50Bl+dyTS6zwCvX7lnPl7fxTS+3wCPc9By4oJfngaUnARgbwz0L3bCH40mkC/y5AeJ6N7NhL85JcE+l+BdP8FunsdwU8vQAZeg+x3HLprNcHPLiIw6AakyzHozmUEZ1xGYP9bkJyfotu/JfjFFQSK/oB0Go5unU9w5rUEDrwH6TgE3TKH4KwbCQy5D+lQhG6aRfCrW5ykv30humEGwTl/IDDsEaRtX3T9xwS/uYfA8AlIm57ouvcJzvszgUMnIa27oz9MI7jgIQI/+QfSsgu6+g2Cix4lcPj/IS2y0VWvElw8gcARzyPN2qErXkSXTCZw1MtIeiuCy55Fl/4fgWNeQwIZBJf+E136L9KOfcvZNkueQle8SNqI153hb59A17xB2tGvOMOLHkPXf0jakc7D2avb99J++n/12vdkyAMQ3Etw9k2g5QT2/z0ESwjOuQMCGc76bdG5hn8YYte0khegLBjLE+wakPcaZz+PRsfa+IoyJuBfPb2NM79jJvP3dmOm5PbxrUGd/KcEteJ/8QhsTMMI5J9FENCZ1zpdQ8r3QLtCaJMPP06Hdv2QdgOdZzStngodD0Y6HugcDV76T+gyAuk0HMr3ooseQXJPcxqEpTvRuXcjfS5Aco5ESzahs29GBlzhNCCL16BfXo0MvoVAzhF1b0AO+XPlBmTR7ZUbkIXX7mtAFq8h0Pe3+xqQO74n0OuX+xqQW+cTyD3NaUCmOV1cZL/jnAZk2U7Y+DnS+SdIeit053LIyESyipBABrrla0hvhbTtA4A27wiB5kjLrs5wemsIpCMZmc6wezbE7xuJGJMsJJAGgZZIWjNnuNV+znuzDpDWwvfEBZpYt7FerbL1j31OiDit5puTRi7je6MT/7sQhRpeSR8zHl2nUqCrU8psH+KwKlPkQnjVyH/7yeacb56xbmNNTCzdxowxJpVYt7EQhWCVh+zVP6bvmmrMVKhjU4/pt6b6vauoy79LKflFjTHGmHppUsmLAuVRJi+JOsMbjzMvkgJnIFJGqqxL2z7+hUzgmbGaT4w3xQ1sjDGmqWtSyQs4F+1HVy7KgHE4YFrnu0H5Ga9eM9ZNXZtiNW2rujY6a4xZt5ApEbO2/b4u67PGmHX+4nWcr47x/P6bBP9vVmCMMcY0BQ2evIjIZOBE4EdVHeSOywKeB/KB5cBZqrpFnCvcxgO/AIqBC1R1tjvP+cD/c8PerapPR7P8oO+HZf0N13hjRtE6FPD/sLm/4ZpszND2sa6CxhhjjEmgRJx5+QfwV+AZz7ibgPdU9V4RuckdvhE4HihwX4cAE4BD3GTndmAoTrNilohMUdUtNS1YkajPvCRK4+3tE00fmfjXwhcxbKBIRat8zRg2elTx4hEzxp0y6u9tjDHGGBODBk9eVPUjEckPG30ycJT7+WngQ5zk5WTgGXVuiTZDRNqLSFe37Duhpw+LyDvASODZ2pZfXsfUoCETingc3G6cCVEiaOoc2U+J5MD2TGOMMcZEL1mueclR1bXu53VAjvu5G7DKU261O6668bWKuZ+5VnqrMilVbt2eEu3YlJAiG9wkMTucYIwxxtRVsiQvFVRVRfx73riIXAJcApCV3sb3WyXH46Jbu/GUafTc62fi8UwW/x+k6Tf7azTGGGPqKlmSl/Ui0lVV17rdwn50x68BenjKdXfHrWFfN7PQ+A8jBVbVJ4AnAPJadFL1oeEQjwfCVxc/eWP6nRLF6fH1SR8zHnuTP3X0zq2q/iYa6rmNt79h4xMTKv5f//Dx3C+NMcaYxi1ZkpcpwPnAve77q57x40TkOZwL9re5Cc7bwB9FpINb7jjg5mgWFKzXb3zVmf1IhuItPjX0O2o8apkKMZOgjtUUr7S3x6l/pO/Xd8XpOS/+xpSaY9ZppST/v0PGGGOMHxJxq+Rncc6aZIvIapy7ht0LvCAivwFWAGe5xd/AuU3yEpxbJV8IoKqbReQu4Eu33J2hi/drotT3VsnJ10CIpkapc0y2upr6/S2j3Y7JG7PylEhJdQx7q1b5ULWIgqTABV4pdTYn1mfLpM4fsjHGGBM3ibjb2DnVTBoRoawCl1cTZzIwOfblxzpHcmtcXyfZEsvkixnKHypv96ox6/ZU+OpnUEnG1L2qun3vFImZChvAGGOMibNk6TbWQMT3h1Q23Yvro02b4vFkw8YXM+rzNlGcJamYGuvNKWoIWTEplpDRfPVYd/ZYz1Y0oZjGGGNMU9CkkhfF/zMvqXFxfTzE0uqMrmxs7dh6PIGxHoVjP2Iej5i1x/X7yH6dkuoEnLhS9b+efses8+X6qXFUwxhjjImrJpW8AKjPt0qOi3o+wR3CEqAYWl81FdPwgXrG9O+uTdVMVZAYW3zx6FYYl66KtVwQ4QzVfV+PVOf6PtcoUsz6dsdKle0VMabP69IYY4xpCppc8hJM4LJra6tUHJGNoWESTVFFoo4ZVTw3cfE7pt9nH0Jx/ZacMT3rwt0+ftdTiMOZy6Rcl2HxKv7nc1xLQIwxxpiYNa3kJQ4Nr1ga3NElGvERa9way8epO5CvddwXtumJ05duym3tpvzdjTHGmGTSpJIXpb7PeYkQMx5HZP0OFofGbDwub4+HVKijbyo9VTJuj2bxTdLcxauRxDTGGGOagiaVvEB9n/NSPwlZcpIehW+IdRGPvC0+MX161GnYRvEzsY5XYzsVuo0lU0zrapbcRGQkMB5IAyap6r1h03OBp4H2bpmbVPUNd9rNwG+AcuAKVX27IetujDGposklLwn98Y+i8ddUjvKGb4Z43SI62e8G53xvSf4zRDF260uy3a3xCLu0ySQPEUkDHgN+BqwGvhSRKaq6wFPs/wEvqOoEERmI8yDmfPfz2UAhsB/wroj0VdXyhv0WxhiT/Jpc8lK9qO+zVWfRJk7JcpS3pljxSLCaaos30Y3QuJxR8T9kdMtNkeQ/GQ8omHobBixR1aUAIvIccDLgTV4UaOt+bgf84H4+GXhOVUuAZSKyxI33WUNU3BhjUkmTSl6UunYbq36eVOiW5Ls6XFwfTcxUkLhuY+El/NsC0SS2qdTYTpbk37p4NTndgFWe4dXAIWFl/gBME5HfAa2BYz3zzgibt1t8qmmMMamtSSUv8ZDs3ZJSRUokba7k6DYWe7pTL/FIWBu72h5+2TC1MMnlHOAfqvqgiBwK/FNEBsUSQEQuAS4ByM3NjUMVjTEmuSVV8iIiVwMX4fyufwNcCHQFngM6ArOAX6nqXhFpDjwDDAE2AaNVdXlty7Cjockr0Zsm0pmFeDxYsVIs4ngxvP8hjTHVWwP08Ax3d8d5/QYYCaCqn4lICyA7ynlx53sCeAJg6NCh9mdujGlyAomuQIiIdAOuAIaq6iCcO7GcDdwHPKyqfYAtOP/4475vccc/7JarlSbwFW3d/Ga/btFRrfqKtlx9Xn7HDAb9r6O9kv9lEu5LoEBEeopIM5zfrylhZVYCIwBEZADQAtjgljtbRJqLSE+gAPiiwWpujDEpJKnOvODUp6WIlAKtgLXAMcC57vSncfoMT8C5wPEP7vgXgb+KiKjW/DPu001pK6LFo7Sf7RAlPs9kSZUuXvGQ7Nc5ifgf0xhTM1UtE5FxwNs4B98mq+p8EbkTmKmqU4Brgb+7vQwUuMD9zZovIi/gXNxfBlxudxozxpjIkiZ5UdU1IvIAzpGp3cA0nG5iW1W1zC3mvYix4uJI90djG07Xso01L8ef+joJgST9XYgE4tKSbboHejXpz45ZwmpMYrjPbHkjbNxtns8LgJ9UM+89wD1xraAxxjQCSZO8iEgHnLMpPYGtwH9w+wbXM27FxY3t0tr41qALxYlHd406x/ShLjU2UL3xk7QlG/aQ+Tgkl/4nrH6LV/VSI2EN1dKvtRCPnT7eMY0xxpjGK2mSF5xbRi5T1Q0AIvIyzhGq9iKS7p598V7EGLrAcbWIpOPcM39TeFDvxY37Ne/cuH/hfWgH1biC4tho9+vkUHj9kyK5jKZ8lF8+yfOmiGqsc9Inl+L72dB4xTTGGGOagmRKXlYCw0WkFU63sRHATOAD4AycO46dD7zqlp/iDn/mTn+/tutdwC5srU20Daq4dG9rrHz8conafeuTXNZyEZqPweoWMpoAfsasc7c++7fLGGOMSZ7kRVU/F5EXgdk4Fyx+hXPG5HXgORG52x33pDvLkzj3yF8CbMa5s4upp6iSO7f15Wci6P+R6NSS7N89aarXEBWJxzIk4sc6xzDGGGOaqqRJXgBU9Xbg9rDRS4FhEcruAc6MeRl1q1qN/L5/WdK3UeJQwWRvvMebJYL+SfabaMQrpomeiLRW1V0i0kZVdya6PsYYY6KXVMlLQ6hbG7GmuerydPSal+Hv7ZwdqdBOSoU6poKm3ihOiuuc4hTTeo75poOIXAgsAd4Knygi5wInAeU4/zS9pqrPNmwVjTHGRNLEkhehbk3kVO2rEhKf2/vGWofapjproD7roeoyJEVSomR/doxJDrZNfTMCuACYLCKdVfXHsOlHqmpFV2QReQyw5MUYY5JAE0te/JU6XT+SoZI118GfGlaN4n/SVp+IVefdd/F2XdZAbXVJhu1euybX7dIkgy+AMUD3CIkLQHMROQHnWWLdgZYNWTljjDHViyp5EZGsKIoFVXVrPesTX+p/949kv3uZSJz67NNUG4n1+dZV563fOqx5bv8ffBmfe0RHHzW6kqnQ7TLJ/9lo9FR1IYCInE/YQyVdY4HTgP1xEphxDVc7Y4wxNYn2zMsP7qum3/A0ILfeNTK+CiVX8bggPBkbYN4kzS609k/duvT5vaISt+KTcV83vjg60khVLQb+r4HrYowxJgrRJi8LVfXAmgqIyFc+1MekgGRuvIcnaclyobVfEvUcHmMaCxH5QlWr3MHSGGNMaog2eTnUpzIJpfh/BNXah6YhRZM4VZwZ8/NsG3F6/Il1ZzQNL8PzuUhElgHfAPM87wtVtSwRlTPGGFOzqJIX95kqiMiZwFuqukNEbgUOBO5W1dmhMsnO7+Ql2Z8bE8+YJjnF44xLvPafuJwZ8z+kaVx2eD7PBU4ABuFc33IccC1QICKrVHVQAupnjDGmBrHebexWVf2PiByOc6vJ+4EJwCG+16wJ8/9Ca0uyjDEGQFWPCBsOXdM5LTRORATo08BVM8YYE4VAjOXL3fcTgCdU9XWgmb9VMn6K79Nj/HsFPe9+vvyso7eefrIzBcYkzF8jjVTHdw1dGWOMMbWL9czLGhGZCPwMuE9EmhN7AmRMFXHrlhSnmKmQcNhZLGNqpqpPJroOxhhjYhNr8nIWMBJ4QFW3ikhX4Hr/qxU/0TY6o2n42R2djF+sq6AxxhhjTO1iSl7ce9+/7BleC6z1qzIi0h6YhHPxpOI8AXkx8DyQDywHzlLVLW6f5PHAL4Bi4AJVnV37d4iuLlE3/OLQQrSEyNRHPHafeCZE8bgDoJ/rIB53MLO7ohljjDF1E1WXLxGpNSmIpkwUxuPczaw/UAQsBG4C3lPVAuA9dxjgeKDAfV2Cc+OABuf3NRUKBDX6l0b5isf3Nk1HKjW0/bx2qtzneN5rsepTp0gvU38iMirRdTDGGFOzaM+8DBCRuTVMF6BdfSoiIu2AI4ALAFR1L7BXRE4GjnKLPQ18CNwInAw8o6oKzBCR9iLS1T0b1GTUlkRUHDH3uV+SSJy6JaVSK9k0esm4OyZjnRqRe4DXEl0JY4wx1Ys2eekfRZn6HvzrCWwAnhKRImAWcCWQ40lI1gE57uduwCrP/KvdcU0qealNXLoQxSForA9WjKUKlhAZY6JUr38tRGQkTg+CNGCSqt4b4cB1rAAAIABJREFUNv1h4Gh3sBXQWVXbu9PKcR6SCbBSVU+qT12MMaaxivYhlSviXRGcuhwE/E5VPxeR8ezrIhaqh4pITAf8ReQSnG5ltE3L9KuuTVpccoEYg8ayE1hCZIyJUp1PKItIGvAYzt04VwNfisgUVV1QEVz1ak/53+E86Dlkt6oeUNflG2NMU5FMtzleDaxW1c/d4Rdxkpn17l3NcN9/dKevAXp45u/ujqtEVZ9Q1aGqOrRVoGXcKm/qJxlygWivSYLorzVK1DVJxpgGNwxYoqpL3W7Pz+F0b67OOcCzDVIzY4xpRJImeVHVdcAqEennjhoBLACmAOe7484HXnU/TwF+LY7hwLamdr2LSQy/b9BgjGkUquvKXIWI5OF0lX7fM7qFiMwUkRkickr8qmmMMakt1ue8xNvvgH+JSDNgKXAhToL1goj8BliB86wZgDdwbpO8BOdWyRc2fHWNqSd1ryGyW24bkwzWN9ByzgZeVFXvtaJ5qrpGRHoB74vIN6r6ffiM3q7Qubm5DVNbY4xJIrUmLyLSWlV3iUgbVd0Zz8qo6tfA0AiTRkQoq8Dl8ayPMfGmEp/np1jeYkzsVPVn9Zg9qq7MrrMJ+/1S1TXu+1IR+RDnepgqyYuqPgE8ATB06FA7eWuMaXKi6TbWQUTGAYfHuzLGGGNMivoSKBCRnm7vgbNxujdXIiL9gQ7AZ55xHUSkufs5G/gJTrdpY4wxYaJJXkbgPHull4h0jm91jDHGmNSjqmXAOOBtnAcsv6Cq80XkThHx3vb4bOA5t/dAyABgpojMAT4A7vXepcwYY8w+0Vzz8gUwBuihqj/WVtgYEz0JvayflzEpT1XfwLke0zvutrDhP0SYbzqwf1wrZ4wxjUStyYuqLnQ/zo1zXUwTpjTe6zQa6/cyJlU15LWcxhhj/BXT3cZEJF9Vl8epLiZFJFOiEU097KyGMSZMBxG5EOdulW8lujLGGGOiF+utkl/GeXBkBREZrqoz/KuS8VM8Eo1Y40WVYITeLdEwxsRf6FrOySLS2bpEG2Nqs/Pjd9jy4tOUrllBRrc8OpxxPm1+WrcbFFqs+okqeRGRs3CSlkwRGQAsVtWgO/kJYLAvtTF1UlN735ICY4ypInQtZ3dLXIypv2Rt9PoVa+fH77D530/QaexNtBhQxJ6Fc9jw+L0AMcezWPVPYKI98/Ip0AK4CHgI6CciW4EfgN31rkWSsi5JxjiSqatgvCTb97MHeMRP6FpOETmfsAvsjUlm1rBPTKwtLz5Np7E30XL/IQC03H8IncbexMZJD1usOMeKJKrkxX141jMi8r2qfgogIh2BfGBRvWvRgALJ1kIxTVo8koJ4dRWMx5+O/TlWz9ZNgzg60RUw/krGxr1fsaxhn7hYpWtW0GJAUaVxLQYUUbpmRUxxLFbssSKJ5jkvFUKJi/t5k6rOUtVdvtTEmCaovg1UifAKeN79fEVaVn1fxjQ0Efki0XVoDHZ+/A6rrvwlS8/4Kauu/CU7P34n4bFCDfLsi66m53MfkH3R1Wz+9xN1ipeMsbyNcUlPr2iMb3nx6Zjr5GesZG30+hkro1seexbOqTRuz8I5ZHTLs1hxjhVJrBfsG2NiFMsNC4wxcZfh+VwkIsuAb4B5nveF7kMnG5XG3k0oWY/a+xUr2Rv2oe8H9W/0JiKWqkJ5OVpeDuVlaHk5Wl4GZWW0/dlJ/PjI3XQ45yKa5/ehZMlCtrzwFG2PO5k9C+egweC+eYOh9yAaLHfGB4NOzGCQFn0LWf/ArbQ5/FjSO3WhdN0adk1/n5YHDGPLS8+AqjtvEDS4b1jVGQ467xoMkt6xE+vuvYmWhQeS1qEj5Vs2sXv+V7QoGMiGifcjkVoXka53EEjPynZi7T+E9I6dKd+6ieI5X9Ky8EA2//sJCKQhgQCkpSGBNPc9sO89sG98y0EHsv6h22k78lTa/GQE5Vs2seHxe8k695KYt2MkSZe8iEgaMBNYo6onikhP4DmgIzAL+JWq7hWR5sAzwBBgEzDabuNsGoKdNTAmpe3wfJ4LnAAMwnlI5HHAtUCBiKxS1UEJqF9cNIUkIVkb937FStYkof3pv+bHx/5E9sXX0Lz3APYsnMOmpx6h/Ulns/eHlVBahpaXuYlAKVrmDpc5iYH3c6hh3/qwY0jP7kzp2tXs+vx/tBx4AJue/qtTzk0qnM9lFfEoL3c+l5U640v3svaua0nv2AlJTye4ezflWzcTaNWKFRee6NZpX6JCeXmt33XjX/9YaXjLc0+y5bknY15nANvffKnS8K5P3mXXJ+9WLiQCEoCAIBJwhgPOu7jjAYpnfwbBIAQCSIuW7F3xPSXLl0RXEdVKn4tnfurEEoG0NIq/mkHxrOnOuBhtfX4yW194iozu+WSde0nD3m2sgV0JLATausP3AQ+r6nMi8jfgN8AE932LqvYRkbPdcqMTUWHT9Ph9MbUlQ8Y0DFU9Imz4B5ybz0wLjRMRAfo0cNXiqikkCcnauK8tVsUR/7LSiiP9FQ3yisZ9KW0OP5Yf/3In7U4+h2bd8yhZ9h3bpr5Am8OPZedH09z5y91EoLSigV/RyC8vQ0tLobyctHYdWPenG2leMJC01pmUbd3E3qXfkt6lGz/cOq5qjIp6hZZRWlG3UKN//T3XV/remyaPh8njY15fADve/m+l4eLZnyFzvoT0dCTNeZGejoSG09MhLR1JS6v4nNGlG4GWrSldtxrdXYy0ak2L/oPI6NrDEyetYr6K+dP+P3v3HR9VlTZw/HempQeSEHrvTUGKoKAEEAVE0FVZEAuKXSxrV3bt7CIW9FWsINgWdBERUVE6UkRAehWIEAIhAdLrlPP+MZMwCQESmGHmJs/385nMbfPk3GnnPPece8fi7k3wbIPZXHo7U/G8p6fBZCpneemeCPd604l7kwXMJs/jPQmKMqFKpt1Jigqiq0JprUv1KuFyld/T5D3vdGKJicNcI8anZQmq5EUp1RD3UbDxwKOeCqQfcJNnk0+BF3AnL8M80wCzgHeVUkprLRfpEX7lj8TFH2/a4PnKEyJovVveQk898ud5LotfVdUk4cRQHwc1hgwn9d3xxN06FluzVhTu3srxLz8ketD1FPy540QDvqRh7vQ6em8vdVQ/pGlLjrw2jvDuvbHExGNPPUTeH6sJbd2BtA8mljrKfyLJcJ7oCShZ7sSVm83hl/6BOTIaTCZ0YQGu/Dwwm9l34+UVOuLv7fj0d0rNZ/3wP7LO9CCTp1Hv1dhXVpv7vASHA6w2LDFxmMLCQWtMISEQEeHZ1lo6UfBOHCxWd6Peaz2e5SUNfqu13IQDixVlMXu2LbvOcuJ/m81B1YivrpRSngQu8KlD4EtQ2lvAk0CUZz4OyPAae3wQaOCZbgAkAWitHUqpTM/2R89fcYU4N/7KtP2REEnVIaoarfXZjfcwIO8k4dC/xhLVdxCW+LpY6jd2z19xDVF9rsJVWEDKK48R1f8aIi6+DGdmOqlvv0Rkn4GEXdAFR/oxdEE+RyaOo+b1t2KKjiHjqyk4c3OIuvxKMubMIGvBd4R16o61Tn0c6cfIW72E0HYXYo6thSP9OAWb1xHSvDUmT2P+8AsPY23UDEtMHPbUFBwpBzHH1OLgY6Nx5ubiyjiGKTIKULgK8tEF+WA2u8f/O04+NSn1jX+Vmk//4gPSz/J5y1nyU8m0u7G/Gb3lD8w1YlAWizsRKcjHWr8RymzBmZWJKy+bkBZtwWzBcfQIaE1Iy3YUJf2FzssBs4WwThdja9Kcwj07cWZlEHnZAJTZQv7W9TizMokeMBRltpC79ldcuTnUuPpGsFjIWTofV2EBMX+7GcwWsn76Bu1wEDNiDMpiJWPWp6BMxN56H8ps4dink1EhodS6/UEA0t5/FXNUNLE33+d+rt4Zj6VWbWJH3uWef+tFrPUbEzP8dgCOvPEcIc1aUfNvtwCQMvFZQlt3pOa17mPKKf9+krALu1FjyHAADr/8GOHdehE9YKh7/oWHiejVv2S++L0X1e9qtMPB4RcfKfPee5zoq64lsvcVuHJzODz+CWpcfQMRPRNwZmVw5LV/UmPoCCK698aRfozUN5+n5nU3E96lJ46jR0h9+2Vq3nAb4Z26Y09JJm3yf4gZMYawDhdRlLyfox+8RuyoewhtewFF+/dxdMqbxN76AKGt2lGYuJtjn/wfcXc8REiz1hT8uYPjn02m1p2PYmvSnIKdWzj+5YfUuvcJbA2akL9tA+kzpxL/wDNY6zYgb9NaMmZ9Su2H/4WlVh3y/viNjG+/oPajL2KJiSN37Qoy586kzhOvYI6uSe5vS8n8YRZ1n56AKSKSnBULyfp5DnX/+TqmkFCyl/1M9sLvqff8WyiLhezFP5C95Cfqv+w+5pK1YC65KxdR7wV371bmT7PJW7eSev96wz0/72vyN6+j7rMTAciY818Kdm+l7pPuoW8Zsz+nMPFP6jz2kvtz8vU07IcOUPuR5wE4PuNjHEdTqf3gOPf8F+/jzM4i/r6nADg2/V10USG17n4MgKNT3wKg1phH3PMfvYGyhRA3euxZfvpOLWiSF6XUECBVa71eKZXgw7h3A3cDRJujzrC1EOeXPxICfyVEvr4Ec3E8SYqE8L+YG24j7b0JhDRvQ+HenRQlJeLKzUaFR+JIOUjhnh0c/fA1tL0InE4Ktm0kzevxhbu3nRTz+GeTS81nzZ9dMp19OKnUupyjqSirFUxmtL2Qgt3bMYWHg8sJZgv25APYD+wDqxVlC8ESXxdzVDSmiHyKCvKwNW+DpUYMzuxMCvfsIKxzDyw1Y3AcP0bB9o1EXNIPc2ws9pRk8jeuJXrAMMwxsRQd2EfeupXUuO5mLDViKNy7g9xVS4m55V4s0TEUbN9A9q8Lib/vKcxR0eSuX03OsvnUeXI8pvBIclcuJnvxD35vQMbccBsA2l6E/dABoq8cBoA99RCOo6lE9Ozjfh12bsaZnVXSi5a7agm6qBCbp6dKhYYBuHt5ABVkQ4+E8AUVLKOslFL/AW4BHLh/EDMa+Ba4Cqjr6V25BHhBa32VUupnz/RqpZQFSAHiTzdsrJ6tjh5dx7enxfjlty/ke0YEGSP9SKVRyulr45PeWa+17hbocojzp1u3bnrdunUV3j7n1wUcnfoWrqwMVFg4tkbNsNZr5B7WY7W6h+9YrWCxlZpXVlvJMKMT23itM3sNIbJYPdtaSw8rMlXqlxmEENWcUuqUdVrQ9LxorZ8BngHw9Lw8rrUepZT6H3AD7iuO3QZ853nIXM/8as/6xYE438Uf//Bc96LcxlsFW3QVbfhpLUlWdWKklzo4Dsf4XlXdL3H+RF42wGdX+xFCiEAJmuTlNJ4CZiqlXgE2AMVjlKcCnyul9gDHgREBKl/Q0WWmVdmFFXzs6TZS6tyTrHL5MMmSBEtUJfJWFkIIIYI0edFaLwWWeqb3AReXs00BcON5LZgB+aXBo3x/FLgk0fBlklWpDStOEiIhhBBCiMAIyuRFVD/+SgiCcVhf6WCAknOnhBBCCCEqQpKXc2Ckk5hFkPK8gXyaD/ljWJ+PhuB5x5BhfUIIIYSorGqXvPh8uJOP44EkROLc+CMh0D6KWTah8sd5U/L5EUIIIaouuXZhENIGuYnqw0gJQaA/F/J5rL6UUgOVUruUUnuUUk+Xs36SUmqj57ZbKZXhte42pdSfnttt57fkQghhHNWu50Wcu+LhckZoMBmp0S2EMC6llBmYDAwADgJrlVJztdbbi7fRWv/Da/sHgYs807HA80A33F+t6z2PPdsfhhdCiCpLel5EpRntV+GNcBNCGN7FwB6t9T6tdRHu3yYbdprtRwIzPNNXAQu01sc9CcsCYKBfSyuEqBIWf72WMd1eYkDU/Yzp9hKLv14bFLH8SXpeRFCorj0k/uzFqq7PqRAB0gBI8po/CPQob0OlVBOgGbD4NI9tcIrH3g3cDdC4ceNzK7EQVdzir9fy5cSfOLArhcZt6jLqyUH0G969ysRa/PVaPnnxOx577xYuuLQlW1bt4Y37PweodDxfxiqO56vnq6xqlbxoqPAJwqc76dk7hlwtSZwLf/ViybA+IYLaCGCW1tpZ2QdqrT8CPgLo1q2bET7mohqQhn1gYn058Scee+8WLurTBoCL+rThsfdu4d3HvgpoLF8nQmVVq+QFKt6gq/BVkPxUdfgyKZJL0lYv/kyI/BHXCHy970bZb1EpyUAjr/mGnmXlGQE8UOaxCWUeu9SHZRMB5ssGuSQJFePrhv2to7uz47WvWLX3MDEt6nHr6O58OfGngMY6sCuF0IwM/jvkJdI9sS666yoO7EqpVBxfx/LlPpan2iUvvm2GaP+dq1GZwBXY1tfJiyRE1Ut1f6kl2RAVsBZopZRqhjsZGQHcVHYjpVRbIAZY7bX4Z+DfSqkYz/yVwDP+LW7VVJUb95IkBK5h7zxwmMPzC+k//lbqdW3J4fV7WDTuM5wHjgc0Vqfm0ayY+A2D3hhTEuunx6bSqXl0QGP5ch/LUw2TF1/yV5Oukk2l0w1x86x2+bj1pahkglXRuNLjJIQwIK21Qyk1FnciYgY+0VpvU0q9BKzTWs/1bDoCmKn1iW9QrfVxpdTLuBMggJe01r6p5f2kKicJvo7lq8a9JAmV48vGeIc4M42H96VhT/dz37BnGxoP70uHQ3NO+zitNU6HC6fDidPhwmF30iHWRNzAnljr1+LIweNQK4bovl1pn7yIvVsOol0al8uFy6lxOl24nC6068S0y6nd91rT1Grnt0MurAt30+hAFgd2Hua3Q3Y6x5lY/L+1Jc3J4q8bXWYefWK6iaWI1Ydc6B+202j3MQ7tS+O3Q3YuijPx63cbMJlN7ptSnmn3vbl4uWfeZDLRPsZE5OVdcNSIJi+noMLPV0VJ8hKUfNfi9t9QH99mLiXnaZxN2DM8RhIiIcT5oLX+EfixzLLnysy/cIrHfgJ84rfCIUlCoGL5qnFf3ZIErTV1urSg3rW96ZD8A8ePZOGwO3AUOXHYndiLHDjs7mlHkQN7kdO93u7EUeR0N8aTXdi/3UyddQdJ+jOVTUlFdIqFaS9/j9MTw+lwesXx3DvcMR12J067k8YuBxOfmcP0937FGmIlLzufY4fSGVLHxcg2z7oTE4ezVJLidLiTjbKubaB564Uf0C+c+KpQaIY1gLt7jq/U83VtA83+VPjrP6VjdbbC+NGV+zq5toHmQCrsf/OXk2K9cNNHlY71/sQF6IkLuW/CDbS4sCGfvL2EHpU/za9cQZO8KKUaAZ8BdXA3Rz/SWr/tuf79V0BT4C9guNY6XSmlgLeBwUAeMFpr/Ucgyl7dKK+/vnWWCdEZep4qnRAFYIyQJERCCH8K5iQhGHsAfBnLV417X8RxuYqP/pupPeRSwpvW5WhKJio+hqiErrQ/uIid6/5yJwblJATFCYN7vfu+oSpg5QFNyvu/EhO/iSMHjrH/r3w6xSheuW0qDrsnTpEDuycZKHl8cTLi+V99rA7+/dgs/vPktzgd7oZ/ccP+xuZPVer5uraB5kAa7H93cckyhaZLKHwx4UcsVjMWmwWL1YTFUjxtxmw1Y7GasXpN26022jSNZs/BTPJzCwmPCqVTxzq48jLo0qMtZosZs8VU6t5iNZVZ7p5O+/JnBndpyG/rkjmekklcvRr0vqQJoYkHeH7ijZ7eixO9GO7eDYUyuXs3TvR0mFj1xMf8+4WBxHdqhjK5f/3k2JZEtn78E9O+d59WV9K+8EyokntOzCtYeM87vDFxCLU7Ny/p6UndsJctH/3ER7Puwel0obWn18fp8vQElZl3ued3TJzJtb2asmLlX3zwzCyatK3H8FsvJnvFpkq9hqcSNMkL4AAe01r/oZSKwv0jXQuA0cAirfUEzy8WPw08BQwCWnluPYD3OcVlKUXw819CdBZOWwzfn+dkhCF4QghjC9YkIVh7ACoSy+l0lRydLzliby9u3Hsa6XYHzUOd/J7iInr1fhoeLWDfloPuoT2xivmfrcJud5aO4/DuSTgRs74zj+WJmu3P/0BEdBjpqVlk7s2jU00Y23eiO0bZx3sShpJeBE9CcG0DzRv//B79z3kl+1OcJDzQ59VKPVfXNtAcTIeD36xHazCZFRFRIdjs+WzaeACrJ0mw2tz3thAL4VGhJ5ZZT6xTq9bTq1ltNu9II/NYLjXjo+jepT7Ww4d4+ImrMVvNWK0WLDYzVpul1LzF6l5m8SQcyx75gEmvX0P97q1LkpK0TXtZ9eo3LNz1XEkjvpjWGu104bQ7cdkduBxOnHYHriInexdsYOP0Rdz59t+IaVWftG37+eOjn2k76nLqdW2By+FEe4aHuYpvdq9phwuXowiXw0lo56Ykr9nN6EFtCY+LIiclg+TfdxLXvjGFqzejnS50yXAxFy6H+75kWfFypwuzSbHu3zOJrBeDJcSKI7+QnJQMwmpFseLRD91DwoqHhmlPC6bsMu3+xTl7XiErnp1OaI0IzCEWXA4n+cdzCIuN4renp6BMJpQnqcIzdEyZTSilSt+bTUTEROD4Yys3dGnERZP/TkhUGIvHfU7Pf5zup68qTml/tJp8QCn1HfCu55agtT6slKoHLNVat1FKfeiZnuHZflfxdqeKWddWR99ae8T5KL4QFeIeLuf7z6BCkpfq5tWD76zXWncLdDnE+dOtWze9bt26Cm07uvZ99L0glv7jb+XN5+fRu3czspeuZ/HmY8R1bc2g23oxYGQPCvKKePZv73LNnZfT94Zu5GTm89zf3+e6+/py2bCLyDyaw6OdnqZrPRtD372H0IbxvDnqPRrmHmef3caTPzzJhDunM+rJQXTt145DiWm8ft/n3DZuCJ0ua03S7hQmPfRfxrwwjA49WzCxzQMciohh9Fu30KxDA/ZsTGL6o5/TsCCTEd/9kz0bk/jfOwu5fmw/ajeM5c9NB5n/2UqGjLmMmPgo9m5JZvm3f3DFTT04PuMX1qU6yA8Np9+N3ck8lsPWeevoGOnEMuBSLFYzyfvSSNyaTPsezTGZTRw5cIzDiUdp1r4+GjieksnxlCwuq1nExnTIs4ZSmG8nJNxKWEE+F9bQLE5VgKKi7adrG2i+SwbtdWSsOFGYk1z+F7VSCovN7PkfiuiYcC63ZvLzcRsFBQ60S2MLtRISaqZ/RD4H27bHbDWTtDsFZTLRvnszLDYzO35PxGKz0CWhDRabhbULthEWGUrrzBRyGjVg8ZK9FOXbqVW/Bpf1akrRuu0U9riIK0f1xGI188WrP9G4dR2uvuMyrDYzk5/4H627NuFv9/XFYrPw79s/ofHh/QyZNIaGPdvw9LXvcMngC+l6YV2Wv/IVG3Q0CTd0Y/DoXminiycGT6LfDd1IuO4iivKL+M/tU7l8aGd6DGhPflY+0x/6lHhnPt3vupKQ+Jp8++r3xDvyaDO4K5GNavPT9BVccEkLGjaPJzcjl5VzN9Cmc2Pi69UgJyOXLb/upmmbukTXDON4Yirpfx0hsn4skTGR5BzNIjclnZDocEIiQynKKyIvKw+bzQIuF06747yMvFBmdxLgcjjdyZ7JhC0yFKdS5OcWElevJiazmbycArIz86nfojYms4msjDwyj+bQ/IKGKLOZY0cySU/NplGTWDIPpGHPLcBlMlG3Q2Mi68VwaG8aGUez6XhJC1CKpD+PkHUsh469WqGAv3amkJ2Ry4W9WoFS7NuaTH5qBuE4KMrKB6sFZ1gYbXu3Qbtc7NuajKPQQfOODdAuFwd2HMblctGoZW1cLheH9qSChjpNYtFOF0f2HEEVFoF2EduyPt3uHUTrIRU/UKKUOmWdFpTJi1KqKbAc6Agc0FrX9CxXQLrWuqZSah4wQWu9wrNuEfCU1npdmVglP+gVbY7qek/d28/bfghRMf45f8gf/97TKy2CkCQv1U9lkpfX2o2l2yPX0vGabjz/9w/oMfACQvJyODBrOX/WrEfXfm3p0LMFedkFzHjjZy7s1ZLmHRuSk5XPT9NX0rZbE+o1iyc3M5/8ecvZmmOiQY82WEOtbF6+myhnIZ3jTCTVa0LijkPUqlsDW5iN/JwC0pIziIgOxWQ2UZhvJy87H5PZhMupGVrXWemG/amUlySYTDC0nuaX7DBsNgtOp4uCvCLi6tckNNRKQV4RmcdyaNquHrYwG9nHc0lLTqd/RC676jZj39ZkCgvsRNQIo13XJjTcvYOVxHLVqJ5YbBb2bEwicXsy13ka81tW7iFxWzI3PTEQq83Cml+2wpI1dHloGLUuaMqy2ev5a8dhRtx2MdumzKeoR2f27zrCE+/dgsVm5uu3F3JoXxrjpt0BuM/NSDuYzpMf3sp/h7xEdoMG5FpDefTdUQC8d+fHODfsYOy6N3A5XLz/5NfgcnH7P4fgsjv55IU52KxmbnigL067kxkTfyI8MoSOLWPY+e1qMiNrEFk/lvbt6rBz9iqyrKFEN6lNp0tb4rQ7WTFnPTXjImnZsQFOu4MNS3ZQIyac+k1r4Sxy8OeG/YRbFDo3n8i6NTl2JIsQqwldUIQlzEZhXhFmk0I7XT4fYqDMJpwujTXUii08BEwmstLziK4VRUTNcJwuzZF9qYSaNK4iB5YwGzlORZOuzYmpV5O87EK2/LaXC3q3plbDWDKP57J20Q56Dr6Q2k3iSDucyYrvN3HFTT2p0zSe5MQ0Fn29jmvv60udprXYt/0Q87/4jVFPD6ZOk1rsXPcX86at5J4JNxDfKJZNK/cw58NlPPHBrcTWj+H3hdv45t3FPP/lPdSoFcmv323g2/eX8NJX9xFZI4wls9bx/ZTl/Hv2WELDbSyYsYafPl3JxO8fxmI1M//z1fzy5WrenP8oAD9MW8HSWet47YdHAPjuo2Ws/nEzE+Y8CMA3kxezYelOXvnf/QB8/dYCtv++jxf+ew8AM17/mT1bkvjXp3cC8PmEH0nafYRnP7n9pPcewJTn5pB1PLfkvfdOgCbaAAAgAElEQVTBM99QWFDEw5NGAjD5ia8BeOC14QC8/Y8ZhITauPc/15/d62uk5EUpFQksA8ZrrWcrpTKKkxfP+nStdUxFkxdv0vMiqgN/9ub4g/QQ+YYkL9VPZZKXd9vexxpTLNHx0exc9xdQ+STBbDFhDbEysGYBC3PCyM+143Q4sdosxNWJoqc+zp7GLd3DeKxm91Aem6Vk2FDxMvcwH/dQofwffiWrXj3WbUohIy2b2DrRXNKjMREHkmj1yA1eQ4Pcw368hwVZvJaZrWbm3zGJno//jYaXtHUvs5hIXrOb5a98xU3znjvzDnr575CXuGzccOp3a+UZAuTg4G+7WP3GHK6ZMhZXkfvkbJfdUTLMyOkZauSyO3EWOdz3dgeH/9hL4qJNtBjYlcg6Ncncn8q+RZuo17UlNRrVKtnuxL13zOKhSw7yjmeTfzSLkJqRKKVw5BdSlFvoSQR9nxygFGbPc2u2WTFZzZ55C2abxTNvxWw1k5+RS1bSUey5Bdiiwohv14iYFnW9ti2O45k+KY6l9LY284ntPOu8/5/JanEPXxJV1umSl2A65wWllBX4BvhSaz3bs/iIUqqe17CxVM/yyvwgWAmf52oqaM7UEALwz/lD/rjCHFTufJ8zJTnFcSQZEuJksS3rMbx3J2Z8+juXxWuOh0TQvk87rLv3MbptOA37d6Zx384oXPz+0n9pde0ltLiqC9puZ/ETn3DhLX1pNbAr+cdz+LTfs/zzHwPoft9gctMy+fnRKTS5rCO75q5h9Md3sODJaXS/7yoaXdqOzKQ0Fj37GRePGUL9ri059uchlr80ky73XEV820ZsCnOw6dNFPPbgAJr168S+he5zC1oM7UGz+BCO7znMjm9W0/baHoTERZO+L4V9CzbQ/MouhEaHk5GYQtJvu2hyWQdqNqrFwsemYAmx0aBHa4qy8zm0fg9mi5k5t72JMpnITcsk+1A60Q3jQENBZi4FGTmE1ohEu1wU5RbgLLSjge9Gv1Xuc/n5Ff86q9dg28zlJdPKpEhes4uDq3eC1oTFRmGyminKKcDlcFKzSW1MVjO5RzJwOpzU7tCYqIa1OLIxkfz0bFx2JyE1woluEIstOpxmCRdgslo4sGIbymSi1eBumK0Wdv+wFkuIlfY39sJkNbPly2WERIdz4S19MVvNrJ38AxG1a9Llrqsw2ywse3kmMc3rcvEDV6PMJn55dCq12jWk690DAfjxwQ+p27kZXcZcCcC8e9+j0SVt6HRbfwDm3vkOzfpewAWjEgCYM/otWg3uSofhlwEw+5Y3aHfdJbT726U47U6+u+MtOtzQm1aDu2HPL+L7u9/hgpF9aDW4G4XZ+fxw/3t0uqUfLa68iPzjOfxw/3tcdPsAmvW7sOS91/WugTS5vAPZh4973nuDS733ejx4DQ0ubk36vhSWPP8ll/zjWup1acGx3ckse3kmvZ64njoXNiVtRxK//vtrLnt2OPHtGnFk81+sfO0b+vxrBHGtG3D4j72snjSHvi+OIqZ5XZJ/382ad76n/79vpUajeJJW7WDt+z8yYOLtRNWLZf/ybaz/eD5XvXknEfE1SFy8mQ3TFjDo7XsIi41k7y8b2PT5Yq5+735CosL488d1bJmxjGs+ehBrmI1d361h26wVDPvkEcxWMztmr2LHt6v52+ePud9PX//Knz+u59rp7p6XLV8uJXHJFoZOcfe8bPp0EUmrdzHkA3fPyx9TfyFlYyKD33H3vKz/aD5Hdxzkqknunpe1k38gPfEIV77u7vVb8/ZcslPSueI/twGw6o1vKcjIpd/LNwOw4tVZOAvs9Hne3fPy63h3z8tl49w9L8tenIE51Ervp244q8/L6QRN8uIZEjYV2KG1ftNr1VzgNmCC5/47r+VjlVIzcZ+on3m6812EEOfK978zX6nfYq3oxnI5ayFO0u3eQfw26TuefWEgmz9fQs2mtTm8fhctruzMwTW7cR4+Rs6GXRTlFVJ4PJsjv+2g8PAxinILyDyQxraZv/LXos0U5RaglGLt5B/Y+8sGlNlE+p+HOLx+L+G1opk96nXy0rKY/8gUlAJHoR1HQRFzbp1Uqjw/3PNeqfn1H85n/YfzS+Z3fLOKHd+sKplf/Ubp34fY8PHPpeZ3zF6F2WoBDYWZuez7ZQMmqxlrRCjOQjv56XlYw20AmMwmwuKisYXbsB4LweVw0qBHa6zhIWQfOsaxPw/RanA3spKOkbR6B/acAsLiomjSpyMAKRv2cfHYIZisZpLX7ObwH3vo/dQNmKwWEpds4vAfe+n38s2YrBZ2fbeGlI37uPKNMZitZrb8dxlHNv/F4Hfvde+3jxqQPR4eCkBBeg4AF9zUB4C07Qcwh1ppfkVnAPYt3ERozQjqdmoGgC06nNCaEUTVjwVw935YzJgs5jO+p4QIlKAZNqaU6g38CmwBii+M/SywBvgaaAzsx32p5OOeZOddYCDuSyXffrohY+AeNnZLvAGGjUlvjqgW/PPd44/Pjq+TIX/8XpAMG6t+KjNsDGD3vLUs+dcX2PMKK7R98ZCd8ob52PMKyUvLwlFQhDU8hJpN6xDdKK5keFDp+/KWmTF5rTdZTCeGJlk8w4I8w8JMVgsmi7n8GBZzyZWOhDCKGTNmMn78BHbs2EG7du0YN+5pRo48u/ZpVY1liGFjnnNXTvXt07+c7TXwgF8LFSja9806+V4Xwcc/vxXky8/OOf14annBvKKedcjgON4kDKj1kO7Eta5PUW5hyfkH5Scn7mRCEgIRCMHUgPZHrBkzZjJu3HNMnfoRvXv3YsWKlYwZczdApeNVh1jlkbOdqrjiRpfWvr8JEXyUT2/Kl/FU8c3kOZpwrnHK3ISogLjWDah3UXNqd2xCXOsG7h6TBnFExNcgtGYE1vAQzFazJC7VwIwZM+nYsTNmcwgdO3ZmxoyZAY9V3Oh95523KCjI4Z133mLcuOfOKl6wxho/fgJTp35E374JWK1W+vZNYOrUjxg/foLEqqCgGTZ2Phhm2FiQ88eQl0pf3reCpP4V1cVryf8nw8aqmcoOGxOB48uj9v48+j9+/Es+O8p+NrE6duzMO++8Rd++CSXLlixZyoMPPsLWrRurRCyzOYSCghysVmvJMrvdTmhoJE5nxYZ0VodYpxs2Jj0votL8kRAoP+XQ/uhxMkIvVjU6JiGEMLhg7AHwZSxfHbWvDkf/d+zYQe/evUot6927Fzt27Kgysdq1a8eKFStLLVuxYiXt2rWTWBUUNOe8nC/VtU3n++tE+ThmNe8h8WWyUdwzVl0TGCOcXO+PmEKciYz/D0ws78Y9UNK4f/DBRyoVy1dxIPgb9t49HOfagK5sLJfLhd1ux263U1RUhN1up2XLlnz99Sy6dr2oZN1vv/1OkyZNWLZseckyh8NR6r68ZRdc0JHrrx/ONdcMoX79euzff4Aff/yJXr0u5ZFHHsXpdOJ0OnE4HCXT7purzLwTi8XM1VcPpV27ttSoUYP09Ax27txJs2ZN6dOnHwBa61K3Uy3Lz89n4MCradasKVFRUeTl5bF37z6aNWtK375XYDKZMJvNmM3mcqfd9+7puLgYhg69jj59Luehh8ZitVpLeuN8odoNGxslw8bOmd+GePkhZnUmz2dgnemb9Wxen9PFfOOQDBurbiozbEyGCRl/mJAvh/Wcz+dKa43T6aSoqIiioiIKCwtLpr1vhYWFzJ//M1OmTGPs2Ptp2bIlW7du5cMPP2bYsGvo3LmTZ1v7SY8tTjS81ycmJrJz5y7atGlNWFgYx4+nk5iYSHx8PGFhYaWSE+97p9NZqf0/V0opLBYLNputJCEwm81YLJZS86VvppL1GRkZJCcfIj8/n/DwcBo3bkTt2rVRSpWcu1Y8faZlhw8fZu/efeTk5BAREUHTpk2Jj6+Fy3UicTp52lVqefF9Tk42WVnZOJ1O2rdv79OrjVWr5KWOrY4eVevsk5fynqmg79Go7irxZJ5uU+8LRQX7UXjt+ePrmEZ5X1bXz6QkL9VPZZKXqt6wD+ZYvnq+ysbRWrNgwUIefvhRVq5cVk4jvuikBn3xbenSZcyc+TW33noLTZo0YufO3cyc+RX9+/ejTZvWFYpRfDt8OIXk5GTq1KmDxWImOzuH9PR0QkJCcLlcFBUV4Y+2ptlsxmazneJmxWazkZWVRXLyIfLy8oiMjKRNm9Y0b94cq9WdLFit1jPcn9hu/fo/+P77H0hOTqZhw4aMGDGcAQOuwGKxYLVasFqtnukz31ut1pLeClE+SV486ljr6JEVTV4q0lrxQ6vGL8NJ/BTTEC266qiSr02F3upnGdOX3y4VjVld3+qTDkvyUt1UJnmp6g37c43ldDpLDRW69NLLefHF5+nevWvJstWrf+PVV19n2rQppzxq75082O0OioqK2LBhA4sWLeHKKwdQu3Y8Bw4cYMmSZXTu3In69eufovegeP7EsuzsbLKzs7HZbCXl9QelFCEhISWJgPd0cVJQ9paamsquXbvJysqiZs2adO/elQ4dOpQTo/TjS8cuXmYrSRjKW1+8zmyWH9KsyuSEfQ8NOCt604G5uc7mca4z3DQ4KnNzVeDmj5hnE9dzO+Xz4svn0eWfmI5KxHRV5EYFt6vE++1sY1bmMb6KGRSfyQDchDgd7xNoExL6M336p6xYsZK2bduSkNCfL774EoC8vDwSEvrz1VdfA5CZmUlCQn9mz/4WgKNHjxIaGsrEia8DkJKSQkJCf9588y3atm3Lvn2JXH55X+bM+Y7U1FRWrlxFz569+PzzL9iyZQuzZ39Lly7dee+991m4cBEXX9yNq64azJ133sNnn33B6NFjuPLKQTRv3oy33nqbBx98mGbNWnH//WN59tl/ctNNt9CwYRNGjryZO++8m6uuGkzt2vUZOHAIoaEhDBx4NVFRMVx88SV06HAhV145iD179tCqVTtatGhDfHw9bLZwYmLiiY6OxWoNQykrFksoYWFRREfHUqtWXXbv3s3IkaNo2bIt7dpdQKdOXbn33gdITEwkIaE/AwYM5Oqrh3LttdczfPhIRo26ldtvv5O7776PsWMf5tFHn+Cpp57hX/96ntmz55CTk8OsWd8wefL7fP/9D9hsNg4dOsySJUtZsmQpR44cIScnh/3795OY+Bd16tShefPmmEwK0AwY0J8RI4bTpEljtNbY7Xbi4+Np3boVl1zSk7feeoP33nuHK67ox5VXDmDmzC+ZPft/XH31IG644W8sXbqIVauWc911wxgz5nZ27tzKvn27GT78Bh599BEyMo6Sl5fFTTeN4MUXnyc/P5vMzGP079+PsWPvZ9++3ezcuZVWrVoxYsTfWbXqV5YuXURoaCgDBvTn999Xk5l5jIEDr2L8+Jf45Zf5TJr0BuvX/0Hjxo345z+f5cknH2fOnLmEh4dz551jGDlyBO+//yG5ublcffVgevW6lOeff5H9+w/QpUsXGjduzN1338cff2ygfv36AAwdeh0LFizEbDaXvPfmz/8ZgKSkJBIS+rNw4SIA9u3bR0JCf5YtWw7Arl27SEjoz6pVqwDYunUrCQn9Wbt2LQAbN24kIaE/Gze6E921a9eSkNCfrVu3ArBq1SoSEvqza9cuAJYtW05CQn/27dsHwMKFi0hI6E9SUhIA8+f/TEJCf1JSUgD4/vt5JCT05+jRowDMnv0tCQn9yczMBOCrr74mIaE/eXl5AHzxxZckJPQvSVKnT/+UhIQTP3v48cdTuOKKq0rm33vvfQYNGlIy//bb/8fQodeVzL/++ptcf/3wkvkJEyYyYsSokvmXXx7PzTffWjL/3HMvcPvtY0rmn3lmHHfffW/J/OOPP8kDDzxYMv/II4/yyCOPlsw/8MCDPP74k/hDtTth3+HyYTDNGQ/JntURW380RKprTD+U0ddXRtN+iFmdyYnwQpxs3LinGTPmbkaPvpUDB5KYOnUaW7duo1evS9i4cTPTp3/G0qXLyMvLY/v2Hbz++iQ+++wL8vLy2LhxI08//SyvvPJvcnPzsNvtPPfcC7zxxiRcLhdZWVklDcQWLVoD8OuvK0r9/zVrfi81/8ADD5Wanzr1E6ZO/aRk/vvv5/H99/NK5t9//8OSMf4Oh4Off/6FsLAwz9j6HPbu3UtkZASxsbGkpqaydu06IiIiaNKkMRkZmbRr147o6EhSUlLYvn0HgwYNpEaNGiQmJvLHHxsZNWokUVFRbN++nd9+W8PYsfezbdt2Zs2aTXp6Og0bNuTvf78RrTWLFi3m3Xffxmq1Mm/ejyxYsJDPPpuG1WplxoyvWLRoMd988zVWq5UPP/yYpUuXMnfuHMDdgFy9+je++cadHE6YMJGNGzcxc6Y7eXz55fHs2rWLL774DHA3IJOSkvjkkymAuwF57NgxPvroA8DdgMzPz+fhh93P565duwH4+9/djdSFCxcRFhZGnz6XA1CrVi3i4uJo06YNAOHh4URERFCjRg0A+X0fYQjVathYvLWOHlbz5GFjFR0hVhmBiHk2r6SvYwbquQxW5zz6sKq8QOcYU5UX4jx9gDQ+ToiK/08FYpa736fwcZoMG6tuKvs7LzNmzOTuu+8jJycHOP3woOKhO+UN7QkJsXHwYDJbtmwlPT2duLg4evW6hM6dO5ecK2CzWb2mbaWmS89bS84BCAkJKZkue/6B1WqVhrUQ1cjpho1Vq54Xl4ZCH15EogIdL5VueLvQmM7wqMrG1GjPL4X7zkkxfX3pJB/ELPf1OeeYPthvo8Q06Otj8vFzeVJJgyVm9TnuZBhKqYHA24AZmKK1PumHLpRSw4EXcL+Cm7TWN3mWO4Etns0OaK2H+rp8I0eOYOjQa1BKlVzZSBICIYTRGDp5qUhF4c2lNXkOJ2VbCmd34LjsksrHPHl77dWkKV5SuXgnb69xUXxyk69iFje9dKn1FY1Zke2DNWbJfvuqvtcGiHn6t3pQxTyb/S5v05JlGs/n50TMc84ZdPH/cMf0VTwRWEopMzAZGAAcBNYqpeZqrbd7bdMKeAbopbVOV0rV9gqRr7Xu7O9yRkRE+PtfCCGEXxk2ealIRVGWS0OOo3TXS2Xq/ZOHcJTfo3EuMU86clzJmOVfkani5SyboJRddmL5yTFPVcbyylTZxOlsYp6qx+l8xTyX59IfMc/m+T8b5ZWxvP/pHo516v0+myRUa31OMct7pPsKgL6NWd5YtDO9Pufr9RNn7WJgj9Z6H4BSaiYwDPCuk+4CJmut0wG01qnnvZRCCGFwhk1eqFhFUYodJ6lkeebKbaaUTKtyU5XSjyzdkD1TvLLblN+Edg8bK+8icCc3rYv/tz5FLO//dHIpvftmTo55ogl8ppjlD0grP6Z35NLUGZuC3o8s3Q9y6q11Oc/7qUpSsb4YJxozyqcxy/a2lR+zMs3V4t42X5+oUfkBi2d8ffSZXu/K7bcTjVmf7iKKlY+pwefldAGm08asLOl+CQINgCSv+YNAjzLbtAZQSq3EPWLgBa31fM+6UKXUOsABTNBaz/FzeYUQwpCMnLxUpKIoxU4Byewtp5o/OUkxnbT05GFhWrtQynSKZoM+aap0zJMbLgpwahfmCsYsbkKfLiaAy6Uxm5RPY2qtMSnfxlQnBv2cMl55EXQ5MRUnjsKfqYzFj/AeVKfP8fWpXEwwn3L40NnFLD53ypcxT/Xo8l+fE6/4KV8fT/JfdV6f8lLQU3x+cHn+e+kSlNe/W7qcp0p4pC/GICxAKyABaAgsV0pdoLXOAJporZOVUs2BxUqpLVrrvWUDKKXuBu4GaNy48fkruRBCBAkjJy8V4v1FD+Sk5a/ZFcjynEIt4GigC3GOjL4PRi8/yD4Eg0CWv0mA/q9wSwYaec039CzzdhBYo7W2A4lKqd24k5m1WutkAK31PqXUUuAi4KTkRWv9EfARgFIqTSm1v8wmRvsMSXn9S8rrX0YrLxinzKes04ycvFSkoij1RR+slFLrjH6JU6Pvg9HLD7IPwcDo5RfnZC3QSinVDHddNAK4qcw2c4CRwDSlVC3cw8j2KaVigDytdaFneS9g4pn+odY6vuwyo70Hpbz+JeX1L6OVF4xZ5rJONzg82JVUFEopG+6KYm6AyySEEKIa0lo7gLHAz8AO4Gut9Tal1EtKqeLLHv8MHFNKbQeWAE9orY8B7YB1SqlNnuUTTnfxGSGEqM4M2/OitXYopYorCjPwidZ6W4CLJYQQoprSWv8I/Fhm2XNe0xp41HPz3mYVcMH5KKMQQhidYZMXKL+iMKigHtZWQUbfB6OXH2QfgoHRyy+Mz2jvQSmvf0l5/cto5QVjlrkU5T4QJIQQQgghhBDBzcjnvAghhBBCCCGqEUlezjOlVCOl1BKl1Hal1Dal1MOe5bFKqQVKqT899zGBLuvpKKXMSqkNSql5nvlmSqk1Sqk9SqmvPBdRCFpKqZpKqVlKqZ1KqR1KqUuM9Boopf7hef9sVUrNUEqFBvtroJT6RCmVqpTa6rWs3Odcuf2fZ182K6W6BK7kJ5xiH17zvI82K6W+VUrV9Fr3jGcfdimlrgpMqUV1oJQa6Hmf7VFKPR3o8pRl1LrPaHWd0eq2YK/LjFZvVZc6SpKX888BPKa1bg/0BB5QSrUHngYWaa1bAYs888HsYdxX1Cn2KjBJa90SSAfGBKRUFfc2MF9r3RbohHtfDPEaKKUaAA8B3bTWHXFfsGIEwf8aTAcGlll2qud8EO7fv2iF+3ea3j9PZTyT6Zy8DwuAjlrrC4HdwDMAns/1CKCD5zHvKaXM56+oorrwvK8m4/7ctAdGet5/wcSodZ/R6jrD1G0GqcumY6x6azrVoI6S5OU801of1lr/4ZnOxv3F0gAYBnzq2exT4NrAlPDMlFINgauBKZ55BfQDZnk2Cfby1wAuB6YCaK2LPL9wbZjXAPfFNsKUUhYgHDhMkL8GWuvlwPEyi0/1nA8DPtNuvwE1lVL1zk9JT628fdBa/+K5TC7Ab7h/cwrc+zBTa12otU4E9gAXn7fCiurkYmCP1nqf1roImIn7/Rc0jFj3Ga2uM2jdFtR1mdHqrepSR0nyEkBKqaa4f0V5DVBHa33YsyoFqBOgYlXEW8CTgMszHwdkeH04DuKulIJVMyAN9w/FbVBKTVFKRWCQ18DzS9yvAwdwf9FnAusx1mtQ7FTPeQMgyWs7o+zPHcBPnmmj7oMwHkO91wxU9xmtrjNU3WbguszI9VaVqKMkeQkQpVQk8A3wiNY6y3ud57cAgvIycEqpIUCq1np9oMtyDixAF+B9rfVFQC5lutGD/DWIwX3EpBlQH4jg5G5iwwnm57wilFLjcA+N+TLQZREiWBml7jNoXWeouq0q1GXB9HyeSVWqoyR5CQCllBX3l/eXWuvZnsVHirsXPfepgSrfGfQChiql/sI9NKEf7jG2NT3dvuDukkwOTPEq5CBwUGu9xjM/C/cXvlFegyuARK11mtbaDszG/boY6TUodqrnPBlo5LVdUO+PUmo0MAQYpU9cf95Q+yAMzRDvNYPVfUas64xWtxm1LjNcvVXV6ihJXs4zz5jZqcAOrfWbXqvmArd5pm8DvjvfZasIrfUzWuuGWuumuE/0Wqy1HgUsAW7wbBa05QfQWqcASUqpNp5F/YHtGOQ1wN3F3lMpFe55PxWX3zCvgZdTPedzgVs9V2/pCWR6ddMHFaXUQNxDS4ZqrfO8Vs0FRiilQpRSzXCfxPl7IMooqry1QCvPVZpsuL+b5wa4TKUYre4zYl1nwLrNqHWZoeqtKllHaa3ldh5vQG/cXYybgY2e22DcY2kXAX8CC4HYQJe1AvuSAMzzTDfH/abfA/wPCAl0+c5Q9s7AOs/rMAeIMdJrALwI7AS2Ap8DIcH+GgAzcI9rtuM+QjjmVM85oHBfPWkvsAX31WiCdR/24B43XPx5/sBr+3GefdgFDAp0+eVWdW+eemS35/02LtDlKad8hq37jFTXGa1uC/a6zGj1VnWpo5Sn8EIIIYQQQggR1GTYmBBCCCGEEMIQJHkRQgghhBBCGIIkL0IIIYQQQghDkORFCCGEEEIIYQiSvAghhBBCCCEMQZIXIYQQQgghhCFI8iKEEEIIIYQwBElehDgDpVR7pdRopVQjpVRUoMsjhBBCnC2p04TRSfIixJlZgQeB64CcsiuVUk2VUvlKqY2+/sdKqTCl1EalVJFSqpav4wshhKh2pE4ThibJixBn1giYBuwBTnWUaq/WurOv/7HWOt8T95CvYwshhKiWpE4ThibJixAeSqnFniNCG5VSBUqp4QBa63nALK31j1rrrArEaaqU2qmUmq6U2q2U+lIpdYVSaqVS6k+l1MWV2U4IIYSoLKnTRFUlyYsQHlrrfp4jQh8Cc4FvvNalVDJcS+ANoK3ndhPQG3gcePYsthNCCCEqTOo0UVVZAl0AIYKJUupWYBBwvdbaeQ6hErXWWzwxtwGLtNZaKbUFaHoW2wkhhBCVInWaqIokeRHCQyl1IzAKGKa1tp9juEKvaZfXvIvSn7uKbieEEEJUmNRpoqqSN5IQgFJqCHA/MERrXRDo8gghhBBnS+o0UZXJOS9CuH0KNARWek5uHBPoAgkhhBBnSeo0UWUprXWgyyCEoSmlmgLztNYd/fg//gK6aa2P+ut/CCGEEFKniWAnPS9CnDsnUMOfP+iF+0fFXL6OL4QQQpQhdZoIatLzIoQQQgghhDAE6XkRQgghhBBCGIIkL0IIIYQQQghDkORFCCGEEEIIYQiSvAghhBBCCCEMQZIXIYQQQgghhCFI8iKEEEIIIYQwBElehBBCCCGEEIYgyYsQQgghhBDCECR5EUIIIYQQQhiCJC9CCCGEEEIIQ5DkRQghhBBCCGEIkrwIIYQQQgghDEGSFyGEEEIIIYQhSPIihBBCCCGEMARJXoQQQgghhBCGIMmLEEIIIYQQwhAkeRFCCCGEEEIYgiQvQgghhBBCCEOQ5EUIIYQQQtjwfjIAACAASURBVAhhCJK8CCGEEEIIIQxBkhchhBBCCCGEIUjyIoQQQgghhDAESV6EEEIIIYQQhiDJixBCCCGEEMIQJHkRQgghhBBCGIIkL0IIIYQQQghDkORFCCGEEEIIYQiSvAghhBBCCCEMQZIXIYQQQgghhCFI8iKEEEIIIYQwBElehBBCCCGEEIZgCdQ/VkqFAfOBflprZznrXwd+1FovPu+FE8LH1q9fX9tisUwBOiIHDYRvuYCtDofjzq5du6YGujDV1anqNKXUdGCe1nqWUmom8C+t9Z8BKqYQPiF1mvCjM9ZpAUtegDuA2eUlLh7vAB8DkrwIw7NYLFPq1q3bLj4+Pt1kMulAl0dUHS6XS6WlpbVPSUmZAgwNdHmqsTPVaQDvA08Cd52fIgnhH1KnCX+pSJ0WyGx5FPAdgFLqKaXUFqXUJqXUBACt9X4gTilVN4BlFMJXOsbHx2fJl7zwNZPJpOPj4zNxHwEVgTMK+E65vauU2qWUWgjU9trmV+AKpVQgDxwK4QtSpwm/qEidFpDkRSllA5prrf9SSg0ChgE9tNadgIlem/4B9ApEGYXwMZN8yQt/8by3ZOhGgHjXacB1QBugPXArcGnxdlprF7AH6BSAYgrhS1KnCb85U50WqMquFpDhmb4CmKa1zgPQWh/32i4VqH+eyyaEEEJUhneddjkwQ2vt1Fof4uShz1KvCSHEOQhU8pIPhFZgu1DPtkIIIUSwqmidBlKvCSHEOQlI8qK1TgfMSqlQYAFwu1IqHEApFeu1aWtgawCKKESVdOONNzaNjY3t1KpVqw7+imM2m7u2bdu2fcuWLTu0adOm/fPPP1/H6TzdOczGcrr9mzdvXlRUVFTntm3btm/btm37Sy+9tDXAo48+Wj8sLOyi5OTkknMdwsPDLyqePnDggGXIkCHNGzVq1LFDhw7t+vTp03Lz5s0hAJs3bw7p06dPyyZNmnRs3759u8GDBzdPSkqScyaCSJk6bTnwd6WUWSlVD+hbZnOp14TwEanTzp0R67RAjpH+BeittZ4PzAXWKaU2Ao8DKKWsQEtgXeCKKETVcscddxydO3fuGS/TOm/evKjrr7++6dnECQkJce3cuXP7nj17ti1evHj3ggULajz++ONVZpjMmfavW7duOTt37ty+c+fO7atWrdpdvLxmzZqOV155pU7ZeC6Xi6FDh7a8/PLLs5OSkrZu27Ztx4QJE5IPHTpkzcvLU9dcc02re+65J23//v1bt2/fvuP+++9PS0lJkeQl+PwC9Aa+Bf4EtgOfAauLN1BK1QHytdYpASmhEFWM1Gnnzoh1WiCTl8nAbQBa6wla6/Za685a62c964cAs7TWjoCVUIgqZtCgQTnx8fHn/JmqaJwGDRo4pkyZ8te0adNqu1yuc/23Qacy+zdy5Mhjc+fOjT1y5IjZe/m8efOiLBaLfvLJJ9OKl11yySX5AwcOzPnoo49iu3TpknPTTTdlFq8bMmRIdvfu3Qt8vjPiXE0GbtNuY7XWbbTWA7TWg7XWszzb3AR8GMAyClGlSJ3mW0ap0wJ29E5r/YdSaolSynyK6+JbgDfOd7mE8Lc77rij0datW8N9GbNjx455n3zySZIvY/pK+/bti5xOJ8nJyZZGjRr59GDExRdf3Obmm28++tBDDx0rLCxUl112WevRo0en3X///cezs7NN/fv3b3XXXXel3nXXXenHjh0zDxo0qOUDDzxw5Lbbbss4fPiwZdiwYS0eeeSRlJtuuinzwIEDlsaNG1e6fN77B7Bu3brItm3btgcYNmzY8VdffTUFIDIy0jly5MijEyZMqDNp0qRDxY/fvHlzWKdOnfLKi71169awLl26lLtOBJcK1GngPqn/8/NZLiH8Teo035E6rWICOvRAa/3Jadb973yWRQgBF154YduioiJTXl6eKTMz01L8hTV+/PiD119/fVagy2cE3bp1y1myZMme8tY9/fTTqZ06dWr/3HPPybChKuh0dZpn/bTzVRYhhNRpvhCMdZqMmxbiPAvWo0kAmzdv3gnubt9p06bFffPNN3+da8zt27fbzGYzDRo08PkQ0N9//31X8XRISIj2no+KinJ5z8fFxTm95+vVq+fwnj+bI1RQev82bdp02m1r1arlvO66646/9tprJT9ceMEFF+TPmTMnprztO3ToULB8+fLIsymXEEKcD1Kn+Y7UaRUjP2omhPCbQ4cOWe66664mt99+e6rJVPW+bs5m/8aNG3fk008/jXc6nQrgmmuuyS4qKlKvv/56reJt1qxZEzZ//vzIu+6669j69esjZ86cWaN43U8//RS5du3ail6WVwghhI9InXayQNRpVe+ZF0Kc0jXXXNOsd+/ebRMTE0Pq1Klz4aRJk2qd+VGVi1NYWGgqvuxi3759W/fv3z/r9ddfP3S6eEZyrvtXr149x6BBg9KLiooUgMlkYu7cuXsXL14c3ahRo44tW7bs8NRTTzVo0KCBPTIyUn/33Xd7Jk+eXLtJkyYdW7Ro0WHy5Mm169atKxcyEUJUe1KnnTsj1mlKa13Z/RRCVNKmTZv+6tSp09FAl0NUXZs2barVqVOnpoEuhxCi6pM6Tfjb6eo06XkRQgghhBBCGIIkL0IIIYQQQghDkORFCCGEEEIIYQiSvAhxfrhcLpcKdCFE1eR5b1W9n3sWQgQrqdOE35ypTpPkRYjzY2taWloN+bIXvuZyuVRaWloNYGugyyKEqDakThN+UZE6TX6kUojzwOFw3JmSkjIlJSWlI3LQQPiWC9jqcDjuDHRBhBDVg9Rpwo/OWKdVu0slK6U+AYYAqVrrjucYqzPwPhANOIHxWuuvzr2UQgghhBBCiLKqY/JyOZADfOaD5KU1oLXWfyql6gPrgXZa6wwfFFUIIYQQQgjhpdp19WmtlwPHvZcppVoopeYrpdYrpX5VSrWtYKzdWus/PdOHgFQg3ueFFkIIIYQQQsg5Lx4fAfd6elB6AO8B/SoTQCl1MWAD9vqhfEIIIYQQQlR71T55UUpFApcC/1Oq5KIZIZ51fwNeKudhyVrrq7xi1AM+B27TWsvlSoUQQgghhPCDap+84B46l6G17lx2hdZ6NjD7dA9WSkUDPwDjtNa/+aeIQgghhBBCiGp3zktZWussIFEpdSOAcutUkccqpWzAt7hP/p/lx2IKIYQQQghR7VW75EUpNQNYDbRRSh1USo0BRgFjlFKbgG3AsAqGGw5cDoxWSm303E7qwRFCCCGEEEKcu2p3qWQhhBBCCCGEMVW7nhchhBBCCCHE/7d35+FRlef/x993AiRsArK4AAooCpRKiyyCS1WwgqLiVyki/gS01oo71qoVl1otpVaxVVpci4qKO+KCsogiLsiq7LLIKsi+h4Rk7t8fZzINMdtMEmYm+byu61yZ58w5c+45Seae55xnSU6qvIiIiIiISFKoVKONNWjQwJs1axbvMEREytzs2bO3uLsmya1ElNNEpKIqKqdVqspLs2bNmDVrVrzDEBEpc2a2Ot4xyKGlnCYiFVVROU3NxkREREREJClUqjsvIiIiicjMegPnA4cBz7r7xDiHJCKSkHTnRUSkBDIzM9m9e3ekPH36dObNmxcp79u3Lx5hSQIws+fMbJOZLci3voeZLTWz5WZ2Z1Gv4e7j3P0a4PdA3/KMV0SkvGVlZfHUU0+xenXZt2hW5UVEKqUpU6bwwQcfRMqPPPIIjz76aKR8+eWXc91110XK7du3Z9CgQZHyVVddxfDhwyPl1q1bc8stt0TKK1asIBQKlVf4klhGAz3yrjCzVGAk0BNoA/QzszZm9nMzey/f0ijPrkPD+4mIJKXp06fTunVrrr32Wl5++eUyf301GxORSmHMmDEsWLCAv/3tbwD8/e9/Z8eOHZx33nkAfPbZZ6SkpDBkyBAAmjZtSu3atSP7//GPf6RevXqR8tixY6lTpw4A2dnZDB48mLZt2wKwe/duTjjhBO6//37uuecesrOz+eyzz+jUqRM1a9Y8JO9XDh13n2ZmzfKt7gQsd/eVAGY2FrjI3YcBvfK/hpkZ8DdggrvPKd+IRUTKx7///W9uvPFGmjVrxoQJEzj33HPL/Bi68yIiFdK4ceO49NJLcXcA5s2bx8SJEyN3Q5555hnGjRt30PZvvfVWpDx8+HCGDh0aKQ8YMIALL7wwUm7fvj3HHXccAFWqVOGOO+7g/PPPByAlJYVnn32Wiy++GIAFCxZw9tlnR463efNmXnnlFbZv314eb10SQ2NgbZ7yuvC6wtwIdAcuNbPfF7aRmf3OzGaZ2azNmzeXTaQSM3cnFApFPmdCoRBZWVmRcnZ2NhkZGZFyVlYWu3fvjpT379/P9u3bI+V9+/axefPmSHn37t1s2LAhcrydO3eyfv36SHnbtm2sWbMmUt68eTOrVq2KlH/88UdWrlx5UDlvM55Nmzaxbt26g/bPe7wtW7aQ9+9s27ZtbNu2LVLesWMHO3bsOOj5vJ9rmzZtYuvWrZHy+vXr2bRpU6S8atUqNm7cGCkvW7bsoOMvWrTooPf7zTffsHbt//6tZs6cedD7/+yzzyLvPxQKMXHiRFasWAEEv4t33nmHZcuWAcHv4tVXX2Xp0qUAZGRk8Pzzz7NkyRIgOPejRo1i8eLFkff62GOPRcpbtmzhb3/7W6S8YcMG7r333kh5zZo13H777ZHXW758OTfccEPkeIsWLeKqq66KxDNv3jz69evH8uXLAfjqq6/o3bs333//PQCffvop5557buT9fvTRR5xxxhmR8/POO+/QqVOnyPkdP3483bt3j/y+Jk6cyODBg9m1axcAK1euZO7cueTk5FBWHn/8ca6//np69erF119/zZo1awiuy5Qxd680y8knn+wiUjF9/PHHfvrpp/u2bdvc3f3pp5/2du3a+ZYtW9zdPTs7O26x7dmzxydMmOCbNm1yd/dXX33VAZ85c6a7u3/zzTc+YsQI3759e8zHAGZ5AnzOVtYFaAYsyFO+FHgmT/n/AU+U5THjldOysrJ8165dkfLYsWN91qxZkfI999zjEydOdHf3AwcO+KBBg3zcuHHu7p6RkeHnnXeev/baa+7uvmvXLu/SpYu/8sor7u6+efNmb926tb/88svu7v7DDz9448aN/aWXXnJ39++//96POuoof/31193dfenSpX7EEUdEXn/+/PnesGFDf//9993dffbs2V6/fv1IPF9++aXXrVvXp06d6u7uU6dO9Vq1avnnn3/u7u4ffvihV69e3b/++mt3d3/nnXe8atWqPm/ePHcP/nfNzBcuXOju7i+88IIDvmzZMnd3f+aZZxzwNWvWuLv7yJEjHfCNGze6u/uIESMciPyvDx8+3AHfu3evu7s/8MADDviBAwfc3X3o0KGekpISObe33367p6enR8o333yz16lTJ1K+7rrrvGHDhpHyVVdd5U2aNImUr7jiCm/RokWk3KdPH2/VqlWkfNFFF3m7du0i5Z49e3rHjh0j5bPPPttPO+20SPm0007zs88+O1Lu2LGj9+jRI1Ju166dX3TRRZFyq1atvE+fPpFyixYtvH///pFy48aN/aqrroqUGzZs6L///e8j5Tp16vjNN98cKaenp/vtt98eKaekpPjQoUPdPfjMB/yBBx5wd/e9e/c64MOHD3d39+3btzvgI0aMcHf3jRs3OuAjR450d/c1a9Y44M8884y7uy9fvtwBf+GFF9zdfeHChQ74q6++6u7uc+fOdcDffvttd3efOXOm16hRwydMmODuwd9e/fr1/ZNPPnF3988++8ybNGniX331lbu7f/LJJ96yZcvI39qUKVO8Xbt2vnjxYnd3nzRpkp9yyim+cuVKd3efOHGin3XWWb5u3Tp3D/52e/bsGckzb775pnft2tV37Njh7kFOrF+/vu/bt8/dg781M4v87U2bNs3feOONmHPlxIkT3cy8d+/enpWV5e7BZ0NOTk5Mr1dUTov7B/6hXFR5Eak4vvnmG+/UqVOkAjBt2jTv1KmTL1q0KM6RFe/AgQM+Z86cyAf8o48+6mamyksSLwVUXroAH+Up3wXcVZbHPBQ5LRQK+ejRo/29996LrKtbt67fdNNNkXKtWrX81ltvjZTT0tIiXyBDoZA3bdrUH3vsMXd3z8zM9A4dOvjo0aPdPfhCec455/gbb7zh7u47d+70Pn36+Icffuju7lu3bvWrr77ap02b5u7umzZt8muuuca/+OILdw8qN9dee23kc2Dt2rV+3XXX+dy5c93dfdWqVX799df7/Pnz3T34AnrjjTf6kiVL3D2o/Nx6662+YsUKd3dfvHix33777b569Wp3D76g3nXXXb5+/Xp3DypH99xzj//444/uHnwO3X///b5161Z3D77APvjgg5EvjHPmzPG//e1vvmfPHnd3nzVrlv/jH//wjIwMdw++4D722GORz4Kvv/7aH3/88cgXvhkzZvioUaMi53bGjBn+3HPPRcpfffWVjxkz5qBy7pdp9+ALc+6XaXf36dOnH1SeOnXqQeVJkyb5W2+9FSlPmDDhoPL48eMP2v7NN988qPz666/7u+++Gym/8cYb/tFHH0XKb731VqTi6O4+btw4nz59eqT8zjvv+IwZMyLld9991+fMmRMpf/DBB5HfpXvwhT33y7178IU/93cZCoX8888/j1Qkc3JyfM6cOZGKZHZ2ti9atCjyu8vOzvaVK1f6zp07I+UNGzZEvtxnZ2f79u3bPTMzM/J6GRkZkS/7oVDIk8maNWsO+l1dfvnl3rRp08j7+Pjjjw8610VZt26d169f39u2beujRo3yTz/9tNTxFZXTLHi+cujQoYNrQi+R5LR69Wp69+7N7bffzuWXX87GjRvp06cPw4YN47TTTot3eKW2adMmGjVqVPyGhTCz2e7eoQxDkiiE+7y85+5tw+UqwHdAN2A9MBO43N0XltUxyyunbd68mcWLF3PGGWcA0K5dO5o3bx5p9vjEE0/QqlUrunfvDgRNfRo0aBDpE+bu5dNURCTBhUIhsrOzycnJIScnp8DHZfV8YT8B0tPTSU9PJy0tjfT0dGrUqEHDhg1p1KgRDRs2pFq1aj+J/cCBA6xZsybSHLpt27YceeSRTJ48GYBdu3Zx2GGHFfi++/bty/jx45k9ezaXXXYZxx13HG+//XapzmVROU0d9kUkIbk7I0aMoH79+gwYMICmTZty/PHHRz48jzzySD777LM4R1l2SlNxkfgys1eAM4EGZrYOuM/dnzWzG4CPgFTgubKsuJSnAQMGMGvWLNavX0/VqlWZMmXKQYNV3HDDDQdt37Jly4PKZVVxcXeys7PJyso6qF9J/quwBa0ran202yTa/jk5ORw4cCCyZGdn/6Sck5NDamrqQUuVKlV+si4lJSWymFmBP3OPGQqFIkveclHPFVdOhn2jqVwkiyZNmtC6dWvatWvHmWeeya9+9Stq1aoVqbhA0Ecmt//S3r17OeaYYxg6dCh/+MMfDnqtyZMn89prr/HnP/+ZNm3a8Pnnn7N///5yjV93XkQkYezcuZP58+dH7qScfvrpNG3atFyGWqxodOel8inLnLZmzRoaNmxI9erVWblyJRkZGfzsZz8rcNtQKMSGDRvYvHkzW7ZsYevWrWzdupU9e/awf/9+MjIyyMjIiDzev38/mZmZZGVlHbQUtC7/IhVfbiUpd8lfqSqqHM22pdk3t+KXtwJY0OPSPl+SbXPLuUv+fdydzMzMyP/d/v372bNnD1u2bGHTpk38+OOPfPfddyxevJj58+eTlZVFrVq16Nu3L7fccktk1My8duzYwYgRIzj//PPp1KkTq1ev5tFHH+W2226jd+/e/Pjjj/Tu3ZsnnniizC5eFJXTVHkRkbjKzs6mSpXgJvBVV13Fm2++yY8//kh6ejr79u2jRo0acY4wOajyUvmUVU7bsWMHrVq14oILLuDpp5/+yXNffvklX375JfPmzWP58uWsXLmSzMzMQl+vWrVqpKenU7169UjzlfT0dKpVq1bkkpaWVuD6qlWrRu4EQPBlN/8S7fpot0mk/VNTU6latWpkqVKlyk/KqampkTsCBd0lyF1y72jl3mXIfZx3XXlXItTEMH4yMjL44osvePnll3n11VfJyMhg8ODBPPzww6Snpxe639ixYxk4cCBPPvkkAwcO5Morr2Ty5MnMmDGDJk2alElsqryEqfIikljef/99rrzySubNm0fTpk1ZtGgRe/bsoWPHjkpoUVLlpfIpy5w2evRoOnXqRJs2bThw4ACvv/46L774IpMnTyY7O5uUlBRat27NCSecwPHHH0+LFi044ogjqF+/Pg0aNKB+/frUrl2btLQ0UlNTyyQmETl0tm3bxn333ccTTzxBx44deeeddzjqqKMK3T4jI4PevXuzaNEivvnmG9LS0sp0HjP1eRGRhLBt2zYefvhhevfuTefOnWndujU9e/aMXMVt06ZNnCMUqVz27t1LzZo1GThwIO7OW2+9xZAhQ1i9ejXNmzdnyJAh9OjRg44dO1KrVq14hysi5eTwww/n8ccfp1u3blxxxRWce+65TJs2jbp16xa4/ebNm5k0aRL33nsvhx9++CGNVZNUiki5Wrt2LfPnzwcgLS2N//znP8yYMQOAFi1aMGbMGI4//vh4hihSKa1cuZLmzZvzxRdfkJmZyZVXXskll1xC3bp1effdd1m+fDnDhw/nrLPOUsVFpJLo3bs348aNY/HixVx33XWFbvfCCy/g7gwcOPDQBReWkJUXM3vOzDaZ2YJCnjcz+5eZLTezb82s/aGOUUSK5+50796dW2+9FYCaNWvyww8/cNNNN8U5MhHJysqiS5cuHHHEEZx77rmMGTOG+++/n1mzZtGrVy9SUhLyK4KIlLPu3btz//33M3bsWN55550Ctxk3bhxdu3alWbNmhzY4ErTyAowGehTxfE+gZXj5HfCfQxCTiJTA2LFjOeeccwiFQpgZTz31FE8++WTkeXXAF0kMrVq1Yty4cfzpT39i2rRpjBkzhvvuuy8ygIaIVF533HEHJ554InfffXdk/phcGzduZPbs2Zx//vlxia3cPqHM7NsSbLbZ3bvlX+nu08ITfhXmIuCF8AycX5lZXTM7yt03xBatiJTGrFmzaNOmDTVq1MDdOXDgAFu2bKFRo0b86le/ind4IkUqTb5KVmvWrKF69epMnDiR1157jWHDhtG/f/94hyUiCaJKlSrcf//99OvXj/fff58LL7ww8tyECRMAOO+88+ITWzm+dipQ1LsyYHyMr90YWJunvC68TpUXkUNs9uzZdOzYkaeffprf/va3XHbZZfTr1y/eYYlEozzzVUL6y1/+whtvvEHVqlXp3Lkzt99+e7xDEpEEc+mll3LTTTfx4osvHlR5mTZtGg0aNKBdu3Zxias8Ky/XuvvqojYws8HlePzcY/yOoGkZxxxzTHkfTqTCc3eGDh1Kw4YNueWWW2jfvj2jR4+md+/eQNnNri1yCCVEvjqUrr32WlJSUnjqqad44403NLyxiPxElSpV6NevH08++SQ7duyIjDw2e/ZsOnToELd8X559XqoX9oSZDQdw9+kxvvZ6oGmecpPwup9w96fcvYO7d2jYsGGMhxOp3NydxYsXA0Hl5Ntvv2XJkiWR8oABA6hTp048QxQpjfLMVwnp5JNP5pNPPuGUU07h9NNPj3c4IpKg+vbtS2ZmJpMmTQKC+V0WLVrEySefHLeYyrPyMtLMDurJY2YpZjYaKO19pvHAleFRx04Bdqq/i0j5GTp0KCeffDLbt28HglFGRo0aFeeoRApmZu2LWgrYpTzzVcJZu3YtL774It999x0DBgzQ3VIRKVSnTp047LDDmDJlCgDz588nJycnrpWX8mw2di4wwcyqufvbZpYOvAHsBC4oakczewU4E2hgZuuA+4CqAO4+CviAoH3ycmAfMKi83oRIZbR+/XoefPBBhgwZQsuWLbniiito1apVZKQwNTGRBPdI+Gc60AH4hqDfyknALKBLvu1jzlfJaNy4cZHhynv16hXnaEQkkVWpUoUuXbpE5mebM2cOAO3bx2+WkhJVXszs/4p63t3fKmDd92bWHfjIzI4ArgBmuvutxR3P3Yvs7RseZez64l5HREouFAqxe/du6tSpQ0pKCi+99BJnnHEGLVu2pHXr1rRu3TreIYqUiLufBWBmbwHt3X1+uNwWuL+A7WPOV8mob9++PPnkk1SrVo0mTZrEOxwRSXDt27fn4YcfJjMzkyVLllCzZs249iMv6Z2X3CtPjYCuwMfh8lnAF8BPKi95bs3fATwPTAJezF3v7nNijFlEypi7c8YZZ3DUUUfx+uuvc9RRR7Fx40bNySLJ7sTciguAuy8ws5/UwitbvqpXrx4rVqxg8OAKNQaBiJSTX/ziF2RnZ7N48WK+//57mjdvHtfmpiWqvLj7IAAzmwi0ye1fYmZHEUwoWZBH8jz+FjgizzoHzo4hXhEpI1u2bGH8+PFcddVVmBn9+/c/qNO9Ki5SAXxrZs8AY8Ll/gT5KL9Kla+efvpp9u/fT4cOHeIdiogkgZYtWwKwcuXKSOUlnqLt89I0X8f4H4EC7xvl3rYXkcQ0ZswYbr31Vk499VROPPFErrvuuniHJFLWBgHXATeHy9OA/+TfqLLlq3vuuQcgbnM0iEhyadGiBRBUXlatWsWZZ54Z13iiHW1sipl9ZGYDzWwg8D4wuaANCxnRJeptRKRsbNq0iYsuuoj33nsPgKuvvpqFCxdy4oknxjkykfLh7vuBUcCd7n6xu48IrztIZctXl19+OfC/LyQiIkWpU6cOhx9+OAsXLmT37t0ceeSRcY0nqsqLu99AkAjahZen3P3GQjb/r5nVM7PDC1uAZ0sXvogU5cCBA6xcuRII2rmvW7eOrVu3AlC7dm3atGkTz/BEypWZXQjMAz4Ml39hZuML2LRS5atdu3bRpEkTRwWWEgAAIABJREFU0tPT4x2KiCSJxo0bs2DBAgAaNGgQ11hiGSp5DrDb3SebWQ0zq+3uuwvYrg4wm2B4ysJsjuH4IlJCl1xyCcuXL2fBggVUrVqVWbNmaU4HqUzuAzoBnwC4+zwzK6ixdqXJVzt37mTGjBkcffTR8Q5FRJJI/fr1mT17NpBklRczuwb4HXA4cBzQmOBOTLf827p7szKIT0SisH79ekaNGsXQoUNJS0vjxhtvJCMjI/K8Ki5SyRxw9535/u49/0aVKV+tWLGCpUuX0rVr13iHIiJJpEGDBuzevTvyOJ6i7fNyPXAqsAvA3ZcRDJ8sInEUCoUAWLx4McOGDeOLL74A4JxzzuHCCy8kJSXaf3WRCmGhmV0OpJpZSzN7nGB4/0qrdevW1KtXT/M2iUhU6tevH3mcbJWXTHfPyi2YWRUKuIolIofG/v37Oeecc/j73/8OQLdu3Vi1ahVnnVWpBk8SKcyNwM+ATOAVggtvt8Q1ojhLS0tj586dce9wKyLJJW/lJe/jeIi28vKpmf0JqG5m5wCvA+8WtrEFmpYmQBE52IEDByLtTtPT02ncuDGHH344EDQL04zZIgF33+fud7t7R3fvEH78k9HGoPLkq6VLlxIKhahatWq8QxGRJJK3whLveeCi7bB/J3A1MB+4FvgAeKawjd3dzewD4OcxRygiB7ntttt47rnnWLt2LfXq1WP06NHxDkkkIZnZu/y0dcBOYBbwZN6KTGXJV7NmzQIgMzMzzpGISDKpV69e5HG1atXiGEn0QyWH3P1pd+/j7peGHxfXbGyOmXUsRYwildqWLVu46667WL16NQCDBw/m1VdfpU6dOnGOTCThrQT2AE+Hl13AbuCEcDm/Cp+vjj32WAA6dqzQb1NEylhaWlrkcbzv3EY72th8Cr+K9aC7by1gt85AfzNbDewlGIrS3f2kGOIVqTRycnJITU0lIyODESNGcMIJJzBo0CBatWpFq1at4h2eSDLo6u55v6W/a2Yz3b2jmS0sYPsKn69yR16rXbt2nCMRkWSS925LvAcBirbZ2AQgB3g5XL4MqAFsBEYDFxSwz7mxBidSWV1xxRUAjBkzhqZNm7Ju3bq4j+4hkoRqmdkx7r4GwMyOAWqFn8sqYPsKn682btwIwI4dO+IciYgkk3g3Fcsr2spLd3dvn6c838zmuHt7M7uioB3cfbWZtQNOD6/6zN2/iSVYkYoqJyeH6dOn86tf/QrgJ3dWVHERicltwHQzW0FwF6U5MNjMagLP59+4MuSr77//HvhfJUZEpCQSqfIS7X2fVDPrlFsItw1ODRezC9rBzG4GXiKYD6YRMMbMbowhVpEKa9SoUZx55pl8803wPWno0KEMHTo0zlGJJDd3/wBoSTA88s3Aie7+vrvvdffH8m9fGfLVSScFLeDU9FREopFIlZdo77z8FnjOzGoRXMXaBfw2fBVrWCH7XA10dve9AGY2HPgSeDy2kEWS3969e3n00Uc5/fTTOfPMM+nfvz+NGjWibdu28Q5NpKJpCZwIpAPtzAx3f6GQbSt8vsrtaJu3862ISHGStvLi7jOBn5tZnXB5Z56nXytkNyPoJ5MrJ7xOpNLJzMwkLS2NKlWq8OSTT3LgwAHOPPNM6tatS58+feIdnkiFYmb3AWcCbQiG9u8JTAcKq7xU+Hy1fv16ALZv3x7nSEQkmSRt5QXAzM4nmLE4PXfUEnd/oIhd/gvMMLO3w+XewLPRHlck2d1xxx1MnDiROXPmkJaWxsKFCzXcsUj5uhRoB8x190FmdgQwpojt45qvwq0YPgXud/f3yuMYq1atAmDz5s3l8fIiUkElUuUlqj4vZjYK6AvcSHA1qg9wbBHbpwBfAYOAbeFlUEFtjUUqmlAoxHvvvUdWVjCoUfv27enRo0dkcjhVXETKXYa7h4BsMzsM2AQ0LWjD0uQrM3vOzDaZ2YJ863uY2VIzW25md5Yg3jsovBVDmfjlL38JwAknnFCehxGRCiaRmppGe+elq7ufZGbfuvufzewRguGTC+TuITMb6e6/BOaUKlKRJPPxxx9zwQUXMHbsWPr27RtZROSQmWVmdQkmpJxNMGHllwVtWMp8NRp4gjzN0cwsFRgJnAOsA2aa2XiCQW7y9xG9iuAO0SKCvjnlpkqVIO0n0lVUEUl8ifSZEe1oY/vDP/eZ2dHAAeCoYvaZYmaXWG4bsxIq7oqVmR1jZlPNbK6ZfWtm50Xz+iJlLRQK8eCDD/LMM88A0K1bN8aNG8cll1wS58hEKp9wzhnm7jvcfRRBJWKAuw8qYreY8pW7TyO4U5NXJ2C5u6909yxgLHCRu8939175lk0EfXNOAS4HrgnfCSpza9euBTTPi4hEJ5krL++Gr2I9THBlahX/m7CyMNcCrwOZZrbLzHab2a6idshzxaonQUfLfmbWJt9mQ4HXwlfJLgP+HeV7ESkTu3YFf84pKSlMmTKFGTNmAMFM1hdddFHkSqeIHDru7gSd9HPLq9z922J2izpfFaExsDZPeV14XWHx3u3utxDk1KfDzd1+wsx+Z2azzGxWLP1Wcud52bYtf11LRKRwSVl5CV8FmhK+ivUmQV+XVu5+bzH79HD3FHev5u6HuXttdz+smMMVeMUq3zYO5L5OHeCHkr4XkbLyz3/+k2bNmkUqMB9++CFPP/10nKMSkbA54fnIilWKfFWm3H10UZ313f0pd+/g7h0aNmwY9et36hRM1XbcccfFHqSIVDpJWXkJXwUamaecmW+o5ML2eSKGuEpyxep+4AozW0dwda1CTSQmiSkUCvHuu+/yww9BXfm0007j2muvJScnGF01kTq0iQidgS/NbEW4efF8Myvw7ksp8lVh1nPw4ABNwuviKrdFXO58LyIiJZGUlZewWNoDx9SGuAT6AaPdvQlwHvBiQW2ES3uLXSSvtWvX0rt3b559Nhg99eSTT2bYsGHUq1cvzpGJSAHOBY4DzgYuAHqFfxamLPPVTKClmTU3s2oEzZvHl8HrlsqaNWsA2LmzyGuPIiIHSebKS2574Kwo2gPHsk9JrlhdTXhISXf/kmCElgb5X6i0t9hFhg0bxpAhQwA49thj+eSTT7jzzpKMeioi8eTuqwlyydnhx/soOu/Fkq8ws1cIRjE70czWmdnV7p4N3AB8BCwm6KO5sJRvqdRy+7yow76IRCOR+u9GVXkJt/9NcfeqJW0PHMs+lOyK1RqgG4CZtSaovOjWipSJ3AQPsHHjRtavX0/Q/xdOP/10NbkQSQJmdh/B3Cl3hVdVpYhJKmPMV7h7P3c/KrxfE3d/Nrz+A3c/wd2Pc/eHyuI9lVaXLl0AaNGiRZwjEZFkUvYNqGIX7SSVZmZXmNk94XJTM+tU1vsUdsXKzB4wswvDm91GMJzkN8ArwEDP/XYpUgpjxoyhRYsWLFgQzDc3YsQIXn311YT6xxWRErkYuBDYC+DuPwC1C9s4lnyVrFJTU+MdgohITKJtNvZvoAvBOPQQTPg1svDNY96nwCtW7n6vu48PP17k7qe6ezt3/4W7T4zyvYgAkJWVxbPPPstXX30FQM+ePRk2bBiNGwdjRKSklMt0CyJS/rLCF7UcwMxqFrN9TPkqmaxatQr43xDvIiLJJtpvZZ3d/XrCk1W6+3aguB48sewjUu5CoVDk55/+9CdeeuklAOrXr8+dd96pTvgiye81M3sSqGtm1wCTgaLGMq/w+Sq3Sezu3bvjHImIJJvf/va3jBlTaMvbQyba3jcHwhNI5l7FaggUOJFWKfcRKVcPPfQQH374IdOmTSM9PZ2ZM2fStGnT4ncUkaTh7v8ws3OAXcCJwL3uPqmIXSp8vjr99NMZNWoUxx57bLxDEZEkkyjz2EV75+VfwNtAIzN7CJgO/LUc9hEpU+7OJ598QnZ2NgCNGzemTZs27N+/H4BjjjlGfVpEKhgzGwIscvfb3f0PxVRcoBLkq9w7zmoOKyLJKqo7L+7+kpnNJhjly4De7r64rPcRKWuTJ0/m17/+Na+99hp9+vRh4MCBDBw4MN5hiUj5qg1MNLNtwKvA6+7+Y2EbV4Z8tWLFCgD27NkT50hERGITVeXFzP4FjHX3qDowuvsSYEk0+4iURk5ODg899BDHHHMMAwcOpFu3brz00ktccEFR89OJSEXi7n8G/mxmJwF9gU/NbJ27dy9inwqdr9auXQvAvn374hyJiEhsor1vPBsYamYrzOwfZtahPIISidWWLVuAYBjQSZMmMWPGDCBoInH55ZeTnp4ez/BEJD42ARuBrUCjOMcSV6eddhpAZDRFEZFkE+0klc+7+3lAR2ApMNzMlpVLZCJReuCBBzjhhBPYu3cvEDQV+89//hPnqEQkXsxssJl9AkwB6gPXuPtJ8Y0qvtTnRUSSXbSjjeU6HmgFHEswiWSRzOxYoKW7Tzaz6kAVd9c4jVIqe/fuZfTo0VxyySUceeSR9OjRg7S0NHLnKk1LS4tzhCISZ02BW9x9Xkl3qOj56rvvvgOIXOQREUk20fZ5+TvBjMUrCDo//sXddxSzzzXA74DDgeOAJsAogg6RIlFzd8yMH374gRtvvBEzY/DgwXTq1IlOnSrkZNgiEgN3vwvAzBoB6XnWrylo+8qQr3744QcgmJxXRCQZRXvfeAXQxd17uPt/i6u4hF0PnEowzj7uvoxK3uZYYuPuDBo0iMGDBwPQsmVLFi1aFCmLiORlZheEmzZ/D3wKrAImFLFLhc9Xp556KgANGzaMcyQiIrGJts/Lk0COmXUyszNyl2J2y3T3yCUeM6tCeAIwkeIcOHCATz/9FAAzo1GjRgcl3VatWsUrNBFJfA8CpwDfuXtzgjsoXxWxfYXPV7nNatXnRUSSVbTNxn4L3ExwK30eQVL4Eji7iN0+NbM/AdXDMx0PBt6NLVypbEaMGMEdd9zBd999R8uWLRk+fHi8QxKR5HHA3beaWYqZpbj7VDN7rIjtK3y+WrIkGAVaQyWLSLKK9tLLzQQjja1297OAXwLFNR27E9gMzAeuBT5w97ujDVQqh61bt3L99dfz+eefAzBw4EDGjx/PcccdF+fIRCQJ7TCzWsA04CUz+ydQVE/1Cp+vfvwxmKMzd9QxEZFkE23lZb+77wcws7TwZF4nFrPPje7+tLv3cfdL3f1pM7s5pmilQnL3yPws1atXZ9y4ccybFwwO1KhRIy644AI1cRCRWFwE7ANuBT4k6LdZ1Ey1FT5fde3aFYC6devGORIRkdhE+41wnZnVBcYBk8zsHWB1MfsMKGDdwCiPKxXY//3f/3HBBcH3iRo1arBy5Uquv/76OEclIsnO3fe6e8jds4Gt7v4vd99axC4VPl+pz4uIJLuo+ry4+8Xhh/eb2VSgDsHVrJ8ws37A5UBzMxuf56nawLYYYpUK4scff+TFF1/k1ltvJTU1lX79+rFnzx5CoRApKSman0VEysMDwHsFPVGZ8tWiRYsAyMzMjHMkIiKxiXWSSoAT3f2pIp7/AtgANAAeybN+N/BtKY4rSSp3fpbPPvuM22+/na5du9K1a1d+85vfxDs0Ean4rIjnKk2+ym2im3sHRkQk2ZSm8vJ7oNDKi7uvJmhS1qUUx5AKYNeuXfTu3Zs+ffpw3XXX0bt3b5YuXcoJJ5wQ79BEpPK4trAnKlO+6tKlC2+++Sa1atWKdygiIjEpTaPXoq5i/W8js91mtiu87DezHDPbVYrjShLYs2cPM2bMAKB27drUq1eP6tWrA1ClShVVXESk3JlZDTO7x8yedvevzaylmfUqYvsKn69yRxlTnxcRSValufNS1IgtEe5eO/exmRnB6C+nlOK4kgSuueYaJk+ezLp160hLS+PNN9+Md0giUvn8F5jN/+6orAdep5C+L5UhXy1cuBCAnJycOEciIhKbqC69mNkRZvasmU1w93Vm1sbMri7p/h4YB5wbdaSS0FasWMGAAQPYvHkzAHfddRfjx49X53sRiafj3P3vwAEAd99HCVsNVNR8tX37dgCCupmISPKJ9r7xaOAj4Ohw+TvglqJ2MLP/y7NcamZ/A/YXdyAz62FmS81suZndWcg2vzGzRWa20Mxeju6tSGm5O3v3BvO9ZWVlMW7cOObOnQvASSedRJcuFb75uIgktiwzqw44gJkdBxQ6zFas+SqZnHJKcCNJF5ZEJFlF22ysgbu/ZmZ3Abh7tpkVd+85b/OybGAVwa34QplZKjASOAdYB8w0s/HuvijPNi2Bu4BT3X27mTWK8r1IKeTk5NC5c2c6d+7MyJEjad26NRs2bKBGjRrxDk1EJNd9BMP5NzWzl4BTKXrelqjzVbLJ7fOiOy8ikqyirbzsNbP6/O8q1inAzqJ2cPdBMcTVCVju7ivDxxlLkEAW5dnmGmCku28PH2dTDMeRKGzfvp2PP/6YSy65hNTUVC6++GKOP/74yPOquIhIInH3SWY2h6DfigE3u/uWIraPJV8llfnz5wOqvIhI8oq28jIEGA8cZ2afAw2BSwva0MweJ1zJKYi731TEcRoDa/OU1wGd821zQvg4nwOpwP3uXuCEmVI2HnnkEYYNG8batWs5+uijufvuu+MdkohIoczsYuBjd38/XK5rZr3DfVnybleafJVUdu0KBk/TaGMikqyiqry4+xwz+xVwIsFVrKXufqCQzWeVNrhiVAFaAmcCTYBpZvZzd9+RdyMz+x3wO4BjjjmmnEOqWH744QeGDBnCrbfeSufOnbnpppvo06cPRx99dPE7i4jE333u/nZuwd13mNl9wLh825V3vkoYnTt3ZsKECaq8iEjSiqryEu6Lch7QLLzvr80Md380/7bu/ny+fWuF1+8pwaHWA03zlJuE1+W1DpgRrjx9b2bfEVRmZuaL4ynCk2l26NBBUwoXIxQKsXXrVho2bEjt2rX56quvWLFiBZ07d6ZRo0Y0aqSuRSKSNAr6hv6TvFfKfJVU1OdFRJJdtM3G3iUYeWU+ECrJDmbWFngRODwo2mbgSndfWMRuM4GWZtacoNJyGXB5vm3GAf2A/5pZA4JmZCujeC9SgPPOO499+/Yxbdo0ateuzYoVK0hNTY13WCIisZhlZo8SDAADcD3BvC8FijFfJZVvv/023iGIiJRKtJWXJu5+UpT7PAUMcfepAGZ2JvA00LWwHcKjmN1AMCxzKvCcuy80sweAWe4+Pvzcr81sEZAD3O7uW6OMrdLbuXMnY8aM4brrriMlJYVBgwaRk5ODu2NmqriISDK7EbgHeDVcnkRQgSlM1Pkq2eQOby8ikqyirbxMMLNfu/vEKPapmZsIANz9EzOrWdxO7v4B8EG+dffmeewEAwgMiSIWyee9997jhhtuoH379nTp0oW+ffvGOyQRkTLh7nuBAucJK0RM+aosmFkK8BfgMIKLdM8Xs0tMOnTowNSpU4vfUEQkQUXbY+8r4G0zyzCzXWa228x2FbPPSjO7x8yahZehqHlX3GRmZnLHHXfw8svBnJ59+/Zl7ty5mlBSRCocM2toZg+b2Qdm9nHuUsQuMeUrM3vOzDaZ2YJ864udbDmPiwj6dx4g6NNZLtxdnfVFJKlF+wn2KNAFqOHuh7l7bXc/rJh9riIYUvmt8NIgvE4OoaysLACqVavG1KlTI+2eq1Spwi9+8Yt4hiYiUl5eApYAzYE/E0w6ObOI7WPNV6OBHnlX5JlsuSfQBuhnZm3M7Odm9l6+pRHBKJ5fuPsQ4LqSv8XozJs3j+zs7PJ6eRGRchdts7G1wIJwk60SCU8ieRNEPsxruntxd2ukDI0cOZJ//OMfLFq0iOrVqzN9+nSqVasW77BERMpbfXd/1sxudvdPgU/NrNDKS6z5yt2nmVmzfKsLnGzZ3YcBvfK/hpmtA7LCxZxi31mMMjMzy+ulRUQOiWgrLyuBT8xsAhD5BCxoqORcZvYy8HuCD+OZwGFm9k93fziGeKWEli1bRqNGjahTpw5t27bl3HPPJSMjg+rVqydkxcXdy3QJhUIJ8Rqxvk5J9imr+EqyFPU7Kuy5/Ovzlkv6XEGP8/7N5P8biqacy8wiw8bmPo62nJKSUmZL8+bN6dw5/5y8EqPcecg2mNn5wA8EI4kVqIzzVUkmW87rLeBxMzsdmFZEjKWau6x9+/bMmDEj6v1ERBJFtJWX78NLtfBSEm3cfZeZ9QcmEHSenA0kReXlo48+YvLkyYRCoZiW3C+ZBa3P+wW0oHXRPJ93yczMZMmSJTRq1IiGDRtGtunatWu5fhGO9TVE8spfMSjocf5tYy2XpDJVUCWqPF155ZWqvJSdB82sDnAb8DhBZ/hbi9g+bvnK3fcBV5dgu1LNXeauPi8iktyiqry4+59jOEZVM6sK9AaecPcDZpY031i//vpr/v3vf8d0BbWgK7K56wr6Wdjj1NTUAp/PW961axe7d+/m2GOPxcyoXr06Rx55JDVq1Dho+8KW/K8b7VLa/ctyKYtYyur9xPI6JdknHucbiPq5/Ovzlgt6LpkUVHkvi6V27drxfmsVhru/F364EzirBLuUZb4qyWTLh9zcuXPZv39/vMMQEYlZiSovZvaEu99gZu8CP/kgd/cLi9j9SYJOkt8A08zsWCBp+rzcc8893HPPPfEOo1hXXnklU6ZMYcaMGQnZLEykoknWSldlYmYtgH8SDDQTAr4EbvVwP5QClGW+Kslky4dcTk65dacRETkkSnrv+Mrwz38AjxSwFMrd/+Xujd39PA+spmRXwKQIixcvpmfPnqxatQqA4cOHs3DhQlVcRET+52XgNeBI4GjgdeCVwjaONV+Z2SsEFaMTzWydmV3t7tlA7mTLi4HX3H1h6d9S6bRr145atWrFOwwRkZiVtNnYCgAPRmuJipnVB+4DTiO4azMdeADYGu1rSdBUxcyoVasWS5YsYdmyZTRr1oyjjjoq3qGJiCSaGu7+Yp7yGDO7vbCNY81X7t6vkPU/mWw53tTnRUSSXUkrLw3NrNCZ7L2I0caAsQQjp1wSLvcHXgW6l/DYEjZkyBA2b97Miy++SNOmTVmxYoWSkIhI4SZYMDnkWILKSF/gAzM7HMDdt+XbvsLnqzlz5rB79+54hyEiErOSVl5SgVpALA28j3L3v+QpP2hmfWN4nUpp//79pKenA1C3bl1ycnIIhUKRAQBERKRQvwn//F34Z24Ou4ygMtMi3/YVPl/l3r0XEUlWJa28bHD3B2I8xkQzu4yg3THApQRtgKUYM2fOpFevXrzzzjuccsop3HvvvfEOSUQk4ZlZR2CtuzcPlwcQ3E1ZBdxfwB2XXBU+X5100kmsXFnYeAUiIomvpJfuo75MY2a7zWwXcA1Bp8ms8DKW/10Fk3zcnS1btgDQunVrzjjjDGrWrBnnqEREksqThGerN7MzgGHA8wRDJj+Vf+PKlK9CoZDuvIhIUivpnZdu0b6wu2uyghhccsklbNiwgS+++IJatWrx+uuvxzskEZFkk5rn7kpf4Cl3fxN408zm5d+4MuWruXPnsn379niHISISsxJVXoq4xV4iZlYPaAmk53nNaaV5zYrku+++4/jjjyclJYXLLruMvXv3ql2yiEjsUs2sSni44m4cfPekyLxX0fOV+kuKSLIr6Z2XmJnZb4GbCWYXngecQjAe/tnlfexk8MUXX3D66afz8ssv07dvX37zm98Uv5OIiBTlFeBTM9sCZACfAZjZ8QRNxwpUGfLVz372MzZs2BDvMEREYnYoLr/cDHQEVrv7WcAvgR2H4LgJa+fOncyZMweAzp0789BDD9G9e4UZiVNEJK7c/SHgNmA0cJq7e/ipFODGInat8PlKfV5EJNmV+50XYL+77zczzCzN3ZeY2YmH4LgJq0+fPixbtoxly5ZRpUoV7rzzzniHJCJSobj7VwWs+66Y3Sp8vpozZw6bN2+OdxgiIjE7FJWXdWZWFxgHTDKz7cDqQ3DchPLll1/Svn170tLS+Otf/0pKSgpVqhyK0y8iIiVU4fNV1apVSU1NjXcYIiIxK/dvz+5+cfjh/WY2FagDfFjex00kixYtomvXrjz88MP84Q9/oEOHDvEOSURE8qkM+ap169bs3Flotx8RkYR3SC/9u/unh/J48eTurFq1iubNm9OmTRvGjBlD79694x2WiIiUQEXNV+rzIiLJLmHHSzSzHma21MyWm1mhnULM7BIzczNLqNsZf/3rXznppJNYt24dAP3799dkkyIiEldz5szRaGMiktQSstOFmaUCI4FzgHXATDMb7+6L8m1Xm2B0mBmHPsqfCoVCZGRkULNmTfr37096ejpHHnlkvMMSEREBID09nWrVqsU7DBGRmCXqnZdOwHJ3X+nuWcBY4KICtvsLMBzYfyiDK0hOTg5nnXUWN9xwAwDNmjXjtttuU6d8ERFJGC1bttRFNRFJaolaeWkMrM1TXhdeF2Fm7YGm7v7+oQwsv1AoBEBqairnn38+3bp1i2c4IiIihXJ3UlISNfWLiBQvKT/BzCwFeJRgErLitv2dmc0ys1llPbb9woULadu2LbNnzwbgj3/8I1dccUWZHkNERKSszJkzhzVr1sQ7DBGRmCVq5WU90DRPuUl4Xa7aQFvgEzNbBZwCjC+o0767P+XuHdy9Q8OGDcs0yMaNG1O/fn327497qzUREZFi1axZk/T09HiHISISs0StvMwEWppZczOrBlwGjM990t13unsDd2/m7s2Ar4AL3X1WeQc2btw4+vXrh7tTt25dPvvsM0499dTyPqyIiEiptWjRgqOPPjreYYiIxCwhKy/ung3cAHwELAZec/eFZvaAmV0Yz9g2bdrEsmXL2Lp1azzDEBERiZr6vIhIsjN3j3cMh0yHDh181qzobs7k5OQwcuRIWrRoQa9evQiFQoRCIY0iJiIJxcxmu3tCzXcl5SuWnNa0aVN27drFzp07yykqEZHSKyqn6fJLMUKhEM888wxvv/02ACkpKaq4iIhIUqpdu7YmTBaRpKZv4cWoWrUqU6dO5fC7YEUEAAAJf0lEQVTDD493KCIiIqXyr3/9S4PMiEhSU+WlBOrXrx/vEEREREqte/fu8Q5BRKRU1GxMRERERESSgiovIiIiIiKSFFR5ERERERGRpFCphko2s83A6nyrGwBb4hBOrBRv+VK85S/ZYk6WeI9194bxDkIOnUJyWkkky990QZI5dkju+BV7fCRz7BB7/IXmtEpVeSmImc1KprkRFG/5UrzlL9liTrZ4RYqTzH/TyRw7JHf8ij0+kjl2KJ/41WxMRERERESSgiovIiIiIiKSFFR5gafiHUCUFG/5UrzlL9liTrZ4RYqTzH/TyRw7JHf8ij0+kjl2KIf4K32fFxERERERSQ668yIiIiIiIkmh0lZezKyHmS01s+Vmdme848nPzJqa2VQzW2RmC83s5vD6w81skpktC/+sF+9Y8zKzVDOba2bvhcvNzWxG+Dy/ambV4h1jXmZW18zeMLMlZrbYzLok8jk2s1vDfw8LzOwVM0tPpHNsZs+Z2SYzW5BnXYHn0wL/Csf9rZm1T5B4Hw7/PXxrZm+bWd08z90VjnepmZ17qOMVKa2KlvsS4XMkv5LmQTNLC5eXh59vFue4S5wPE+28R5MbE+G8l1WuNLMB4e2XmdmAOMYedd4szWdRpay8mFkqMBLoCbQB+plZm/hG9RPZwG3u3gY4Bbg+HOOdwBR3bwlMCZcTyc3A4jzl4cAIdz8e2A5cHZeoCvdP4EN3bwW0I4g9Ic+xmTUGbgI6uHtbIBW4jMQ6x6OBHvnWFXY+ewItw8vvgP8cohjzGs1P450EtHX3k4DvgLsAwv9/lwE/C+/z7/BniUhSqKC5LxE+R/IraR68GtgeXj8ivF08RZMPE+a8x5AbE+G8j6aUudLMDgfuAzoDnYD77NBcbB1NKfNmaT+LKmXlheCXvNzdV7p7FjAWuCjOMR3E3Te4+5zw490EHyKNCeJ8PrzZ80Dv+ET4U2bWBDgfeCZcNuBs4I3wJokWbx3gDOBZAHfPcvcdJPA5BqoA1c2sClAD2EACnWN3nwZsy7e6sPN5EfCCB74C6prZUYcm0kBB8br7RHfPDhe/ApqEH18EjHX3THf/HlhO8FkikiwqYu6L++dIXlHmwbzv6Q2gW3j7Qy6GfJhQ553ocmPcz3sZ5cpzgUnuvs3dtxNUIPJXKg5J7DHkzVJ9FlXWyktjYG2e8rrwuoQUvqX5S2AGcIS7bwg/tRE4Ik5hFeQx4I9AKFyuD+zI8wedaOe5ObAZ+G/4Fv8zZlaTBD3H7r4e+AewhuCDeScwm8Q+x1D4+UyG/8OrgAnhx8kQr0hRkupvuIS5L9HeUzR5MBJ7+Pmd4e3jIdp8mDDnPYbcmEjnPa9oz3XC/A7yKUneLFXslbXykjTMrBbwJnCLu+/K+5wHQ8UlxHBxZtYL2OTus+MdSxSqAO2B/7j7L4G95GsilmDnuB7BlYnmwNFATQ7BVZaylEjnszhmdjdBE5aX4h2LSGWTLLkvryTNg7mSKh/mVRFyY36Jeq6Lc6jyZmWtvKwHmuYpNwmvSyhmVpXgw/sld38rvPrH3Fuz4Z+b4hVfPqcCF5rZKoLbf2cTtJ+tG76NC4l3ntcB69x9Rrj8BsGHd6Ke4+7A9+6+2d0PAG8RnPdEPsdQ+PlM2P9DMxsI9AL6+//Gk0/YeEVKKCn+hqPMfYn0nqLNg5HYw8/XAbYeyoDziDYfJtJ5jzY3JtJ5zyvac51Iv4No82apYq+slZeZQMvwSBTVCDoTjY9zTAcJt798Fljs7o/meWo8kDuixADgnUMdW0Hc/S53b+LuzQjO58fu3h+YClwa3ixh4gVw943AWjM7MbyqG7CIBD3HBLfETzGzGuG/j9x4E/YchxV2PscDV4ZHUjkF2JnnlnncmFkPgmYfF7r7vjxPjQcus2CkmuYEnSe/jkeMIjGqiLkvYT5HYsiDed/TpeHt43K1PYZ8mDDnnehzY8Kc93yiPdcfAb82s3rhu0+/Dq875GLIm6X7LHL3SrkA5xGMiLACuDve8RQQ32kEtwy/BeaFl/MI2mVOAZYBk4HD4x1rAbGfCbwXftwi/Ie6HHgdSIt3fPli/QUwK3yexwH1EvkcA38GlgALgBeBtEQ6x8ArBG2ODxBcybu6sPMJGMFoIyuA+QQjxSRCvMsJ2uLm/t+NyrP93eF4lwI94/33oEVLtEtFy32J8DlSyPsoNg8C6eHy8vDzLeIcc4nzYaKd92hyYyKc97LKlQT9S5aHl0FxjD3qvFmazyILv4CIiIiIiEhCq6zNxkREREREJMmo8iIiIiIiIklBlRcREREREUkKqryIiIiIiEhSUOVFRERERESSgiovIiIiIiKSFFR5ERERERGRpKDKi0gxzKyNmQ00s6ZmVjve8YiIiJQH5TtJBqq8iBSvKnAjcDGwJ/+TZtbMzDLMbF5ZH9jMqpvZPDPLMrMGZf36IiJSOZlZEzPrm291qfOd8paUN1VeRIrXFPgvsBwo7ErUCnf/RVkf2N0zwq/7Q1m/toiIVGrdgPb51pU63ylvSXlT5UUkzMw+Dl8tmmdm+83sNwDu/h7whrt/4O67SvA6zcxsiZmNNrPvzOwlM+tuZp+b2TIz6xTNdiIiImXJzE4DHgUuDee8FhBTvqtpZu+b2TdmtqCAOzkiZU6VF5Ewdz87fLXoSWA88Gae5zZG+XLHA48ArcLL5cBpwB+AP8WwnYiISJlw9+nATOAid/+Fu6/M81w0+a4H8IO7t3P3tsCHZRyqyE+o8iKSh5ldCfQE+rt7Tile6nt3n+/uIWAhMMXdHZgPNIthOxERkbJ0IrCklK8xHzjHzIab2enuvrMM4hIpkiovImFm1gfoD/zG3Q+U8uUy8zwO5SmHgCoxbCciIlImwh3pd7p7dmlex92/I+g3Mx940MzuLYv4RIqiL0cigJn1AgYDvdx9f7zjERERKUfNKIMO9WZ2NLDN3ceY2Q7gt6V9TZHi6M6LSOB5oAnwebjz4tXxDkhERKScLAEahDvZdy3F6/wc+Do8dPJ9wINlEp1IESxoXi8isTKzZsB74c6K5XWMVUAHd99SXscQEREpSjT5TnlLyovuvIiUXg5QpzwnqSSYOCxU1q8vIiIShWLznfKWlDfdeRERERERkaSgOy8iIiIiIpIUVHkREREREZGkoMqLiIiIiIgkBVVeREREREQkKajyIiIiIiIiSUGVFxERERERSQqqvIiIiIiISFJQ5UVERERERJKCKi8iIiIiIpIU/j8T/CRYExznUAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "T_ref = param.evaluate(dfn.param.T_ref)\n", "var = \"X-averaged cell temperature [K]\"\n", @@ -813,7 +828,20 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.9" + "version": "3.8.6" + }, + "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 } }, "nbformat": 4, diff --git a/examples/scripts/compare_comsol/compare_comsol_DFN.py b/examples/scripts/compare_comsol/compare_comsol_DFN.py index 427f149d4e..8dbb05d596 100644 --- a/examples/scripts/compare_comsol/compare_comsol_DFN.py +++ b/examples/scripts/compare_comsol/compare_comsol_DFN.py @@ -82,22 +82,26 @@ def get_interp_fun(variable_name, domain): pybamm_x = mesh.combine_submeshes(*domain).nodes * L_x variable = interp.interp1d(comsol_x, variable, axis=0)(pybamm_x) - def myinterp(t): - try: - return interp.interp1d( - comsol_t, variable, fill_value="extrapolate", bounds_error=False - )(t)[:, np.newaxis] - except ValueError as err: - raise ValueError( - ( - "Failed to interpolate '{}' with time range [{}, {}] at time {}." - + "Original error: {}" - ).format(variable_name, comsol_t[0], comsol_t[-1], t, err) - ) - - # Make sure to use dimensional time - fun = pybamm.Function( - myinterp, + # def myinterp(t): + # try: + # return interp.interp1d( + # comsol_t, variable, fill_value="extrapolate", bounds_error=False + # )(t)[:, np.newaxis] + # except ValueError as err: + # raise ValueError( + # ( + # "Failed to interpolate '{}' with time range [{}, {}] at time {}." + # + "Original error: {}" + # ).format(variable_name, comsol_t[0], comsol_t[-1], t, err) + # ) + + # # Make sure to use dimensional time + # fun = pybamm.Function( + # myinterp, + # pybamm.t * pybamm_model.timescale.evaluate(), + # name=variable_name + "_comsol", + # ) + fun = pybamm.Interpolant( pybamm.t * pybamm_model.timescale.evaluate(), name=variable_name + "_comsol", ) diff --git a/examples/scripts/experimental_protocols/cccv.py b/examples/scripts/experimental_protocols/cccv.py index 26b2327544..f6b98dcb21 100644 --- a/examples/scripts/experimental_protocols/cccv.py +++ b/examples/scripts/experimental_protocols/cccv.py @@ -4,10 +4,10 @@ import pybamm import matplotlib.pyplot as plt -pybamm.set_logging_level("DEBUG") +pybamm.set_logging_level("INFO") experiment = pybamm.Experiment( [ - "Discharge at C/1 for 1 hours or until 3.3 V", + "Discharge at C/10 for 10 hours or until 3.3 V", "Rest for 1 hour", "Charge at 1 A until 4.1 V", "Hold at 4.1 V until 50 mA", @@ -15,7 +15,7 @@ ] * 3 ) -model = pybamm.lithium_ion.SPM() +model = pybamm.lithium_ion.DFN() sim = pybamm.Simulation(model, experiment=experiment, solver=pybamm.CasadiSolver()) sim.solve() diff --git a/pybamm/solvers/processed_symbolic_variable.py b/pybamm/solvers/processed_symbolic_variable.py index 443e39ec0a..1f5054b8a7 100644 --- a/pybamm/solvers/processed_symbolic_variable.py +++ b/pybamm/solvers/processed_symbolic_variable.py @@ -27,23 +27,23 @@ def __init__(self, base_variable, solution): t_MX = casadi.MX.sym("t") y_MX = casadi.MX.sym("y", solution.y.shape[0]) # Make all inputs symbolic first for converting to casadi - all_inputs_as_MX_dict = {} + symbolic_inputs_dict = {} symbolic_inputs_dict = {} for key, value in solution.inputs.items(): if not isinstance(value, casadi.MX): - all_inputs_as_MX_dict[key] = casadi.MX.sym("input") + symbolic_inputs_dict[key] = casadi.MX.sym("input") else: - all_inputs_as_MX_dict[key] = value + symbolic_inputs_dict[key] = value # Only add symbolic inputs to the "symbolic_inputs" dict symbolic_inputs_dict[key] = value - all_inputs_as_MX = casadi.vertcat(*[p for p in all_inputs_as_MX_dict.values()]) + symbolic_inputs = casadi.vertcat(*[p for p in symbolic_inputs_dict.values()]) # The symbolic_inputs dictionary will be used for sensitivity symbolic_inputs = casadi.vertcat(*[p for p in symbolic_inputs_dict.values()]) - var = base_variable.to_casadi(t_MX, y_MX, inputs=all_inputs_as_MX_dict) + var = base_variable.to_casadi(t_MX, y_MX, inputs=symbolic_inputs_dict) self.base_variable = casadi.Function( - "variable", [t_MX, y_MX, all_inputs_as_MX], [var] + "variable", [t_MX, y_MX, symbolic_inputs], [var] ) # Store some attributes self.t_sol = solution.t diff --git a/pybamm/solvers/solution.py b/pybamm/solvers/solution.py index bdad8a833b..f92c014dbd 100644 --- a/pybamm/solvers/solution.py +++ b/pybamm/solvers/solution.py @@ -72,7 +72,6 @@ def t(self): @t.setter def t(self, t): self._t = t - self._t_MX = casadi.MX.sym("t") @property def y(self): @@ -82,7 +81,6 @@ def y(self): @y.setter def y(self, y): self._y = y - self._y_MX = casadi.MX.sym("y", y.shape[0]) @property def model(self): @@ -139,13 +137,6 @@ def inputs(self, inputs): else: inp = np.tile(inp, len(self.t)) self._inputs[name] = inp - self._all_inputs_as_MX_dict = {} - for key, value in self._inputs.items(): - self._all_inputs_as_MX_dict[key] = casadi.MX.sym("input", value.shape[0]) - - self._all_inputs_as_MX = casadi.vertcat( - *[p for p in self._all_inputs_as_MX_dict.values()] - ) @property def t_event(self): @@ -201,15 +192,25 @@ def update(self, variables): if key in self.model._variables_casadi: var_casadi = self.model._variables_casadi[key] else: + self._t_MX = casadi.MX.sym("t") + self._y_MX = casadi.MX.sym("y", self.y.shape[0]) + self._symbolic_inputs_dict = { + key: casadi.MX.sym("input", value.shape[0]) + for key, value in self._inputs.items() + } + self._symbolic_inputs = casadi.vertcat( + *[p for p in self._symbolic_inputs_dict.values()] + ) + # Convert variable to casadi # Make all inputs symbolic first for converting to casadi var_sym = var_pybamm.to_casadi( - self._t_MX, self._y_MX, inputs=self._all_inputs_as_MX_dict + self._t_MX, self._y_MX, inputs=self._symbolic_inputs_dict ) var_casadi = casadi.Function( "variable", - [self._t_MX, self._y_MX, self._all_inputs_as_MX], + [self._t_MX, self._y_MX, self._symbolic_inputs], [var_sym], ) self.model._variables_casadi[key] = var_casadi @@ -265,8 +266,8 @@ def clear_casadi_attributes(self): "Remove casadi objects for pickling, will be computed again automatically" self._t_MX = None self._y_MX = None - self._all_inputs_as_MX = None - self._all_inputs_as_MX_dict = None + self._symbolic_inputs = None + self._symbolic_inputs_dict = None def save(self, filename): """Save the whole solution using pickle""" diff --git a/tests/unit/test_solvers/test_processed_variable.py b/tests/unit/test_solvers/test_processed_variable.py index 153d8a092f..6fb5d750da 100644 --- a/tests/unit/test_solvers/test_processed_variable.py +++ b/tests/unit/test_solvers/test_processed_variable.py @@ -13,16 +13,16 @@ def to_casadi(var_pybamm, y, inputs=None): t_MX = casadi.MX.sym("t") y_MX = casadi.MX.sym("y", y.shape[0]) - all_inputs_as_MX_dict = {} + symbolic_inputs_dict = {} inputs = inputs or {} for key, value in inputs.items(): - all_inputs_as_MX_dict[key] = casadi.MX.sym("input", value.shape[0]) + symbolic_inputs_dict[key] = casadi.MX.sym("input", value.shape[0]) - all_inputs_as_MX = casadi.vertcat(*[p for p in all_inputs_as_MX_dict.values()]) + symbolic_inputs = casadi.vertcat(*[p for p in symbolic_inputs_dict.values()]) - var_sym = var_pybamm.to_casadi(t_MX, y_MX, inputs=all_inputs_as_MX_dict) + var_sym = var_pybamm.to_casadi(t_MX, y_MX, inputs=symbolic_inputs_dict) - var_casadi = casadi.Function("variable", [t_MX, y_MX, all_inputs_as_MX], [var_sym]) + var_casadi = casadi.Function("variable", [t_MX, y_MX, symbolic_inputs], [var_sym]) return var_casadi From 9ff40eca3967c114d55c12bb826f23a79418dd69 Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Tue, 29 Dec 2020 14:56:16 +0100 Subject: [PATCH 08/13] #1221 fix examples --- .../notebooks/models/pouch-cell-model.ipynb | 36 ++------------- examples/notebooks/parameter-values.ipynb | 46 ++++++++++++++----- pybamm/__init__.py | 1 + 3 files changed, 39 insertions(+), 44 deletions(-) diff --git a/examples/notebooks/models/pouch-cell-model.ipynb b/examples/notebooks/models/pouch-cell-model.ipynb index 3366aaf060..afb6b7c8cd 100644 --- a/examples/notebooks/models/pouch-cell-model.ipynb +++ b/examples/notebooks/models/pouch-cell-model.ipynb @@ -568,36 +568,6 @@ "and plot the negative current collector potential" ] }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'interp1d' object has no attribute '__name__'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/operations/convert_to_casadi.py\u001b[0m in \u001b[0;36mconvert\u001b[0;34m(self, symbol, t, y, y_dot, inputs)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_casadi_symbols\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 42\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: 3707944294786099166", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m comsol_model.variables[\"Terminal voltage [V]\"].to_casadi(\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mcomsol_solution\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_t_MX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcomsol_solution\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_y_MX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m )\n", - "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/symbol.py\u001b[0m in \u001b[0;36mto_casadi\u001b[0;34m(self, t, y, y_dot, inputs, casadi_symbols)\u001b[0m\n\u001b[1;32m 994\u001b[0m \u001b[0mSee\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;32mclass\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0mpybamm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCasadiConverter\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 995\u001b[0m \"\"\"\n\u001b[0;32m--> 996\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mpybamm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCasadiConverter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasadi_symbols\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconvert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_dot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 997\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 998\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mnew_copy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/operations/convert_to_casadi.py\u001b[0m in \u001b[0;36mconvert\u001b[0;34m(self, symbol, t, y, y_dot, inputs)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[0;31m# Change inputs to empty dictionary if it's None\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0minputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minputs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m \u001b[0mcasadi_symbol\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_convert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_dot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 46\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_casadi_symbols\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcasadi_symbol\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/operations/convert_to_casadi.py\u001b[0m in \u001b[0;36m_convert\u001b[0;34m(self, symbol, t, y, y_dot, inputs)\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mconverted_children\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 138\u001b[0m )\n\u001b[0;32m--> 139\u001b[0;31m \u001b[0;32melif\u001b[0m \u001b[0msymbol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"elementwise_grad_of_\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 140\u001b[0m \u001b[0mdifferentiating_child_idx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 141\u001b[0m \u001b[0;31m# Create dummy symbolic variables in order to differentiate using CasADi\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAttributeError\u001b[0m: 'interp1d' object has no attribute '__name__'" - ] - } - ], - "source": [ - "comsol_model.variables[\"Terminal voltage [V]\"].to_casadi(\n", - " comsol_solution._t_MX, comsol_solution._y_MX\n", - ")" - ] - }, { "cell_type": "code", "execution_count": 15, @@ -645,7 +615,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -709,7 +679,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -761,7 +731,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": { "scrolled": true }, diff --git a/examples/notebooks/parameter-values.ipynb b/examples/notebooks/parameter-values.ipynb index d89916f930..99644cc0e5 100644 --- a/examples/notebooks/parameter-values.ipynb +++ b/examples/notebooks/parameter-values.ipynb @@ -18,9 +18,19 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING: You are using pip version 20.2.4; however, version 20.3.3 is available.\n", + "You should consider upgrading via the '/Users/vsulzer/Documents/Energy_storage/PyBaMM/.tox/dev/bin/python -m pip install --upgrade pip' command.\u001b[0m\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], "source": [ "%pip install pybamm -q # install PyBaMM if it is not installed\n", "import pybamm\n", @@ -41,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -69,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -146,7 +156,7 @@ "parameter values are {'a': 4,\n", " 'b': 5,\n", " 'c': 6,\n", - " 'cube function': }\n" + " 'cube function': }\n" ] } ], @@ -176,8 +186,8 @@ "parameter values are {'a': 4,\n", " 'b': 5,\n", " 'c': 6,\n", - " 'cube function': ,\n", - " 'square function': }\n" + " 'cube function': ,\n", + " 'square function': }\n" ] } ], @@ -191,7 +201,8 @@ ")\n", "f.close()\n", "parameter_values.update({\"square function\": pybamm.load_function(\"squared.py\")}, check_already_exists=False)\n", - "print(\"parameter values are {}\".format(parameter_values))" + "print(\"parameter values are {}\".format(parameter_values))\n", + "os.remove(\"squared.py\")" ] }, { @@ -341,7 +352,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -413,7 +424,7 @@ { "data": { "text/plain": [ - "{Variable(-0x5d1a09af22d01535, u, children=[], domain=[], auxiliary_domains={}): Multiplication(0x196c827dd508e63d, *, children=['-a', 'y[0:1]'], domain=[], auxiliary_domains={})}" + "{Variable(0x2d386efb3bed2d38, u, children=[], domain=[], auxiliary_domains={}): Multiplication(0x7851652896e183c2, *, children=['-a', 'y[0:1]'], domain=[], auxiliary_domains={})}" ] }, "execution_count": 13, @@ -493,7 +504,20 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.8" + "version": "3.8.6" + }, + "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 } }, "nbformat": 4, diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 0bb685fefe..9a272781eb 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -56,6 +56,7 @@ def version(formatted=False): ABSOLUTE_PATH = root_dir() PARAMETER_PATH = [ + root_dir(), os.getcwd(), os.path.join(root_dir(), "pybamm", "input", "parameters"), ] From 8bd8dc4ce64ab82e673cb9429aed824cc93d643c Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Tue, 29 Dec 2020 17:41:13 +0100 Subject: [PATCH 09/13] #1221 fix ProcessedSymbolicVariable --- pybamm/solvers/processed_symbolic_variable.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pybamm/solvers/processed_symbolic_variable.py b/pybamm/solvers/processed_symbolic_variable.py index 1f5054b8a7..443e39ec0a 100644 --- a/pybamm/solvers/processed_symbolic_variable.py +++ b/pybamm/solvers/processed_symbolic_variable.py @@ -27,23 +27,23 @@ def __init__(self, base_variable, solution): t_MX = casadi.MX.sym("t") y_MX = casadi.MX.sym("y", solution.y.shape[0]) # Make all inputs symbolic first for converting to casadi - symbolic_inputs_dict = {} + all_inputs_as_MX_dict = {} symbolic_inputs_dict = {} for key, value in solution.inputs.items(): if not isinstance(value, casadi.MX): - symbolic_inputs_dict[key] = casadi.MX.sym("input") + all_inputs_as_MX_dict[key] = casadi.MX.sym("input") else: - symbolic_inputs_dict[key] = value + all_inputs_as_MX_dict[key] = value # Only add symbolic inputs to the "symbolic_inputs" dict symbolic_inputs_dict[key] = value - symbolic_inputs = casadi.vertcat(*[p for p in symbolic_inputs_dict.values()]) + all_inputs_as_MX = casadi.vertcat(*[p for p in all_inputs_as_MX_dict.values()]) # The symbolic_inputs dictionary will be used for sensitivity symbolic_inputs = casadi.vertcat(*[p for p in symbolic_inputs_dict.values()]) - var = base_variable.to_casadi(t_MX, y_MX, inputs=symbolic_inputs_dict) + var = base_variable.to_casadi(t_MX, y_MX, inputs=all_inputs_as_MX_dict) self.base_variable = casadi.Function( - "variable", [t_MX, y_MX, symbolic_inputs], [var] + "variable", [t_MX, y_MX, all_inputs_as_MX], [var] ) # Store some attributes self.t_sol = solution.t From ad10f3af46a4ee2e22b92b34f810865733bf48df Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Thu, 31 Dec 2020 14:40:23 +0100 Subject: [PATCH 10/13] #1221 coverage --- pybamm/simulation.py | 28 ------------------- pybamm/solvers/base_solver.py | 1 - .../test_solvers/test_external_variables.py | 5 ++-- .../test_unary_operators.py | 9 +++--- .../test_expression_tree/test_variable.py | 3 ++ tests/unit/test_simulation.py | 18 ------------ 6 files changed, 9 insertions(+), 55 deletions(-) diff --git a/pybamm/simulation.py b/pybamm/simulation.py index 6627898b70..ccb34aa570 100644 --- a/pybamm/simulation.py +++ b/pybamm/simulation.py @@ -528,34 +528,6 @@ def step(self, dt, solver=None, npts=2, save=True, **kwargs): return self.solution - def get_variable_array(self, *variables): - """ - A helper function to easily obtain a dictionary of arrays of values - for a list of variables at the latest timestep. - - Parameters - ---------- - variable: str - The name of the variable/variables you wish to obtain the arrays for. - - Returns - ------- - variable_arrays: dict - A dictionary of the variable names and their corresponding - arrays. - """ - - variable_arrays = {} - for var in variables: - processed_var = self.solution[var].data - if processed_var.ndim == 1: - variable_arrays[var] = processed_var[-1] - elif processed_var.ndim == 2: - variable_arrays[var] = processed_var[:, -1] - elif processed_var.ndim == 3: - variable_arrays[var] = processed_var[:, :, -1] - return variable_arrays - def plot(self, output_variables=None, quick_plot_vars=None, **kwargs): """ A method to quickly plot the outputs of the simulation. Creates a diff --git a/pybamm/solvers/base_solver.py b/pybamm/solvers/base_solver.py index 3a6d8175a5..13ff8f1f1e 100644 --- a/pybamm/solvers/base_solver.py +++ b/pybamm/solvers/base_solver.py @@ -942,7 +942,6 @@ def __init__(self, function, name, model): self.timescale = self.model.timescale_eval def __call__(self, t, y, inputs): - # y = y.reshape(-1, 1) if self.name in ["RHS", "algebraic", "residuals"]: pybamm.logger.debug( "Evaluating {} for {} at t={}".format( diff --git a/tests/integration/test_solvers/test_external_variables.py b/tests/integration/test_solvers/test_external_variables.py index 1e301bd1fc..1a6eb4af9b 100644 --- a/tests/integration/test_solvers/test_external_variables.py +++ b/tests/integration/test_solvers/test_external_variables.py @@ -45,9 +45,8 @@ def test_external_variables_SPMe(self): T_av += 1 sim.step(dt, external_variables=external_variables) var = "Terminal voltage [V]" - t = sim.solution.t[-1] - sim.solution[var].data - sim.solution[var](t) + V = sim.solution["Terminal voltage [V]"].data + np.testing.assert_array_less(np.diff(V), 0) # test generate with external variable sim.built_model.generate("test.c", ["Volume-averaged cell temperature"]) os.remove("test.c") diff --git a/tests/unit/test_expression_tree/test_unary_operators.py b/tests/unit/test_expression_tree/test_unary_operators.py index fc3d53be3a..4c3a523a53 100644 --- a/tests/unit/test_expression_tree/test_unary_operators.py +++ b/tests/unit/test_expression_tree/test_unary_operators.py @@ -16,11 +16,10 @@ def test_unary_operator(self): self.assertEqual(un.domain, a.domain) # with number - absval = pybamm.AbsoluteValue(-10) - self.assertEqual(absval.evaluate(), 10) - - log = pybamm.log(10) - self.assertEqual(log.evaluate(), np.log(10)) + a = pybamm.InputParameter("a") + absval = pybamm.AbsoluteValue(-a) + self.assertEqual(absval.evaluate(inputs={"a": 10}), 10) + self.assertEqual(absval.evaluate(inputs={"a": 10}, known_evals={})[0], 10) def test_negation(self): a = pybamm.Symbol("a") diff --git a/tests/unit/test_expression_tree/test_variable.py b/tests/unit/test_expression_tree/test_variable.py index b023f1e439..b9c780be60 100644 --- a/tests/unit/test_expression_tree/test_variable.py +++ b/tests/unit/test_expression_tree/test_variable.py @@ -91,6 +91,9 @@ def test_external_variable_vector(self): a_test = 2 * np.ones((10, 1)) np.testing.assert_array_equal(a.evaluate(inputs={"a": a_test}), a_test) + np.testing.assert_array_equal( + a.evaluate(inputs={"a": a_test.flatten()}), a_test + ) np.testing.assert_array_equal(a.evaluate(inputs={"a": 2}), a_test) diff --git a/tests/unit/test_simulation.py b/tests/unit/test_simulation.py index 72279a4e36..0d5152d9df 100644 --- a/tests/unit/test_simulation.py +++ b/tests/unit/test_simulation.py @@ -140,24 +140,6 @@ def test_set_crate(self): self.assertEqual(sim.parameter_values["Current function [A]"], 2 * current_1C) self.assertEqual(sim.C_rate, 2) - def test_get_variable_array(self): - - sim = pybamm.Simulation(pybamm.lithium_ion.SPM()) - sim.solve([0, 600]) - - phi_s_n = sim.get_variable_array("Negative electrode potential")[ - "Negative electrode potential" - ] - - self.assertIsInstance(phi_s_n, np.ndarray) - - c_s_n_surf, c_e = sim.get_variable_array( - "Negative particle surface concentration", "Electrolyte concentration" - ).values() - - self.assertIsInstance(c_s_n_surf, np.ndarray) - self.assertIsInstance(c_e, np.ndarray) - def test_set_external_variable(self): model_options = { "thermal": "lumped", From 47cf25fd6684947ae5cf39c1e2373f11396cd936 Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Thu, 31 Dec 2020 14:41:42 +0100 Subject: [PATCH 11/13] #1221 changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 914b444b80..86dd9c9570 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,7 @@ ## Optimizations +- Variables are now post-processed using CasADi ([#1316](https://github.com/pybamm-team/PyBaMM/pull/1316)) - Operations such as `1*x` and `0+x` now directly return `x` ([#1252](https://github.com/pybamm-team/PyBaMM/pull/1252)) ## Bug fixes From 8157f5ff18fdd391feace46776834ea4f6d139b8 Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Thu, 31 Dec 2020 14:44:51 +0100 Subject: [PATCH 12/13] #1221 flake8 --- tests/integration/test_solvers/test_external_variables.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/integration/test_solvers/test_external_variables.py b/tests/integration/test_solvers/test_external_variables.py index 1a6eb4af9b..8ad4759c50 100644 --- a/tests/integration/test_solvers/test_external_variables.py +++ b/tests/integration/test_solvers/test_external_variables.py @@ -44,7 +44,6 @@ def test_external_variables_SPMe(self): external_variables = {"Volume-averaged cell temperature": T_av} T_av += 1 sim.step(dt, external_variables=external_variables) - var = "Terminal voltage [V]" V = sim.solution["Terminal voltage [V]"].data np.testing.assert_array_less(np.diff(V), 0) # test generate with external variable From 4b84f39c3a9273311c5cfe630a9679e41fdd634d Mon Sep 17 00:00:00 2001 From: Valentin Sulzer Date: Thu, 31 Dec 2020 22:02:58 +0100 Subject: [PATCH 13/13] #1221 fix test --- pybamm/solvers/base_solver.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/pybamm/solvers/base_solver.py b/pybamm/solvers/base_solver.py index 6a663f67de..497b295be7 100644 --- a/pybamm/solvers/base_solver.py +++ b/pybamm/solvers/base_solver.py @@ -911,7 +911,11 @@ def get_termination_reason(self, solution, events): # causes an error later in ProcessedVariable) if solution.t_event - solution._t[-1] > self.atol: solution._t = np.concatenate((solution._t, solution.t_event)) - solution._y = np.concatenate((solution._y, solution.y_event), axis=1) + if isinstance(solution.y, casadi.DM): + solution._y = casadi.horzcat(solution.y, solution.y_event) + else: + solution._y = np.hstack((solution._y, solution.y_event)) + for name, inp in solution.inputs.items(): solution._inputs[name] = np.c_[inp, inp[:, -1]]