From 979d20bbdcf23b4b20d94058a36d53f243a90dbc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20A=20Le=C3=B3n=20Baldelli?= Date: Wed, 20 Mar 2024 16:25:58 +0100 Subject: [PATCH 1/8] adding practice script --- playground/benchmark-umut-at2/parameters.yaml | 128 ++++++++++++++++++ .../benchmark-umut-at2/vs_analytics_at2.py | 123 +++++++++++++++++ 2 files changed, 251 insertions(+) create mode 100644 playground/benchmark-umut-at2/parameters.yaml create mode 100644 playground/benchmark-umut-at2/vs_analytics_at2.py diff --git a/playground/benchmark-umut-at2/parameters.yaml b/playground/benchmark-umut-at2/parameters.yaml new file mode 100644 index 00000000..765fe3fe --- /dev/null +++ b/playground/benchmark-umut-at2/parameters.yaml @@ -0,0 +1,128 @@ +# === Loading === # +loading: + min: 0 + max: 1.001 + steps: 10 + +# === Geometry === # +geometry: + geometric_dimension: 2 + geom_type: "bar" + Lx: 1. + Ly: .1 + lc: 0.02 + mesh_size_factor: 3 + +# === Material === # +model: + E: 1. + sigma_D0: 1. + nu: 0.3 + ell: 0.1 + model_dimension: 2 + model_type: "2D" + # could be "2D"/ "3D" / "plane_stress" / "plane_strain" +# === Solver === # +solvers: + elasticity: + prefix: elasticity + snes: + snes_type: newtontr + snes_stol: 1e-8 + snes_atol: 1e-8 + snes_rtol: 1e-8 + snes_max_it: 200 + # snes_divergence_tolerance: -1.0 + snes_monitor: "" + ksp_type: preonly + pc_type: lu + pc_factor_mat_solver_type: mumps + + # Damage solver parameters + damage: + type: SNES + prefix: damage + snes: + # Options in the case of SNES solver + snes_type: vinewtonrsls + snes_linesearch_type: basic + ksp_type: preonly + pc_type: lu + pc_factor_mat_solver_type: mumps + snes_atol: 1.0e-8 + snes_rtol: 1.0e-8 + # snes_stol: 0.0 + snes_max_it: 50 + # snes_divergence_tolerance: -1.0 + snes_monitor: "" + tao: + # Options in the case of TAO solver + tao_type: tron + tao_gpcg_maxpgits: 50 + tao_max_it: 100 + tao_steptol: 1.0e-7 + tao_gatol: 1.0e-8 + tao_grtol: 1.0e-8 + tao_gttol: 1.0e-8 + tao_catol: 0. + tao_crtol: 0. + tao_ls_ftol: 1e-5 + tao_ls_gtol: 1e-5 + tao_ls_rtol: 1e-5 + ksp_rtol: 1e-6 + tao_ls_stepmin: 1e-8 + tao_ls_stepmax: 1e6 + pc_type: lu + tao_monitor: "" + + # Damage Elasticity Solver parameters + damage_elasticity: + max_it: 200 + alpha_rtol: 1.0e-4 + criterion: "alpha_H1" + + newton: + snes_type: "vinewtonrsls" + snes_linesearch_type: "basic" + snes_rtol: 1.0e-8 + snes_atol: 1.0e-8 + snes_max_it: 30 + snes_monitor: "" + linesearch_damping: 0.5 + +stability: + order: 3 + maxmodes: 10 + checkstability: "True" + continuation: "False" + cont_rtol: 1.0e-10 + inactiveset_gatol: 1.e-6 + inactiveset_pwtol: 1.e-6 + is_elastic_tol: 1.e-6 + + inertia: + # MUMPS + ksp_type: "preonly" + pc_type: "cholesky" + pc_factor_mat_solver_type: "mumps" + mat_mumps_icntl_24: 1 + mat_mumps_icntl_13: 1 + + eigen: + eps_type: "krylovschur" + # eps_type: "lanczos" + # eps_monitor: "" + eps_tol: 1.e-5 + eig_rtol: 1.e-8 + eps_max_it: 100 + + cone: + cone_atol: 1.0e-06 + cone_max_it: 3000 + cone_rtol: 1.0e-06 + maxmodes: 3 + scaling: 1.e-5 + + linesearch: + order: 4 + method: 'min' diff --git a/playground/benchmark-umut-at2/vs_analytics_at2.py b/playground/benchmark-umut-at2/vs_analytics_at2.py new file mode 100644 index 00000000..84bef742 --- /dev/null +++ b/playground/benchmark-umut-at2/vs_analytics_at2.py @@ -0,0 +1,123 @@ +#!/usr/bin/env python3 +import json +import logging +import os +import sys +from pathlib import Path + +import dolfinx +import dolfinx.mesh +import dolfinx.plot +import numpy as np +import pandas as pd +import petsc4py +import pyvista +import ufl +import yaml +from dolfinx.fem import ( + Constant, + Function, + assemble_scalar, + dirichletbc, + form, + locate_dofs_geometrical, + set_bc, +) +from dolfinx.common import list_timings +from dolfinx.fem.petsc import assemble_vector, set_bc +from dolfinx.io import XDMFFile +from mpi4py import MPI +from petsc4py import PETSc + +from irrevolutions.algorithms.am import HybridSolver +from irrevolutions.algorithms.so import BifurcationSolver, StabilitySolver +from irrevolutions.solvers import SNESSolver +from irrevolutions.solvers.function import vec_to_functions +from irrevolutions.utils import ( + ColorPrint, + _logger, + _write_history_data, + history_data, + norm_H1, + norm_L2, +) +from irrevolutions.utils.plots import ( + plot_AMit_load, + plot_energies, + plot_force_displacement, +) +from irrevolutions.test.test_1d import _AlternateMinimisation1D as am1d + + +petsc4py.init(sys.argv) +comm = MPI.COMM_WORLD + +# Mesh on node model_rank and then distribute +model_rank = 0 + +def run_computation(parameters, storage=None): + + return + + +def load_parameters(file_path, ndofs, model="at1"): + """ + Load parameters from a YAML file. + + Args: + file_path (str): Path to the YAML parameter file. + + Returns: + dict: Loaded parameters. + """ + import hashlib + + with open(file_path) as f: + parameters = yaml.load(f, Loader=yaml.FullLoader) + + parameters["model"]["model_dimension"] = 1 + parameters["model"]["model_type"] = "1D" + # parameters["model"]["mu"] = 1 + parameters["model"]["w1"] = 1 + + parameters["geometry"]["geom_type"] = "discrete-damageable" + # Get mesh parameters + + if model == "at2": + parameters["loading"]["min"] = 0.9 + parameters["loading"]["max"] = 0.9 + parameters["loading"]["steps"] = 1 + + elif model == "at1": + parameters["loading"]["min"] = 0.0 + parameters["loading"]["max"] = 1.5 + parameters["loading"]["steps"] = 20 + + parameters["geometry"]["geom_type"] = "traction-bar" + parameters["geometry"]["mesh_size_factor"] = 4 + parameters["geometry"]["N"] = ndofs + + parameters["stability"]["cone"]["cone_max_it"] = 400000 + parameters["stability"]["cone"]["cone_atol"] = 1e-6 + parameters["stability"]["cone"]["cone_rtol"] = 1e-6 + parameters["stability"]["cone"]["scaling"] = 1e-2 + + parameters["model"]["w1"] = 1 + parameters["model"]["ell"] = 0.2 + parameters["model"]["k_res"] = 0.0 + + signature = hashlib.md5(str(parameters).encode("utf-8")).hexdigest() + + return parameters, signature + + +if __name__ == "__main__": + # Set the logging level + logging.basicConfig(level=logging.INFO) + + # Load parameters + parameters, signature = load_parameters( + os.path.join(os.path.dirname(__file__), "parameters.yaml"), 100, "at1") + + # Run computation + run_computation(parameters) \ No newline at end of file From 4637db4179ff5e718f6cf978d42dde06369d83fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20A=20Le=C3=B3n=20Baldelli?= Date: Wed, 20 Mar 2024 17:07:05 +0100 Subject: [PATCH 2/8] simple run at2 for umut benchmarck --- playground/benchmark-umut-at2/parameters.yaml | 6 +- .../benchmark-umut-at2/vs_analytics_at2.py | 301 ++++++++++++++++-- 2 files changed, 272 insertions(+), 35 deletions(-) diff --git a/playground/benchmark-umut-at2/parameters.yaml b/playground/benchmark-umut-at2/parameters.yaml index 765fe3fe..b0614b85 100644 --- a/playground/benchmark-umut-at2/parameters.yaml +++ b/playground/benchmark-umut-at2/parameters.yaml @@ -17,10 +17,10 @@ geometry: model: E: 1. sigma_D0: 1. - nu: 0.3 ell: 0.1 - model_dimension: 2 - model_type: "2D" + model_dimension: 1 + model_type: "1D" + kappa: 10. # could be "2D"/ "3D" / "plane_stress" / "plane_strain" # === Solver === # solvers: diff --git a/playground/benchmark-umut-at2/vs_analytics_at2.py b/playground/benchmark-umut-at2/vs_analytics_at2.py index 84bef742..349c392b 100644 --- a/playground/benchmark-umut-at2/vs_analytics_at2.py +++ b/playground/benchmark-umut-at2/vs_analytics_at2.py @@ -1,9 +1,11 @@ #!/usr/bin/env python3 +import hashlib import json import logging import os import sys from pathlib import Path +from typing import Optional import dolfinx import dolfinx.mesh @@ -14,40 +16,22 @@ import pyvista import ufl import yaml -from dolfinx.fem import ( - Constant, - Function, - assemble_scalar, - dirichletbc, - form, - locate_dofs_geometrical, - set_bc, -) from dolfinx.common import list_timings +from dolfinx.fem import (Constant, Function, assemble_scalar, dirichletbc, + form, locate_dofs_geometrical, set_bc) from dolfinx.fem.petsc import assemble_vector, set_bc from dolfinx.io import XDMFFile -from mpi4py import MPI -from petsc4py import PETSc - from irrevolutions.algorithms.am import HybridSolver from irrevolutions.algorithms.so import BifurcationSolver, StabilitySolver from irrevolutions.solvers import SNESSolver from irrevolutions.solvers.function import vec_to_functions -from irrevolutions.utils import ( - ColorPrint, - _logger, - _write_history_data, - history_data, - norm_H1, - norm_L2, -) -from irrevolutions.utils.plots import ( - plot_AMit_load, - plot_energies, - plot_force_displacement, -) -from irrevolutions.test.test_1d import _AlternateMinimisation1D as am1d - +from irrevolutions.test.test_1d import _AlternateMinimisation1D as am1d +from irrevolutions.utils import (ColorPrint, _logger, _write_history_data, + history_data, norm_H1, norm_L2) +from irrevolutions.utils.plots import (plot_AMit_load, plot_energies, + plot_force_displacement) +from mpi4py import MPI +from petsc4py import PETSc petsc4py.init(sys.argv) comm = MPI.COMM_WORLD @@ -55,7 +39,261 @@ # Mesh on node model_rank and then distribute model_rank = 0 + +def a(alpha): + # k_res = parameters["model"]['k_res'] + return (1 - alpha) ** 2 + +def a_atk(alpha): + parameters["model"]["k_res"] + _k = parameters["model"]["k"] + return (1 - alpha) / ((_k - 1) * alpha + 1) + +def w(alpha): + """ + Return the homogeneous damage energy term, + as a function of the state + (only depends on damage). + """ + # Return w(alpha) function + return alpha**2 + +def elastic_energy_density_atk(state): + """ + Returns the elastic energy density from the state. + """ + # Parameters + alpha = state["alpha"] + u = state["u"] + eps = ufl.grad(u) + + _mu = parameters["model"]["E"] + energy_density = _mu / 2.0 * a_atk(alpha) * ufl.inner(eps, eps) + return energy_density + +def elastic_energy_density(state, u_zero: Optional[dolfinx.fem.function.Function] = None): + """ + Returns the elastic energy density of the state. + """ + # Parameters + alpha = state["alpha"] + u = state["u"] + eps = ufl.grad(u) + + _mu = parameters["model"]["E"] + _kappa = parameters["model"].get("kappa", 1.0) + + energy_density = _mu / 2.0 * a(alpha) * ufl.inner(eps, eps) + + if u_zero is None: + u_zero = Constant(u.function_space.mesh, 0.0) + # u_zero.vector.ghostUpdate( + # addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD + # ) + + substrate_density = _kappa / 2.0 * ufl.inner(u - u_zero, u - u_zero) + + return energy_density + substrate_density + +def damage_energy_density(state): + """ + Return the damage energy density of the state. + """ + # Get the material parameters + _w1 = parameters["model"]["w1"] + _ell = parameters["model"]["ell"] + # Get the damage + alpha = state["alpha"] + # Compute the damage gradient + grad_alpha = ufl.grad(alpha) + # Compute the damage dissipation density + D_d = _w1 * w(alpha) + _w1 * _ell**2 * ufl.dot(grad_alpha, grad_alpha) + return D_d + +def stress(state): + """ + Return the one-dimensional stress + """ + u = state["u"] + alpha = state["alpha"] + dx = ufl.Measure("dx", domain=u.function_space.mesh) + + return parameters["model"]["E"] * a(alpha) * u.dx() * dx + + + + + + + + def run_computation(parameters, storage=None): + Lx = parameters["geometry"]["Lx"] + _nameExp = parameters["geometry"]["geom_type"] + parameters["model"]["ell"] + + # Get geometry model + parameters["geometry"]["geom_type"] + _N = int(parameters["geometry"]["N"]) + + mesh = dolfinx.mesh.create_unit_interval(MPI.COMM_WORLD, _N) + outdir = os.path.join(os.path.dirname(__file__), "output") + + if storage is None: + prefix = os.path.join(outdir, f"thin-film-at2") + else: + prefix = storage + + if comm.rank == 0: + Path(prefix).mkdir(parents=True, exist_ok=True) + + signature = hashlib.md5(str(parameters).encode("utf-8")).hexdigest() + + if comm.rank == 0: + with open(f"{prefix}/parameters.yaml", "w") as file: + yaml.dump(parameters, file) + + with open(f"{prefix}/signature.md5", "w") as f: + f.write(signature) + + with XDMFFile( + comm, f"{prefix}/{_nameExp}.xdmf", "w", encoding=XDMFFile.Encoding.HDF5 + ) as file: + file.write_mesh(mesh) + + # Functional Setting + element_u = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), degree=1) + element_alpha = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), degree=1) + + V_u = dolfinx.fem.FunctionSpace(mesh, element_u) + V_alpha = dolfinx.fem.FunctionSpace(mesh, element_alpha) + + u = dolfinx.fem.Function(V_u, name="Displacement") + u_ = dolfinx.fem.Function(V_u, name="BoundaryDisplacement") + + alpha = dolfinx.fem.Function(V_alpha, name="Damage") + + # Perturbations + β = Function(V_alpha, name="DamagePerturbation") + v = Function(V_u, name="DisplacementPerturbation") + + # Pack state + state = {"u": u, "alpha": alpha} + + # Bounds + alpha_ub = dolfinx.fem.Function(V_alpha, name="UpperBoundDamage") + alpha_lb = dolfinx.fem.Function(V_alpha, name="LowerBoundDamage") + + dx = ufl.Measure("dx", domain=mesh) + ds = ufl.Measure("ds", domain=mesh) + + # Useful references + Lx = parameters.get("geometry").get("Lx") + + # Define the state + u = Function(V_u, name="Unknown") + u_zero = Function(V_u, name="Inelastic displacement") + zero_u = Function(V_u, name="Boundary Unknown") + + # Measures + dx = ufl.Measure("dx", domain=mesh) + ds = ufl.Measure("ds", domain=mesh) + + dofs_u_left = locate_dofs_geometrical(V_u, lambda x: np.isclose(x[0], 0.0)) + dofs_u_right = locate_dofs_geometrical(V_u, lambda x: np.isclose(x[0], Lx)) + + alpha_lb.interpolate(lambda x: np.zeros_like(x[0])) + alpha_ub.interpolate(lambda x: np.ones_like(x[0])) + + eps_t = dolfinx.fem.Constant(mesh, np.array(0., dtype=PETSc.ScalarType)) + u_zero.interpolate(lambda x: eps_t/2. * (2*x[0] - Lx)) + + for f in [zero_u, u_zero, alpha_lb, alpha_ub]: + f.vector.ghostUpdate( + addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD + ) + + bcs_u = [] + bcs_alpha = [] + + bcs = {"bcs_u": bcs_u, "bcs_alpha": bcs_alpha} + + total_energy = (elastic_energy_density(state) + damage_energy_density(state)) * dx + + load_par = parameters["loading"] + loads = np.linspace(load_par["min"], load_par["max"], load_par["steps"]) + + hybrid = HybridSolver( + total_energy, + state, + bcs, + bounds=(alpha_lb, alpha_ub), + solver_parameters=parameters.get("solvers"), + ) + + bifurcation = BifurcationSolver( + total_energy, state, bcs, bifurcation_parameters=parameters.get("stability") + ) + + stability = StabilitySolver( + total_energy, state, bcs, cone_parameters=parameters.get("stability") + ) + + history_data["F"] = [] + + logging.basicConfig(level=logging.INFO) + + + for i_t, t in enumerate(loads): + + + # u_zero.interpolate(lambda x: t * np.ones_like(x[0])) + + eps_t.value = t + + u_zero.interpolate(lambda x: eps_t/2. * (2*x[0] - Lx)) + u_zero.vector.ghostUpdate( + addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD + ) + + # update the lower bound + alpha.vector.copy(alpha_lb.vector) + alpha_lb.vector.ghostUpdate( + addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD + ) + + _logger.critical(f"-- Solving for t = {t:3.2f} --") + hybrid.solve(alpha_lb) + + is_unique = bifurcation.solve(alpha_lb) + is_elastic = not bifurcation._is_critical(alpha_lb) + inertia = bifurcation.get_inertia() + + ColorPrint.print_bold(f"State is elastic: {is_elastic}") + ColorPrint.print_bold(f"State's inertia: {inertia}") + ColorPrint.print_bold(f"Evolution is unique: {is_unique}") + + z0 = ( + bifurcation._spectrum[0]["xk"] + if bifurcation._spectrum and "xk" in bifurcation._spectrum[0] + else None + ) + + stable = stability.solve(alpha_lb, eig0=z0, inertia=inertia) + + with dolfinx.common.Timer(f"~Postprocessing and Vis") as timer: + pass + + fracture_energy = comm.allreduce( + assemble_scalar(form(damage_energy_density(state) * dx)), + op=MPI.SUM, + ) + elastic_energy = comm.allreduce( + assemble_scalar(form(elastic_energy_density(state) * dx)), + op=MPI.SUM, + ) + _F = assemble_scalar(form(stress(state))) + return @@ -84,9 +322,9 @@ def load_parameters(file_path, ndofs, model="at1"): # Get mesh parameters if model == "at2": - parameters["loading"]["min"] = 0.9 - parameters["loading"]["max"] = 0.9 - parameters["loading"]["steps"] = 1 + parameters["loading"]["min"] = 0.0 + parameters["loading"]["max"] = 3.0 + parameters["loading"]["steps"] = 10 elif model == "at1": parameters["loading"]["min"] = 0.0 @@ -117,7 +355,6 @@ def load_parameters(file_path, ndofs, model="at1"): # Load parameters parameters, signature = load_parameters( - os.path.join(os.path.dirname(__file__), "parameters.yaml"), 100, "at1") - + os.path.join(os.path.dirname(__file__), "parameters.yaml"), 100, "at2") # Run computation run_computation(parameters) \ No newline at end of file From 242c4c0c5bdc1fa2f7d6baffde129bce08f1c7a2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20A=20Le=C3=B3n=20Baldelli?= Date: Wed, 20 Mar 2024 17:11:35 +0100 Subject: [PATCH 3/8] at2 runs without energy --- .../benchmark-umut-at2/vs_analytics_at2.py | 48 +++++++++++++++---- 1 file changed, 39 insertions(+), 9 deletions(-) diff --git a/playground/benchmark-umut-at2/vs_analytics_at2.py b/playground/benchmark-umut-at2/vs_analytics_at2.py index 349c392b..3f6156e1 100644 --- a/playground/benchmark-umut-at2/vs_analytics_at2.py +++ b/playground/benchmark-umut-at2/vs_analytics_at2.py @@ -30,6 +30,8 @@ history_data, norm_H1, norm_L2) from irrevolutions.utils.plots import (plot_AMit_load, plot_energies, plot_force_displacement) +from irrevolutions.utils import ResultsStorage, Visualization + from mpi4py import MPI from petsc4py import PETSc @@ -120,13 +122,6 @@ def stress(state): return parameters["model"]["E"] * a(alpha) * u.dx() * dx - - - - - - - def run_computation(parameters, storage=None): Lx = parameters["geometry"]["Lx"] _nameExp = parameters["geometry"]["geom_type"] @@ -294,8 +289,33 @@ def run_computation(parameters, storage=None): ) _F = assemble_scalar(form(stress(state))) + _write_history_data( + hybrid, + bifurcation, + stability, + history_data, + t, + inertia, + stable, + [fracture_energy, elastic_energy], + ) + history_data["F"].append(_F) + + with XDMFFile( + comm, f"{prefix}/{_nameExp}.xdmf", "a", encoding=XDMFFile.Encoding.HDF5 + ) as file: + file.write_function(u, t) + file.write_function(alpha, t) - return + if comm.rank == 0: + a_file = open(f"{prefix}/time_data.json", "w") + json.dump(history_data, a_file) + a_file.close() + + + # df = pd.DataFrame(history_data) + print(pd.DataFrame(history_data)) + return history_data, stability.data, state def load_parameters(file_path, ndofs, model="at1"): @@ -357,4 +377,14 @@ def load_parameters(file_path, ndofs, model="at1"): parameters, signature = load_parameters( os.path.join(os.path.dirname(__file__), "parameters.yaml"), 100, "at2") # Run computation - run_computation(parameters) \ No newline at end of file + + _storage = f"output/one-dimensional-bar/MPI-{MPI.COMM_WORLD.Get_size()}/{signature}" + visualization = Visualization(_storage) + + with dolfinx.common.Timer(f"~Computation Experiment") as timer: + history_data, stability_data, state = run_computation(parameters, _storage) + + from irrevolutions.utils import table_timing_data + _timings = table_timing_data() + visualization.save_table(_timings, "timing_data") + list_timings(MPI.COMM_WORLD, [dolfinx.common.TimingType.wall]) From dec010942c86caf07c39084a90458629cbe9736c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20A=20Le=C3=B3n=20Baldelli?= Date: Wed, 20 Mar 2024 18:07:23 +0100 Subject: [PATCH 4/8] still no energy. --- .../benchmark-umut-at2/vs_analytics_at2.py | 240 +++++++++++------- 1 file changed, 149 insertions(+), 91 deletions(-) diff --git a/playground/benchmark-umut-at2/vs_analytics_at2.py b/playground/benchmark-umut-at2/vs_analytics_at2.py index 3f6156e1..98022716 100644 --- a/playground/benchmark-umut-at2/vs_analytics_at2.py +++ b/playground/benchmark-umut-at2/vs_analytics_at2.py @@ -26,14 +26,16 @@ from irrevolutions.solvers import SNESSolver from irrevolutions.solvers.function import vec_to_functions from irrevolutions.test.test_1d import _AlternateMinimisation1D as am1d -from irrevolutions.utils import (ColorPrint, _logger, _write_history_data, - history_data, norm_H1, norm_L2) +from irrevolutions.utils import (ColorPrint, ResultsStorage, Visualization, + _logger, _write_history_data, history_data, + norm_H1, norm_L2) from irrevolutions.utils.plots import (plot_AMit_load, plot_energies, plot_force_displacement) -from irrevolutions.utils import ResultsStorage, Visualization - +from irrevolutions.utils.viz import (plot_mesh, plot_profile, plot_scalar, + plot_vector) from mpi4py import MPI from petsc4py import PETSc +from pyvista.utilities import xvfb petsc4py.init(sys.argv) comm = MPI.COMM_WORLD @@ -46,11 +48,6 @@ def a(alpha): # k_res = parameters["model"]['k_res'] return (1 - alpha) ** 2 -def a_atk(alpha): - parameters["model"]["k_res"] - _k = parameters["model"]["k"] - return (1 - alpha) / ((_k - 1) * alpha + 1) - def w(alpha): """ Return the homogeneous damage energy term, @@ -59,21 +56,10 @@ def w(alpha): """ # Return w(alpha) function return alpha**2 + # return alpha -def elastic_energy_density_atk(state): - """ - Returns the elastic energy density from the state. - """ - # Parameters - alpha = state["alpha"] - u = state["u"] - eps = ufl.grad(u) - - _mu = parameters["model"]["E"] - energy_density = _mu / 2.0 * a_atk(alpha) * ufl.inner(eps, eps) - return energy_density - -def elastic_energy_density(state, u_zero: Optional[dolfinx.fem.function.Function] = None): +def elastic_energy_density(state, + u_zero: Optional[dolfinx.fem.function.Function] = None): """ Returns the elastic energy density of the state. """ @@ -85,13 +71,11 @@ def elastic_energy_density(state, u_zero: Optional[dolfinx.fem.function.Function _mu = parameters["model"]["E"] _kappa = parameters["model"].get("kappa", 1.0) + # energy_density = _mu / 2.0 * ufl.inner(eps, eps) energy_density = _mu / 2.0 * a(alpha) * ufl.inner(eps, eps) if u_zero is None: u_zero = Constant(u.function_space.mesh, 0.0) - # u_zero.vector.ghostUpdate( - # addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD - # ) substrate_density = _kappa / 2.0 * ufl.inner(u - u_zero, u - u_zero) @@ -101,16 +85,18 @@ def damage_energy_density(state): """ Return the damage energy density of the state. """ - # Get the material parameters + _w1 = parameters["model"]["w1"] _ell = parameters["model"]["ell"] - # Get the damage + alpha = state["alpha"] - # Compute the damage gradient grad_alpha = ufl.grad(alpha) + # Compute the damage dissipation density - D_d = _w1 * w(alpha) + _w1 * _ell**2 * ufl.dot(grad_alpha, grad_alpha) - return D_d + damage_density = _w1 * w(alpha) + \ + _w1 * _ell**2 * ufl.dot(grad_alpha, grad_alpha) + + return damage_density def stress(state): """ @@ -187,8 +173,8 @@ def run_computation(parameters, storage=None): # Define the state u = Function(V_u, name="Unknown") - u_zero = Function(V_u, name="Inelastic displacement") - zero_u = Function(V_u, name="Boundary Unknown") + u_zero = Function(V_u, name="InelasticDisplacement") + zero_u = Function(V_u, name="BoundaryUnknown") # Measures dx = ufl.Measure("dx", domain=mesh) @@ -200,7 +186,7 @@ def run_computation(parameters, storage=None): alpha_lb.interpolate(lambda x: np.zeros_like(x[0])) alpha_ub.interpolate(lambda x: np.ones_like(x[0])) - eps_t = dolfinx.fem.Constant(mesh, np.array(0., dtype=PETSc.ScalarType)) + eps_t = dolfinx.fem.Constant(mesh, np.array(1., dtype=PETSc.ScalarType)) u_zero.interpolate(lambda x: eps_t/2. * (2*x[0] - Lx)) for f in [zero_u, u_zero, alpha_lb, alpha_ub]: @@ -208,12 +194,15 @@ def run_computation(parameters, storage=None): addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD ) + # bcs_u = [dirichletbc(u_zero, dofs_u_right), + # dirichletbc(u_zero, dofs_u_left)] + bcs_u = [] bcs_alpha = [] bcs = {"bcs_u": bcs_u, "bcs_alpha": bcs_alpha} - total_energy = (elastic_energy_density(state) + damage_energy_density(state)) * dx + total_energy = (elastic_energy_density(state, u_zero) + damage_energy_density(state)) * dx load_par = parameters["loading"] loads = np.linspace(load_par["min"], load_par["max"], load_par["steps"]) @@ -240,10 +229,7 @@ def run_computation(parameters, storage=None): for i_t, t in enumerate(loads): - - - # u_zero.interpolate(lambda x: t * np.ones_like(x[0])) - + eps_t.value = t u_zero.interpolate(lambda x: eps_t/2. * (2*x[0] - Lx)) @@ -277,48 +263,120 @@ def run_computation(parameters, storage=None): stable = stability.solve(alpha_lb, eig0=z0, inertia=inertia) with dolfinx.common.Timer(f"~Postprocessing and Vis") as timer: - pass - - fracture_energy = comm.allreduce( - assemble_scalar(form(damage_energy_density(state) * dx)), - op=MPI.SUM, - ) - elastic_energy = comm.allreduce( - assemble_scalar(form(elastic_energy_density(state) * dx)), - op=MPI.SUM, - ) - _F = assemble_scalar(form(stress(state))) - - _write_history_data( - hybrid, - bifurcation, - stability, - history_data, - t, - inertia, - stable, - [fracture_energy, elastic_energy], - ) - history_data["F"].append(_F) - - with XDMFFile( - comm, f"{prefix}/{_nameExp}.xdmf", "a", encoding=XDMFFile.Encoding.HDF5 - ) as file: - file.write_function(u, t) - file.write_function(alpha, t) - - if comm.rank == 0: - a_file = open(f"{prefix}/time_data.json", "w") - json.dump(history_data, a_file) - a_file.close() + if comm.rank == 0: + plot_energies(history_data, file=f"{prefix}/{_nameExp}_energies.pdf") + plot_AMit_load(history_data, file=f"{prefix}/{_nameExp}_it_load.pdf") + plot_force_displacement( + history_data, file=f"{prefix}/{_nameExp}_stress-load.pdf" + ) + + + xvfb.start_xvfb(wait=0.05) + pyvista.OFF_SCREEN = True + + plotter = pyvista.Plotter( + title="Thin film", + window_size=[1600, 600], + shape=(1, 2), + ) + _plt = plot_scalar(alpha, plotter, subplot=(0, 0)) + _plt = plot_scalar(u, plotter, subplot=(0, 1)) + _plt.screenshot(f"{prefix}/thinfilm-state.png") + + plotter = pyvista.Plotter( + title="Test Profile", + window_size=[800, 600], + shape=(1, 1), + ) + + tol = 1e-3 + xs = np.linspace(0 + tol, parameters["geometry"]["Lx"] - tol, 101) + points = np.zeros((3, 101)) + points[0] = xs + + _plt, data = plot_profile( + alpha, + points, + plotter, + lineproperties={ + "c": "k", + "label": f"$\\alpha$ with $\ell$ = {parameters['model']['ell']:.2f}" + }, + ) + ax = _plt.gca() + _plt.legend() + _plt.fill_between(data[0], data[1].reshape(len(data[1]))) + _plt.title("Damage profile") + ax.set_ylim(-0.1, 1.1) + + _plt, data = plot_profile( + u_zero, + points, + plotter, + fig=_plt, + ax=ax, + lineproperties={ + "c": "r", + "label": "$u_0$" + }, + ) + + + _plt, data = plot_profile( + u, + points, + plotter, + fig=_plt, + ax=ax, + lineproperties={ + "c": "g", + "label": "$u$" + }, + ) + + _plt.savefig(f"{prefix}/damage_profile-{i_t}.png") + + + fracture_energy = comm.allreduce( + assemble_scalar(form(damage_energy_density(state) * dx)), + op=MPI.SUM, + ) + elastic_energy = comm.allreduce( + assemble_scalar(form(elastic_energy_density(state, u_zero) * dx)), + op=MPI.SUM, + ) + _F = assemble_scalar(form(stress(state))) + + _write_history_data( + hybrid, + bifurcation, + stability, + history_data, + t, + inertia, + stable, + [fracture_energy, elastic_energy], + ) + history_data["F"].append(_F) + + with XDMFFile( + comm, f"{prefix}/{_nameExp}.xdmf", "a", encoding=XDMFFile.Encoding.HDF5 + ) as file: + file.write_function(u, t) + file.write_function(alpha, t) + + if comm.rank == 0: + a_file = open(f"{prefix}/time_data.json", "w") + json.dump(history_data, a_file) + a_file.close() # df = pd.DataFrame(history_data) print(pd.DataFrame(history_data)) + return history_data, stability.data, state - -def load_parameters(file_path, ndofs, model="at1"): +def load_parameters(file_path, ndofs, model="at2"): """ Load parameters from a YAML file. @@ -335,23 +393,16 @@ def load_parameters(file_path, ndofs, model="at1"): parameters["model"]["model_dimension"] = 1 parameters["model"]["model_type"] = "1D" - # parameters["model"]["mu"] = 1 - parameters["model"]["w1"] = 1 - parameters["geometry"]["geom_type"] = "discrete-damageable" + parameters["geometry"]["geom_type"] = "thinfilm" # Get mesh parameters if model == "at2": parameters["loading"]["min"] = 0.0 - parameters["loading"]["max"] = 3.0 + parameters["loading"]["max"] = 1.0 parameters["loading"]["steps"] = 10 - elif model == "at1": - parameters["loading"]["min"] = 0.0 - parameters["loading"]["max"] = 1.5 - parameters["loading"]["steps"] = 20 - - parameters["geometry"]["geom_type"] = "traction-bar" + parameters["geometry"]["geom_type"] = "1d-bar" parameters["geometry"]["mesh_size_factor"] = 4 parameters["geometry"]["N"] = ndofs @@ -360,25 +411,28 @@ def load_parameters(file_path, ndofs, model="at1"): parameters["stability"]["cone"]["cone_rtol"] = 1e-6 parameters["stability"]["cone"]["scaling"] = 1e-2 - parameters["model"]["w1"] = 1 - parameters["model"]["ell"] = 0.2 + parameters["model"]["w1"] = 10000 + parameters["model"]["ell"] = (0.158114)**2 / 2 parameters["model"]["k_res"] = 0.0 + parameters["model"]["mu"] = 1 + parameters["model"]["kappa"] = (.34)**(-2) signature = hashlib.md5(str(parameters).encode("utf-8")).hexdigest() return parameters, signature - if __name__ == "__main__": # Set the logging level logging.basicConfig(level=logging.INFO) # Load parameters parameters, signature = load_parameters( - os.path.join(os.path.dirname(__file__), "parameters.yaml"), 100, "at2") + os.path.join(os.path.dirname(__file__), "parameters.yaml"), + ndofs=100, + model="at2") + # Run computation - - _storage = f"output/one-dimensional-bar/MPI-{MPI.COMM_WORLD.Get_size()}/{signature}" + _storage = f"output/thinfilm-1d/MPI-{MPI.COMM_WORLD.Get_size()}/{signature}" visualization = Visualization(_storage) with dolfinx.common.Timer(f"~Computation Experiment") as timer: @@ -388,3 +442,7 @@ def load_parameters(file_path, ndofs, model="at1"): _timings = table_timing_data() visualization.save_table(_timings, "timing_data") list_timings(MPI.COMM_WORLD, [dolfinx.common.TimingType.wall]) + + ColorPrint.print_bold(f"===================- {signature} -=================") + ColorPrint.print_bold(f"===================- {_storage} -=================") + From 2e1e23d83797d4ed3f0788661d1b8bccfbfc08df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20A=20Le=C3=B3n=20Baldelli?= Date: Fri, 22 Mar 2024 10:47:51 +0100 Subject: [PATCH 5/8] practicing smooth --- .../benchmark-umut-at2/vs_analytics_at2.py | 2 +- .../benchmark-umut-at2/vs_analytics_at2_2d.py | 430 ++++++++++++++++++ src/irrevolutions/algorithms/so.py | 17 + 3 files changed, 448 insertions(+), 1 deletion(-) create mode 100644 playground/benchmark-umut-at2/vs_analytics_at2_2d.py diff --git a/playground/benchmark-umut-at2/vs_analytics_at2.py b/playground/benchmark-umut-at2/vs_analytics_at2.py index 98022716..268fa942 100644 --- a/playground/benchmark-umut-at2/vs_analytics_at2.py +++ b/playground/benchmark-umut-at2/vs_analytics_at2.py @@ -355,7 +355,7 @@ def run_computation(parameters, storage=None): t, inertia, stable, - [fracture_energy, elastic_energy], + [elastic_energy, fracture_energy], ) history_data["F"].append(_F) diff --git a/playground/benchmark-umut-at2/vs_analytics_at2_2d.py b/playground/benchmark-umut-at2/vs_analytics_at2_2d.py new file mode 100644 index 00000000..b5438f0b --- /dev/null +++ b/playground/benchmark-umut-at2/vs_analytics_at2_2d.py @@ -0,0 +1,430 @@ +#!/usr/bin/env python3 +import hashlib +import json +import logging +import os +import sys +from pathlib import Path +from typing import Optional + +import dolfinx +import dolfinx.mesh +import dolfinx.plot +import numpy as np +import pandas as pd +import petsc4py +import pyvista +import ufl +import yaml +from dolfinx.common import list_timings +from dolfinx.fem import (Constant, Function, assemble_scalar, dirichletbc, + form, locate_dofs_geometrical, set_bc) +from dolfinx.fem.petsc import assemble_vector, set_bc +from dolfinx.io import XDMFFile, gmshio +from irrevolutions.algorithms.am import HybridSolver +from irrevolutions.algorithms.so import BifurcationSolver, StabilitySolver +from irrevolutions.meshes.primitives import mesh_bar_gmshapi +from irrevolutions.models import \ + BrittleMembraneOverElasticFoundation as ThinFilm +from irrevolutions.solvers.function import vec_to_functions +from irrevolutions.test.test_1d import _AlternateMinimisation1D as am1d +from irrevolutions.utils import (ColorPrint, ResultsStorage, Visualization, + _logger, _write_history_data, history_data, + norm_H1, norm_L2) +from irrevolutions.utils.plots import (plot_AMit_load, plot_energies, + plot_force_displacement) +from irrevolutions.utils.viz import (plot_mesh, plot_profile, plot_scalar, + plot_vector) +from mpi4py import MPI +from petsc4py import PETSc +from pyvista.utilities import xvfb + +petsc4py.init(sys.argv) +comm = MPI.COMM_WORLD + +# Mesh on node model_rank and then distribute +model_rank = 0 + +class ThinFilmAT2(ThinFilm): + + def w(self, alpha): + """ + Return the dissipated energy function as a function of the state + (only depends on damage). + """ + # Return w(alpha) function + return alpha**2 + +def stress(state): + """ + Return the one-dimensional stress + """ + u = state["u"] + alpha = state["alpha"] + dx = ufl.Measure("dx", domain=u.function_space.mesh) + + return parameters["model"]["E"] * a(alpha) * u.dx() * dx + +def run_computation(parameters, storage=None): + + Lx = parameters["geometry"]["Lx"] + Ly = parameters["geometry"]["Ly"] + geom_type = parameters["geometry"]["geom_type"] + tdim = parameters["geometry"]["geometric_dimension"] + lc = parameters["model"]["ell"] / parameters["geometry"]["mesh_size_factor"] + + _nameExp = parameters["geometry"]["geom_type"] + + # Get geometry model + outdir = os.path.join(os.path.dirname(__file__), "output") + + if storage is None: + prefix = os.path.join(outdir, f"thin-film-at2-2d") + else: + prefix = storage + + if comm.rank == 0: + Path(prefix).mkdir(parents=True, exist_ok=True) + + signature = hashlib.md5(str(parameters).encode("utf-8")).hexdigest() + + if comm.rank == 0: + with open(f"{prefix}/parameters.yaml", "w") as file: + yaml.dump(parameters, file) + + with open(f"{prefix}/signature.md5", "w") as f: + f.write(signature) + + gmsh_model, tdim = mesh_bar_gmshapi(geom_type, Lx, Ly, lc, tdim) + model_rank = 0 + mesh, mts, fts = gmshio.model_to_mesh(gmsh_model, comm, model_rank, tdim) + + with XDMFFile( + comm, f"{prefix}/{_nameExp}.xdmf", "w", encoding=XDMFFile.Encoding.HDF5 + ) as file: + file.write_mesh(mesh) + + # Functional Setting + element_u = ufl.VectorElement("Lagrange", mesh.ufl_cell(), degree=1, dim=tdim) + element_alpha = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), degree=1) + + V_u = dolfinx.fem.FunctionSpace(mesh, element_u) + V_alpha = dolfinx.fem.FunctionSpace(mesh, element_alpha) + + u = dolfinx.fem.Function(V_u, name="Displacement") + u_ = dolfinx.fem.Function(V_u, name="BoundaryDisplacement") + u_zero = Function(V_u, name="InelasticDisplacement") + zero_u = Function(V_u, name="BoundaryUnknown") + + alpha = dolfinx.fem.Function(V_alpha, name="Damage") + alphadot = dolfinx.fem.Function(V_alpha, name="Damage_rate") + + # Perturbations + β = Function(V_alpha, name="DamagePerturbation") + v = Function(V_u, name="DisplacementPerturbation") + + # Pack state + state = {"u": u, "alpha": alpha} + + # Bounds + alpha_ub = dolfinx.fem.Function(V_alpha, name="UpperBoundDamage") + alpha_lb = dolfinx.fem.Function(V_alpha, name="LowerBoundDamage") + + dx = ufl.Measure("dx", domain=mesh) + ds = ufl.Measure("ds", domain=mesh) + + # Useful references + Lx = parameters.get("geometry").get("Lx") + + # Measures + dx = ufl.Measure("dx", domain=mesh) + ds = ufl.Measure("ds", domain=mesh) + + dofs_u_left = locate_dofs_geometrical(V_u, lambda x: np.isclose(x[0], 0.0)) + dofs_u_right = locate_dofs_geometrical(V_u, lambda x: np.isclose(x[0], Lx)) + + alpha_lb.interpolate(lambda x: np.zeros_like(x[0])) + alpha_ub.interpolate(lambda x: np.ones_like(x[0])) + + # eps_t = dolfinx.fem.Constant(mesh, np.array(1., dtype=PETSc.ScalarType)) + + for f in [zero_u, u_zero, alpha_lb, alpha_ub]: + f.vector.ghostUpdate( + addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD + ) + + # bcs_u = [dirichletbc(u_zero, dofs_u_right), + # dirichletbc(u_zero, dofs_u_left)] + + bcs_u = [] + bcs_alpha = [] + + bcs = {"bcs_u": bcs_u, "bcs_alpha": bcs_alpha} + + tau = Constant(mesh, np.array(0., dtype=PETSc.ScalarType)) + eps_t = tau * ufl.as_tensor([[1., 0], [0, 0]]) + + model = ThinFilmAT2(parameters["model"], eps_0=eps_t) + + f = Constant(mesh, np.array([0, 0], dtype=PETSc.ScalarType)) + external_work = ufl.dot(f, state["u"]) * dx + total_energy = model.total_energy_density(state) * dx - external_work + _stress = model.stress(model.eps(u), alpha) + + load_par = parameters["loading"] + loads = np.linspace(load_par["min"], load_par["max"], load_par["steps"]) + + hybrid = HybridSolver( + total_energy, + state, + bcs, + bounds=(alpha_lb, alpha_ub), + solver_parameters=parameters.get("solvers"), + ) + + bifurcation = BifurcationSolver( + total_energy, state, bcs, bifurcation_parameters=parameters.get("stability") + ) + + stability = StabilitySolver( + total_energy, state, bcs, cone_parameters=parameters.get("stability") + ) + + history_data["F"] = [] + + logging.basicConfig(level=logging.INFO) + + for i_t, t in enumerate(loads): + tau.value = t + + # update the lower bound + alpha.vector.copy(alpha_lb.vector) + alpha_lb.vector.ghostUpdate( + addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD + ) + + _logger.critical(f"-- Solving Equilibrium (Criticality) for t = {t:3.2f} --") + hybrid.solve(alpha_lb) + + _logger.critical(f"-- Solving Bifurcation (Uniqueness) for t = {t:3.2f} --") + is_unique = bifurcation.solve(alpha_lb) + is_elastic = not bifurcation._is_critical(alpha_lb) + inertia = bifurcation.get_inertia() + + ColorPrint.print_bold(f"State is elastic: {is_elastic}") + ColorPrint.print_bold(f"State's inertia: {inertia}") + ColorPrint.print_bold(f"Evolution is unique: {is_unique}") + + z0 = ( + bifurcation._spectrum[0]["xk"] + if bifurcation._spectrum and "xk" in bifurcation._spectrum[0] + else None + ) + + _logger.critical(f"-- Solving Stability (Stability) for t = {t:3.2f} --") + stable = stability.solve(alpha_lb, eig0=z0, inertia=inertia) + + with dolfinx.common.Timer(f"~Postprocessing and Vis") as timer: + if comm.rank == 0: + plot_energies(history_data, file=f"{prefix}/{_nameExp}_energies.pdf") + plot_AMit_load(history_data, file=f"{prefix}/{_nameExp}_it_load.pdf") + plot_force_displacement( + history_data, file=f"{prefix}/{_nameExp}_stress-load.pdf" + ) + + + xvfb.start_xvfb(wait=0.05) + pyvista.OFF_SCREEN = True + + plotter = pyvista.Plotter( + title="Thin film", + window_size=[1600, 600], + shape=(1, 2), + ) + _plt = plot_scalar(alpha, plotter, subplot=(0, 0)) + _plt = plot_scalar(u, plotter, subplot=(0, 1)) + _plt.screenshot(f"{prefix}/thinfilm-state.png") + + plotter = pyvista.Plotter( + title="Test Profile", + window_size=[800, 600], + shape=(1, 1), + ) + + tol = 1e-3 + xs = np.linspace(0 + tol, parameters["geometry"]["Lx"] - tol, 101) + points = np.zeros((3, 101)) + points[0] = xs + + _plt, data = plot_profile( + alpha, + points, + plotter, + lineproperties={ + "c": "k", + "label": f"$\\alpha$ with $\ell$ = {parameters['model']['ell']:.2f}" + }, + ) + ax = _plt.gca() + _plt.legend() + _plt.fill_between(data[0], data[1].reshape(len(data[1]))) + _plt.title("Damage profile") + ax.set_ylim(-0.1, 1.1) + + _plt, data = plot_profile( + u_zero, + points, + plotter, + fig=_plt, + ax=ax, + lineproperties={ + "c": "r", + "label": "$u_0$" + }, + ) + + + _plt, data = plot_profile( + u, + points, + plotter, + fig=_plt, + ax=ax, + lineproperties={ + "c": "g", + "label": "$u$" + }, + ) + + _plt.savefig(f"{prefix}/damage_profile-{i_t}.png") + + fracture_energy = comm.allreduce( + assemble_scalar(form(model.damage_energy_density(state) * dx)), + op=MPI.SUM, + ) + elastic_energy = comm.allreduce( + assemble_scalar(form(model.elastic_energy_density(state) * dx)), + op=MPI.SUM, + ) + _stress = model.stress(model.eps(u), alpha) + + stress = comm.allreduce( + assemble_scalar(form(_stress[0, 0] * dx)), + op=MPI.SUM, + ) + + _write_history_data( + hybrid, + bifurcation, + stability, + history_data, + t, + inertia, + stable, + [elastic_energy, fracture_energy], + ) + history_data["F"].append(stress) + + with XDMFFile( + comm, f"{prefix}/{_nameExp}.xdmf", "a", encoding=XDMFFile.Encoding.HDF5 + ) as file: + file.write_function(u, t) + file.write_function(alpha, t) + + if comm.rank == 0: + a_file = open(f"{prefix}/time_data.json", "w") + json.dump(history_data, a_file) + a_file.close() + + xvfb.start_xvfb(wait=0.05) + + pyvista.OFF_SCREEN = True + plotter = pyvista.Plotter( + title="Thin Film", + window_size=[1600, 600], + shape=(1, 2), + ) + _plt = plot_scalar(alpha, plotter, subplot=(0, 0)) + _plt = plot_vector(u, plotter, subplot=(0, 1)) + _plt.screenshot(f"{prefix}/traction-state.png") + + _plt.close() + + # df = pd.DataFrame(history_data) + print(pd.DataFrame(history_data)) + + return history_data, stability.data, state + +def load_parameters(file_path, ndofs, model="at2"): + """ + Load parameters from a YAML file. + + Args: + file_path (str): Path to the YAML parameter file. + + Returns: + dict: Loaded parameters. + """ + import hashlib + + with open(file_path) as f: + parameters = yaml.load(f, Loader=yaml.FullLoader) + + parameters["model"]["model_dimension"] = 2 + parameters["model"]["model_type"] = "2d" + + parameters["geometry"]["geom_type"] = "thinfilm" + # Get mesh parameters + + if model == "at2": + parameters["loading"]["min"] = 0.0 + parameters["loading"]["max"] = 1.5 + parameters["loading"]["steps"] = 50 + + parameters["geometry"]["geom_type"] = "bar" + parameters["geometry"]["mesh_size_factor"] = 3 + parameters["geometry"]["Lx"] = 3 + parameters["geometry"]["Ly"] = 5e-2 + + parameters["stability"]["cone"]["cone_max_it"] = 400000 + parameters["stability"]["cone"]["cone_atol"] = 1e-6 + parameters["stability"]["cone"]["cone_rtol"] = 1e-6 + parameters["stability"]["cone"]["scaling"] = 1e-2 + + parameters["model"]["w1"] = 1 + parameters["model"]["ell"] = (0.158114)**2 / 2 + # parameters["model"]["ell"] = .1 + parameters["model"]["k_res"] = 0.0 + parameters["model"]["E"] = 1 + parameters["model"]["ell_e"] = .34 + + signature = hashlib.md5(str(parameters).encode("utf-8")).hexdigest() + + return parameters, signature + +if __name__ == "__main__": + # Set the logging level + logging.basicConfig(level=logging.INFO) + + # Load parameters + parameters, signature = load_parameters( + os.path.join(os.path.dirname(__file__), "parameters.yaml"), + ndofs=100, + model="at2") + + # Run computation + _storage = f"output/thinfilm-bar/MPI-{MPI.COMM_WORLD.Get_size()}/{signature}" + visualization = Visualization(_storage) + ColorPrint.print_bold(f"===================- {_storage} -=================") + + with dolfinx.common.Timer(f"~Computation Experiment") as timer: + history_data, stability_data, state = run_computation(parameters, _storage) + + from irrevolutions.utils import table_timing_data + _timings = table_timing_data() + visualization.save_table(_timings, "timing_data") + list_timings(MPI.COMM_WORLD, [dolfinx.common.TimingType.wall]) + + ColorPrint.print_bold(f"===================- {signature} -=================") + ColorPrint.print_bold(f"===================- {_storage} -=================") + diff --git a/src/irrevolutions/algorithms/so.py b/src/irrevolutions/algorithms/so.py index 1ea224a2..640c0313 100644 --- a/src/irrevolutions/algorithms/so.py +++ b/src/irrevolutions/algorithms/so.py @@ -513,6 +513,23 @@ def process_eigenmode(self, eigen, i): def store_results(self, eigen, spectrum): """Store eigenmodes and results.""" + + if not spectrum: + # Spectrum is empty, handle this case accordingly + self.spectrum = [] + self._spectrum = [] + self.minmode = None + self.mineig = None + self.data = { + "inf_spectrum": [], + "eigs": [], + "perturbations_beta": [], + "perturbations_v": [], + "stable": False, + } + self.perturbation = {} + return False + unstable_spectrum = list(filter(lambda item: item.get("lambda") <= 0, spectrum)) # spectrum = unstable_spectrum From 2e0fb9e49fe99ea233e6d1a5ee0c07a381276d1a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20A=20Le=C3=B3n=20Baldelli?= Date: Fri, 22 Mar 2024 10:59:38 +0100 Subject: [PATCH 6/8] scripting benchmarcks and postprocessing --- playground/nb/1d-fundamental-bar.ipynb | 261 ++++++++++++----- playground/nb/multifissa.ipynb | 386 +++++++++++++++++-------- playground/nb/postprocess.py | 6 +- 3 files changed, 451 insertions(+), 202 deletions(-) diff --git a/playground/nb/1d-fundamental-bar.ipynb b/playground/nb/1d-fundamental-bar.ipynb index 0133588a..7157f031 100644 --- a/playground/nb/1d-fundamental-bar.ipynb +++ b/playground/nb/1d-fundamental-bar.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -61,84 +61,7 @@ " closest_index = np.argmin(np.abs(discrete_times - physical_time))\n", "\n", " # Return the corresponding index value\n", - " return time_data[closest_index, 1]\n", - "\n", - "# def read_mode_data_from_npz(npz_file, time_step, num_points = -1, num_modes=1):\n", - "# \"\"\"\n", - "# Read mode data for a given timestep and x_values from an npz file.\n", - "\n", - "# Parameters:\n", - "# - npz_file (numpy.lib.npyio.NpzFile): The npz file containing mode shapes data.\n", - "# - time_step (int): The timestep to read.\n", - "# - num_modes (int): The number of modes.\n", - "# - num_points (int): The number of domain nodes.\n", - "\n", - "# Returns:\n", - "# - mode_data (dict): A dictionary containing mode-specific fields for the given timestep.\n", - "# \"\"\"\n", - "# mode_data = {}\n", - "# mode_data[\"x_values\"] = npz_file[\"point_values\"].item()[\"x_values\"]\n", - "# if 'time_steps' not in npz_file or time_step not in npz_file['time_steps']:\n", - "# print(f\"No data available for timestep {time_step}.\")\n", - "# return None\n", - "\n", - "# index = np.where(npz_file['time_steps'] == time_step)[0][0]\n", - "\n", - "# for mode in range(1, num_modes + 1):\n", - "# mode_key = f'mode_{mode}'\n", - "\n", - "# # print(f\"{mode_key not in npz_file['point_values']}\")\n", - " \n", - "# if mode_key not in npz_file['point_values'].item():\n", - "# print(f\"No data available for mode {mode} at timestep {time_step}.\")\n", - "# continue\n", - "\n", - "# fields = npz_file['point_values'].item()[mode_key]\n", - "# if 'bifurcation' not in fields or 'stability' not in fields:\n", - "# print(f\"Incomplete data for mode {mode} at timestep {time_step}.\")\n", - "# continue\n", - " \n", - "\n", - "# field_1_values = np.array(fields['bifurcation'][index])\n", - "# field_2_values = np.array(fields['stability'][index])\n", - "\n", - "# # Assuming x_values is known or can be obtained\n", - "# if num_points == -1:\n", - "# num_points = len(npz_file[\"point_values\"].item()[\"x_values\"])\n", - "# x_values = np.linspace(0, 1, num_points) # Replace with actual x_values\n", - " \n", - "# mode_data[\"fields\"] = {\n", - "# 'bifurcation': {'x_values': x_values, 'values': field_1_values},\n", - "# 'stability': {'x_values': x_values, 'values': field_2_values},\n", - "# }\n", - "# mode_data[\"time_step\"] = time_step\n", - "# mode_data[\"lambda_bifurcation\"] = np.nan\n", - "# mode_data[\"lambda_stability\"] = np.nan\n", - " \n", - "# # print(mode_data[mode_key])\n", - "# return mode_data\n", - "\n", - "# def plot_fields_for_time_step(mode_shapes_data):\n", - "# x_values = mode_shapes_data[\"x_values\"]\n", - "# fields = mode_shapes_data[\"fields\"]\n", - "# if 'bifurcation' in fields and 'stability' in fields:\n", - "# bifurcation_values = np.array(fields['bifurcation']['values'])\n", - "# stability_values = np.array(fields['stability']['values'])\n", - "\n", - "# fig, axes = plt.subplots(1, 2, figsize=(10, 5))\n", - "\n", - "# axes[0].plot(x_values, bifurcation_values, label='Bifurcation Mode')\n", - "# axes[0].set_title(f'Bifurcation')\n", - "\n", - "# axes[1].plot(x_values, stability_values, label='Stability Mode')\n", - "# axes[1].set_title(f'Stability')\n", - "\n", - "# for axis in axes:\n", - "# axis.axhline(0., c='k')\n", - " \n", - "# return fig, axes\n", - "\n", - "\n" + " return time_data[closest_index, 1]\n" ] }, { @@ -892,6 +815,186 @@ "axis.tick_params(axis='x', colors='k')" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### AT2" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle 0.5 E_{0} \\left(1 - α{\\left(x \\right)}\\right)^{2} \\left(\\frac{d}{d x} u{\\left(x \\right)}\\right)^{2} + w_{1} \\left(η^{2} \\left(\\frac{d}{d x} α{\\left(x \\right)}\\right)^{2} + α^{2}{\\left(x \\right)}\\right)$" + ], + "text/plain": [ + "0.5*E0*(1 - α(x))**2*Derivative(u(x), x)**2 + w1*(η**2*Derivative(α(x), x)**2 + α(x)**2)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "E0, L, w1, η, σc, n = sp.symbols('E0 L w1 η σ_c n')\n", + "\n", + "x, t = sp.symbols('x t')\n", + "\n", + "α = sp.Function('α')(x)\n", + "u = sp.Function('u')(x)\n", + "\n", + "state = {u: u, α: α}\n", + "\n", + "\n", + "matpar = {\"n\": 2, \"E0\": E0, \"w1\": w1, \"η\": η, \"L\": L}\n", + "_matpar = {\"n\": 2, \"E0\": 1, \"w1\": 1, \"η\": .1, \"L\": 1}\n", + "\n", + "\n", + "at2 = DamageATn(state, matpar=matpar,\n", + " name=\"At2 Damage Model\",\n", + " slug=f\"at2\")\n", + "\n", + "ana = ModelAnalysis(at2)\n", + "\n", + "ana.criterion()\n", + "at2.energy(state)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[E0*t**2/(E0*t**2 + 2*L**2*w1)]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ana.critical_load(matpar=_matpar)\n", + "ana._homogeneous_alpha()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArcAAAIsCAYAAADoPIH3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA76UlEQVR4nO3daZRc5X3v+1/NU3f13NWD5hFJoFlCEkJCmMEhJrZjsGODgx0TG8cOsTk2XvfNXX51V7ATfIIdxybEMQaOnRBMTpwAMlhoAoHQgASaWmhoST1P1VPNVfu+aFFSSy2pkbp7V+36ftZigXbVVv+FReu7ys9+HpthGIYAAAAAC7CbPQAAAAAwVohbAAAAWAZxCwAAAMsgbgEAAGAZxC0AAAAsg7gFAACAZRC3AAAAsAziFgAAAJZB3AIAAMAynGYPcCWxWEzbtm2Tx+PRunXrzB4HAAAAOSxn43br1q3q7e1VKBRSY2Ojpk6davZIAAAAyHE5G7fnf0p75MgREycBAABAvmDNLQAAACyDuAUAAIBlELcAAACwDOIWAAAAlpGzD5Rdq127dmn37t2jeu+yZcu0fPnycZ4IAAAA482yn9wmEgkNDAyM6q8VK1bIZrNd8a/Vq1df9HVWr149qnu///3vD7uvr69vVPfZbDbt2LFj2L3PP//8qO4LBoMXzfvggw+O6t577733onsnTZo0qnufeuqpYfcdOHBg1L/WM2fODLv38ccfH9V9CxYsuGjeO++8c1T3PvLIIxfdO9p5N27cOOy+jRs3jvreCz3yyCOjuu/OO++86N4FCxaM6t7HH3982H1nzpwZ9bwHDhwYdu9TTz01qvsmTZp00bz33nvvqO598MEHL7o3GAyO6t7nn39+2H07duwY9a+1r69v2L3f//73R3Uf3yP4HnHhX3yPuPJ9fI/ge8SFf13qe8RoWfaTW7fbraKiolG/3263q7a29rLvqaqqGvFafX39FX/+C3+D2Gy2Ud0nDf1azufz+UZ170i//rKyslHdW15eftG1mpqaK94nSX6/f9iPnU7nqH+tDodj2I+LiopGdW8oFLroWmVl5ajuLSkpuejaaOf1eDwX/Xi09440x2juraysvOhaKBRSb2/vFe+98PeEw+EY9bxO5/BvF36/f1T3jvT7pry8fFT3lpWVXXStrq5OAwMDV7zX5/MN+7Hb7R71r/XCb6LBYHBU9/I9gu8RF+J7BN8jzsf3iPH/HiFJNsMwjFG/2yTPPPOMampqdPvtt4/Lz//hb5ALPxEAAABAfrHssgQAAAAUHuIWAAAAlkHcAgAAwDKIWwAAAFhGXsRtPB5XLBYzewwAAADkuJzdLWHnzp1qa2tTOBxWe3u7JGnKlCnyer2aO3eu5syZM2Zfi90SAAAArCFn97lduXKl2SMAAAAgz+TFsgQAAABgNIhbAAAAWAZxCwAAAMsgbgEAAGAZxC0AAAAsg7gFAACAZRC3AAAAsAziFgAAAJZB3AIAAMAyiFsAAABYBnELAAAAyyBuAQAAYBnELQAAACyDuAUAAIBlELcAAACwDOIWAAAAlkHcAgAAwDKIWwAAAFgGcQsAAADLIG4BAABgGcQtAAAALIO4BQAAgGUQtwAAALAM4hYAAACWQdwCAADAMohbAAAAWAZxCwAAAMsgbgEAAGAZxC0AAAAsg7gFAACAZRC3AAAAsAziFgAAAJZB3AIAAMAyiFsAAABYBnELAAAAyyBuAQAAYBnELQAAACyDuAUAAIBlELcAAACwDOIWAAAAlkHcAgAAwDKIWwAAAFgGcQsAAADLIG4BAABgGcQtAAAALIO4BQAAgGUQtwAAALAM4hYAAACWQdwCAADAMohbAAAAWAZxCwAAAMsgbgEAAGAZxC0AAAAsg7gFAACAZRC3AAAAsAziFgAAAJZB3AIAAMAyiFsAAABYBnELAAAAyyBuAQAAYBnELQAAACyDuAUAAIBlELcAAACwDOIWAAAAlkHcAgAAwDKcZg8AAAAAnM8wDHUOpnSiO6bjXXGd6I7p//nYpFHdS9wCAADAVOFoSie6YjreHdeJrphOdMfVH09f1c9F3AIAAGDCDCbSw0L2eFdcPdHUmP38xC0AAADGRTpj6HQ4rmNdMR3rjOlYV0wtfckr3lfksWtGuVfTK7yaUe7R9ArvqL8mcQsAAIBrZhiGuiOpoZA9G7Mnu+NKpI3L3ud12jX9bMDOqPBoerlXlQGnbDbbVc1B3AIAAOAjS6QyOtEd1wedUX3QGdPxrph6opdfJ+uwS1NLPZpR6dXMCq+ml3tVE3TJfpUhOxLiFgAAAFfUE0npaGdURztiOtoZVWNPXOnM5e+pDDg1q9KrGRVezar0akqZR27H+O5ES9wCAABgmA/Xyn4Ysh90xtQ5ePmHvrxOu2ZUeDSz0qtZFUNBW+Kb+NQkbgEAAApcNJnR0Y6oGjqiOto5tF72Smtla4Muza70aXbV0BKDuqBbdvvYLS+4WsQtAABAgemNptTQEdWRjpga2qNqDMdlXKZl3Q6bZlZ4NavKq9mVPs2s9KrY45i4gT8C4hYAAMDCDMNQ+0BSDR0xHWmP6khHVG39l9+Oq8Lv1Owqr2ad/WR2cqlHzhz4VHY0iFsAAAALMQxDzX0JHWqL6nD70FKD8GV2MbBJmlTq1pwqn+ZWDcVsRcA1cQOPMeIWAAAgjxmGoabehA63R7NBe7mjax12aUa5V3OqfJpTPfT3gDs3lxhcDeIWAAAgj3zUmPU6bZpV6dPcap/mVg3tYuB2ju92XGYibgEAAHLY0DKDpA62RnS4/cox63PZNbfKp3mhoaCdWuaRI0/Wy44F4hYAACDHdA0mdbAtqgOtER1si1x2zazfZdfcap+uqx4K2imlnpzYksssxC0AAIDJ+uNpHWqL6GBrVAfaIpfdzYCYvTziFgAAYILFUxkdaY/qYFtUB1sjauyJ61LbzLodNl1X7dP8Gr/mE7NXRNwCAACMM8MwdCqc0Pstg3qvJaKGjphSmZFz1mGTZlZ6NT/k14Iav2ZWeOV0ELOjRdwCAACMg95oSu+3RvReS0QHWiPqjV163eyUUrfm1wzF7Nwqn7wu6+5mMN6IWwAAgDGQTGfU0BHT+y0Rvdca0ame+CXfWxlw6vqzMTsv5FPQS5KNFf5NAgAAXKW2/oT2NUe0v3lQh9ujSqRHXmrgcdo0P+TX9TV+XV/rV02xSzYbSw3GA3ELAAAwSsn00INg+5oj2tc8qNZL7GpgkzS13KMbav26ocavWZU+1s1OEOIWAADgMjoHk9p/NmYPtEYu+elsmc+h62v9ur4moAU1LDUwC//WAQAAzpPKGDraEc0G7ZnexIjvs9uk2VU+Larza2FtQJNL3Sw1yAHELQAAKHiDibT2NQ9q75lB7W+JKJrMjPi+Eq9DC+v8WlQX0IIavwJuxwRPiishbgEAQEFq609ob9NQ0B7piGqkbWdtkmZUeLWozq9F9QFNLfPIzqezOY24BQAABSGTMXSsK6Y9Z4O2uW/k5QYBt1031Pq1uC6gG2oDKvby6Ww+IW4BAIBlxVMZvdcS0d6mAb3bFFF/fOSDFKqLXFo6KaCl9QHNrvLJwfG2eYu4BQAAljIQT2tv06B2nR7Q+60RJUfY3cAmaVaVV0vrA1pcX6S6IPvOWgVxCwAA8l5PJKXdZwa06/SADrePvH7W47Tphlq/ltQXaVGdn626LIr/VQEAQF5q609o1+mhT2iPdcVGfE+J16Flk4q0ZFJA80I+uR32CZ4SE424BQAAecEwDJ0OJ7Tr9IB2nxnQ6fDID4RVBZxaPrlIyycXaWall90NCgxxCwAActaHQbvzVL/ePjWgtkscdzupxJ0NWg5TKGzELQAAyCmGYaipN6G3Tw1o56l+tfSNHLQzK7xaPjmgZZOKVBN0T/CUyFXELQAAyAlNvXG93TignacGRtyD1iZpbrVPK6cUaemkIpX7yRhcjN8VAADANE29Cb1zdslBU+/IQTun2qcbpwwtOSj1kS64PH6HAACACdU5mNSOk/16q7F/xIfCbJLmVHm1YkqxVkwuUhmf0OIj4HcLAAAYd/2xtHae7tebJ/t1tGPkbbtmV3l145RiLZ/MkgNcPX7nAACAcRFPZbT7zIB2nOzX+y0RjXBQmGZWeHXj1CKtmFykioBr4oeE5RC3AABgzKQyht5viWjHyX7tPjOgxAhFW1/i1uppxVo1tVjVRQQtxhZxCwAArolhGPqgM6Y3TvZr56l+DcQzF72n3O/U6qnFWj2tmH1oMa6IWwAAcFU6B5N640S/tp/oG/FwhYDbrpVTirR6WlBzqjgpDBODuAUAAKMWS2b0zukBbT/Rp0Nt0YtedztsWjopoNVTi3VDbUBOB0GLiUXcAgCAy8oYhg63RbXtRJ92nR5QPDV8Ha1N0ryQT2unB7VscpF8Lrs5gwIibgEAwCW09iW0/USf3jjRr65I6qLXQ8Uu3Tw9qDXTi1XJTgfIEcQtAADIiiUzevtUv7Ye69PRzov3o/W77LpxapHWTg9qVqWXB8OQc4hbAAAKnGEYOt4V1+ZjvXq7sV+xC5cd2KSFtX6tnR7UkkkBuR0sO0DuIm4BAChQ/fG03jzRpy3H+nSm9+JjcCeVuLV2RlBrphWr1EcyID/wOxUAgAKSMQwdaotqy7Fe7To9qFRm+Ke0Xqddq6cVaf3MEk0v97DsAHmHuAUAoAB0R1LafrxPW471qmPw4ofDZld6dcusEq2cUiSPk2UHyF/ELQAAFpXJGHqvJaJNH/Tq3eZBGRechFvsceim6cVaPzOo+hKPOUMCY4y4BQDAYvpiKW093qdNR3vVecGntDZJC2r8umVWUEvqA3LxcBgshrgFAMACDMNQQ0dMm4726p3TAxetpS33O7VuRlA3zwiqqog9aWFdxC0AAHksmszozZNDn9KeDl+848ENtX59bHaJFtUF5LDzcBisj7gFACAPnQ7H9YejvXrzRN9F+9IWeexaN6NEG2YFFSp2mzQhYA7iFgCAPJHKGNp1akCvHQ2roePi08NmVXr1sdklWjGliIMWULCIWwAAclxfLKXXP+jTpqNh9UTTw17zOG1aM61Yt84u1dQydjwAiFsAAHLUqZ64Nh4J662T/Upe8IBYfYlbH5tdojXTiuV3O0yaEMg9xC0AADkkkzG0u2lQrx4J63B7dNhrNpu0tD6gO+aW6rpqH6eHASMgbgEAyAGDibS2HOvTaw3hi/am9bvsWj8zqNvmlLKNF3AFxC0AACZq6k3o1Yawth/vUyI9fOlBbdCl2+eUau30oLwuHhADRoO4BQBgghmGoUPtUb18qEf7miMXvb6w1q875pbq+lq/7Cw9AD4S4hYAgAmSzhh659SAXjrco5Pd8WGveZw23Tw9qNvnlqo2yN60wNUibgEAGGexZEZbj/fplcM9F62nrfA7dcfcUq2bGVSAXQ+Aa0bcAgAwTsLRlF5tCGvT0V4NJjLDXpta5tFd88q0ckoRx+ICY4i4BQBgjDX3JvTy4R69caJfqQv2p11Y69dd88o0L8RWXsB4IG4BABgjR9qjeulQj/Y2DQ677rBLq6cW6655ZZpUyiliwHgibgEAuAaGYWh/S0S/O9Ctho7YsNd8LrtunVWi2+eWqtzPH7nAROC/NAAArkLGMLTr9IB+d6BHjT3Ddz4o9zt159xS3TIrKJ+Lh8SAiUTcAgDwEaQyht462a/fHexWS19y2Gv1JW59Yn6ZbpxaLCcPiQGmIG4BABiFRDqjbcf79D8HL97Oa1q5R3+yoFxLJwU4dAEwGXELAMBlxJIZbfqgVy8f6lFvLD3stblVXt29oFw31PrZ+QDIEcQtAAAjGEyk9eqRsDYeCV+0R+3CWr/uXlCuudU+k6YDcCnELQAA5xlMpLXx8FDURpPnotYmafnkIt29oEzTyr3mDQjgsohbAAAkRRJpbTwS1sbDYUXOi1q7TVo9rVifmF+u+hK3iRMCGA3iFgBQ0KLJoU9qX7kgah026eYZQd29oFxVRS4TJwTwURC3AICCFE1m9GpDWC8f6hm2ptZ+Nmr/hKgF8hJxCwAoKLEPo/Zwjwbiw6P2pulBffL6clUTtUDeIm4BAAUhnsrotYawXjoUVn/83JZeNpt007RiffL6coWKWVML5DviFgBgacl0RpuO9uq/DvRcFLWrpw5FbW2QqAWsgrgFAFhSJmPojZP9+u3+LnVFzp0oZpO06mzU1rH7AWA5xC0AwFIMw9DuM4N6YX+XmnoTw167cUqRPnVDuepLPCZNB2C8EbcAAMs42BbRv7/bqeNd8WHXF9X5dc+iSk0tI2oBqyNuAQB570R3TM+/26X3WyPDrs+u9OrexZW6jmNygYJB3AIA8lZLX0Iv7O/SzlMDw65PKnHr3kUVWlwfkM1mM2k6AGYgbgEAeac7ktSL73Vr2/E+ZYxz1ysDTn1mYYVWTy2W3U7UAoWIuAUA5I1oMq3/PtijVw6HlUyfq9qg16FPLijXhlklcjqIWqCQEbcAgJyXzhjacqxXv32vW32xc3vV+lx2/fG8Mt0xt1Rel93ECQHkCuIWAJCzDMPQvuaIfrO3U81957b1ctil22aX6k+uL1exx2HihAByDXELAMhJjT1x/XpPhw62RYddXzmlSJ9dXKnqIpdJkwHIZcQtACCndEdSemF/p7Yf79d5z4ppZoVXX1haqdlVbOsF4NKIWwBAToglM3rpUI9eOtSjxHkPi1UFnPrs4kqtnFLEtl4Aroi4BQCYKpMxtPV4n17Y36Xe8x4W87vs+uT15bptTolcDh4WAzA6xC0AwDSH2yJ6ZneHTofPe1jMJn1sTqk+ycNiAK4CcQsAmHBdg0n9Zm+n3r7gZLFlkwL63OJK1QTdJk0GIN8RtwCACZNIZ/TyobB+d6B72LraaWUefWFZla6r5mExANeGuAUAjDvDMLTnzKD+z54OdQymsteLPQ7ds6hC62cEOS4XwJggbgEA46qpN6Hndnfo/dZI9prdNnQIw6cXlivgZl0tgLFD3AIAxkUkkdaL73XrtYawzluBoPkhn+5fVqVJpR7zhgNgWcQtAGBMZQxD24736fl9Xeo7b2uvyoBTn19SqeWT2a8WwPghbgEAY+Z4V0xPv9OuE93x7DWXw6a755fprnllcjvZrxbA+CJuAQDXbDCR1vP7uvT60d5hR+aunFKkP1tSqcqAy7TZABQW4hYAcNUMw9COk/369d7OYaeLTSpx6/7lVZof8ps4HYBCRNwCAK5KS19CT7/TroNt0ew1j9OmP72hQrfPLZWTrb0AmIC4BQB8JIlURv91oEcvHepRKnNuEcKySQHdv6xKFSxBAGAi4hYAMGr7mwf1q10dah9IZq9VBpz64vIqLakvMnEyABhC3AIArqg7ktJzuzv0zumB7DWHXbrrujL9yfXl8rALAoAcQdwCAC4pnTH0akNYv93fpVjq3BKE66p9emBFlepLOIgBQG4hbgEAIzrRHdMv3m5XY8+5PWuLPQ59fkmlbppezEEMAHIScQsAGCaeyujF97r1yuEenfe8mDbMCureRZUq8jjMGw4AroC4BQBkHWyL6Bdvtw97YGxyqVtfWlGt2VU+EycDgNEhbgEAGkyk9Zu9ndpyrC97zWm36VPXl+uu+WXsWQsgbxC3AFDgdp0e0K92tSscPXfC2Jwqr/5iZUh1JW4TJwOAj464BYACFY6m9Myu4dt7eZ02fXZxpW6dXSI7D4wByEPELQAUGMMwtPV4n369p1ORZCZ7fVGdX19aUc0JYwDyGnELAAWkfSCpX7zdpoNt0ey1Yo9D9y+r0qqpRWzvBSDvEbcAUAAyGUO/bwjrP/Z1KZE+t7/XTdOK9YWlVSr2sr0XAGsgbgHA4tr6E/rnt9rU0BHLXqvwO/XlldVaWBcwcTIAGHvELQBYVMYw9IeGXv3bu53ZT2ttkm6bU6J7FlXK57KbOyAAjAPiFgAsqGMgqX+5YG1tdZFLD64K6bpqDmMAYF3ELQBYiGEY2nysT7/e06FY6tza2o/NLtHnFlfKy6e1ACyOuAUAi+iOJPWLt9u1vyWSvVbhd+orq0K6vsZv4mQAMHGIWwDIc4Zh6I0T/Xp2d8ewfWvXzwzqC0sr5XOxEwKAwkHcAkAeC0dT+ted7drbNJi9VuZz6C9WhrSonp0QABQe4hYA8pBhGHq7cUBP72rXYOLcp7VrphXri8urFHDzaS2AwkTcAkCeGUyk9fQ77XqrcSB7Leh16MsrqrVscpGJkwGA+YhbAMgjh9oi+vmONnVHUtlrK6cU6YHl1ZwyBgAibgEgL6TShl7Y36WXDvXoww2+/C67vrSiWqumFZs6GwDkEuIWAHJcU29CP3uzVY098ey1eSGfvroqpIqAy8TJACD3ELcAkKMMw9Afjvbq13s7lTx7fK7DLt2zsFJ/NK9UdpvN5AkBIPcQtwCQg3qjKT31dpv2NZ87kKEu6NbXb6rR1DKPiZMBQG4jbgEgx+w9M6Cn3m5XfzydvXbbnBL92eJKuZ0cnwsAl0PcAkCOiKcy+j97OvT6B33ZayVehx5cFdKiOg5kAIDRIG4BIAec6I7pn95oVWt/MnttSX1AX7mxWkEv36oBYLT4jgkAJsoYhjYeDuvf3+3U2WfG5HbYdN+yKt0yMygbD40BwEdC3AKASfpiKf3zW8MfGpte7tFDa2pUG3SbOBkA5C/iFgBMcKgtop+92aqe6LmHxv54Xpk+s6hCTjuf1gLA1SJuAWACZTKG/vP9bv3f97uzJ40Vexz62uqQFvLQGABcM+IWACZIdySlf3qzVUfao9lr80M+PbSmRqU+vh0DwFjguykATIB3mwb15FutGohnJEl2m/SnCyv0iXllsrMMAQDGDHELAOMolTb07/s69crhcPZaud+pr6+p0dxqn3mDAYBFEbcAME7a+hP66RutOtEdz15bOimgB28MqcjjMHEyALAu4hYAxsFbjf36xdvtiqWGliE47Tb92ZJK3T6nhL1rAWAcEbcAMIYS6Yye2z38CN1QsUvfuKlG08q9Jk4GAIWBuAWAMdIxkNSPt7XoZM+5ZQhrphXrgRXV8rnsJk4GAIWDuAWAMbD3zIB+vqNNkeTQMgS3w6YHVlRr7fRiliEAwAQibgHgGqQzhl7Y36X/PtiTvRYqdunhm2s1udRj4mQAUJiIWwC4SuFoSv/0RqsOnXcow4rJRXpwVbV8LnZDAAAzjEncbty4UcXFxVqzZs2Ir0ciEfn9/rH4UgCQEw63R/XTN1oUjqYlSQ6b9LkllbpzbinLEADARDbDMIwrv+3Kjh07pu3btysYDOrTn/70sNc2btwom82mO+64Yyy+1Jiz2Wyqr6/XmTNnzB4FQI4zDEMvHQrr+X2dypz97lnmc+qba2s0u4pDGQDAbGMWtx9qbW3Vxo0bdfPNN2vGjBnZ608//bQeeOCBsfxSY4a4BTAag4m0nnqrTbvPDGavzQ/59Fc31SjoZZUXAOSCMftuHIlE9O6776qtrU2S9Nhjj2nx4sXy+/1qa2tTa2vrWH0pAJhwjT1x/Xhbi9oHktlrn7y+XJ++vlx2O8sQACBXjEncvvjii/rlL3950fVXXnlFkjRz5kw9+uijY/GlAGDCbTnWq1+906Hk2XUIAbddD62p0aK6gMmTAQAudM1xu3HjRr388sv63ve+p1AopJqammGv79u3T5Iuug4AuS6ZzuiZXR3afOzcaWMzyj365s21qgy4TJwMAHAp1xy3ra2tevLJJy/5+po1a/T0009fcicFAMhFPZGUntjWomNdsey122aX6PNLK+VycNoYAOSqa/4OHQwGr/iee+65R7///e+v9UsBwIRo6Ijq/33lVDZsXQ6bvrY6pD9fUU3YAkCOu+ZPbltaWq74nkAgoIGBgWv9UgAwrgzD0KYPevXsrg6lz+4jUxlw6uGbazWt3GvucACAUbnmuA0EAtq/f78WLlx42fexqTmAXJZIZ/Srdzq09fi59bXzQz5946ZaFXs5bQwA8sU1//9r99xzj37yk59ox44dl31fX1/fZV8HALN0R5L6/147Myxs/+i6Un13Qz1hCwB5Zkw+uf3e976nRx55RIsXL9bHP/5xrV69eth72OcWQK460h7Vj7e3qC82dIyu22HTV24MafW0YpMnAwBcjTE9fvexxx5Te3u7JA3bFmzfvn16/PHHh51Ylks4oQwoPIZh6A9He/Xc7uHra7+1rk5TyjzmDgcAuGpjfvzuCy+8oO3bt+v48eMKBAKaNWuWHnjgAc2cOXMsv8yYIm6BwpJIZ/T0O+3adrw/e21BjU9/dVOtij0sQwCAfDbmcZuPiFugcHQNJvXEthad6I5nr901r0z3LqqQg2N0ASDvjcnxuwCQDxo6onpi2/D1tQ+uCmnVVNbXAoBVELcACsLWY73613falc4M/bgq4NTfsL4WACyHuAVgaZmMod+826lXDoez1+aHfPrm2loVsb4WACyHuAVgWZFEWj99o1X7WyLZa7fNKdEXllbJyfpaALAk4haAJbX2JfSjrc1q6UtKkhw26YvLq3Xr7BKTJwMAjCfiFoDlHGiN6CfbWzSYGFpgG3Db9fDNtZoX8ps8GQBgvBG3ACzltYawnt3doczZTQ7rS9z69vo6VRe5zB0MADAhiFsAlpDKGHp2d4c2He3NXltcF9DXbwrJ5+LBMQAoFMQtgLzXH0/rJ9tbdKgtmr32x2cPZrDz4BgAFBTiFkBea+qN60dbWtQ+MPTgmNNu01+srNbaGUGTJwMAmIG4BZC39jUN6h/faFUsNfTgWInXoYdvrtXsKp/JkwEAzELcAshLrx4J69k9HTLOPjg2tcyjb62rVUWAB8cAoJARtwDySiZj6Lk9HXq14dyDYysmF+mrq0PyOO0mTgYAyAXELYC8EU1m9NM3WrSv+dyJY3fPL9NnFlXIbuPBMQAAcQsgT3RHknp8c7NOhROShk4c+/LKaq2byYljAIBziFsAOe9Ed0w/2tKscDQtSfK77Hp4Xa3mc+IYAOACxC2AnLb7zID+6Y1WJdJDT45VF7n0yPo61ZW4TZ4MAJCLiFsAOckwDL1yOKzf7O3U2Q0RNLvSq79ZV6ugl29dAICR8ScEgJyTzhh6ZleHNn1wbkeEVVOL9OCqkNwOdkQAAFwacQsgp0QSaf1ke6vebz23I8Knri/Xp28ol40dEQAAV0DcAsgZHQNJPb6lWU29QzsiOO02feXGat00naN0AQCjQ9wCyAnHu4Z2ROiNDe2IEHDb9a11dZpbzVG6AIDRI24BmG5v04D+cfu5HRFCxS79r/V1qgmyIwIA4KMhbgGYatPRsJ7e1SHj7JYIc6u8enhdnYo9DnMHAwDkJeIWgCkyhqH/2Nel/z7Yk71245QifXV1SC52RAAAXCXiFsCES6Yzeuqtdu1o7M9e++N5Zbp3cYXs7IgAALgGxC2ACTWYSOuJrS061B6VJNls0heXVem2OaXmDgYAsATiFsCE6RxM6u83n9vqy+2w6es31WjZpCKTJwMAWAVxC2BCNPbE9fjmJvVEh7b6KvY49Mj6Os2s9Jo8GQDASohbAOPuvZZB/Xhbi2Kps1t9Fbn0nQ11ChWz1RcAYGwRtwDG1bbjffrF2206u4WtZlZ49e31tQp6+fYDABh7/OkCYFwYhqH/fL9bL77Xnb22bFJAD62pkcfJVl8AgPFB3AIYc6mMoV/ubNfW433Za7fPKdF9S6tkt7PVFwBg/BC3AMZUPJXRT7a3aF9zJHvt80sq9fHrSmVjD1sAwDgjbgGMmf5YWo9vadaxrpgkyWm36WurQ7pxarHJkwEACgVxC2BMdAwk9cPXm9Tan5Qk+Vx2fWtdreaF/CZPBgAoJMQtgGt2qieuH77epN7Y0B62pT6HvnNLvaaUeUyeDABQaIhbANfkYFtE/7C1RdFkRpJUG3TpuxvqVRlwmTwZAKAQEbcArtrOU/362ZttSmWGNrGdWeHVI7fUqdjjMHkyAEChIm4BXJXfHwnrud0dOns2gxbV+fXNtbXsYQsAMBVxC+AjMQxD/7GvS7872JO9tm5GUF9eWS0He9gCAExG3AIYtVTG0L/ubNO24/3Za3+yoFyfWVjOHrYAgJxA3AIYlQsPZ7BJ+uLyKt02p9TUuQAAOB9xC+CKRjqc4etrQloxhcMZAAC5hbgFcFmdg0OHM7T0DR3O4D97OMN1HM4AAMhBxC2AS2rqjesHm5rVE01Jksp8Dn1nQ70ml3I4AwAgNxG3AEb0QWdUf7+5WYOJocMZaopdevRWDmcAAOQ24hbARfY3D+qJbS1KpId2sZ1W7tF3bqlT0Mu3DABAbuNPKgDD7DjZryd3tOps12p+yKe/WVcnn4vDGQAAuY+4BZD16pGwnj3v1LEVk4v00JqQXA7CFgCQH4hbADIMQy++163/fL87e23DrKAeWF4tO6eOAQDyCHELFLhMxtCvdnVo0we92WucOgYAyFfELVDAkumMfr6jTTtPDWSv3b+sSnfMLTVvKAAArgFxCxSoaDKjJ7Y160BrVJLksEl/uSqkNdODJk8GAMDVI26BAtQXS+nvNzfrRHdckuR22PTXN9dqUV3A5MkAALg2xC1QYC48TjfgtuuR9XWaXeUzeTIAAK4dcQsUkObehH7wepO6I+eO0/3uhnpN4jhdAIBFELdAgTjRHdPfvd6s/nhakhQqdunRDfWqKuI4XQCAdRC3QAE41BbRj7a0KJbKSJKmlHn06AaO0wUAWA9/sgEWt+fMgP5xe6uSmaFzx+ZWefXt9XXyux0mTwYAwNgjbgEL2368T0+93aazXatFdX59c22tPE6O0wUAWBNxC1jUxsM9em5PZ/bHq6cW6y9Xh+TkOF0AgIURt4DFGIahF9/r1n++3529dtucEt2/rEp2jtMFAFgccQtYSMYw9OzuDr3W0Ju99qnry/XpG8plI2wBAAWAuAUsIpUx9NRbbXrzZH/22n1LK3XndWUmTgUAwMQibgELSKQy+sn2Vr3bPChJstukB28Mae2MoMmTAQAwsYhbIM9FEmn9aGuLjrRHJUkuu03fWFujpZOKTJ4MAICJR9wCeawvltIPX29WY09ckuR12vXt9bWaF/KbPBkAAOYgboE81TmY1A82Nam1PylJKvY49J0NdZpe7jV5MgAAzEPcAnmopS+hxzY1qTuSkiSV+516dEO96krcJk8GAIC5iFsgz5zsjumHrzerP56WJIWKXfrerfWqDLhMngwAAPMRt0AeOdIe1eNbmhVNZiRJU8o8+u4tdSrx8Z8yAAAScQvkjX1Ng3pie4uSaUOSNLvKq0fW1yngdpg8GQAAuYO4BfLAW439+vmbrTrbtVpY69df31wrj9Nu7mAAAOQY4hbIcZuO9urpd9p1tmu1ckqRHlpdI6eD43QBALgQcQvksN8d6Nbz+7qyP75lZlBfWlEtu52wBQBgJMQtkIMMw9C/v9ul/znUk732x/PK9NnFFbLZCFsAAC6FuAVyTCZj6Old7Xr9g77stXsXVejuBeUmTgUAQH4gboEckkob+tmOVu08NSBJskl6YEW1bp1dYu5gAADkCeIWyBHxVEY/3tai/S0RSZLDJn1tdY1WTSs2eTIAAPIHcQvkgMFEWo9vadbRjpgkyeWw6eG1tVpUHzB5MgAA8gtxC5isN5rSD19v0qlwQpLkc9n1yPo6za32mTwZAAD5h7gFTNQxkNQPNjWpbSApSSr2OPTdDXWaVu41eTIAAPITcQuYpKk3rh9salJPNC1JqvA79eit9aoNuk2eDACA/EXcAiY43hXTD19v0mAiI0mqDbr06IZ6VQRcJk8GAEB+I26BCXawLaL/vaVZsdTQgbrTyj36zi11Cnr5zxEAgGvFn6bABNp9ZkA/3d6qZGYobK+r9unb62vlczlMngwAAGsgboEJsu14n/7l7Tad7VotqQ/oGzfVyO20mzsYAAAWQtwCE2Dj4R49t6cz++M104r14KqQnHabiVMBAGA9xC0wjgzD0Ivvdes/3+/OXrt9TonuW1Ylu42wBQBgrBG3wDjJGIae292hVxt6s9c+dX25Pn1DuWyELQAA44K4BcZBKmPon3e0aUdjf/bafUsrded1ZSZOBQCA9RG3wBiLpzL68bYW7W+JSJLsNukrN4Z084ygyZMBAGB9xC0whgbiaT2+pVkfdMYkSS67Td9YW6Olk4pMngwAgMJA3AJjpDuS0g9fb1JTb0KS5HPZ9e31dbqu2mfyZAAAFA7iFhgDrX0J/eD1JnUOpiRJJV6HvrOhXlPLPCZPBgBAYSFugWt0sjumH77erP54WpJUFXDq0VvrFSp2mzwZAACFh7gFrsHBtoj+95YWxVIZSdLkUre+u6FepT7+0wIAwAz8CQxcpV2nB/TTN1qVOnue7pwqr769vk4Bt8PkyQAAKFzELXAVthzr1S92tssY6lotqvPrm2tr5XHazR0MAIACR9wCH4FhGPqfQz3693e7stduml6sr9wYktPOqWMAAJiNuAVGKWMY+re9nXr5cDh77ePXlerPllTKznG6AADkBOIWGIVUxtAv3m7T9hPnjtO9d1GFPjG/TDbCFgCAnEHcAldw4XG6Npv0pRXV2jCrxOTJAADAhYhb4DL6Yik9vrlZx7vjkoaO031oTUgrphSbPBkAABgJcQtcQvtAUj98vUlt/UlJkt9l17c4ThcAgJxG3AIjONkd099vblZvbOjUsTKfU9/ZUKfJpRynCwBALiNugQu83zKoJ7a1KJYa2sS2LujWdzfUqSLgMnkyAABwJcQtcJ43T/Tpn99qU/rs4Qyzq7z69ro6FXk4dQwAgHxA3AJnvXyoR7/e25n98bJJAX19TY3cnDoGAEDeIG5R8DKGoV/v6dTGI+HstQ2zgnpgebXsnDoGAEBeIW5R0JLpjP75rTa91TiQvfanN5Trk9eXczgDAAB5iLhFwYom0/qHrS062BaVNHQ4w5dXVOsWDmcAACBvEbcoSOFoSn+3uVmneoYOZ3A7bPrGTTVaMqnI5MkAAMC1IG5RcM6E4/r7zc3qiqQkSQG3XY+sr9PsKg5nAAAg3xG3KCjvt0b0420tiiYzkqTKgFPfuaVedSVukycDAABjgbhFwdhyrFe/3Nme3cN2WrlHj6yvU6mP/wwAALAK/lSH5RmGoRf2d+m/DvRkry2pD+ivbqqRhz1sAQCwFOIWljbSVl93zCnVF5ZWsoctAAAWRNzCsvrjaf3D1mY1dMQkSTZJ9y2r0h1zS02dCwAAjB/iFpbU1p/Q321uVlt/UtLQVl9/dVONlrLVFwAAlkbcwnKOdkT1o63NGogP7YhQ4nXo2+vrNKPCa/JkAABgvBG3sJS3G/v15I42JTNDWyLUl7j1v26pU2XAZfJkAABgIhC3sATDMPTfB3v0/L6u7LUFNT799dpa+d0OEycDAAATibhF3ktlDP3qnXZtPtaXvbZuRlBfWlktJzsiAABQUIhb5LX+WFo/2d6iQ+3R7LV7Flbo7gVlstkIWwAACg1xi7x1OhzXj7Y0q3MwJUly2m36y1UhrZ5WbPJkAADALMQt8tLu0wP62Y5WxVNDD46VeB16+OZaza7ymTwZAAAwE3GLvGIYhv7rQI9e2H/uwbFp5R59a12tyv3siAAAQKEjbpE34qmho3R3njp3lO6qqUV68MaQ3E67iZMBAIBcQdwiL3QOJvUPW1vU2BOXNHSU7j2LKvSJ+Tw4BgAAziFukfMaOqJ6YluL+mJpSZLXadfX14S0hKN0AQDABYhb5LQtx3r1y3falR46SVfVRS59e32t6ks85g4GAAByEnGLnJTOGPr1nk79viGcvTY/5NM319aqyMOJYwAAYGTELXLOQDytf3yjRQdazx3McPucEn1+aRUnjgEAgMsibpFTTnbH9JPtrWofSEqSHHbpgeXVumVWicmTAQCAfEDcIicYhqHNx/r07K4OJTNDBzMUe4YOZphbzcEMAABgdIhbmC6eyuiXO9v1xsn+7LUZ5R598+ZaVQY4mAEAAIwecQtTNfcm9OPtLWrqTWSv3TanRJ9fUimXg4MZAADAR0PcwjRvnezXv+xsUzw1tAzB67TpL24MadXUYpMnAwAA+Yq4xYRLpjP69Z5OvXa0N3utvsSth2+uVW3QbeJkAAAg3xG3mFAdA0n94/YWHe+OZ6/dNL1YX1pRLY+TZQgAAODaELeYMHubBvTkjjYNJoaOG3PZbfri8iqtnxmUzcb+tQAA4NoRtxh36YyhF/Z36b8P9mSvVRe59M21NZpW7jVxMgAAYDXELcZVTySlf3qzVYfbz502tmxSQH+5KiS/m2N0AQDA2CJuMW52nurXv+5szy5DcNikzy6u1MevK2UZAgAAGBfELcbcYCKtZ3Z16M3zDmUo8zn1jbU1mlPFaWMAAGD8ELcYUwfbInpyR5u6I6nstRWTi/SlldUq9rAMAQAAjC/iFmMikc7o+Xe7tPFIOHvN57Lrz5dXac20YpYhAACACUHc4pqd7I7p5zvahh2hOy/k01+uCqky4DJxMgAAUGiIW1y1TMbQ/xzq0W/f61J66Jkxuew23bu4QnfMLZWdT2sBAMAEI25xVdoHkvr5jlYd7Yhlr00p8+ih1SFNKvWYOBkAAChkxC0+EsMwtOVYn57b06F4ypAk2WzSJ+aV6dM3VMjp4NNaAABgHuIWo9Y1mNSvdnVob9Ng9lp1kUtfXR1iiy8AAJATiFtcUSpj6PdHwnrxva7sp7WStH5mUF9YWiWfy27idAAAAOcQt7isho6ofrmzXWfO2wkh6HXoL1ZWa+mkIhMnAwAAuBhxixH1x9L6zbud2na8L3vNJunW2SW6Z1GFAm4OZAAAALmHuMUwGcPQ1mN9+rd3OzWYyGSvTyv36EsrqjWjwmvidAAAAJdH3CLrVE9cv3ynXR90ntvey+ey656FFfrY7BLZ7eyEAAAAchtxC0WTGf12f5debQgrc+55Ma2eWqzPL61UqY/fJgAAID9QLQXMMAy9c3pAz+3uVE80lb1eG3Tpz5dXa0GN38TpAAAAPjritkAd64zp+X2dOtgWzV5zOWz65IJy/dG8UrkcbO8FAADyD3FbYE71xPXC/q5hBzFI0qI6v764vFrVRS6TJgMAALh2xG2BaOlL6Lf7u/T2qYFh16uLXPrckkotnxSQzcYDYwAAIL8RtxbXOZjUi+91a/uJPhnnPSxW5nPqUzeU6+YZQTnZBQEAAFgEcWtR4WhK//V+t14/1qv0ue1qVexx6O4FZbp1doncrKsFAAAWQ9xaTH88rf852KPXGsJKpM99VOt32XXXvDLdMbdUXhdRCwAArIm4tYj+WFqvNoT1yuGwYqlzH9V6nDbdObdUfzSvjCNzAQCA5RG3ecwwDB3viuu1o2HtbBxQ8rwTGFx2m26dXaK7F5Qp6OV/ZgAAUBionjwUT2X0VmO//nC0Vye748Nec9ikdTOD+uT15Sr3s60XAAAoLMRtHmnrT+gPR3u17XifBhOZYa/5XXatmxnUbXNK2asWAAAULOI2x2Uyht5tHtQfjvbqvZbIRa9PK/PoY3NKtGpqsTxOHhQDAACFjbjNUX2xlLYc69Omo73qiqSGveay27RyapFum12qGRUeDl8AAAA4Ky/itrGxUY2NjSotLVUsFpMkrVy50uSpxl5LX0J7zgxqb9OAjnbGhh26IEmVAac+NrtE62aUqNjLzgcAAAAXyvm4bWho0JEjR3T33XdnrzU2Nur555/Xvffea+Jk1y6dMXS0M6a9Zwa0t2lQrf3Ji95jk7Swzq+PzS7Vwlq/7JwmBgAAcEk5HbexWEy///3v9eCDDw67PnXqVG3dulX79+/XwoULTZru6kSTab3XEtHeM4N6t3nwogfDPlQbdGnZpCKtnxlUqNg9wVMCAADkp5yO24aGBpWUlMjr9V702ty5c7Vv376cj9tU2lBzX0INHVHtOTOoQ+2RYcfhfshuk+ZU+bSkPqAl9QHVBAlaAACAjyqn4/bIkSMjhq0klZaWqr29XbFY7JLvmWj9sbROheM61RPP/r25LzFizEqS12nXwjq/ltYHtLAuoCIP62gBAACuRU7HbVtbm+bOnTviayUlJZKk3t7eCY/bTMZQ20ByWMSe6kmoJ5q64r2VAacW1we0tD6g66r9cjpYQwsAADBWcjpu4/G4PB7PZd/T29urUCh0zV8rmTb05sk+RRIZRZKZob8n0sP+eTCZUTSZ0WAifclPY89nt0l1QbemlHk0pcyj62v8mlzqZusuAACAcZLTcXs5H0bvh1uDXWjXrl3avXv3qH++gXhaP3uz7arn8bvsQxFb6tGUsqGgrStxy+3gYAUAAICJkrdxeyWJREIDAwNj9vPZJPlcdvnddvlddlUXu86G7NBfFX4nn8gCAACYLG/jNh6PS9Il19u63W4VFRWN+ufzuey6f1mV/OcFrN/tyP6z12WXnXgFAADIaXkbt1eyfPlyLV++fFTvfeihh+R12XXH3NLxHQoAAADjKqcXhJaUlKi3t3fE1z5ca/vhrgkAAABATsdtKBS65ANjH0bvWOyUAAAAAGvI6bidOnXqJT+5DYfDmjJlygRPBAAAgFyW03E7Z84cxWIxhcPhi15raGjQokWLJn4oAAAA5Kycjluv16s77rhD27ZtG3a9oaFBJSUlmjNnjkmTAQAAIBfZDMMwzB7iShobG9XY2KjS0tLsGtyVK1eO2c9vs9lUX1+vM2fOjNnPCQAAgImXF3E73ohbAAAAa8jpZQkAAADAR0HcAgAAwDKIWwAAAFgGcQsAAADLIG4BAABgGcQtAAAALIO4BQAAgGUQtwAAALAM4hYAAACWQdwCAADAMohbAAAAWAZxCwAAAMsgbgEAAGAZxC0AAAAsg7gFAACAZRC3AAAAsAziFgAAAJZB3AIAAMAyiFsAAABYBnELAAAAyyBuAQAAYBnELQAAACyDuAUAAIBlELcAAACwDOIWAAAAlkHcAgAAwDKIWwAAAFgGcQsAAADLIG4BAABgGcQtAAAALIO4BQAAgGU4zR7AbMuXL5cktbS0aNKkSSZPAwAAgEupqanRrl27Lvuego/bAwcOSJIymYyamppMngYAAADXouDjNhaLZf+5vr7exEkAAABwOTU1NVd8j80wDGMCZslZDodDmUxGdrtd6XTa7HEAAABwDXigDAAAAJZB3AIAAMAyiFsAAABYBnELAAAAyyBuAQAAYBnELQAAACyDuAUAAIBlELcAAACwjII/oewTn/iEent7VVJSYvYoAAAAuEYFf0IZAAAArINlCQAAALAM4hYAAACWQdwCAADAMohbAAAAWAZxCwAAAMsoyLjdvHmz7Ha7GhsbzR4FAAAAY6ggtwKbN2+eDh8+rAL8pQMAAFhaQcat3++XJEUiEZMnAQAAwFgqyGUJ0WhUN9xwg9ljAAAAYIwVXNz+4Ac/kCR95jOfMXkSAAAAjLWCWJbw3HPP6eGHH5Yk9fT0yDAMlZeXS5J8Pp/OnDlj5ngAAAAYIwURt+djvS0AAIB1FdyyBNbbAgAAWFdBxS3rbQEAAKytoOL2hRdekCR97nOfM3kSAAAAjIeCWnPr9/uVTCaVTCbNHgUAAADjoKA+uY1Go5o1a5bZYwAAAGCcOM0eYKJ8uN72rrvuyl7bvHmznnrqKT377LPD3nv//fcrFApJktra2i56HQAAALmpYJYl3HXXXXr55Zd18uRJTZ06VZI0b948HTp0aNj7Kioq9MQTT+i+++5TY2Ojpk+frk2bNumWW24xYWoAAAB8FAWzLGHevHmSlA3b+++/X1/+8peHvefGG29UdXW17rvvvux7//Zv/5awBQAAyBMF88mtdC5wg8GgPvOZz+jRRx8d9rrNZtNjjz120XUAAADkh4KK28t57rnndP/994t/HQAAAPmrYJYljIbNZhvxemNj4wRPAgAAgKvBJ7fnsdvtOnHiRHZdrjT0INpLL71k4lQAAAAYrYLZCmw0nnnmGX32s5/V2rVrs9cIWwAAgPzBJ7cAAACwDNbcAgAAwDKIWwAAAFgGcQsAAADLIG4BAABgGcQtAAAALIO4BQAAgGUQtwAAALAM4hYALOj48eMqKytTOBw2exQAmFDELQBY0GOPPaZwOKzS0lKzRwGACUXcAoAF7dq1S0uXLjV7DACYcMQtAFjQnj17dNttt5k9BgBMOOIWACzmtddekyTdfvvtJk8CABPPZhiGYfYQAIBrs2fPHn3ve9+TNLQkIRwOZz+5LS0t1fPPP2/meAAwYYhbALCYZcuWSZJ2795t8iQAMPFYlgAAFsN6WwCFjLgFAAthvS2AQkfcAoCFvPrqq5Kk5cuXmzwJAJiDNbcAYCHLli1TOBzWsWPHzB4FAEzBJ7cAYCGstwVQ6IhbALCIkdbbHj9+XE8++aRZIwHAhCNuAcAi9uzZI0nDPrl97LHH9NWvftWskQBgwhG3AGARM2bMkDR0aIMkPfnkk7r33ntNnAgAJh4PlAGAhXzta1+TNBS4t99+O+tvARQc4hYAAACWwbIEAAAAWAZxCwAAAMsgbgEAAGAZxC0AAAAsg7gFAACAZRC3AAAAsAziFgAAAJZB3AIAAMAyiFsAAABYBnELAAAAyyBuAQAAYBnELQAAACyDuAUAAIBl/P/tDqjoZJ2TdwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ana.plot_homogeneous_alpha(matpar = _matpar)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\begin{cases} \\sqrt{2} \\sqrt{\\frac{E_{0} t^{2} \\left(- \\frac{E_{0} t^{2}}{E_{0} t^{2} + 2 L^{2} w_{1}} + 1\\right)^{3}}{E_{0} t^{2} + 2 L^{2} w_{1}}} & \\text{for}\\: t \\geq 0 \\\\t & \\text{otherwise} \\end{cases}$" + ], + "text/plain": [ + "Piecewise((sqrt(2)*sqrt(E0*t**2*(-E0*t**2/(E0*t**2 + 2*L**2*w1) + 1)**3/(E0*t**2 + 2*L**2*w1)), t >= 0), (t, True))" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ana._stress(ana._homogeneous_alpha()[0], matpar=_matpar)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "_uh = t*x/L\n", + "_ah = ana._homogeneous_alpha()[0]\n", + "\n", + "_stress = ana._stress(_ah, matpar=_matpar)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ana.plot_homogeneous_stress(matpar = _matpar, ah=ana._homogeneous_alpha()[0], elements=100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "_B0 = (1/2*ana._spp * _stress**2 - ana._wpp).subs(_matpar).subs({α: _ah})\n", + "_A = (2 * _matpar[\"η\"]**2 / _B0).subs(_matpar)\n", + "_B = (ana._a.subs({α: _ah}).simplify() / _B0).subs(_matpar)\n", + "_C = - (ana._ap/ana._a * ana.symbols[\"t\"]).subs(_matpar).subs({α: _ah}).simplify().subs(_matpar)" + ] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/playground/nb/multifissa.ipynb b/playground/nb/multifissa.ipynb index 7a46ce4e..d0576457 100644 --- a/playground/nb/multifissa.ipynb +++ b/playground/nb/multifissa.ipynb @@ -16,7 +16,7 @@ "source": [ "# Testing Pacman\n", "import postprocess as pp\n", - "import plots as plots" + "# import plots as plots" ] }, { @@ -54,27 +54,6 @@ "\n" ] }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.016666666666666666" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# 50/1400\n", - "50/3000" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -84,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -108,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -120,7 +99,7 @@ "Eq(u(x), C1*exp(-sqrt(k)*x) + C2*exp(sqrt(k)*x))" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -131,7 +110,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -141,7 +120,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -153,7 +132,7 @@ "(t*exp(2*L*sqrt(k))/(sqrt(k)*exp(5*L*sqrt(k)/2) - sqrt(k)*exp(L*sqrt(k)/2)) - t*exp(L*sqrt(k))/(sqrt(k)*exp(5*L*sqrt(k)/2) - sqrt(k)*exp(L*sqrt(k)/2)))*exp(sqrt(k)*x) + (-t*exp(9*L*sqrt(k)/2)/(sqrt(k)*exp(5*L*sqrt(k)) - 2*sqrt(k)*exp(3*L*sqrt(k)) + sqrt(k)*exp(L*sqrt(k))) + t*exp(7*L*sqrt(k)/2)/(sqrt(k)*exp(5*L*sqrt(k)) - 2*sqrt(k)*exp(3*L*sqrt(k)) + sqrt(k)*exp(L*sqrt(k))) + t*exp(5*L*sqrt(k)/2)/(sqrt(k)*exp(5*L*sqrt(k)) - 2*sqrt(k)*exp(3*L*sqrt(k)) + sqrt(k)*exp(L*sqrt(k))) - t*exp(3*L*sqrt(k)/2)/(sqrt(k)*exp(5*L*sqrt(k)) - 2*sqrt(k)*exp(3*L*sqrt(k)) + sqrt(k)*exp(L*sqrt(k))))*exp(-sqrt(k)*x)" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -164,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -174,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -186,7 +165,7 @@ "Eq(u(x), -t*exp(L*sqrt(k))*exp(-sqrt(k)*x)/(sqrt(k)*exp(L*sqrt(k)) + sqrt(k)) + t*exp(sqrt(k)*x)/(sqrt(k)*exp(L*sqrt(k)) + sqrt(k)))" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -197,16 +176,28 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{k: 10.0, L: 1}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "matpar = {k: (.1)**(-1), L: 1, t: 1}" + "matpar = {k: (.1)**(-1), L: 1}\n", + "matpar" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -215,7 +206,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -227,7 +218,7 @@ "2*t*exp(L*sqrt(k)/2)/(exp(L*sqrt(k)) + 1)" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -238,67 +229,25 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name '_eq' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/kumiori/Documents/WIP/m4s-MEC647/mec647/playground/nb/multifissa.ipynb Cell 15\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m _eq\n", - "\u001b[0;31mNameError\u001b[0m: name '_eq' is not defined" - ] - } - ], - "source": [ - "_eq" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name '_eq' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/kumiori/Documents/WIP/m4s-MEC647/mec647/playground/nb/multifissa.ipynb Cell 16\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m _eq\u001b[39m.\u001b[39mdiff(x)\n", - "\u001b[0;31mNameError\u001b[0m: name '_eq' is not defined" - ] - } - ], - "source": [ - "_eq.diff(x)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[,\n", - " ]" + "[,\n", + " ]" ] }, - "execution_count": 15, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -308,36 +257,39 @@ "source": [ "fig, ax = plt.subplots(1, 2)\n", "for c, lmbda in enumerate([.1, .2, .3]):\n", - " matpar = {k: (lmbda)**(-2), L: 1, t: 1}\n", + " matpar = {k: (lmbda)**(-2), L: 1}\n", " _eq = equilibrium.rhs.subs(matpar)\n", " eps = _eq.diff(x)\n", - " eps_0 = eps.subs(x, L/2).subs(matpar)\n", + " eps_0 = eps.subs(x, L/2).subs(matpar).subs({t: 1})\n", "\n", " x_coordinates = np.linspace(0, float(L.subs(matpar)), 100)\n", "\n", - " _f = sp.lambdify(x, _eq, 'numpy')\n", - " _e = sp.lambdify(x, eps, 'numpy')\n", + " _f = sp.lambdify(x, _eq.subs({t: 1}), 'numpy')\n", + " _e = sp.lambdify(x, eps.subs({t: 1}), 'numpy')\n", "\n", " ax[0].plot(x_coordinates, _f(x_coordinates), c='C'+str(c), label=f'$\\lambda = {lmbda}$')\n", - " ax[0].plot(x_coordinates, eps_0*(x_coordinates-1/2), c='C'+str(c), ls = '--') \n", + " ax[0].plot(x_coordinates, eps_0*(x_coordinates-1/2), c='C'+str(c), ls = '--')\n", + " \n", " ax[1].plot(x_coordinates, _e(x_coordinates), c='C'+str(c), label=f'$\\lambda = {lmbda}$')\n", " ax[1].axhline(0, color='black', linestyle='--')\n", " ax[1].axhline(eps_0, c='C'+str(c), linestyle='--')\n", + " ax[1].set_title('Strain $u\\'(x)$')\n", + " ax[0].set_title('Displacement $u(x)$')\n", "[a.legend() for a in ax]" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{k: 11.111111111111112, L: 1, t: 1}" + "{k: 11.111111111111112, L: 1}" ] }, - "execution_count": 16, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -348,14 +300,14 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -378,99 +330,293 @@ "ax2.set_xlabel('$\\lambda$')\n", "top_ticks = np.linspace(k_values[-1]**(-2), k_values[0]**(-2), 5)\n", "\n", - "# top_ticks = np.arange(0, 11, 2) # Customize the tick positions as needed\n", - "# top_ticks = np.arange(10, -1, -2) # Customize the tick positions as needed\n", "\n", "ax2.set_xticks(top_ticks)\n", "ax2.set_xlim(k_values[-1]**(-2), k_values[0]**(-2))\n", "ax2.invert_xaxis()\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Elastic energy" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "del matpar" + ] + }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { + "text/latex": [ + "$\\displaystyle 0.5 L t^{2} + \\begin{cases} \\frac{\\left(0.5 k^{\\frac{3}{2}} t^{2} e^{4 L \\sqrt{k}} + 2.0 k^{\\frac{3}{2}} t^{2} e^{3 L \\sqrt{k}} + 3.0 k^{\\frac{3}{2}} t^{2} e^{2 L \\sqrt{k}} + 2.0 k^{\\frac{3}{2}} t^{2} e^{L \\sqrt{k}} + 0.5 k^{\\frac{3}{2}} t^{2}\\right) e^{2 L \\sqrt{k}} + \\left(- 0.5 k^{\\frac{3}{2}} t^{2} e^{6 L \\sqrt{k}} - 2.0 k^{\\frac{3}{2}} t^{2} e^{5 L \\sqrt{k}} - 3.0 k^{\\frac{3}{2}} t^{2} e^{4 L \\sqrt{k}} - 2.0 k^{\\frac{3}{2}} t^{2} e^{3 L \\sqrt{k}} - 0.5 k^{\\frac{3}{2}} t^{2} e^{2 L \\sqrt{k}}\\right) e^{- 2 L \\sqrt{k}} + \\left(- 1.0 k^{\\frac{3}{2}} t^{2} e^{5 L \\sqrt{k}} - 5.0 k^{\\frac{3}{2}} t^{2} e^{4 L \\sqrt{k}} - 10.0 k^{\\frac{3}{2}} t^{2} e^{3 L \\sqrt{k}} - 10.0 k^{\\frac{3}{2}} t^{2} e^{2 L \\sqrt{k}} - 5.0 k^{\\frac{3}{2}} t^{2} e^{L \\sqrt{k}} - 1.0 k^{\\frac{3}{2}} t^{2}\\right) e^{L \\sqrt{k}} + \\left(1.0 k^{\\frac{3}{2}} t^{2} e^{6 L \\sqrt{k}} + 5.0 k^{\\frac{3}{2}} t^{2} e^{5 L \\sqrt{k}} + 10.0 k^{\\frac{3}{2}} t^{2} e^{4 L \\sqrt{k}} + 10.0 k^{\\frac{3}{2}} t^{2} e^{3 L \\sqrt{k}} + 5.0 k^{\\frac{3}{2}} t^{2} e^{2 L \\sqrt{k}} + 1.0 k^{\\frac{3}{2}} t^{2} e^{L \\sqrt{k}}\\right) e^{- L \\sqrt{k}}}{1.0 k^{2} e^{6 L \\sqrt{k}} + 6.0 k^{2} e^{5 L \\sqrt{k}} + 15.0 k^{2} e^{4 L \\sqrt{k}} + 20.0 k^{2} e^{3 L \\sqrt{k}} + 15.0 k^{2} e^{2 L \\sqrt{k}} + 6.0 k^{2} e^{L \\sqrt{k}} + 1.0 k^{2}} - \\frac{0.5 k^{\\frac{3}{2}} t^{2} e^{6 L \\sqrt{k}} + 2.0 k^{\\frac{3}{2}} t^{2} e^{5 L \\sqrt{k}} + 2.5 k^{\\frac{3}{2}} t^{2} e^{4 L \\sqrt{k}} - 2.5 k^{\\frac{3}{2}} t^{2} e^{2 L \\sqrt{k}} - 2.0 k^{\\frac{3}{2}} t^{2} e^{L \\sqrt{k}} - 0.5 k^{\\frac{3}{2}} t^{2}}{1.0 k^{2} e^{6 L \\sqrt{k}} + 6.0 k^{2} e^{5 L \\sqrt{k}} + 15.0 k^{2} e^{4 L \\sqrt{k}} + 20.0 k^{2} e^{3 L \\sqrt{k}} + 15.0 k^{2} e^{2 L \\sqrt{k}} + 6.0 k^{2} e^{L \\sqrt{k}} + 1.0 k^{2}} & \\text{for}\\: 1.0 k^{2} e^{6 L \\sqrt{k}} + 6.0 k^{2} e^{5 L \\sqrt{k}} + 15.0 k^{2} e^{4 L \\sqrt{k}} + 20.0 k^{2} e^{3 L \\sqrt{k}} + 15.0 k^{2} e^{2 L \\sqrt{k}} + 6.0 k^{2} e^{L \\sqrt{k}} + 1.0 k^{2} \\neq 0 \\\\L \\left(- 0.5 t^{2} + \\frac{0.5 t^{2} e^{2 L \\sqrt{k}} - 1.0 t^{2} e^{L \\sqrt{k}} + 0.5 t^{2}}{1.0 e^{2 L \\sqrt{k}} + 2.0 e^{L \\sqrt{k}} + 1.0}\\right) & \\text{otherwise} \\end{cases}$" + ], "text/plain": [ - "array([1.0000000e-08, 2.5000075e-03, 5.0000050e-03, 7.5000025e-03,\n", - " 1.0000000e-02])" + "0.5*L*t**2 + Piecewise((((0.5*k**(3/2)*t**2*exp(4*L*sqrt(k)) + 2.0*k**(3/2)*t**2*exp(3*L*sqrt(k)) + 3.0*k**(3/2)*t**2*exp(2*L*sqrt(k)) + 2.0*k**(3/2)*t**2*exp(L*sqrt(k)) + 0.5*k**(3/2)*t**2)*exp(2*L*sqrt(k)) + (-0.5*k**(3/2)*t**2*exp(6*L*sqrt(k)) - 2.0*k**(3/2)*t**2*exp(5*L*sqrt(k)) - 3.0*k**(3/2)*t**2*exp(4*L*sqrt(k)) - 2.0*k**(3/2)*t**2*exp(3*L*sqrt(k)) - 0.5*k**(3/2)*t**2*exp(2*L*sqrt(k)))*exp(-2*L*sqrt(k)) + (-1.0*k**(3/2)*t**2*exp(5*L*sqrt(k)) - 5.0*k**(3/2)*t**2*exp(4*L*sqrt(k)) - 10.0*k**(3/2)*t**2*exp(3*L*sqrt(k)) - 10.0*k**(3/2)*t**2*exp(2*L*sqrt(k)) - 5.0*k**(3/2)*t**2*exp(L*sqrt(k)) - 1.0*k**(3/2)*t**2)*exp(L*sqrt(k)) + (1.0*k**(3/2)*t**2*exp(6*L*sqrt(k)) + 5.0*k**(3/2)*t**2*exp(5*L*sqrt(k)) + 10.0*k**(3/2)*t**2*exp(4*L*sqrt(k)) + 10.0*k**(3/2)*t**2*exp(3*L*sqrt(k)) + 5.0*k**(3/2)*t**2*exp(2*L*sqrt(k)) + 1.0*k**(3/2)*t**2*exp(L*sqrt(k)))*exp(-L*sqrt(k)))/(1.0*k**2*exp(6*L*sqrt(k)) + 6.0*k**2*exp(5*L*sqrt(k)) + 15.0*k**2*exp(4*L*sqrt(k)) + 20.0*k**2*exp(3*L*sqrt(k)) + 15.0*k**2*exp(2*L*sqrt(k)) + 6.0*k**2*exp(L*sqrt(k)) + 1.0*k**2) - (0.5*k**(3/2)*t**2*exp(6*L*sqrt(k)) + 2.0*k**(3/2)*t**2*exp(5*L*sqrt(k)) + 2.5*k**(3/2)*t**2*exp(4*L*sqrt(k)) - 2.5*k**(3/2)*t**2*exp(2*L*sqrt(k)) - 2.0*k**(3/2)*t**2*exp(L*sqrt(k)) - 0.5*k**(3/2)*t**2)/(1.0*k**2*exp(6*L*sqrt(k)) + 6.0*k**2*exp(5*L*sqrt(k)) + 15.0*k**2*exp(4*L*sqrt(k)) + 20.0*k**2*exp(3*L*sqrt(k)) + 15.0*k**2*exp(2*L*sqrt(k)) + 6.0*k**2*exp(L*sqrt(k)) + 1.0*k**2), Ne(1.0*k**2*exp(6*L*sqrt(k)) + 6.0*k**2*exp(5*L*sqrt(k)) + 15.0*k**2*exp(4*L*sqrt(k)) + 20.0*k**2*exp(3*L*sqrt(k)) + 15.0*k**2*exp(2*L*sqrt(k)) + 6.0*k**2*exp(L*sqrt(k)) + 1.0*k**2, 0)), (L*(-0.5*t**2 + (0.5*t**2*exp(2*L*sqrt(k)) - 1.0*t**2*exp(L*sqrt(k)) + 0.5*t**2)/(1.0*exp(2*L*sqrt(k)) + 2.0*exp(L*sqrt(k)) + 1.0)), True))" ] }, - "execution_count": 61, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "np.linspace(k_values[-1]**(-2), k_values[0]**(-2), 5)" + "_u = equilibrium.rhs\n", + "\n", + "def elastic_energy(u):\n", + " k, t, L = sp.symbols('k t L')\n", + "\n", + " density = (1/2*(u.diff(x) - t)**2 + 1/2*k*u**2).simplify()\n", + " \n", + " return sp.integrate(density, (x, 0, L))\n", + " \n", + " \n", + "elastic_energy(_u)" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/latex": [ - "$\\displaystyle \\frac{2 e^{\\frac{L \\sqrt{k}}{2}}}{e^{L \\sqrt{k}} + 1}$" + "$\\displaystyle \\frac{0.5 t^{2} \\left(\\left(e^{L \\sqrt{k}} - e^{2 \\sqrt{k} x}\\right)^{2} + \\left(- \\left(e^{L \\sqrt{k}} + 1\\right) e^{\\sqrt{k} x} + e^{L \\sqrt{k}} + e^{2 \\sqrt{k} x}\\right)^{2}\\right) e^{- 2 \\sqrt{k} x}}{\\left(e^{L \\sqrt{k}} + 1\\right)^{2}}$" ], "text/plain": [ - "2*exp(L*sqrt(k)/2)/(exp(L*sqrt(k)) + 1)" + "0.5*t**2*((exp(L*sqrt(k)) - exp(2*sqrt(k)*x))**2 + (-(exp(L*sqrt(k)) + 1)*exp(sqrt(k)*x) + exp(L*sqrt(k)) + exp(2*sqrt(k)*x))**2)*exp(-2*sqrt(k)*x)/(exp(L*sqrt(k)) + 1)**2" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(1/2*(_u.diff(x) - t)**2 + 1/2*k*_u**2).simplify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Experiment" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "experiment = '../../playground/benchmark-umut-at2/output/thinfilm-bar/MPI-1/af8b6d4845926418186744c206a13d20'\n", + "params, data, signature = pp.load_data(experiment)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.34" ] }, - "execution_count": 28, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "(uprime/t).subs(x, L/2)" + "params['model']['ell_e']" ] }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([10, 8, 6, 4, 2, 0])" + "{L: 1, Ly: 0.05, k: 8.650519031141867}" ] }, - "execution_count": 53, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "np.arange(10, -1, -2) " + "_matpar = {L: params[\"geometry\"][\"Lx\"], sp.symbols('Ly'): params[\"geometry\"][\"Ly\"], k: params['model']['ell_e']**(-2)}\n", + "_matpar\n" ] }, { "cell_type": "code", - "execution_count": 110, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { - "text/latex": [ - "$\\displaystyle \\frac{2 e^{\\frac{L \\sqrt{k}}{2}}}{e^{L \\sqrt{k}} + 1}$" - ], "text/plain": [ - "2*exp(L*sqrt(k)/2)/(exp(L*sqrt(k)) + 1)" + "" ] }, - "execution_count": 110, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAGrCAYAAAAPX6kCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABkCklEQVR4nO3deVhb16Eu/HdrBgkksI3kCdmWDZ4CxHFIYoyTNINJW6c9cdwhJ4lpmiZtko7n3Jt+92lyv6fteW5yv3vT054kp/bpQDq3ttM0bhtwZmOcxLUTwCOTbcDGEh5AaAs07+8PWQpCYhAItoD318cP0t5LSwuhSm/WWnstQZIkCUREREQ0Zgq5G0BEREQ03TBAERERESWJAYqIiIgoSQxQREREREligCIiIiJKEgMUERERUZIYoIiIiIiSpJK7ATPRj3/8YwSDQQiCgMzMTLmbQ0RERGPQ398PSZKgVCrxzW9+c8SyDFCTIBgMQpIkSJIEURTlbg4RERElIRgMjlqGAWoSCIIASZIgCAL0er3czSEiIqIxcLvd0e/v0TBATYLMzEyIogi9Xo9HH31U7uYQERHRGOzYsQOiKI5p+g0nkRMREREliQGKiIiIKEkMUERERERJYoAiIiIiShIDFBEREVGSGKCIiIiIksQARURERJQkBigiIiKiJDFAERERESWJAYqIiIgoSQxQREREREligCIiIqJp5W9na3D08glZ28AARURERNOCJEnY0/YX7D79Cp4/+lOc6mmWrS0q2Z6ZZiS73Y7q6mrU1NQgKysLmzdvjjnX0NAAs9mMH/zgB2hra0NVVRUcDgd27twpY6uJiCjdSZKEP7Tuxr7OtwAAvpAfP258Ef9a8g3YjMumvD0MUJRSFosFlZWVaGhowPLly7F169aY86Io4tlnnwUA2Gw2bN26FS+++GLKnr+6uhoVFRUxx6qqqmC32/Hd7343Zc9DRERTJySF8OumP+CdrtqY456gFx3ieVkCFIfwaFIYDIZhj5eUlETvZ2VlpfR56+vr446VlJSgvLw8pc9DRERTIxgK4ucnfxUXngQI+NLK+3HrQnk+39kDRVNCFEWIogiLxQKbzQZRFIcNWeNVXV0Nh8MRd3xwYCMioukjEApg54lf4h/dH8YcVwgKPLxqO26ylMrUMgaotOMNhHChzyd3M6LmZ2ugVU28o3JwsBkt0IiiiJqaGlgsFtTX16OiogI2my16vrq6GhaLBW63G3a7HXq9PlrWbrdjz549AICtW7eOOM+quro65v7QoT8iIpKPP+jHi8f/C/WXjsYcVwpKfHXNl7E+71qZWhbGAJVmLvT58HR1p9zNiPp+xWIsydWN67Gtra3Ys2cPXC4XDh48iCeffHJMj9u9ezcqKipgsVhQVlaGRx55BM899xwMBgPq6uoAfBzC7HY76uvro/cdDkfMvCubzYbKysrovKuISLsqKysBAHV1dairq0NZWdm4flciIkodb9CH/2j8KY73nIw5rlao8fjaR1A8d61MLfsYA1SamZ+twfcrFsvdjKj52ZpxPzbRJPKxiISiSI+Q2WxGQ0NDNNzU1dVh48aNMBgMsFgsWLFiRVL1i6KIl156Cb/73e+ix2pra5Ouh4iIUm8g4MG/N7yAZmdrzHGtUotvXPNVrM5dKVPLYjFApRmtSjHuHp90VlFRAbfbHb3f1tYWMyw3WORqOVEU4XA4IIoiXC4XAKCsrAzV1dW47777YLPZsHHjxqRDWmtrK/R6fcwcLF6hR0QkP7ffjecansfpvrMxxzOUOny7+AmsMCX+3pADAxRNCYvFEnO/paVl2ADV1taGXbt2oaSkBBs3boTZbI45H1lDqr6+HjU1NQCQMETZ7fa45wUQE+SIiCg99Pn68H/r/wMd4rmY43qVHv9S8nUszbbK1LLEuIwBTbm2traEwQYI9zp973vfw7Zt21BRUQGDwRANPJFFOoGP15B67rnncODAgWGfJxGbzZYwRImiOJ5fh4iIJuiy5wr+14fPxYWnbHUWnlz3rbQLTwADFE2SkcJIVVXVsAHK4XDA7XbH9E5F6mpra4Pb7Y67ei7SQ2WxWGC32wGEw9ZwPVwWiwUbNmyIXq0XeY7hghgREU0ee383/teR/wt7f+wyNCaNEd9d9x0sNiySqWUj4xAepVSklygSdgaHlMhWLpGhtchQnd1uR1VVFSorK2Gz2XDPPfegqqoqemXdk08+iaqqKpSXl0Ov1wNA9Go8u92OJ554AkA4GG3evDka0CoqKmKeY8+ePdGhvu9+97uoqqrCnj17YLFY4HK5uIwBEdEU6xTP4f/U/wf6fH0xx+fp5uBfr/0m8jLmydSy0QmSJElyNqC9vR3t7e0wmUzweDwAgNLS5BfGSqaexsZG9Pb2wuFwwOPxwGq1YtOmTeP/JYbYsWNHdKHIRx99NGX1EhERzRRtztN4ruF59AcGYo4vyLTgX6/9JnK0pilvUzLf37L2QDU3N6OpqQlbtmyJHmtvb8euXbuwbdu2Saln//79KCoqQlFREQDA4/Fg7969eP755/Hwww9Dp5t5V8ARERGlkxNXTuEnR38Kb9Abc3xJVj6+U/x1ZGlSu1PFZJBtDpTH48G+fftwxx13xBy3Wq3weDxobGxMeT3Nzc0oLCyEyWSKHtPpdNiyZQu8Xi/27t07/l+IiIiIRvXRxQb8qPGFuPBUYFyO/3btt6ZFeAJkDFDNzc0wGo0Je3wKCwvR0NCQ8nrsdnvcJfFAOEQVFRWho6MjOvxHREREqfWe/RCeP7YTgVAg5vg1uavxnZKvI1OVIVPLkidbgGpqahp2uMxkMqG7u3tMYSaZehobG7Fr166EZSPBKtFmtERERDQxb517F/91ogohKRRz/Pq8dfhG0degVY5/5ws5yBagHA5HzFDaYEajEQDgdDpTWk+i3qeISMjiHCgiIqLUkSQJfz1bjV83/wESYq9bK5+/AV9d82WoFNNvUQDZWuz1eqHVakcs43Q6Rww9ydYz0sT0sYSsw4cP48iRIyM+F8CVromIiAAgJIXwx9aXsa/zzbhzdy6+DV9YvhWCIMjQsolLy8gXCUQTnY+UTD2NjY3RK/OG4/P5uFr1KCLrQNXU1CArKwubN2+OOXfgwAFs3rwZlZWV8jWSiIgmXSAUxC9P/RoH7R/EnfvM0k/hM0s+NW3DE5CmAWqq7d+/H0ajEeXl5SOW02g0MRvQDsftdkPm5bVkY7FYUFlZiYaGBixfvjxuj7qKioq4lcRTqbq6mgtiEhHJzBf04T+P/wz1l47Gnfviim24c/EnZGhVaqVlgPJ6w5c2TnQ+0ljqcTgcaGxsxP333z/q861fvx7r168f9XkjC3HNZsMFTZvNNuw2LqlQX1/PAEVEJKP+wAB+3PAimp2tMccVggJfXvUgNlhukKllqZWWAWoq7d27F9u2bRt2IjqlXmQ7llSrrq7mVZRERDJyep34vw3Po3PIpsAahRqPrf0KiudeI1PLUk+2AGU0Goe9yi4yZylyFd1k1bNr1y7ccccdo05Un0pSwAP0tcvdjI9lWyGoJn5lYn19PSwWS/Tft7/9bZjNZlRUVKC+vh4AUFlZCVEUUVNTA4vFEu1NGrop8NAhwEgd9fX10T3vAGDr1q1oa2tDVVUVHA4Hdu7cCSC8mXFNTQ22b98efexLL72UsD0AovvlRfbwKysrm/DrQUQ001wcuIT/U/8TdA9cjDmeqcrAt4oexwpT4g3epyvZApTZbB52cvdYroibaD2vv/46SktLYbVax9rkqdHXjsBrD8ndiijVXb8AcgsnXE9dXV10PlRJSQncbjd2794NACgvL0dtbS0AYPfu3aioqIgGlUceeQTPPfdcdEhwz549cLlc0XBTV1eHurq6aKhxOBwx865sNhu2bt2KF198MXqssrISbW1t0fsjteeZZ55BeXl5tP6nnnoKFoslLtQREc1mneJ5PFf/H+j1xXZoGDXZ+JeSr2OxYZFMLZs8sgUoq9WKQ4cOJTzX29uL/Pz8Savn0KFDKCgoiAtPvb29cDqd8oaqbGs4tKSL7PG/Fq2trdHAc+DAgZhgo9fr0dbWhpKSEgCIBhK73R4zj8lsNqOhoQFlZWUQRREvvfQSfve730Xrqa2txYoVK0ZsR1ZWVtyxocOIidpjt9tx8OBBfPe7342WKysrQ3V1NR5//PGxvxBERDNYS28b/r3xhbhNgefp5uJfr/0G8jLmydSyySVbgCooKMD+/fvR29sbN/+oubkZmzZtijnm8XjgcDjiwk2y9TQ3N8NsNicMSd3d3cjLyxv/L5UCgkqXkh6fdDD4KrxEISfRZPJIWBFFEQ6HA6IowuVyAQgHMr1eHzNBfXC4maih7amvr4der48O6QHhgGe321P2nERE09mHFxvw0+M/hz/kjzm+2LAI/1L8BIza0afiTFeyBSidToc777wTtbW12LJlS/R4ZG+7goKCmPJ79+5FR0cH7rjjjpj1mpKpx+FwoKGhAYWFhTGbDEeGAJuamvDAAw+k/HcloLi4OO5YosnkbW1t2LVrF0pKSrBx48aY4ddkFyiNzFlKJFFdQ9vjdrthsViivVIAYm4TEc1m754/gJeafhe3uvgKow3fKnoMmepMmVo2NWS9Cq+goABarRb79++HyWSKBplEK4ZbrVY4HI6E85nGWs+uXbvg9XrR0dGRsD1jmbRO4zOW9bNEUcT3vvc9/PCHP4wO6UWCjt1uh81mSxh8RFFMWH9bW9uwAWosy0zYbLbovKixPB8R0WwgSRJePft3vHLmr3Hniudcg6+tfXja7Ws3HrIvY2C1Wsc056i0tBSlpaUTqueJJ55Iun00PuNZB8vhcMDtdsdM0I7U09bWhrKyMmzYsAF79uyJDg2KoogDBw5EJ55HhtcigQsIz6MaPOwmiiLsdvuoPVolJSVYvnx5zCR1ANHnIyKabUJSCL9p/gPePl8bd658/gZsL7wPSoVShpZNPUGarUtmT6LIQpoGgwGPPvqo3M2ZUna7HXV1ddi9e3d0KxebzRYz9FVfX489e/agtbUV9957L8rKyqI9RVVVVQA+HiqzWCyoqqqKuRKuqqoKWVlZsFgscLlcMWEm8niLxRJzPLK0QeR5amtrcfr0aWzfvh16vX7Y9kTqtFgs0cnoXMaAiGYjX9CHHSd+iQ8v1sed27LkLvzT0i3TemsWILnvbwaoSTCbAxQREc08br8bP2n8adzq4gIE3F/weXxi0c0ytSy1kvn+ln0Ij4iIiNLXFU8Pnmt4HufdXTHHVYIKj675EtbnrZOpZfJigCIiIqKEzrsv4Ln6/8AVb0/M8QylDt8o+hpW5hQM88iZjwGKiIiI4jT3tuDHjf8Zt0CmSWPEd0qemJGriyeDAYqIiIhiHHIcwX+dqEJACsQct2Sa8S/FX8fcjDkytSx9MEARERERgPAaT/s638QfWvfEnVuWvQTfKnocWRqugwcwQBERERHCazz9vmU33jj3dty5krlF+OqaL8+KBTLHigGKUsput6O6uho1NTXRdaAGn2toaIDZbMYPfvADtLW1oaqqCg6HAzt37pSx1WMTWUsKQHT9qbq6uphNkuXwwgsv4MCBA3jyySe51QwRjYsv6MPOE7/EkQRrPN26cBPuL/g8FIJi6huWxhigKKUsFgsqKyvR0NAQs5lwhCiKePbZZwGEt0rZunUrXnzxxZQ9f3V1ddwq4VVVVbDb7RPaePiFF15ARUVFzCrpzzzzzLjrS6XHH38cra2toxckIkrA5RPxk6P/iVbn6bhz99o+i0/m3zntF8icDAxQaSIkhSD6k9ssd6oY1Pqk/8tjuL3iDAZDTC9JZHXvVKmvr48LUCUlJUlvRDzUgQMH8Pjjj8cce+KJJ/D8889PqF4iIjl1D1zEjxqeh72/O+a4UlDiy6sexE2W4bdQm+0YoNKE6Hfjmwf+u9zNSOjHG/83sjUTCzqiKEIURVgsFthstknZkLe6uhoOhyPueCqGtdxuN+x2e8wWLwaDAStWrJhw3UREcjjT145/b3gBfX5XzPEMpQ5fL/oqVuUUytSy6YEBiqbE4GAzWqARRRE1NTWwWCzRHqXBQ2fV1dWwWCzRUKPX66Nl7XZ7dK7S1q1bR5xnVV1dHXN/pA2CbTYbnn76aTz22GMx7R86RLlnz55oyLLb7dHzidpRVVWFmpoabN++HRUVFaivr8dLL70EINy7ZbfbYbfb4XK5UFlZGfc8er0+5T14RDQ7fHixATuO/wK+kC/meI42B98pfhyLDAtlatn0wRlhNGlaW1uxZ88eVFVVRec9jcXu3btRVlaGsrIyPP7443j22WchiiIAoK6uDkA4hEXKRO5XVFTAYrFg69at0eBis9niwgcQDiB2ux0VFRWoqKhAVlZWtO5EnnzySQDA008/jbvvvhtPPfUU6uvrY8o888wzsNls0XaVlZXhqaeeirZjaNiqrKzE8uXLo/dLSkqwfft2uN1uuFwulJWVYevWrTh48CDa2tqi5aqqqqDX61FRUYGysjIUFxfHnCciGk5kmYLnj+6IC0+LDQvx1Pr/zvA0RgxQNGkik8grKyuxYcOGMT/ObrfHhBOz2YyGhobo/bq6umigslgsSQ+jiaKIl156Cffee2/0WG1tLex2+7CPsVgs2LlzJ77//e/jnnvugSiKePrpp6Ohq62tDQ0NDTG9UxaLBaIoRn+XRL1Fer0+5n5WVhbsdntMPWazOdo2URTx8ssvx/SWGQyGmB46IqJEgqEgftvyJ/y+ZTckSDHnVucU4rvr/gU5WpM8jZuGOISXJgxqPX688X/L3YyEDGr96IVGUVFRETORu62tbdgv/cjVcqIowuFwQBRFuFzhMfqysjJUV1fjvvvug81mw8aNG5NeRqC1tRV6vT5mDtZYr9ArKSmJhpuqqio8//zzKCsrQ0tLS8z8qAiz2Yz6+vqk5mENrUev10d//4aGhrjQRUQ0Gk/Ag58e/zkaLh+LO7fRchO2r7wPKgUjQTL4aqUJhaCY8ETtdDY0FLS0tAwboNra2rBr1y6UlJRg48aNMJvNMecja0jV19ejpqYGQPxcJABxk74jkr0iTxRFNDQ0RIcLIyorK/Hyyy9DFMVxX+U3nsdx3hMRJaPH24t/b3gRHWJn3Ll7lt2NT1sruEzBOHAIj6ZcW1tbwmADhMPK9773PWzbtg0VFRUwGAzRkBFZpBP4eE7Rc889hwMHDgz7PInYbLaEwSUyLJhIS0tLwuMWiyW6NEOiIUCHwzHiEONIz5mIzWYbcaiRiGiwDtc5/ODws3HhSSWo8Ojqh7BlyV0MT+PEAEWTYqRgUFVVNWyAcjgccLvdMb1Tkbra2trgdrvjrp6L9FBZLJZouLDb7cP2cFksFmzYsCFmZXFRFIcNYgBQU1MTN2m8vr4+OrfLZrOhuLg4pkwkwEV6rgbPZYo8p91uH7UXavB5i8WCzZs3x7wGoihGXxsioojGy8fwvz78P+jx9sYcN6j1+G/XfhM3Wq6Xp2EzhCBJkjR6MUrGjh07ouscPfroo3I3Z0pFeolefvnl6Jf94HMNDQ2w2+149dVXo0N1Bw8exD333BO9Wq6qqgrAx8sdWCwWVFVVoby8PDoXKDKMZbfbsXnz5uh8pshjLRYLKioqYp5j+/btMUN9VVVVyMrKgsViiW7NkkgkXFkslrheraFDh4PDod1uT7j8QKR9QHjy+unTp7F9+3ZYLJa4tu7Zswe7d++GxWLBvffeGw1jkeUSIvOhIssfbN++ndu5EBHePr8fv2n+I0JSKOa4OSMP3yp+HJbMPJlalt6S+f5mgJoEszlAERGRfEJSCH9o2Y3XE2wIvMJowzeKvgqDOrWLGM8kyXx/cxI5ERHRDDAQGMBPj/8CjQmutLvRfD0eWvUA1Aq1DC2bmRigiIiIprlLA5fx740v4ry7K+7c3Us+ic8u/TQni6cYAxQREdE01uJsw380/hQuf+zFOypBhS+tvB8b5t8gU8tmNgYoIiKiaeo9+yH84uSvEZACMccNagO+cc1XscLEXQomCwMUERHRNBOSQnjlzF+x9+xrcecW6OfjW0WPYV7GXBlaNnswQFFK2e12fPvb30ZxcXH0Uv2DBw9Cr9dj48aNcLlc0X3tfvSjH6X8+dva2lBVVQWHw4GdO3eO2tbq6mrU1NQgKysr4ZILZrMZP/jBD1LeznSSzOuQzOubLgav9xVZrqKuri7pLYBS7YUXXsCBAwfw5JNPcukJSoo36MPPTryEwxc/jDt3Te5qfHXtw8hUZcjQstmFAYpSyu1249577435cjp48CCKi4tjjj311FNjqq+6unrY9ZkSiaxQ/uKLL45a1mKxoLKyEg0NDdGNjwcTRRHPPvvsmJ97ukrmdUjm9R2rRH/jqqoq2O32Me9ROJwXXngBFRUVMYuqPvPMMxOqM1Uef/xxtLa2yt0MmmZ6vL34SeNPcdbVHnfu9kW34gvLt0KpUMrQstmHK5FTSrlcrpgeDAAJN78duq/ccIau/j0Wye4VN3hT4aHHZ1PPwFhfh1TvxZfob1xSUoLy8vIJ133gwIG4FemfeOKJCddLJIfTfWfx/X88ExeeFIICDxR8Af9c8DmGpynEHqg0IYUkSAM+uZuRkJChgaAY2+Wvbrd72C/iwSwWS3SxsuFUV1fD4XCMuZ2pIooiRFGExWKBzWYbtZ0z1VS8DsP9jVMVXN1ud9ym0gaDYcT9CYnS0UH7B/jlqd8gEIqdLJ6hysDja7+CNbmrZGrZ7MUAlSakAR/EZ6pHLygDw3crIOi1Yyo71p6lyBdkZEsSIDzfJjJ8VF9fj/r6etjt9ugclsg5URRRU1MDi8WC+vr6uCGaiRr8hR5pZ319fXS7lCeeeAJ2ux12ux0ulyvhdi2RffksFgvKysqijzebzaioqIj2ulRWVkIURbz00kuw2WzRjZZtNhuqq6tRXl6O3bt3w263R+fK2O12PP300zCbzXj88ceH3VdwMl6H4Yz2N6murobFYokGGr1eHy079G880jyrofsgjja8a7PZ8PTTT+Oxxx6L+R2GDlMO9z5M1JaqqirU1NRg+/bt0b9lMu8NvV6f8l48mrlCUgi72/6C1zr2xZ3Ly5iHbxU9hvn6yfkMoJExQJFsnnnmGVRUVES/2Ox2O5566in84Ac/iB5zOBxxX3a7d+9GRUVFNJw88sgjeO655ybUO9La2oo9e/bA5XLh4MGDePLJJ2POR9rz4osvwuVyRYPiI488gvLy8mhYeOaZZ1BeXh49/9RTT8FisaCkpARutxu7d+8GAJSXl6O2thYA8Pzzz0cfI4oivvOd72Dnzp3R59Tr9XjxxRdj9gbcvHnzpEyCHu11GM5If5O6ujoAiPk719fXD/s3ttlsqKysjJt/FmlXJJTU1dWhrq5uxND+5JNP4umnn8bTTz8NANG5eIPD1Ejvw0RzviorK2P2RBzreyOyT2Ik9M2WOXY0fgOBAew4/gs0JFhZfHVOIb629iswqOOnSNDU4BwokkVbWxsaGhpivsgiw3qjzXuKfAFHmM3m6JV94xWZPF1ZWYkNGzYkLJOVlQW73R7TZrPZDLvdHm3XwYMHY77Qy8rKor0mer0ebW1tKCkpiYYEIDzJPvIlazAYoj0YESUlJXC5XDFf2pPV6zSW1yGR0f4mdXV1EMXwIn8WiyXpIbRIL929994bPVZbWxvzOiVisViwc+dOfP/738c999wDURTx9NNPR0PdWN6HiXqLhs7rG+29IYoiXn755ZgeM4PBkNKeU5pZHP3d+OHh/50wPN2+6BZ8u/jrDE8yYw8UyaKlpSVhCDCbzTG9E4lErswSRREOhwOiKMLlcqWsbRUVFXC73dH7bW1t0S+6oW3W6/XR566vr4der48JEkPDUKLf2WazxTxfonKbN29GbW0tbDYb6uvrUVxcPL5fLgkjvQ5DjfQ3iYTI++67DzabDRs3bky696y1tRV6vT6mlzGZK/RKSkqi76mqqio8//zzKCsrm9D7cKiR3hsNDQ0JL6YgSuT4lZP4z2M/gzvQH3NcKSjxQMEXcPPCjTK1jAZjgEoTQoYGhu+O/XL9qSRkaFJe59DAMBaROUVtbW3YtWsXSkpKsHHjRpjN5pS2begXYUtLy5h6Ctxud3S4LmLoF3CiL9HNmzdj165deOKJJ1BTU4PHHnssrkx5eTm+973vobKyMq6nI5Fvf/vbMcFt6NISY5HM6zDa3ySyhlR9fT1qamoAxM9DAhA34TtiPO8XURTR0NAQN8RXWVmJl19+GaIojqve8baH855oNJIk4Y1zb+MPrXsQkkIx5wxqA75+zSMoMPECiHTBAJUmBIUw5onaM0FJSUl0PtBgDodj2MvX29raYDAY8L3vfQ8//OEPo1/mkS+z4b58JyIyqXssbDZbwt9pLFevPfHEE9Ev++F6qbKyslBXVzemL+JUL1I60usgiuKIf5PBk8ptNhs2b96Mp556KmGAGu55EvXSRZ57pNe2paUl4Rwpi8USXZ4h2fdh5HmTYbPZRh1upNnNH/Tj181/QO2Fg3HnFhsW4hvXfA1zM+bI0DIaDudA0aRzu91xX342mw3FxcUxw12ROT6RL7zIlWxA+IvYZrPB4XDA7XbH9IREvswGzxFKxkhfhpGJv8MZ/HuVlJRg+fLl0fk1EQcOHBjx+SPBcLjwFLF58+bo0NNkGO/rMNrfxO12x109F+mhSvQ3TsRisWDDhg0xq4qLojjqa1tTUxM3p66+vj46v2ss78PBc5kiz2u320fthRp8PjLxf/DrIIpi9PWh2a3H24tnPnouYXhaN68E/2PdvzI8pSFBkiRJ7kbMNDt27Ij+l/Gjjz4qd3NkE7lq6uWXX45+gUSu0ooY/MVst9vjLvuuqqoCgJirlyLHBl+VVlVVhfLyclgsFuzatQsHDx7EPffcE1ffYJEtTAa3b/C5hoYG2O12vPrqq9EhqoMHD2L79u3YunUr9uzZg927d8NiseDee++N/l6R3ynSUxRZxmDPnj1obW2Nlo383nV1dXj22Wejl7fr9Xps3rw57hJ9u92OqqqqCa/OnarXYfDrO9LfJDIPKPJ62O12bN68OdpzNPRvnOi1jqiqqkJWVhYsFkt0W5bhRAJWZNh3sKG9X6O9DyPBLVKmtrYWp0+fxvbt22Pec6O9NyLLJUSGciPLH2zfvn1WLdpKH2vpbcPzx3aiz9cXd+4zSz6Fu5d+EgqBfR1TJZnvbwaoScAARWMliiKef/55PPHEEzAYDNFJ2FVVVSgrK4sJCKIoorW1lV+0RDOAJEl4p6sWv23+E4JSMOacVqnFl1c9iOvz1snUutkrme9vzoEiklFNTQ0qKiqivTEGgwEGgwGVlZWorq6OmeNz4MCBpPYFJKL05A/58ZumP2L/hbq4c/N0c/GNoq9ikWGhDC2jZLBfkEhGNpstbs4UgOgl9C+99FJ03gyv4iKa/nq8vXj2wx8lDE9rc1fj6eu/y/A0TbAHikhGw21pE5krZrFY0NLSgurqavY+EU1zLc42vHB0J5wJ5jt90roZW5fdzflO0wgDFJHMBi/yOFTk0n8imr7C850O4LfNf4yb76RRaPDlVQ+i1HydTK2j8WKAIiIimiS+oA+/bv4DDlx4L+7cPN0cfL3oq1hsWCRDy2iiGKCIiIgmwcWBS3j+6E50iJ1x59bkrMJX1z4Eg3r8m6CTvBigiIiIUuzo5ePYcfwXcfvZAcBd+Xdg67LPQKlQytAyShUGKCIiohQJSSH89Ww1XjnzV0iIXWZRp9TiIa7vNGMwQBEREaWA2+/Gf52oQsPlY3Hn5mda8MQ1j2CBfr4MLaPJwABFREQ0QR2uc3j+6A5c9FyKO7d+3rV4aNWDyFDpZGgZTRYGKCIiogk4eOEDvNT0W/hC/pjjAgRsW/5PqFh8OwRBkKl1NFkYoIiIiMbBH/Tjty1/wrtdB+LOZakN+Nrah7Eqp1CGltFUYIAiIiJKUnf/RbxwbCc6xHNx52zZS/HY2q8gV5cjQ8toqjBAERERJeFw90f4xclfYSDoiTt368JN+OKKe6FWqGVoGU0lBigiIqIxCISC2N32Z9R0vhl3TqPQoHLlP+MmS6kMLSM5MEARERGN4oqnB/95/GdodZ6OO7cg04LHrnkEC7lEwazCAEVERDSCY5dPYMeJX0L0i3HnbjSXYnvhF6HjEgWzDgMUERFRAiEphL+c+Rv2nn0tblVxlaDCfQWfwy0LNnKJglmKAYqIiGiIHm8vdh7/JU71Nsedm6ebg8eueQRLsvJlaBmlCwYoIiKiQY5ePoH/OvFLuBIM2a2bW4wvr3oQmepMGVpG6YQBioiICOGr7P58+lX8vWNf3DmFoMA22z9h8+LbOGRHABigiIiIcNlzBf957Odo64u/ym6ONhePrn0IK4w2GVpG6YoBioiIZrWPLjbg5yd/BXegP+7ctXOL8dCqB2BQ62VoGaUzBigiIpqVAqEAdrX9Gfs634o7pxSU+Nzye3DHols5ZEcJMUAREdGs4+jvxk+P/wJnXe1x5+bp5uJrax/G0myrDC2j6YIBioiIZpWDFz7Ar5t/D0/QG3fu+rx1qFx5PzJVGTK0jKYTBigiIpoVBgID+FXTH/C+41DcOZVChftWcGFMGjsGKCIimvHanGew4/gvcNFzKe6cJTMPX1vzFeRnLZKhZTRdMUAREdGMFZJC+Hv7PrxyZi+CUijufPn8Dfjngs9Bq9TK0DqazhigiIhoRhppO5YMVQYqC/8ZpebrZGgZzQQMUERENON8eLEBvzj5a7gD7rhzy43L8OjqhzA3Y44MLaOZggGKiIhmDG/Qiz+27sHb52vjzgkQcPeST2LLkrugVChlaB3NJAxQREQ0I5zuO4udx38Jx0B33LlcbQ4eXfMlFJhWyNAymokYoIiIaFoLhoL4W3sNXj37t4QTxdfPW4fKlfdBz+1YKIUYoIiIaNrqHriI/zpRhVZn/CbAGoUG9xVsw6b5ZVzbiVKOAYqIiKYdSZJQZ38fv23+Y8IVxZdlL8FXVn8Jlsw8GVpHswEDFBERTSuiX8RLp36Hwxc/ijunEBTYYr0Ln15yF1ScKE6TiAGKiIimjaOXT+AXJ3+FXp8z7lxexjx8ZXUllhuXydAymm0YoIiIKO15Ah78sfVlvNMVvzwBEF5R/IsrtiFDpZviltFsxQBFRERprbm3BT878auE+9gZ1HpUrrwf180rmfqG0azGAEVERGnJH/Tj5TOvoqbjTUiQ4s6vzV2NL696ECatUYbW0WzHAEVERGnnrKsDPztRhfPuC3HnNAoNvrBiK25ZUM7lCUg2DFBERJQ2AqEg/tZejb1n/55wUcwVRhseXrUdeZnzZGgd0cdkD1Dt7e1ob2+HyWSCx+MBAJSWlk56PR6PB7W1tdBqtdi0adP4Gk9ERClz3n0BPzvxEs662uPOqQQV7lm2BZvzb4dCUMjQOqJYsgao5uZmNDU1YcuWLdFj7e3t2LVrF7Zt2zYp9ezfvx9OpxNmsxnt7e2wWq0T/0WIiGjcgqEgqjvfwCtn/opAKBB3Pt+wGF9ZvR2LDAtlaB1RYrLFeI/Hg3379uGOO+6IOW61WuHxeNDY2Dgp9WzatAlbtmxBaWkptFrtxH4JIiKakPNiF/7tyP+H3W2vxIUnhaDA3Us+iafW/3eGJ0o7svVANTc3w2g0QqeLX7OjsLAQDQ0NKCoqmrJ6iIho6gRDQbzWsQ9/OfN3BKT4Xqf5mRY8vHo7lmUvmfrGEY2BbAGqqakpYegBAJPJhO7ubng8nmHLpLoeIiKaGp3iefzi5K9w1tURd06AgDsX34Z7lm2BRqmRoXVEYyNbgHI4HCgsLEx4zmgMr+nhdDpHDT6pqoeIiCZXIBTE39tr8OrZvyMoBePOWzLN+PKqB7kVC00LsgUor9c76hykyGTvqaiHiIgmT4frHH5+8lfoEDvjzgkQUJF/Bz679FPsdaJpQ/ZlDBKJBKLIcgRy1xNx+PBhHDlyZNRybrc7Jc9HRDTd+YN+vHr273itY1/CdZ0WZFrw0KoHYTMulaF1ROOXlgEqXfl8PoiiKHcziIimhebeFvzy1G9h73fEnRMg4C7rnfjskk9BrVTL0DqiiUnLAOX1egFgwvOWUlVPhEajgcFgGLWc2+2GJMXv20RENBsMBAawq+0VvH1+f8LzC/Xz8dCqB3mFHU1raRmg0tX69euxfv36Ucvt2LGDPVVENCvVXzqKXzX9Hj3enrhzSkGBT1o3Y8uSu6BWsNeJpjfZApTRaITT6Ux4LjJnKXIV3VTUQ0RE49fn68Pvmnfhg+7DCc8vzbLiS6vux2LDoiluGdHkkC1Amc3mYSd3RwLRWK6cS1U9RESUPEmScND+AX7fshvuQPwFNBqFBvcsuxt3LL6Ve9jRjCJbgLJarTh06FDCc729vcjPz5/SeoiIKDn2fgd+1fR7nOxpSnh+dc5KVK78Z8zLmDvFLSOafLL950BBQQE8Hg96e3vjzjU3N6O4uDjmmMfjQXt7/A7dydZDREQT4w/58Zczf8NTh36YMDzpVZn48qoH8a8l32B4ohlLtgCl0+lw5513ora2NuZ4ZG+7goKCmON79+7F7t274zYHTraewbxeb8rWiCIimg1O9TTj6UP/hlfO/DVu818AuD7vOvzbjf8TG+ffBEEQZGgh0dSQ9Sq8goICaLVa7N+/HyaTKRpmtm3bFlfWarXC4XAknM+UTD2HDh2Cw+FAb28vnE4nnE4ndu3aBZ1Oh8LCwhEDFxHRbOXyifhT68s4YH8v4flcbQ7uL/g8rp3HXn+aHWRfxsBqtcJqtY5arrS0FKWlpSmph4iIxkaSJNTZ38cfW/dA9MdPElcICtyx6FZ8dumnoVNxz1GaPWQPUERElJ7Ouy/gN01/wKne5oTnl2ZZsX3lP8OatXiKW0YkPwYoIiKK4Ql48OrZ17Cv842E+9fplDpstX0Gn1i4iUsT0KzFAEVERADCw3WHL36E37fsTriSOABcn7cOX1yxDTlaU0qfOxiScNzej390iihflo2CeRkprZ8o1RigiIgI9n4HftP8Rxy/cjLh+Tm6XDxQ8AUUz70mZc8pSRI6en04cLoP77e74PQEIQAISWCAorTHAEVENIt5gz789exrqO54AwEpflkCpaBERf7t2LLkLmiV2pQ855X+AN4724e6My6cc/qQpVXipiVZKFuahbdbnGi7zOVlKP0xQBERzUKSJOGjS434XcufcNlzJWGZ1TkrcX/B5zFfb5nw8/kCIfyjU8SBM304YR+ASiFg3SI9PlcyF2vnZ0KlCK8ZdSbXi/2n++ALhKBRcX4VpS8GKCKiWeaC247ft+7G0cvHE543aYz44optuD5v3YQXwzzX68U7rX04cKYP/f4QCvMy8NANebh+sQGZGmVc+SW5WoQkoLPXB9tcLotA6YsBioholhgIDODVs3/H651vJby6TikocMfiT+DuJZ9CxgTWdIr0Nr3V6kTLRQ+ydUrcusKIW2zZMGdpRnzsIpMGSgE42+NhgKK0xgBFRDTDhaQQDto/wK62V9Dn60tYptC0Ag8UfAELDQvG/TznnT683epE3Zk+uH0hrDZn4ImNFqxbaIBKObaeLI1SgYUmLc5e8Y67HURTgQGKiGgGa3Oewe9a/oTTfWcTnjdqsvH55Vtxo/n6cQ3XBYJSuLeppRdNFz3I0ipxi82Im23ZsGSP3Ns0nKW5WpxhgKIRdDl9UCkF5BnUsrWBAYqIaAZyep3Y1fYK6uzvJzyvFJTYvPg2fHrJXeMarrvs9uPt1j682+aE0xPEqrwMPFZmwXWL9FArJzb5e0muFgdO98EXDEEzwbpo5rjs9uP9dhHvt7vQ3uPF7QVGPLg+T7b2MEAREc0g/qAfr597G3vPvgZPMPFyAMVzrsEXVtwLS2ZyXz6SJOG4YwBvNvfiw/NuaJUKbFyWhdtWGLHQmJolDgBgSY4OQQk41+vDsjmcBzWb9XkC+EeniPfOutB80QO1UkDJAj3uXpuL4gWZsraNAYqIaAYIryL+IXa1/hkXPZcTlrFk5uGLK7ahaM7apOp2+4I4cLoPb7U6caHPj4VGDR5cPw8blmQjQ536HqLFORooBODsFQ8D1Cw04A/iSKcb77e7cMzeDwBYa8nEIzeacd1iPTLU8VdvyoEBiohomjvddxZ/aNmNFmdbwvM6pQ6fWfop3L7oFqgUY//YP9frxevNvag740IwJOG6xQZ8qdSMwnm6CS9vMBKNUoGFRg0nks8i3kAI9efd+KDDhYaufviDEgrn6fDA+nm4frEB2br0iyvp1yIiIhqTy54r2N32F7zvODRsmY2Wm3Cv7TMwao1jqjMYkvDheTfeaOrFye4BmDKU+NTqHNy63AhTxtR9ZSzJ1TFAzXC+YAhHu/rxQYcLH55zwxeUsDRXi61Fc3BDvgFz9PJNEB8LBigiomnGE/Dg7x37UN3xBvwhf8IyK4w2fGHFvViWvWRMdbo8QbzT5sSbLU5c6Q9gxTwdHiuzYP2isS9BkEpLc7U4eLYP/mBowpPSKX0EguFNo9+/GpoG/CEsNmnwmbW5KM03jLpOWDphgCIimiZCUggHLryHl0+/Cucw6znN083B55bfg+vmXTumYbYzVzx4vakXH7SLgADcZM3C7QVGLMmVd+7RklwtgiHgnNOHpTK3hSYmEJJwwt6PQx0ijpwT4faFMD9bjYqVJtyQn4UFxukTmgZjgCIiSnOSJKHh8jHsbvszzrsvJCyTodRhy9JP4vZFt0CtGHnoIxCScLhDxL7mXrRe8mCuXoV7inKxyWZEljY9Jujmm7RXJ5J7GaCmoUShyWxQ4xPLjbjBmoXFJs2kzqObCgxQRERp7HTfWfyp9WU09bYkPK8QFLhlwUZ8Zumnka3JGrEu50AAb7c68VarE70DQaw2Z+Cb5fNx7UI9FIr0+jLTqCITyT0AxjZ/i+QVCU3/6BRxuDM2NJVas5A/A0LTYAxQRERpyNHfjT2n/4J/dH84bJlr5qzB55dvxUL9/BHrOn3Zg31NvTjUIUIhAGVLs3BHgQmLTKlbu2kyWHO4pUu6CwQlHHf04x+Depryroam6/MNsOZoZ1RoGowBiogojfT5XNh79u94+/z+hBv+AsBiwyJss/0Trpmzeth6AkEJhzpdeL3JibbL4WG6bcVzsMmWDb0mPYbpRrMkV4f320UEgpIsE9kpMV8whGMXwqHpo/Nu9PvDPU23LjeidIaHpsEYoIiI0oAn4MG+zrfwWsfrw64gPkebi3uW3Y0bLddDISS+Mq03MkzXEt5iZbU5A9/aNB8lC9JvmG40S3O1CIQknHN6ZZ/UPtt5AyE0dLlxuFNE/Xk3PAEJC40a3FlowvrFhhkxpylZDFBERDLyh/x453wt/nq2Gn1+V8IymaoMfHrJXbh94S1QKxNPEG+75MHrzb34oMMFpSBg49Js3F5gTPthupHk52ghXJ1IzgA19dy+IBrOu3H4nIjGrn74ghLyTRp8anUu1i82YOE0vXouVRigiIhkEAwFUWf/AK+e+Rsue68kLKNSqHD7olvwKWsFDGp93PlAUMKhDhdebw4P083Tq/C54rnTaphuJFqVAguyuSL5VOrzBHDknBtHOkUcd/QjGAKW5Wqn5TpNk40BiohoCoWkEI5c/Agvn94Le78jYRkBAm6ylOKflm7B3Iw5ceeHDtOtsUzfYbrRLMnVXr0SjybLJbcfhztFHDnnRnP3ACAAK+dl4IvXzsN1i/RpvyK4XBigiIimgCRJOHrlOPa0vYoOsXPYcsVz1uKeZXcjP2tx3OPbLnvwepMThzqvDtMty8YdBUYsNE7fYbrRLMnR4lC7iEBIgmqGhUO5SJKE805fuKfpnIizV7xQKQSssWTgoRvycO1CfVruPZdu+AoREU2yUz3N+PPpvWh2tg5bptC0AluXfQYrTLaY4/5gCB+0i3i9uRdnrniRZ1DPqGG60SzJ1cEfktDl9CE/Z+YGxckWCkloueTBh+fCPU3doh86lQJFCzJx18oclCzMRIZ65r+fUokBiohokjT1tOCVM3/Fqd7mYctYsxZj67LPYm3uqpirmK70B/BWSy/ebu2DyxvEWksmvn3zfBTPn3nDdCOx5mghILzlDANUcnyBEI7b+3HknBsfnXfD5Q3CqFNi3SI9Hlw0D6vMGdxncAIYoIiIUqyltw2vnNmLEz1Nw5aZn2nBPy3bgvWD9qyTJAnNF8NX0x3uFKFRRobpTJifPTsn7+rUCsy/OpH8Ztvo5We7Pk8ADV39+PCciKMXwlfOWbLU2GTLxnWL9Fg2RwfFLFtuYLIwQBERpUir8zReOf1XHO85OWyZOdpcfHbZp3GTuRRKRXjIxBsI4b2zLrzR3IuOXh8sWWrct24eypdlcVgFkYnkvBJvOF1OHz46L+LD8260XgxPuF8+V4fPrM3FdYsM03az3nTHAEVENEGn+87ildN7cfTKiWHL5GhN+LS1AuULNkQ3++0W/XizuRf7T/eh3xdCyUI9PlcyF2vnZ7KXYJAluVr8o1NEMCRBOYuGL4cTDEloveTBh+dFfHTODbvLD41SwNr5mZwEPoX4ChMRjVNLbxv2nv37iMHJpDHiU0sqcPP8MqiVaoQkCY1dbrze3IvGrn5kahS42WbEbSuMmGfg5eKJLMnVwR+U0NXnw+JpvDDoRLh9QRzt6kd9lxsNXW64fSEYdUpcu1CPL66bizXmTGhUnM80lRigiIiSIEkSTvY0Ye/Z10acHG7UZOOT1s24ZcFGaJQauH1BvNnSgzebnXCIfuTnaPHQDXm40ZoFLb/4RhSZSH72indWBagLfT7Un3ej/rwbTRcHEJLCq7PfXmBCyQI9ls7RsqdSRgxQRERjIEkSGi8fx96zr6Gt7/Sw5bLVWfikdTNuXVgOjVKD9h4v3mh24L2zLgRDEq7PN+CRm8xYPlc36/YOG68MtQKWbDXOXPGgfFm23M2ZNIGghOaLA/jovBv1XW44XH6olQJWmzPw4Pp5KFmoR24meynTBQMUEdEIQlIIH15swN6zr424AGaW2oC7rHfiEws3QQE1DnWIeLPFgdZLHuRmqrBlTS5utmXDlMGP3fFYkqObkRPJe/oDaLwQ7mU6bu+HJyAhJ0OJkoV63HftXKy2ZLKHMk3x/8lERAkEQkEc6j6Mv7fX4Lz7wrDlTBoj7rLeiZsXbETfgIC/HHXi3bbw2k1rLBn4Rvl8XLtQz8nPE7QkV4sj56b/RPJQKLyifEOXG/Vd/ejo8UIQgOVzdPj0mlwUL9Aj36Rh7+Q0wABFRDSIN+jF/q461HS+icuexJv8AsBc3Rx80roZGyw34JTDjxdqL6Ghy40MtQLly7LxiRXGWbt202RYmquFLyjhQp8Pi6bZPCjnQADH7P1o6HLj6IV+uH0hGLQKFM3X41OrcrB2fiaytFyuYrphgCIiAuDyiXjz3Dt48/w7EP3uYctZMvPwKWsF1hjX4cAZN/6fw+dxyR1Afo4WXyrNw01LOCl8MkRWIT9zxZv2ASp4tZepscuNxgv90aHHJbla3LbCiOIFetjm6GbVivIzEQMUEc1qlwYuo6bzTezvqoMv5Bu23EL9AmyxViALq/BOmws/7+yAQhBwo9WATyw3YdkcLYddJlGmRglzlhrtV7woXyZ3a+L1DgSigenYhX70+0PQaxS4Zn4m7iww4Zr5mTBy/tuMwr8mEc1KneI5vNb+Oj7oPoyQFBq2nC17GW5beDv6nFb8+bALXX0XMD9bjc+XzEX5stmxoW+6WJqrxZkej9zNAAD4giE0X/Tg6AU3jl3oR2evDwKApXO0uLPQhKIFmViWy16mmYwBiohmjZAUwrErJ1DT8SZO9JwasWxR7hoU59yK1q45+Pl+EcHQZVy32IDt18/DyrwM9jbJYEmuDh+eu4xQSJryYCJJErr6/NHAdKp7AL6gBFOGEmstmfj06lyssWRwBfBZhH9pIprxfEEf3rMfwr7ON9HVbx+2nEJQ4Lq512GesAH1HRmoOuHDXP0A7l6bi03LuASB3JZEJpK7fFhonPx5UC5PEMcd/Thu78fRC/240h+AWiGgIE+He4rmYK0lE4t5xdysxU8DIpqxnL4+vHXuXbx1fj9EvzhsOY1Cg6KcGxAS1+HDEyoEQxKuXRQepuO+dOnDenUi+dkr3kkJUL5gCC0XPThm78fxC/1o7/FCArAgW4PrFxuwdn4mVuZl8CIBAsAARUQz0DnxPPZ1voX3HIcQCAWGLWdQG7BEdwO6u9figy4l8gxqfGZtNsrZ25SW9Jrw3+jMFS/Klk68vpAk4VyvD8fs4YnfTRcH4A9KMOqUWGPJxB2FJqyxZHD1b0qInxBENCMEQ0HUXz6KNzrfHnGPOgCYozUjO1iKs13LcCykxLpFBjywLhurLextSndLcrVovzL+ieTdoh/H7eFhuZOOAbi8QWiUAgrzMnBv0Rys4bAcjREDFBFNa6JfxLtddXj73H5c9g6/8CUA5GmWY8B5Lbrti6DI0mDrNdnYuDSbl5dPI0tztfjLMTdCkjSmsOscCOCEYwAnrs5luuQOQBCAZbk63LI8G2vMmVg+TweNksNylBx+ahDRtNThOoc3zr2N9x3/gD/kH7acQlAiW1qLK5eLcDmUh9J8A26+3oiCedzMdzpakquDJyDB3ufHAmP8Su9uXxCnHAM4eTU0nXOG1/ZaaNTg2oV6rLaE5zFx+QmaKAYoIpo2AqEgPrpUjzc630Gzs3XEshpBD2mgCJ6+IhhNubj7WiNutBqQoeYX53S2JDcykdyDBUYNBvxBNHV7cNIRHpKLTPyeq1dhlTkTn16dg9WWTM5po5TjO4qI0t6lgct4t+sA9l84iD5f34hlNaH58PQVQwitRPnSXNy8IRuL03zrDxq7yETy6qZevN7sxJkrHoQkICdDhVXmDNxWYMRqcybmGTjxmyYXAxQRpaWQFELj5WN4+3wtjl4+DgnSsGUFKCB5CiG5S1Awz4ZN67NRslAPNee1zEjFCzJxqEPEyrwMlC/Lw2pzBsxZag7J0pRigCKitNLj7cX+rjrs76rDFW/PiGWFkB5BdxHylNfhlmULULY0i0M1s8AD6/PwwPo8uZtBsxw/aYhIdiEphKOXT2D/hTrUX2occW86AJB8C6D2Xoub5q/DzSW53MiXiKYcAxQRyaZ74CJquw6izv4+ery9IxcOaSB5VmOF/gbctsqGdYv0vPSciGTDAEVEU8oX9OHIxXrs76obdcFLAJB8ZuQqrsNti0pRvmwON2slorTATyIimnSSJKHd1YH9Fw7ifcc/MBAYGLl8SA1NYBVK527AXStWYWGC9X6IiOTEAEVEk6bH24v37Ydw0H4I59znRy0vBMxYmrEen7bdhOL5udxWhYjSFgMUEaWUN+jFhxcbUGd/HyeunBpx+QEAQEiHeaoi3LqoDLctXc55TUQ0LTBAEdGEhaQQTvU046D9Axy5+BE8Qe+I5SUJMAhLcf28m/DZFdfDqNNNUUuJiFKDAYqIxkWSJHSK5/C+4zDed/wDPaOs2QQASikbq7Kvxz0rNmGpiev4ENH0xQBFREmx9zvwvuMfOOQ4ggv99lHLC5IG1sxrULFkA663rIRC4BAdEU1/DFBENKrLnis45DiM9x2H0SF2jv4ASYBZuxyfWLwBNy9aB62SV9ER0czCAEVECfV4e3HkYj0OOQ6jxdk2pscYVRZsnH8jbs+/ESatcZJbSEQkHwYoIoq67LmCw90f4cjFj8YcmjIVJlyfdx1uy78Riw2LJrmFRETpgQGKaJbr7r+IwxfDoel039kxPUanMGB93jrcvPAG2LKXch86Ipp1GKCIZhlJknDe3YWPLjXicPdHY5vTBEAj6LBu3rUoX1CKQtMKKBXKSW4pEVH6YoAimgWCoSCana2ov9SIjy424KLn8pgep1HoUDznGtxkuQ5r56yGWqGe5JYSEU0PDFBEM9RAYADHrpzAhxcbcfTyMbgD/WN6nE6RgevySnB93rVYnbuSoYmIKAEGKKIZxNHfjcbLx9B4+ThO9TQjIAXG9Di9yoD1eSVYP+9arMwphIrDc5SmJCmE4MHvQ+p4dyylU/WsKapnrE83xc+Xdsb2+ytW3QfltV+b5LYMjwGKaBrzBX1o6m1B4+XjaLx8DN0DF8f8WJMmB9flFeO6eSUoMC7nnCaaFkJHqyCdfQOKax4CUrVUxpRfBDHLL7pI0est5CxPST3jxQBFNM10D1zE0cvHcfTycZzsaYIv5B/zY/MNi3HtvCKsm1uMxYZFvHqOppXQuVqEjv4ciqKvQHlNpdzNoVmOAYoozbn9bpzsacKJnlM4fuVUUr1MSkGJlTkFuHZuEUrmFmGOLncSW0o0eaS+dgQP/gDConIo1j4od3OIGKCI0o0/5Eer8zROXDmF41dO4qyrA1ISczCy1dkomrMG18xZg7VzViNTlTGJrSWafJLfjcC7/wPImAPlhqcgcD9FSgMMUEQyC4SCaHd14FRvM071NKO5tyWpYTkBAmzGpbgmdw2K5q5FvmERN+ylGUOSJATf+zegvxuqip9BUOvlbhIRAAYooikXCAVwxtWOpp4WnOptRqvzNLxBb1J1ZKkNuGbOGhTNWYM1uatgUBsmqbVE8god/zWkzneh3PQMBKNV7uYQRTFAEU0yb9CHs33taHa24lRPODD5Qr6k6lAr1CgwLceanJVYnbsKiw0L2ctEM16o632EGnZCsbYSisXlcjeHKAYDFFGK9Xh70epsQ6vzNFqdp9Hu6kBQCiVVhwAB1qx8rM5diTU5K7HCaINayQUtafaQXOcQrPt/ISy4EYqiL8vdHKI4DFBEExAIBXBOPI/WvjPR0HTZc2VcdS3Qz8dK0wqszCnEqpxCGDjXg2YpKTCAwP7/AWiNUJb9T04ap7TEAEU0RiEpBEd/N073ncUZVzvO9J1Fh3gOgdDYVvseapF+IQpzVqDQtAKFpuXI1mSnuMVE048kSQi+/78AsQuqzTshaLLkbhJRQgxQRAmEpBAuDVxGu9iJs33tON13Fu2uDgwEPeOqT4CAxYaFKDCtwMqcAhQYlyNLw4nfRBFSKAD0dSB0pgZS+5tQlv8QgmmZ3M0iGhYDFM16/qAf591d6BDPhf+5OtEpnodnnGEJADJUGVievRTLjTYsNy7D0uwlyFDpUthqoulL8vdD6m2D1NMCqacFuNIMyXkaCIYvrlBc8yUo8m+VuZVEI2OAolkjJIVw2XMF590XcN7dhfNiFzrF87jQfyHpSd5DmTPysNy4LPpvgX4+r5KjWU2SJMDbC8l1DnB1Quo7B8nVGQ5MrnMAJEBQAqalEHIKoFi6GULOCgg5yzlsR9MCAxTNOCEphB5vbzgkuS+gSwwHpq5+e9LrLSWSozVhaZYVS7OtWJq9BEuy8qHnhG+ahaRQABi4BMltB0R7OCBFApPrPOAXPy6cMQ9C9iIoFtx4NSitAIxLICg18v0CRBMge4Bqb29He3s7TCYTPJ7wkElpaemk1pOq5yR5iX43HP0O2Pu7Ye93wDHQDXt/Nxz93UmvszQcg9oAa9biq4FpCZZmW5GjNaWkbqJ0JkkS4HeHA1K/A3A7ILntkNwOwG0Ph6b+i4AU/PhBujkQshYBOSugyL8VQtYiCFmLgayFELilEM0wsgao5uZmNDU1YcuWLdFj7e3t2LVrF7Zt2zYp9aTqOWnyBUNB9Hh7cdFzCRcHLuOS5xIuDVxG98AlOAYcEP3ulD5fXsY8WLMWI9+wCIsNi5GftQgmjRGCIKT0eYjkFA5GIuDpgeS5AgxchjRwCei/GP45cAlSf/gnAgODHikAGXMh6C2A3gLF3LWA3gJBb44eE9SZsv1eRFNNtgDl8Xiwb98+PPzwwzHHrVYr9u/fj8bGRhQVFaW0nlQ9J6XGQMCDHm8Pery9uOIJ/7zkuRz+N3AJV7w9E56blEimKgML9QuwQD8fiwwLYTUsxiLDQk7ypmlJkkKATwR8fZC8vYC3Lzz3yNv3cUjy9ACeK5A8PeHbQ/daVGqBzHkQMuYCGXOhyF0ZDksZc4HMuRAy5gGZeRC4mCtRlGwBqrm5GUajETpd/JdWYWEhGhoaxhRmkqknVc9Jw5MkCf2BfvT5XHD6+tDnc6HP1wenrw+9Pid6PL3o8fWix9Mz7iUBxipDqcMC/QIs1M/HQsP8aGhirxKlG0kKhXt7/G7AJ0LyuYCr/4a9fTUoweeKHUaLUGUAuhwIuhxAlwshdyUEnSl8O3Ls6k9osvj/CaIkyRagmpqaEgYZADCZTOju7obH4xm2zHjqSdVzzgaSJMEf8mMg6EG/vx9iwA23v3/QbTfcgX64/f1w+0X0+V1Xw5ILwUQf5pNEKSgwL2MeLJl5MGeYYcnMgyXTDHNmHoMSTZpw4PEAQW84+AQ8kAL9gH8AuPrz4/tuIDAAyd8PRP+JkPzucGDyu8PHICV+MqUW0BjCIUeTDWiyAMMCKOasBLQmQJMdDkaabAhaE6DNBrRGTs4mmmSyBSiHw4HCwsKE54xGIwDA6XSOGmaSqSdVzykHz4AbXc1NkCQJIUkCEP4Z/l8o9pgkIYQQgqEgAlLg6s9g9GcgFEDw6k9fyAd/yA9f0AdfyB/+Fwwfk5IYPtMCmAcF5sE44d9VGpJ51Ao1jBojjNpsmDTZMGqNyNHmIFdrglGTDYVC+XFh39V/vQEEhcuDahES3owxNGwNvSskqkOILRcpIyQ6N+SYQrh6KMFjBh9LcF4QBpWLKSPEHhMwo0OkFAoAoUB4/aCQHwj6wz9DfiDogxQ97g2XCfqAkA9ScPAxT/hnwAsp6L16/Oq/gBcIeiAFrgal4KCfoxGUgDoTUGUC6gwIqszwfbUeyMiFQq0P31brIWgM4XIaw9X7WeGgpDFAUGon/4UkoqTJFqC8Xi+02pE/GJxOJ8xmc8rqSdVzyuFKtx1zd3emoCbl1X/T2cDVf12Y3EHAGSQmbCE2dF1drkqIORf/TxCkQfelj38i/DN8PvIvhPA6P+HbgiABCF09HgKEYMxPAcGrt4MAAh//lPxX7wcgwAdIAQB+QPIB8EJAIPw4IRiuWwhCiNyP1C8E47IxBCWg1Fz9pw3/U2nDYUWpBZS6cLjR5UJQaiGodOFjKh2gygjfV318HyodBGXG1cB09adCPaPDK9FsJ/syBolEQk5kiYGpqGcsZQ8fPowjR46MWpfbndqrw4CZ3YtAU0ACIA0dIpJGuJe4injCkJ9pSikASgUElQJQKcO3lQpApYCgUgJXj0fOC+oh91UKQK2EoFZ+fD7mvhKSWglBCv8HiiAIgBpp/7IQ0filZYBKVz6fD6Iojl5wEnBVa6IJCEpAMAjJFwQQvgJttMCYEoOCl6BWAhoVBI0Kgubqbe2g2xoVoFGGz2vD/6BVR28LWlW4nJKfBUTpIC0DlNcbnl8w0blIydQzlrIajQYGw+gbwLrd7vBaKymkUCjh0gxaHDJmOk7i/8yNHI/0XkXvhw9GjwkQro7uhMdnBCF66+pjh3uGSTCml00a8W588Y8LxBSVhtyI66CREpQd7riUuMyUfEtT2gqEgEAI0oA/dW8FtfLjQKVTQ9BdDVmR2zo1oBt0P0MNIUPz8U/1dB/CJ0oPaRmg0tX69euxfv36Ucvt2LEj5T1V8xYuBp5anNI6aWpJ0qCQFQ1YiY7F35YGlx362AT3pVCCMhKAkBQ+H3Ncunr84/tSKLZ89HFD7iMU/icNuh1/LASEAIRC4cdHj0lAUIIUuR2SgODVMsHwMSkYCvcehULhc8PcRnAWJVV/EJI/CEkc57ZEKsXVYDUoVOk14Z+Zg27rr97PvHpfwfFIosFkC1BGoxFOpzPhucg8pMiVcamqJ1XPSTQe0SvnwveSe2zKWzOzSJJ0dZguEq4G/Yz0AgVDQCAYPh5zLHxcGu6n/+rj/OFjkj8A+ENX7398HP6pW75jQgIhSKI3uQAmIByiDFoI+vA/hUETvS3otRAMWiiytBAMOvZy0awgW4Aym83DTtiOhJyxXA2XTD2pek4iSi+CIAAqITznCPIETikkXQ1cV0OVL3D155BjvvDP2NtB4OoxyRsAvOGfki98W3YSIPX7IPX7ALhGL69TQ2HQQsjSQcjShYNVlg4Kgw6CUQdFdgaEbF14Aj/RNCVbgLJarTh06FDCc729vcjPz095Pal6TiKioQSF8PFk8BSSQtLH4coTCN/2+CF5ApC8/qu3/UDk/oA/HL4Grp4b8E19CPP4EfL4gUsjT2UQ9NqPA5UxA4psHYTsDKiWzoXCyM2HKb3JFqAKCgqwf/9+9Pb2wmQyxZxrbm7Gpk2bYo55PB44HA5YrdZx15PscxIRyU1QCNHJ4sgeXx1SMHQ1VPmAgasha8D38c9+HyS3D6FBt6cieEluLyS3F6GuIVMrFAIytq6DumjRpD4/0UTIFqB0Oh3uvPNO1NbWYsuWLdHjkf3qCgoKYsrv3bsXHR0duOOOO2L2q0umnmSfk4hoJhCUCgiZGiAzue1dpEAwHLJEL6R+LyTRh9DV0CO5w/OoQu7wcUn0hOeTpUJIgueNkwxQlNZkvQqvoKAAWq0W+/fvh8lkis5P2rZtW1xZq9UKh8ORcI5SMvUkU5aIaDYTVEoIWUoga/SlYCRJArwBhFweSC4PJJcXITF8O+TyXj3mQahvAPCNPuFe6ulHqG8AimwO5VF6kn0ZA6vVGjcsl0hpaSlKS0snXE+yZYmIaHSCEB5qVOrUwLysYctFg5ZzAFLfAELOcKiSnAPwHz0fczVjsKMHirUMUJSeZA9QREQ0e8QELXPspK5QnwfB1u7o/WDnFajXLpjqJhKNCfcEICKitKDKz425H+y8IlNLiEbHAEVERGlBuTgn5n6wyxleQ4soDTFAERFRWlAuyoldBTUYQvBC4t0jiOTGAEVERGlB0KmhyIudF8VhPEpXDFBERJQ24obxOhigKD0xQBERUdpQLo6fSC5JkkytIRoeAxQREaUN5ZAr8SSXF5JzQKbWEA2PAYqIiNKGYo4+vO3MIBzGo3TEAEVERGlDEIT4eVCcSE5piAGKiIjSytB5UIHOHplaQjQ8BigiIkorQ3ugQheckHwBmVpDlBgDFBERpRXlwhxAMWhFzZCEYFevbO0hSoQBioiI0oqgVUExZKPhYAeH8Si9MEAREVHa4URySncMUERElHZU+VxQk9IbAxQREaWdoVfiSW4fpJ5+mVpDFI8BioiI0o6QkwnBoI05FuCCmpRGGKCIiCjtcEFNSncMUERElJbiNhZmDxSlEQYoIiJKS0M3Fg45+iB5/TK1higWAxQREaUl5QJT7IKaEhA83ytXc4hiMEAREVFaEtRKKOYbY45xGI/SBQMUERGlrfj1oLgiOaUHBigiIkpbcRPJO69ACnFBTZIfAxQREaWtoRPJpQE/QpdFmVpD9DEGKCIiSlsKYwaEbF3MMa4HRemAAYqIiNJa/HpQnAdF8mOAIiKitDZ0GI89UJQOGKCIiCitDd3SJXTRBWmAC2qSvBigiIgorSnnGwHloK8rCQie4zAeyYsBioiI0pqgUkK50BRzLMBhPJIZAxQREaW9ocN4nAdFcmOAIiKitBe/oGYPF9QkWTFAERFR2ht6JR68AYQuuuRpDBEYoIiIaBpQZOkgmDJijnFjYZITAxQREU0LifbFI5ILAxQREU0LqiHDeIFmB/yN5yAFQzK1iGYzBigiIpoWhl6JJ7l9GNh1BOKP3oC3rhWSh4tr0tRRyd0AIiKisVBYjBCydJBcnpjjknMA3urj8L7dBM11VmhuWgaFKVOmVtJswR4oIiKaFgSlAhmfXw8hZ5hw5A3Ad7AN4o/eQP8f/8HVymlSsQeKiIimDZV1DgzfvA2Bk3b4DrYi2JkgJIUkBI51IXCsC0rrHGjKl0O1wgxBIUx9g2nGYoAiIqJpRVAqoF67AOq1CxDouAJfXSsCJy8ACdbVDLZfxkD7ZSjmZUGz0QZ10SIIKuXUN5pmHAYoIiKatlT5uVDllyJ0xQ3fe6fh+7Ad8AXjyoUuuuD5cz28b5yCZsMyaNYvgaBTy9BimikYoIiIaNpT5Oqh+9Q10H6iEL7D7fC9dzpusjkASC4PvDUn4H2nGZrrl4QnnGdnJKiRaGQMUERENGMIGRpoy1dAc5MN/qPn4KttTbzlizcA34FW+N5rg7p4MTTlK6Cca5j6BtO0xQBFREQzjqBSQHNtPtTFixFoccB3oBXBs5fjCwYl+D/sgP+jDqhWL4B20wooF5imvL00/TBAERHRjCUoBKgLLVAXWhDovALfgWEmnEtA4HgXAse7oFw+D9pNBVAumQNB4JV7lBgDFBERzQqqxblQfbEUwUsifAfb4P+oAwjEbwMTbL2I/taLUC7OgWZTAVQFXAKB4jFAERHRrKKca0DG3cXhCecHT8N36AzgDcSVC3b2YOC3H0CRlwXtpgKo1i6AoOT60xTGdwIREc1KCoMOujtXI+tf7oT29lUQ9JqE5ULdLgzsPgL3T96C70g7Ny8mAOyBIiKiWU7IUEN7cwE0Ny2D/8MOeA+0QnIOxJULXXHD80o9vG83QbtpBdTX5kNQc1HO2YoBioiICICgUUFz4zKor18Cf+M5+GpbELooxpWTnAPw7G0MryW1cTk0660QNPw6nW34FyciIhpEUA5aAuGUHd53mxDqcsaVk1weeF87Bt/+Zmg22KC5YSkELVc3ny0YoIiIiBIQFALUq+dDtcqCYGs3vO80I9hxJa6c5PbB+/pJeA+0QrvBBs2Ny7hNzCzAAEVERDQCQRCgWmGGcnkegmcuwftuM4KnL8UXHPDD++YpeOvawkHqJgapmYwBioiIaAwEQYBq2Tyols1DoOMKfO80IdDSHV/Q44f3rVPwHmz7uEcqg0FqpmGAIiIiSpIqPxeqB29C8HwvvO82IXDSHl8oGqRaob3JBs1NNgapGYQBioiIaJyUC03IvO8GBO1OeN9uQuDEhfhCngC8bzfB+14bNDfZoGWQmhEYoIiIiCZIaTEi84ul4SD1TjMCx7viC3kC8L3dBN97p6EtuzpHilftTVsMUERERCmitBiR+YXrEbT3wftO0zBBKjzZ3Pfe6fA6Ujcs5TpS0xD/YkRERCmmtGSHg5RjUJCSYstI/T54952Ar64Nmk0roLl+CVc2n0YYoIiIiCaJ0pyNzM9fDVJvJ+6Rktze8IKcB1qhvXkF1NdZIagYpNIdAxQREdEkU5qv9khdcML71ikETsVftSe5PPD89Si8ta3Q3lIQ3mtPqZChtTQW/MsQERFNEeV8IzL/+Qbov3ozVAXmhGUk5wA8f2mA+z/egr/xHKSQlLAcyYsBioiIaIopF5qQ+cCNyPxKOZS2eQnLhC67MbDrCNwvvgN/kx2SxCCVTjiER0REJBNVfi5UlRsQOHMJ3rdOIXj2clyZkKMPA7/5AMrFOdDesRqqpXNlaCkNxR4oIiIimamWzkXmQ2XI3H4TFAtNCcsEO3vQ/4s6uKsOIniuZ2obSHHYA0VERJQGBEGAanke9LZ5CJy0w/vmSYS6XXHlgm0X4W67CNWq+dDesQrKeVkytJYYoIiIiNKIIAhQr54P1UoL/I3n4H3rFKSe/rhygZMXEDh1Aep1+dDeuhIKY4YMrZ29GKCIiIjSkKAQoClZDPXahfB/2A7vO02QXN7YQhLgP9IBf8M5aG5cBm35CgiZGnkaPMswQBEREaUxQaWApnQp1Nfmw/fBGfhqWyD1+2ILBULwHWiF73A7tOUrwvvscVXzScVJ5ERERNOAoFZCu3E5DN++HZqbC4BEAcnjh/f1ExB/9AZ8h89CCoamvqGzBAMUERHRNCLo1NDdvgqGb98OdekSQCHElZFcnvBinM+/Df/JC1xDahIwQBEREU1DiiwdMrYUQ/+NT0C1dkHCMqFLIgZ+dwj9P69DoPPKFLdwZmOAIiIimsaUcwzI/Pz10H/15mFXNQ+2X0b/zlr0//EfCF1xT3ELZyZOIiciIpoBlAtN0FduQKC1G57XTyDU5YwrEzjWBfHkBWhKl0JzcwEUeq0MLZ0ZGKCIiIhmENXyPOiXzUPg6Hl43jgBqXcgtkBQgu+90/B91AFteQGv2BsnBigiIqIZRlAIUBcvgmrNfPg+OAPvO82Axx9byBOA9/UT8B06A+3tq6AuWgQhwYR0SoxzoIiIiGYoQaWEtmw5sr59OzRlywFl/Ne+5ByAZ8+HcO/cj0CCzYwpMQYoIiKiGU7I1EBXsQaGb94GddGihGVC53vR//MD6P/9IU40HwMGKCIiollCkZOJjG3Xha/YWzY3YZnAiQsQf/ImPK8dgzTgS1iGZJwD1d7ejvb2dphMJng8HgBAaWnppNfj8XhQW1sLrVaLTZs2ja/xRERE05hyoQmZlRsQaHbAW30coUtibIGgBN/BNvg/6oDm1kJoSpdCSDD8N5vJEqCam5vR1NSELVu2RI+1t7dj165d2LZt26TUs3//fjidTpjNZrS3t8NqtU78FyEiIpqmBEGAutAC1fI8+A+fhfetprg99qQBP7x/Pwb/B2egrVgLVaEZgsCJ5oAMQ3gejwf79u3DHXfcEXPcarXC4/GgsbFxUurZtGkTtmzZgtLSUmi1XPeCiIgIAASlApoblsHwrduh2Zh4onnoshsDv/0A/S+9h6CjT4ZWpp8pD1DNzc0wGo3Q6XRx5woLC9HQ0DCl9RAREREgZKih27wGhm98Aqo1ibeGCbZdhPvFdzDw10aE+mf3/KgpD1BNTU0JQw8AmEwmdHd3R+cyTUU9RERE9DFFrh6ZX7gemQ9vhGKRKb5ASIL/gzMQ//0NeN9rgxQMTXkb08GUByiHwwGTyZTwnNFoBAA4nfHLz09WPURERBRPZZ0D/Vc2IePedRCyE3RYXJ0f5X7hbQRaHFPfQJlNeYDyer2jzkEaS/BJVT1ERESUWHhF88UwfPM2aG4pBFQJ5kddFNH/q/fR/+v3EbzokqGV8kirrVwigWiiQ2+pqmeow4cP48iRI6OWc7u5ABkREc0cgkYF3W0robkuH559JxA4ej6uTKDZgUBrNzQ32aC9pQCCTi1DS6dOWgWodOfz+SCK4ugFiYiIZiCFKROZn1uPwA1L4fn7UYS6hoz0hCT46lrhb+iE9s7VUBcvnrH766VVgPJ6vQAw7OTwqa5nKI1GA4PBMGo5t9sNSZJS+txERETpQmWdA/2jN8Nf3wnv6ycgid6Y85Loheflj+A/dBa6T10D5aIcmVo6ecYcoHbt2oWOjo5xPcnjjz+e8jAjh/Xr12P9+vWjltuxYwd7qoiIaEYTFAI06/KhXjMf3ndb4DvYBgy5Ii94rgfuHfuhXpcP7R2roDBM/ywQMeYAlcwK4SMxGo3DTu6OzFmKXEU3FfUQERHR+AlaNXR3rob6unx4XzuGQFP8FXn+DzvgP94F7SdWQnPDzNgWZsp/A7PZPOzk7kggMpvNU1YPERERTZxyjgGZ99+IjAduhGKOPr6ANwDva1eXPTh9ceobmGJTHqCsVuuwPUe9vb3Iz8+f0nqIiIgoddQFZuifuBXaO1cDGmXc+dBFEf2/PIj+Px1GqG9AhhamxpQHqIKCAng8HvT29sada25uRnFxccwxj8eD9vb2CddDREREU0NQKaEtXwHDN2+DunhRwjKBo+ch/vhNeA+0TsvVzKc8QOl0Otx5552ora2NOR7Z266goCDm+N69e7F79+64zYGTrWcwr9fLbV6IiIgmmSI7Axn3XofMr5RDsSDBvGRfEN6a49NyWE+WZQwKCgqg1Wqxf/9+mEymaJhJNFHdarXC4XAknM+UTD2HDh2Cw+FAb28vnE4nnE4ndu3aBZ1Oh8LCwhEDFxEREY2fKj83vOzB4bPwvHESGPDHnI8M66nWLoTurjVQZGfI1NKxk20dKKvVCqvVOmq50tJSlJaWpqQeIiIikoegEKApXQrVmgXwvn4C/iPxSyMFjp2H2GyH9tZCaG6ypfXVeunbMiIiIppxFHotMj57LTIfGWlY7wTcL76DwNlLU9/AMWKAIiIioimnWhwe1tNtKQIy4vfNC3W70P/zOgy8/CFCbm+CGuSVVlu5EBER0ewRM6z3xkn4j7QDQ3ZC83/UCf8pO3R3rIb6Omva7K3HHigiIiKSlUKvRcZnSsJX681PMKw34Ifn1Qb0/1ctgl29U96+RBigiIiIKC2Eh/U2QfvJtYA2fpAseK4H7p++C8/fjkLy+BPUMHUYoIiIiChtCEoFtDfZYPjmbVBdszC+gAT43j8N8Sdvwn/0PCRJii8zBRigiIiIKO0osnTI/Nx6ZFbelHBvPcnlxcCfDsNX2yJD6xigiIiIKI2pbHnhvfU+sRJQDYktWhXU18qz9y0DFBEREaU1QaWE9tZCGL7+CahW5EWP625fBUWWTpY2cRkDIiIimhYUuXpkPHAjAicuwF/fCXXpUtnawgBFRERE04YgCFCvWQD1mgWytoNDeERERERJYoAiIiIiShIDFBEREVGSGKCIiIiIksQARURERJQkBigiIiKiJDFAERERESWJAYqIiIgoSQxQREREREligCIiIiJKEgMUERERUZIYoIiIiIiSxM2EJ0F/fz8AwO12Y8eOHTK3hoiIiMbC7XYD+Ph7fCQMUJNAkqToT1EUZW4NERERJSPyPT4SBqhJoFQqEQwGIQgCMjMzU1q32+2GJEkQBAF6vT6lddPsxfcVTRa+t2gyTNb7qr+/H5IkQalUjlpWkMYSsyht7NixA6IowmAw4NFHH5W7OTRD8H1Fk4XvLZoM6fC+4iRyIiIioiQxQBEREREliQGKiIiIKEkMUERERERJYoAiIiIiShIDFBEREVGSGKCIiIiIksQARURERJQkrkQ+zVx33XXw+XzQaDRyN4VmEL6vaLLwvUWTIR3eV1yJnIiIiChJHMIjIiIiShIDFBEREVGSGKCIiIiIksQARURERJQkXoWXBtrb29He3g6TyQSPxwMAKC0tla0emhlS8X7Yu3cvdDodioqKYDab4fF44HA40NjYiNLSUpjN5sloOqUxj8eD2tpaaLVabNq0aVx18LOKhpro+0qOzyoGKJk1NzejqakJW7ZsiR5rb2/Hrl27sG3btimvh2aGVL0fPB4Pmpub0djYGD2m1WqxZcsWhqdZZv/+/XA6nTCbzWhvb4fVah1XPfysosFS9b6S47OKAUpGHo8H+/btw8MPPxxz3Gq1Yv/+/WhsbERRUdGU1UMzQyrfD2azGaWlpXA4HAAAk8mEgoKClLeZ0t/gXoGmpqZx1cHPKhoqFe8rQJ7PKgYoGTU3N8NoNEKn08WdKywsRENDw5g+TFJVD80MqX4/WK3Wcf9XIdFg/KyiyTTVn1WcRC6jpqamhB8kQDg9d3d3R+cHTEU9NDPw/UDpiu9NmkkYoGTkcDhgMpkSnjMajQAAp9M5ZfXQzMD3A6UrvjdpJuEQnoy8Xi+0Wu2IZSKT66aiHpoZUv1+6O3tRUdHR8z90tLSYXsSiIbDzyqaTFP9WcUAlaYiHzIT7c5OVT00MyT7fnA6neju7o6Zl+JwOPCb3/wG999/P0MUpQw/q2gi5Pis4hAeEQ1ry5YtcVeymM1mmM1mvP766zK1iogolhyfVQxQacrr9QLAhFNzquqhmSFV7wer1Yrm5uZUNIkIAD+raHJM5mcVAxQRJS3yJRdZc4WIKB1N5mcVA5SMjEbjsFecROYBRK5MmYp6aGZI1fvh9ddfx/79+xOe43wVGg9+VtFkkOuzigFKRpH9ehKJfMiM5WqUVNVDM0Oq3g9NTU3DftnxfUXjwc8qmgxyfVYxQMnIarUO+0fv7e1Ffn7+lNZDM0Oq3g9FRUUx+5UN1t7ePuyK0kTD4WcVTQa5PqsYoGRUUFAAj8eD3t7euHPNzc0oLi6OOebxeNDe3j7hemhmS9X7ymKxJJw3ENm0czw7ptPswM8qmgzp9lnFACUjnU6HO++8E7W1tTHHI/tFDb0kc+/evdi9e3fMbtPjqYdmtlS9rwoKCtDY2Bj3wbRr1y4UFRXxfTWLeb3eEeeU8LOKxmO87yu5PqsESZKkSamZxqy9vR3t7e0wmUzRN09paWlcuUOHDuHQoUPYtm1bwvHcsdZDs0Oq3leHDh2Cx+OJfrgVFhbyi24WOnToEBwOB3p7e9Hd3Q0AyM/Ph06ni3tP8LOKxiqV76up/qxigCIiIiJKEofwiIiIiJLEAEVERESUJAYoIiIioiQxQBEREREliQGKiIiIKEkMUERERERJYoAiIiIiShIDFBEREVGSGKCIiIiIksQARURERJQkBigiIiKiJDFAERERESWJAYqIiIgoSf8/jHG2ZVBHfcUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "eps_0" + "figure, axis = plt.subplots(1, 1)\n", + "\n", + "_el_energy = (elastic_energy(_u)*sp.symbols('Ly')).subs(_matpar)\n", + "_f_el = sp.lambdify(t, _el_energy, 'numpy')\n", + "_el_0 = [_f_el(t) for t in data['load']]\n", + "\n", + "axis.plot(data['load'], data['elastic_energy'], lw = \"1\", label = \"Elastic\")\n", + "axis.plot(data['load'], data['fracture_energy'], lw = \"1\", label = \"Fracture\")\n", + "axis.plot(data['load'], _el_0,\n", + " label = \"Elastic Sound\", lw=3)\n", + "axis.plot(data['load'], data['fracture_energy'] + data['elastic_energy'] - _el_0,\n", + " label = \"Total Energy - Elastic Sound\", lw=3)\n", + "\n", + "\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Energy vs. Load')" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure, axis = plt.subplots(1, 1)\n", + "\n", + "_el_energy = (elastic_energy(_u)*sp.symbols('Ly')).subs(_matpar)\n", + "_f_el = sp.lambdify(t, _el_energy, 'numpy')\n", + "\n", + "\n", + "axis.plot(data['load'], data['elastic_energy'])\n", + "axis.plot(data['load'], data['fracture_energy'])\n", + "axis.plot(data['load'], [_f_el(t) for t in data['load']] )\n", + "\n", + "axis.set_xlabel('$t$')\n", + "axis.set_ylabel('$E$')\n", + "\n", + "# Set title for the plot\n", + "axis.set_title('Energy vs. Load')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pp.plot_operator_spectrum(data, params)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "experiment = '../../playground/benchmark-umut-at2/output/thinfilm-bar/MPI-1/0c399a5dac634681c7325af864a4faa0'\n", + "params, data, signature = pp.load_data(experiment)\n", + "pp.plot_operator_spectrum(data, params)\n" ] }, { @@ -1682,7 +1828,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.11.6" }, "orig_nbformat": 4 }, diff --git a/playground/nb/postprocess.py b/playground/nb/postprocess.py index 74f36640..ed0cc788 100644 --- a/playground/nb/postprocess.py +++ b/playground/nb/postprocess.py @@ -132,9 +132,9 @@ def plot_fills(ax, ell, tc): def plot_spectrum(params, data, tc, ax=None, tol=1e-12): - E0 = params['material']['E'] - w1 = params['material']['sigma_D0']**2 / E0 - ell = params['material']['ell'] + E0 = params['model']['E'] + w1 = params['model']['sigma_D0']**2 / E0 + ell = params['model']['ell'] fig = plt.figure() for i, d in enumerate(data['eigs']): if d is not (None and np.inf and np.nan): From 0d72836007a8d31b0db3fbd34264907b874039aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20A=20Le=C3=B3n=20Baldelli?= Date: Thu, 11 Apr 2024 13:26:57 +0200 Subject: [PATCH 7/8] extension bug fixed PLC online --- .../benchmark-umut-at2/vs_analytics_at2.py | 8 +-- src/irrevolutions/algorithms/so.py | 53 ++++++++++++++----- src/irrevolutions/test/test_1d.py | 4 +- 3 files changed, 46 insertions(+), 19 deletions(-) diff --git a/playground/benchmark-umut-at2/vs_analytics_at2.py b/playground/benchmark-umut-at2/vs_analytics_at2.py index 268fa942..f972b78a 100644 --- a/playground/benchmark-umut-at2/vs_analytics_at2.py +++ b/playground/benchmark-umut-at2/vs_analytics_at2.py @@ -399,8 +399,8 @@ def load_parameters(file_path, ndofs, model="at2"): if model == "at2": parameters["loading"]["min"] = 0.0 - parameters["loading"]["max"] = 1.0 - parameters["loading"]["steps"] = 10 + parameters["loading"]["max"] = 3.0 + parameters["loading"]["steps"] = 30 parameters["geometry"]["geom_type"] = "1d-bar" parameters["geometry"]["mesh_size_factor"] = 4 @@ -409,9 +409,9 @@ def load_parameters(file_path, ndofs, model="at2"): parameters["stability"]["cone"]["cone_max_it"] = 400000 parameters["stability"]["cone"]["cone_atol"] = 1e-6 parameters["stability"]["cone"]["cone_rtol"] = 1e-6 - parameters["stability"]["cone"]["scaling"] = 1e-2 + parameters["stability"]["cone"]["scaling"] = 1e-4 - parameters["model"]["w1"] = 10000 + parameters["model"]["w1"] = 1 parameters["model"]["ell"] = (0.158114)**2 / 2 parameters["model"]["k_res"] = 0.0 parameters["model"]["mu"] = 1 diff --git a/src/irrevolutions/algorithms/so.py b/src/irrevolutions/algorithms/so.py index 640c0313..3d0f9864 100644 --- a/src/irrevolutions/algorithms/so.py +++ b/src/irrevolutions/algorithms/so.py @@ -745,7 +745,7 @@ def solve(self, alpha_old: dolfinx.fem.function.Function, eig0=None, inertia=Non self.eigen = eigen _Ar = constraints.restrict_matrix(eigen.A) _xk = constraints.restrict_vector(_x) - _y = constraints.restrict_vector(_y) + _yr = constraints.restrict_vector(_y) self._Axr = constraints.restrict_vector(_Ax) self._xoldr = constraints.restrict_vector(self._xold) @@ -754,12 +754,15 @@ def solve(self, alpha_old: dolfinx.fem.function.Function, eig0=None, inertia=Non self._residual_norm = 1.0 self.Ar_matrix = _Ar.copy() - _y, _xk, _lmbda_k = self.convergence_loop(errors, _Ar, _xk) + _yr, _xk, _lmbda_k = self.convergence_loop(errors, _Ar, _xk) # process eigenmode - # ... normalise ... + # ... extend ... + self._extend_vector(_yr, _y) + self._extend_vector(_xk, _x) + y = self.normalise_eigenmode(_y, mode="functional") - xk = self.normalise_eigenmode(_xk, mode="functional") + xk = self.normalise_eigenmode(_x, mode="functional") # store self.store_results(_lmbda_k, xk, y) @@ -768,6 +771,23 @@ def solve(self, alpha_old: dolfinx.fem.function.Function, eig0=None, inertia=Non return stable def convergence_loop(self, errors, _Ar, _xk): + """ + Perform a convergence loop to iteratively solve the variational inequality problem. + + This method iteratively updates the solution `_xk` until convergence is achieved + based on the given convergence criteria `errors`. + + Parameters: + - errors (list): List of error tolerances for convergence criteria. + - _Ar (petsc4py.PETSc.Mat): Precomputed product of the system matrix `A` and the current solution `_xk`. + - _xk (petsc4py.PETSc.Vec): Current solution vector. + + Returns: + - _y (petsc4py.PETSc.Vec): Final solution vector. + - _xk (petsc4py.PETSc.Vec): Updated solution vector after convergence. + - _lmbda_k (float): Updated Lagrange multiplier corresponding to the final solution. + """ + _s = float(self.parameters.get("cone").get("scaling")) while self.iterate(_xk, errors): @@ -777,10 +797,19 @@ def convergence_loop(self, errors, _Ar, _xk): return _y, _xk, _lmbda_k def update_lambda_and_y(self, xk, Ar): - # Update λ_t and y computing: - # λ_k = / - # y_k = A x_k - λ_k x_k + """ + Update the eigenvalue and solution vector based on the current solution `xk` and the product `Ar`. + λ_k = / + y_k = A x_k - λ_k x_k + + Parameters: + - xk (petsc4py.PETSc.Vec): Current solution vector. + - Ar (petsc4py.PETSc.Mat): Precomputed product of the system matrix and the current solution. + Returns: + - _lmbda_t (float): Updated eigenvalue. + - y (petsc4py.PETSc.Vec): Updated solution vector. + """ _Axr = xk.copy() y = xk.copy() @@ -861,14 +890,13 @@ def initialize_restricted_vectors(self, constraints): def finalise_eigenmode(self, xt, yt, lmbda_t): # Extract, extend, and finalize the converged eigenmode self._xk = xt - self._extend_vector(xt, self._v) (v, β) = ( Function(self.V_u, name="Displacement_perturbation"), Function(self.V_alpha, name="Damage_perturbation"), ) - vec_to_functions(self._v, [v, β]) + vec_to_functions(xt, [v, β]) self.perturbation = {"v": v, "β": β, "λ": lmbda_t} self._y = create_vector_block(self.F) @@ -878,8 +906,7 @@ def finalise_eigenmode(self, xt, yt, lmbda_t): Function(self.V_alpha, name="Damage_residual"), ) - self._extend_vector(yt, self._y) - vec_to_functions(self._y, [w, ζ]) + vec_to_functions(yt, [w, ζ]) self.residual = {"w": w, "ζ": ζ} return self.perturbation @@ -1077,8 +1104,8 @@ def _cone_project_restricted(self, v): # _logger.info(f"Cone Project: Local data of the subvector x_alpha: {x_alpha}") x = self.constraints.restrict_vector(_x) - - _x.copy(result=x) + # __import__('pdb').set_trace() + # _x.copy(result=x) _x.destroy() return x diff --git a/src/irrevolutions/test/test_1d.py b/src/irrevolutions/test/test_1d.py index b70aee53..ecc0c6ee 100644 --- a/src/irrevolutions/test/test_1d.py +++ b/src/irrevolutions/test/test_1d.py @@ -696,7 +696,6 @@ def load_parameters(file_path, ndofs, model="at1"): return parameters, signature -# if __name__ == "__main__": def test_1d(): import argparse @@ -744,4 +743,5 @@ def test_1d(): np.testing.assert_array_equal(_stability, np.array([True, True, True, False, False])) np.testing.assert_array_equal(_uniqueness, np.array([True, True, True, False, False])) - \ No newline at end of file +if __name__ == "__main__": + test_1d() \ No newline at end of file From a6a6401b9002e77d55f2116b71f21ec3d340c024 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20A=20Le=C3=B3n=20Baldelli?= Date: Thu, 11 Apr 2024 14:05:53 +0200 Subject: [PATCH 8/8] benchmarking at2 with umut's solution --- playground/benchmark-umut-at2/vs_analytics_at2.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/playground/benchmark-umut-at2/vs_analytics_at2.py b/playground/benchmark-umut-at2/vs_analytics_at2.py index f972b78a..22820452 100644 --- a/playground/benchmark-umut-at2/vs_analytics_at2.py +++ b/playground/benchmark-umut-at2/vs_analytics_at2.py @@ -94,7 +94,7 @@ def damage_energy_density(state): # Compute the damage dissipation density damage_density = _w1 * w(alpha) + \ - _w1 * _ell**2 * ufl.dot(grad_alpha, grad_alpha) + _w1 * _ell**2 / 2. * ufl.dot(grad_alpha, grad_alpha) return damage_density @@ -194,10 +194,10 @@ def run_computation(parameters, storage=None): addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD ) - # bcs_u = [dirichletbc(u_zero, dofs_u_right), - # dirichletbc(u_zero, dofs_u_left)] + bcs_u = [dirichletbc(u_zero, dofs_u_right), + dirichletbc(u_zero, dofs_u_left)] - bcs_u = [] + # bcs_u = [] bcs_alpha = [] bcs = {"bcs_u": bcs_u, "bcs_alpha": bcs_alpha} @@ -409,10 +409,11 @@ def load_parameters(file_path, ndofs, model="at2"): parameters["stability"]["cone"]["cone_max_it"] = 400000 parameters["stability"]["cone"]["cone_atol"] = 1e-6 parameters["stability"]["cone"]["cone_rtol"] = 1e-6 - parameters["stability"]["cone"]["scaling"] = 1e-4 + parameters["stability"]["cone"]["scaling"] = 1e-3 parameters["model"]["w1"] = 1 - parameters["model"]["ell"] = (0.158114)**2 / 2 + # parameters["model"]["ell"] = (0.158114)**2 / 2 + parameters["model"]["ell"] = 0.158114 parameters["model"]["k_res"] = 0.0 parameters["model"]["mu"] = 1 parameters["model"]["kappa"] = (.34)**(-2)