From dfee63a6dd1961d9cd0b38a50f32c756f50f787a Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Mon, 15 Jan 2024 16:25:04 +0530 Subject: [PATCH 01/26] define a `lazy_import` function --- pybamm/util.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/pybamm/util.py b/pybamm/util.py index 8f76566171..abb4862f19 100644 --- a/pybamm/util.py +++ b/pybamm/util.py @@ -368,3 +368,33 @@ def have_optional_dependency(module_name, attribute=None): except ModuleNotFoundError: # Raise an ModuleNotFoundError if the module or attribute is not available raise ModuleNotFoundError(err_msg) + + +def lazy_import(name): + """ + Lazily import a module. + + This function finds the module specification, creates a LazyLoader for the + loader, creates a module from the specification, updates the sys.modules + dictionary, and finally, executes the module. + + Parameters: + - name (str): The name of the module to import. + + Returns: + - module: The lazily imported module. + """ + # Find the module specification + spec = importlib.util.find_spec(name) + loader = importlib.util.LazyLoader(spec.loader) + spec.loader = loader + + # Create a module from the specification + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + + # Execute the module + loader.exec_module(module) + + # Return the lazily imported module + return module From c9ae592862e52c2cecca98015caf465ba3848c57 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Tue, 16 Jan 2024 15:50:21 +0530 Subject: [PATCH 02/26] Modify `lazy_import` to have attribute --- pybamm/util.py | 48 +++++++++++++++++++++++++++++++++--------------- 1 file changed, 33 insertions(+), 15 deletions(-) diff --git a/pybamm/util.py b/pybamm/util.py index abb4862f19..dd5c1ab53e 100644 --- a/pybamm/util.py +++ b/pybamm/util.py @@ -370,31 +370,49 @@ def have_optional_dependency(module_name, attribute=None): raise ModuleNotFoundError(err_msg) -def lazy_import(name): +def lazy_import(name, attribute=None): """ - Lazily import a module. + Lazily import a module or attribute. This function finds the module specification, creates a LazyLoader for the loader, creates a module from the specification, updates the sys.modules - dictionary, and finally, executes the module. + dictionary, and finally, executes the module. If an attribute is specified, + it checks if it's available. Parameters: - name (str): The name of the module to import. + - attribute (str, optional): The name of the attribute to import. Returns: - - module: The lazily imported module. + - module or attribute: The lazily imported module or attribute. """ - # Find the module specification - spec = importlib.util.find_spec(name) - loader = importlib.util.LazyLoader(spec.loader) - spec.loader = loader + try: + # Try to find the module specification + spec = importlib.util.find_spec(name) + loader = importlib.util.LazyLoader(spec.loader) + spec.loader = loader - # Create a module from the specification - module = importlib.util.module_from_spec(spec) - sys.modules[name] = module + # Create a module from the specification + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module - # Execute the module - loader.exec_module(module) + # Execute the module + loader.exec_module(module) - # Return the lazily imported module - return module + if attribute: + # If an attribute is specified, check if it's available + if hasattr(module, attribute): + imported_attribute = getattr(module, attribute) + return imported_attribute # Return the imported attribute + else: + # Raise an AttributeError if the attribute is not available + raise AttributeError( + f"Attribute '{attribute}' not found in module '{name}'" + ) + else: + # Return the entire module if no attribute is specified + return module + + except ModuleNotFoundError: + # If the module is not available, raise an exception + raise ModuleNotFoundError(f"Module '{name}' not found.") From 40d1994d21f05457523ae70d5c729c097a712873 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Tue, 16 Jan 2024 15:54:58 +0530 Subject: [PATCH 03/26] Implement lazy import to idaklu solver --- pybamm/__init__.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 00c596314a..1bb94742af 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -13,6 +13,7 @@ # Version info # from pybamm.version import __version__ +from pybamm.util import lazy_import # # Constants @@ -221,7 +222,8 @@ from .solvers.jax_solver import JaxSolver from .solvers.jax_bdf_solver import jax_bdf_integrate -from .solvers.idaklu_solver import IDAKLUSolver, have_idaklu +IDAKLUSolver = lazy_import("pybamm.solvers.idaklu_solver","IDAKLUSolver") +have_idaklu = lazy_import("pybamm.solvers.idaklu_solver", "have_idaklu") # # Experiments From 2e4bdad092d9a8b8e810b06fbd49b07b6079e352 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Tue, 16 Jan 2024 16:03:01 +0530 Subject: [PATCH 04/26] Add handling for `*` --- pybamm/util.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/pybamm/util.py b/pybamm/util.py index dd5c1ab53e..6dd60c05a0 100644 --- a/pybamm/util.py +++ b/pybamm/util.py @@ -377,11 +377,13 @@ def lazy_import(name, attribute=None): This function finds the module specification, creates a LazyLoader for the loader, creates a module from the specification, updates the sys.modules dictionary, and finally, executes the module. If an attribute is specified, - it checks if it's available. + it checks if it's available. If attribute is set to '*', it imports all + attributes using wildcard. Parameters: - name (str): The name of the module to import. - attribute (str, optional): The name of the attribute to import. + If set to '*', all attributes will be imported. Returns: - module or attribute: The lazily imported module or attribute. @@ -400,8 +402,11 @@ def lazy_import(name, attribute=None): loader.exec_module(module) if attribute: - # If an attribute is specified, check if it's available - if hasattr(module, attribute): + if attribute == "*": + # If attribute is set to '*', import all attributes using wildcard + return module + elif hasattr(module, attribute): + # If a specific attribute is specified, check if it's available imported_attribute = getattr(module, attribute) return imported_attribute # Return the imported attribute else: From c7108fc18b595fe9f16faea460ab33371f369571 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Wed, 17 Jan 2024 20:59:54 +0530 Subject: [PATCH 05/26] Start reolving `.util` imports --- pybamm/__init__.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 1bb94742af..2239544b27 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -37,7 +37,10 @@ # # Utility classes and methods # -from .util import Timer, TimerTime, FuzzyDict +Timer = lazy_import("pybamm.util", "Timer") +TimerTime = lazy_import("pybamm.util", "TimerTime") +FuzzyDict = lazy_import("pybamm.util", "FuzzyDict") + from .util import ( root_dir, rmse, From 26a78d5658286f1adc5dd4160af2d567bbbc6b7f Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Wed, 17 Jan 2024 21:07:42 +0530 Subject: [PATCH 06/26] Resolve `.util` imports lazily --- pybamm/__init__.py | 26 ++++++++++++-------------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 2239544b27..66ebda2174 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -41,20 +41,18 @@ TimerTime = lazy_import("pybamm.util", "TimerTime") FuzzyDict = lazy_import("pybamm.util", "FuzzyDict") -from .util import ( - root_dir, - rmse, - load, - is_constant_and_can_evaluate, -) -from .util import ( - get_parameters_filepath, - have_jax, - install_jax, - have_optional_dependency, - is_jax_compatible, - get_git_commit_info, -) +root_dir = lazy_import("pybamm.util", "root_dir") +rmse = lazy_import("pybamm.util", "rmse") +load = lazy_import("pybamm.util", "load") +is_constant_and_can_evaluate = lazy_import("pybamm.util", "is_constant_and_can_evaluate") + +get_parameters_filepath = lazy_import("pybamm.util", "get_parameters_filepath") +have_jax = lazy_import("pybamm.util", "have_jax") +install_jax = lazy_import("pybamm.util", "install_jax") +have_optional_dependency = lazy_import("pybamm.util", "have_optional_dependency") +is_jax_compatible = lazy_import("pybamm.util", "is_jax_compatible") +get_git_commit_info = lazy_import("pybamm.util", "get_git_commit_info") + from .logger import logger, set_logging_level, get_new_logger from .settings import settings from .citations import Citations, citations, print_citations From 258bf3ff46a4a096f61245b8b2690943c511eeb4 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Thu, 18 Jan 2024 12:53:46 +0530 Subject: [PATCH 07/26] Resolve `.logger`, `.settings` & `.citations` imports lazily --- pybamm/__init__.py | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 66ebda2174..8ce72d83d2 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -53,9 +53,15 @@ is_jax_compatible = lazy_import("pybamm.util", "is_jax_compatible") get_git_commit_info = lazy_import("pybamm.util", "get_git_commit_info") -from .logger import logger, set_logging_level, get_new_logger -from .settings import settings -from .citations import Citations, citations, print_citations +logger = lazy_import("pybamm.logger", "logger") +set_logging_level = lazy_import("pybamm.logger", "set_logging_level") +get_new_logger = lazy_import("pybamm.logger", "get_new_logger") + +settings = lazy_import("pybamm.settings","settings") + +Citations = lazy_import("pybamm.citations", "Citations") +citations = lazy_import("pybamm.citations", "citations") +print_citations = lazy_import("pybamm.citations", "print_citations") # # Classes for the Expression Tree From 948381b31b22dd9b2fc4e27a44a3780216e7709d Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Thu, 18 Jan 2024 19:12:02 +0530 Subject: [PATCH 08/26] Resolve `.expression_tree` imports lazily --- pybamm/__init__.py | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 8ce72d83d2..5560c93b34 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -69,22 +69,27 @@ from .expression_tree.symbol import * from .expression_tree.binary_operators import * from .expression_tree.concatenations import * -from .expression_tree.array import Array, linspace, meshgrid -from .expression_tree.matrix import Matrix +Array = lazy_import("pybamm.expression_tree.array", "Array") +linspace = lazy_import("pybamm.expression_tree.array", "linspace") +meshgrid = lazy_import("pybamm.expression_tree.array", "meshgrid") +Matrix = lazy_import("pybamm.expression_tree.matrix", "Matrix") from .expression_tree.unary_operators import * from .expression_tree.averages import * -from .expression_tree.averages import _BaseAverage +_BaseAverage = lazy_import("pybamm.expression_tree.averages", "_BaseAverage") from .expression_tree.broadcasts import * from .expression_tree.functions import * -from .expression_tree.interpolant import Interpolant -from .expression_tree.input_parameter import InputParameter -from .expression_tree.parameter import Parameter, FunctionParameter -from .expression_tree.scalar import Scalar +Interpolant = lazy_import("pybamm.expression_tree.interpolant", "Interpolant") +InputParameter = lazy_import("pybamm.expression_tree.input_parameter", "InputParameter") +Parameter = lazy_import("pybamm.expression_tree.parameter", "Parameter") +FunctionParameter = lazy_import("pybamm.expression_tree.parameter", "FunctionParameter") +Scalar = lazy_import("pybamm.expression_tree.scalar", "Scalar") from .expression_tree.variable import * from .expression_tree.independent_variable import * from .expression_tree.independent_variable import t -from .expression_tree.vector import Vector -from .expression_tree.state_vector import StateVectorBase, StateVector, StateVectorDot +Vector = lazy_import("pybamm.expression_tree.vector", "Vector") +StateVectorBase = lazy_import("pybamm.expression_tree.state_vector", "StateVectorBase") +StateVector = lazy_import("pybamm.expression_tree.state_vector", "StateVector") +StateVectorDot = lazy_import("pybamm.expression_tree.state_vector", "StateVectorDot") from .expression_tree.exceptions import * From 05bf354bb21ff4da9cef47a51299f11a7a31f0bd Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Thu, 18 Jan 2024 19:17:35 +0530 Subject: [PATCH 09/26] Resolve remaining operational `.expression_tree` imports lazily --- pybamm/__init__.py | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 5560c93b34..ca9ecd3905 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -94,19 +94,16 @@ from .expression_tree.exceptions import * # Operations -from .expression_tree.operations.evaluate_python import ( - find_symbols, - id_to_python_variable, - to_python, - EvaluatorPython, -) - -from .expression_tree.operations.evaluate_python import EvaluatorJax -from .expression_tree.operations.evaluate_python import JaxCooMatrix - -from .expression_tree.operations.jacobian import Jacobian -from .expression_tree.operations.convert_to_casadi import CasadiConverter -from .expression_tree.operations.unpack_symbols import SymbolUnpacker +find_symbols = lazy_import("pybamm.expression_tree.operations.evaluate_python", "find_symbols") +id_to_python_variable = lazy_import("pybamm.expression_tree.operations.evaluate_python", "id_to_python_variable") +to_python = lazy_import("pybamm.expression_tree.operations.evaluate_python", "to_python") +EvaluatorPython = lazy_import("pybamm.expression_tree.operations.evaluate_python", "EvaluatorPython") + +EvaluatorJax = lazy_import("pybamm.expression_tree.operations.evaluate_python", "EvaluatorJax") +JaxCooMatrix = lazy_import("pybamm.expression_tree.operations.evaluate_python", "JaxCooMatrix") +Jacobian = lazy_import("pybamm.expression_tree.operations.jacobian", "Jacobian") +CasadiConverter = lazy_import("pybamm.expression_tree.operations.convert_to_casadi", "CasadiConverter") +SymbolUnpacker = lazy_import("pybamm.expression_tree.operations.unpack_symbols", "SymbolUnpacker") # # Model classes From 13ac84c4b30255093178160e505e597dfe16b33d Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Thu, 18 Jan 2024 19:20:43 +0530 Subject: [PATCH 10/26] Resolve model imports lazily --- pybamm/__init__.py | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index ca9ecd3905..496a200152 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -108,18 +108,17 @@ # # Model classes # -from .models.base_model import BaseModel -from .models.event import Event -from .models.event import EventType +BaseModel = lazy_import("pybamm.models.base_model", "BaseModel") +Event = lazy_import("pybamm.models.event", "Event") +EventType = lazy_import("pybamm.models.event", "EventType") # Battery models -from .models.full_battery_models.base_battery_model import ( - BaseBatteryModel, - BatteryModelOptions, -) -from .models.full_battery_models import lead_acid -from .models.full_battery_models import lithium_ion -from .models.full_battery_models import equivalent_circuit +BaseBatteryModel = lazy_import("pybamm.models.full_battery_models.base_battery_model", "BaseBatteryModel") +BatteryModelOptions = lazy_import("pybamm.models.full_battery_models.base_battery_model", "BatteryModelOptions") + +lead_acid = lazy_import("pybamm.models.full_battery_models.lead_acid", "lead_acid") +lithium_ion = lazy_import("pybamm.models.full_battery_models.lithium_ion", "lithium_ion") +equivalent_circuit = lazy_import("pybamm.models.full_battery_models.equivalent_circuit", "equivalent_circuit") # # Submodel classes From 9b54d71f377ecb5d4c9ca76d307f53a7c084d925 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Thu, 18 Jan 2024 19:22:22 +0530 Subject: [PATCH 11/26] Resolve submodels imports lazily --- pybamm/__init__.py | 37 ++++++++++++++++++------------------- 1 file changed, 18 insertions(+), 19 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 496a200152..c9d2e2e70b 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -123,25 +123,24 @@ # # Submodel classes # -from .models.submodels.base_submodel import BaseSubModel - -from .models.submodels import ( - active_material, - convection, - current_collector, - electrolyte_conductivity, - electrolyte_diffusion, - electrode, - external_circuit, - interface, - oxygen_diffusion, - particle, - porosity, - thermal, - transport_efficiency, - particle_mechanics, - equivalent_circuit_elements, -) +BaseSubModel = lazy_import("pybamm.models.submodels.base_submodel", "BaseSubModel") + +active_material = lazy_import("pybamm.models.submodels.active_material", "active_material") +convection = lazy_import("pybamm.models.submodels.convection", "convection") +current_collector = lazy_import("pybamm.models.submodels.current_collector", "current_collector") +electrolyte_conductivity = lazy_import("pybamm.models.submodels.electrolyte_conductivity", "electrolyte_conductivity") +electrolyte_diffusion = lazy_import("pybamm.models.submodels.electrolyte_diffusion", "electrolyte_diffusion") +electrode = lazy_import("pybamm.models.submodels.electrode", "electrode") +external_circuit = lazy_import("pybamm.models.submodels.external_circuit", "external_circuit") +interface = lazy_import("pybamm.models.submodels.interface", "interface") +oxygen_diffusion = lazy_import("pybamm.models.submodels.oxygen_diffusion", "oxygen_diffusion") +particle = lazy_import("pybamm.models.submodels.particle", "particle") +porosity = lazy_import("pybamm.models.submodels.porosity", "porosity") +thermal = lazy_import("pybamm.models.submodels.thermal", "thermal") +transport_efficiency = lazy_import("pybamm.models.submodels.transport_efficiency", "transport_efficiency") +particle_mechanics = lazy_import("pybamm.models.submodels.particle_mechanics", "particle_mechanics") +equivalent_circuit_elements = lazy_import("pybamm.models.submodels.equivalent_circuit_elements", "equivalent_circuit_elements") + from .models.submodels.interface import kinetics from .models.submodels.interface import sei from .models.submodels.interface import lithium_plating From 983e0f800ac32ee11e810ff4812e762238d6edd4 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Thu, 18 Jan 2024 19:23:38 +0530 Subject: [PATCH 12/26] Remaining submodel interfaces --- pybamm/__init__.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index c9d2e2e70b..a820210ab4 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -141,11 +141,11 @@ particle_mechanics = lazy_import("pybamm.models.submodels.particle_mechanics", "particle_mechanics") equivalent_circuit_elements = lazy_import("pybamm.models.submodels.equivalent_circuit_elements", "equivalent_circuit_elements") -from .models.submodels.interface import kinetics -from .models.submodels.interface import sei -from .models.submodels.interface import lithium_plating -from .models.submodels.interface import interface_utilisation -from .models.submodels.interface import open_circuit_potential +kinetics = lazy_import("pybamm.models.submodels.interface.kinetics", "kinetics") +sei = lazy_import("pybamm.models.submodels.interface.sei", "sei") +lithium_plating = lazy_import("pybamm.models.submodels.interface.lithium_plating", "lithium_plating") +interface_utilisation = lazy_import("pybamm.models.submodels.interface.interface_utilisation", "interface_utilisation") +open_circuit_potential = lazy_import("pybamm.models.submodels.interface.open_circuit_potential", "open_circuit_potential") # # Geometry From b48169ce307008439957d825c967b0f95448deeb Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Thu, 18 Jan 2024 19:24:44 +0530 Subject: [PATCH 13/26] Resolve `.geometry` imports lazily --- pybamm/__init__.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index a820210ab4..127d4b5b57 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -150,11 +150,11 @@ # # Geometry # -from .geometry.geometry import Geometry -from .geometry.battery_geometry import battery_geometry +Geometry = lazy_import("pybamm.geometry.geometry", "Geometry") +battery_geometry = lazy_import("pybamm.geometry.battery_geometry", "battery_geometry") -from .expression_tree.independent_variable import KNOWN_COORD_SYS -from .geometry import standard_spatial_vars +KNOWN_COORD_SYS = lazy_import("pybamm.expression_tree.independent_variable", "KNOWN_COORD_SYS") +standard_spatial_vars = lazy_import("pybamm.geometry.standard_spatial_vars", "standard_spatial_vars") # # Parameter classes and methods From bae2485dfabca2f0fefbe38dedf63bd11aa685d8 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Thu, 18 Jan 2024 19:27:23 +0530 Subject: [PATCH 14/26] Resolve `.parameter` imports lazily --- pybamm/__init__.py | 30 +++++++++++++++++------------- 1 file changed, 17 insertions(+), 13 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 127d4b5b57..13634ea330 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -159,20 +159,24 @@ # # Parameter classes and methods # -from .parameters.parameter_values import ParameterValues -from .parameters import constants -from .parameters.geometric_parameters import geometric_parameters, GeometricParameters -from .parameters.electrical_parameters import ( - electrical_parameters, - ElectricalParameters, -) -from .parameters.thermal_parameters import thermal_parameters, ThermalParameters -from .parameters.lithium_ion_parameters import LithiumIonParameters -from .parameters.lead_acid_parameters import LeadAcidParameters -from .parameters.ecm_parameters import EcmParameters +ParameterValues = lazy_import("pybamm.parameters.parameter_values", "ParameterValues") +constants = lazy_import("pybamm.parameters.constants", "constants") +geometric_parameters = lazy_import("pybamm.parameters.geometric_parameters", "geometric_parameters") +GeometricParameters = lazy_import("pybamm.parameters.geometric_parameters", "GeometricParameters") + +electrical_parameters = lazy_import("pybamm.parameters.electrical_parameters", "electrical_parameters") +ElectricalParameters = lazy_import("pybamm.parameters.electrical_parameters", "ElectricalParameters") + +thermal_parameters = lazy_import("pybamm.parameters.thermal_parameters", "thermal_parameters") +ThermalParameters = lazy_import("pybamm.parameters.thermal_parameters", "ThermalParameters") +LithiumIonParameters = lazy_import("pybamm.parameters.lithium_ion_parameters", "LithiumIonParameters") +LeadAcidParameters = lazy_import("pybamm.parameters.lead_acid_parameters", "LeadAcidParameters") +EcmParameters = lazy_import("pybamm.parameters.ecm_parameters", "EcmParameters") from .parameters.size_distribution_parameters import * -from .parameters.parameter_sets import parameter_sets -from .parameters_cli import add_parameter, remove_parameter, edit_parameter +parameter_sets = lazy_import("pybamm.parameters.parameter_sets", "parameter_sets") +add_parameter = lazy_import("pybamm.parameters_cli", "add_parameter") +remove_parameter = lazy_import("pybamm.parameters_cli", "remove_parameter") +edit_parameter = lazy_import("pybamm.parameters_cli", "edit_parameter") # # Mesh and Discretisation classes From fd9a4e00c131d5e1f40951c416c77fd7cb663b3d Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 20 Jan 2024 19:53:03 +0530 Subject: [PATCH 15/26] Revert breaking imports --- pybamm/__init__.py | 82 ++++++++++++++++++++++------------------------ 1 file changed, 40 insertions(+), 42 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 13634ea330..c432e77a31 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -116,36 +116,38 @@ BaseBatteryModel = lazy_import("pybamm.models.full_battery_models.base_battery_model", "BaseBatteryModel") BatteryModelOptions = lazy_import("pybamm.models.full_battery_models.base_battery_model", "BatteryModelOptions") -lead_acid = lazy_import("pybamm.models.full_battery_models.lead_acid", "lead_acid") -lithium_ion = lazy_import("pybamm.models.full_battery_models.lithium_ion", "lithium_ion") -equivalent_circuit = lazy_import("pybamm.models.full_battery_models.equivalent_circuit", "equivalent_circuit") +from .models.full_battery_models import lead_acid +from .models.full_battery_models import lithium_ion +from .models.full_battery_models import equivalent_circuit # # Submodel classes # BaseSubModel = lazy_import("pybamm.models.submodels.base_submodel", "BaseSubModel") -active_material = lazy_import("pybamm.models.submodels.active_material", "active_material") -convection = lazy_import("pybamm.models.submodels.convection", "convection") -current_collector = lazy_import("pybamm.models.submodels.current_collector", "current_collector") -electrolyte_conductivity = lazy_import("pybamm.models.submodels.electrolyte_conductivity", "electrolyte_conductivity") -electrolyte_diffusion = lazy_import("pybamm.models.submodels.electrolyte_diffusion", "electrolyte_diffusion") -electrode = lazy_import("pybamm.models.submodels.electrode", "electrode") -external_circuit = lazy_import("pybamm.models.submodels.external_circuit", "external_circuit") -interface = lazy_import("pybamm.models.submodels.interface", "interface") -oxygen_diffusion = lazy_import("pybamm.models.submodels.oxygen_diffusion", "oxygen_diffusion") -particle = lazy_import("pybamm.models.submodels.particle", "particle") -porosity = lazy_import("pybamm.models.submodels.porosity", "porosity") -thermal = lazy_import("pybamm.models.submodels.thermal", "thermal") -transport_efficiency = lazy_import("pybamm.models.submodels.transport_efficiency", "transport_efficiency") -particle_mechanics = lazy_import("pybamm.models.submodels.particle_mechanics", "particle_mechanics") -equivalent_circuit_elements = lazy_import("pybamm.models.submodels.equivalent_circuit_elements", "equivalent_circuit_elements") - -kinetics = lazy_import("pybamm.models.submodels.interface.kinetics", "kinetics") -sei = lazy_import("pybamm.models.submodels.interface.sei", "sei") -lithium_plating = lazy_import("pybamm.models.submodels.interface.lithium_plating", "lithium_plating") -interface_utilisation = lazy_import("pybamm.models.submodels.interface.interface_utilisation", "interface_utilisation") -open_circuit_potential = lazy_import("pybamm.models.submodels.interface.open_circuit_potential", "open_circuit_potential") +from .models.submodels import ( + active_material, + convection, + current_collector, + electrolyte_conductivity, + electrolyte_diffusion, + electrode, + external_circuit, + interface, + oxygen_diffusion, + particle, + porosity, + thermal, + transport_efficiency, + particle_mechanics, + equivalent_circuit_elements, +) + +from .models.submodels.interface import kinetics +from .models.submodels.interface import sei +from .models.submodels.interface import lithium_plating +from .models.submodels.interface import interface_utilisation +from .models.submodels.interface import open_circuit_potential # # Geometry @@ -154,29 +156,25 @@ battery_geometry = lazy_import("pybamm.geometry.battery_geometry", "battery_geometry") KNOWN_COORD_SYS = lazy_import("pybamm.expression_tree.independent_variable", "KNOWN_COORD_SYS") -standard_spatial_vars = lazy_import("pybamm.geometry.standard_spatial_vars", "standard_spatial_vars") +from .geometry import standard_spatial_vars # # Parameter classes and methods # -ParameterValues = lazy_import("pybamm.parameters.parameter_values", "ParameterValues") -constants = lazy_import("pybamm.parameters.constants", "constants") -geometric_parameters = lazy_import("pybamm.parameters.geometric_parameters", "geometric_parameters") -GeometricParameters = lazy_import("pybamm.parameters.geometric_parameters", "GeometricParameters") - -electrical_parameters = lazy_import("pybamm.parameters.electrical_parameters", "electrical_parameters") -ElectricalParameters = lazy_import("pybamm.parameters.electrical_parameters", "ElectricalParameters") - -thermal_parameters = lazy_import("pybamm.parameters.thermal_parameters", "thermal_parameters") -ThermalParameters = lazy_import("pybamm.parameters.thermal_parameters", "ThermalParameters") -LithiumIonParameters = lazy_import("pybamm.parameters.lithium_ion_parameters", "LithiumIonParameters") -LeadAcidParameters = lazy_import("pybamm.parameters.lead_acid_parameters", "LeadAcidParameters") -EcmParameters = lazy_import("pybamm.parameters.ecm_parameters", "EcmParameters") +from .parameters.parameter_values import ParameterValues +from .parameters import constants +from .parameters.geometric_parameters import geometric_parameters, GeometricParameters +from .parameters.electrical_parameters import ( + electrical_parameters, + ElectricalParameters, +) +from .parameters.thermal_parameters import thermal_parameters, ThermalParameters +from .parameters.lithium_ion_parameters import LithiumIonParameters +from .parameters.lead_acid_parameters import LeadAcidParameters +from .parameters.ecm_parameters import EcmParameters from .parameters.size_distribution_parameters import * -parameter_sets = lazy_import("pybamm.parameters.parameter_sets", "parameter_sets") -add_parameter = lazy_import("pybamm.parameters_cli", "add_parameter") -remove_parameter = lazy_import("pybamm.parameters_cli", "remove_parameter") -edit_parameter = lazy_import("pybamm.parameters_cli", "edit_parameter") +from .parameters.parameter_sets import parameter_sets +from .parameters_cli import add_parameter, remove_parameter, edit_parameter # # Mesh and Discretisation classes From 3fe12fd283400b3cbaad6a21f5721399648139bf Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 20 Jan 2024 20:21:42 +0530 Subject: [PATCH 16/26] Try `lazy_loader` instead --- pybamm/__init__.py | 31 +++++++++++++------------------ pyproject.toml | 1 + 2 files changed, 14 insertions(+), 18 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index c432e77a31..3e4229ae8c 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -14,6 +14,7 @@ # from pybamm.version import __version__ from pybamm.util import lazy_import +import lazy_loader as lazy # # Constants @@ -34,24 +35,18 @@ ] -# -# Utility classes and methods -# -Timer = lazy_import("pybamm.util", "Timer") -TimerTime = lazy_import("pybamm.util", "TimerTime") -FuzzyDict = lazy_import("pybamm.util", "FuzzyDict") - -root_dir = lazy_import("pybamm.util", "root_dir") -rmse = lazy_import("pybamm.util", "rmse") -load = lazy_import("pybamm.util", "load") -is_constant_and_can_evaluate = lazy_import("pybamm.util", "is_constant_and_can_evaluate") - -get_parameters_filepath = lazy_import("pybamm.util", "get_parameters_filepath") -have_jax = lazy_import("pybamm.util", "have_jax") -install_jax = lazy_import("pybamm.util", "install_jax") -have_optional_dependency = lazy_import("pybamm.util", "have_optional_dependency") -is_jax_compatible = lazy_import("pybamm.util", "is_jax_compatible") -get_git_commit_info = lazy_import("pybamm.util", "get_git_commit_info") +__getattr__, __dir__, __all__ = lazy.attach( + __name__, + submod_attrs={ + # + # Utility classes and methods + # + 'util': ['Timer', 'TimerTime', 'FuzzyDict', + 'root_dir', 'rmse', 'load', 'is_constant_and_can_evaluate', + 'get_parameters_filepath', 'have_jax', 'install_jax', + 'have_optional_dependency', 'is_jax_compatible', 'get_git_commit_info'], + } +) logger = lazy_import("pybamm.logger", "logger") set_logging_level = lazy_import("pybamm.logger", "set_logging_level") diff --git a/pyproject.toml b/pyproject.toml index a39a37ecc4..89d6a9bd17 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -41,6 +41,7 @@ dependencies = [ "casadi>=3.6.3", "xarray>=2022.6.0", "anytree>=2.8.0", + "lazy_loader>=0.3", ] [project.urls] From fcdf41dcf4329bda16c0529b367c45ea2a55cc81 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 20 Jan 2024 20:31:27 +0530 Subject: [PATCH 17/26] Revert breaking `.expression_tree`, `.models` & `.submodels` imports --- pybamm/__init__.py | 64 +++++++++++++++++++++++----------------------- 1 file changed, 32 insertions(+), 32 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 3e4229ae8c..1cdc2a014c 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -64,52 +64,52 @@ from .expression_tree.symbol import * from .expression_tree.binary_operators import * from .expression_tree.concatenations import * -Array = lazy_import("pybamm.expression_tree.array", "Array") -linspace = lazy_import("pybamm.expression_tree.array", "linspace") -meshgrid = lazy_import("pybamm.expression_tree.array", "meshgrid") -Matrix = lazy_import("pybamm.expression_tree.matrix", "Matrix") +from .expression_tree.array import Array, linspace, meshgrid +from .expression_tree.matrix import Matrix from .expression_tree.unary_operators import * from .expression_tree.averages import * -_BaseAverage = lazy_import("pybamm.expression_tree.averages", "_BaseAverage") +from .expression_tree.averages import _BaseAverage from .expression_tree.broadcasts import * from .expression_tree.functions import * -Interpolant = lazy_import("pybamm.expression_tree.interpolant", "Interpolant") -InputParameter = lazy_import("pybamm.expression_tree.input_parameter", "InputParameter") -Parameter = lazy_import("pybamm.expression_tree.parameter", "Parameter") -FunctionParameter = lazy_import("pybamm.expression_tree.parameter", "FunctionParameter") -Scalar = lazy_import("pybamm.expression_tree.scalar", "Scalar") +from .expression_tree.interpolant import Interpolant +from .expression_tree.input_parameter import InputParameter +from .expression_tree.parameter import Parameter, FunctionParameter +from .expression_tree.scalar import Scalar from .expression_tree.variable import * from .expression_tree.independent_variable import * from .expression_tree.independent_variable import t -Vector = lazy_import("pybamm.expression_tree.vector", "Vector") -StateVectorBase = lazy_import("pybamm.expression_tree.state_vector", "StateVectorBase") -StateVector = lazy_import("pybamm.expression_tree.state_vector", "StateVector") -StateVectorDot = lazy_import("pybamm.expression_tree.state_vector", "StateVectorDot") +from .expression_tree.vector import Vector +from .expression_tree.state_vector import StateVectorBase, StateVector, StateVectorDot from .expression_tree.exceptions import * # Operations -find_symbols = lazy_import("pybamm.expression_tree.operations.evaluate_python", "find_symbols") -id_to_python_variable = lazy_import("pybamm.expression_tree.operations.evaluate_python", "id_to_python_variable") -to_python = lazy_import("pybamm.expression_tree.operations.evaluate_python", "to_python") -EvaluatorPython = lazy_import("pybamm.expression_tree.operations.evaluate_python", "EvaluatorPython") +from .expression_tree.operations.evaluate_python import ( + find_symbols, + id_to_python_variable, + to_python, + EvaluatorPython, +) + +from .expression_tree.operations.evaluate_python import EvaluatorJax +from .expression_tree.operations.evaluate_python import JaxCooMatrix -EvaluatorJax = lazy_import("pybamm.expression_tree.operations.evaluate_python", "EvaluatorJax") -JaxCooMatrix = lazy_import("pybamm.expression_tree.operations.evaluate_python", "JaxCooMatrix") -Jacobian = lazy_import("pybamm.expression_tree.operations.jacobian", "Jacobian") -CasadiConverter = lazy_import("pybamm.expression_tree.operations.convert_to_casadi", "CasadiConverter") -SymbolUnpacker = lazy_import("pybamm.expression_tree.operations.unpack_symbols", "SymbolUnpacker") +from .expression_tree.operations.jacobian import Jacobian +from .expression_tree.operations.convert_to_casadi import CasadiConverter +from .expression_tree.operations.unpack_symbols import SymbolUnpacker # # Model classes # -BaseModel = lazy_import("pybamm.models.base_model", "BaseModel") -Event = lazy_import("pybamm.models.event", "Event") -EventType = lazy_import("pybamm.models.event", "EventType") +from .models.base_model import BaseModel +from .models.event import Event +from .models.event import EventType # Battery models -BaseBatteryModel = lazy_import("pybamm.models.full_battery_models.base_battery_model", "BaseBatteryModel") -BatteryModelOptions = lazy_import("pybamm.models.full_battery_models.base_battery_model", "BatteryModelOptions") +from .models.full_battery_models.base_battery_model import ( + BaseBatteryModel, + BatteryModelOptions, +) from .models.full_battery_models import lead_acid from .models.full_battery_models import lithium_ion @@ -118,7 +118,7 @@ # # Submodel classes # -BaseSubModel = lazy_import("pybamm.models.submodels.base_submodel", "BaseSubModel") +from .models.submodels.base_submodel import BaseSubModel from .models.submodels import ( active_material, @@ -147,10 +147,10 @@ # # Geometry # -Geometry = lazy_import("pybamm.geometry.geometry", "Geometry") -battery_geometry = lazy_import("pybamm.geometry.battery_geometry", "battery_geometry") +from .geometry.geometry import Geometry +from .geometry.battery_geometry import battery_geometry -KNOWN_COORD_SYS = lazy_import("pybamm.expression_tree.independent_variable", "KNOWN_COORD_SYS") +from .expression_tree.independent_variable import KNOWN_COORD_SYS from .geometry import standard_spatial_vars # From 2b979af41e7d2fd798234071f666a2db2d4f55c9 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sat, 20 Jan 2024 20:51:40 +0530 Subject: [PATCH 18/26] Resolve other utility imports --- pybamm/__init__.py | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 1cdc2a014c..6944886a86 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -45,19 +45,12 @@ 'root_dir', 'rmse', 'load', 'is_constant_and_can_evaluate', 'get_parameters_filepath', 'have_jax', 'install_jax', 'have_optional_dependency', 'is_jax_compatible', 'get_git_commit_info'], + 'logger': ['logger', 'set_logging_level', 'get_new_logger'], + 'settings': ['settings'], + 'citations': ['Citations', 'citations', 'print_citations'] } ) -logger = lazy_import("pybamm.logger", "logger") -set_logging_level = lazy_import("pybamm.logger", "set_logging_level") -get_new_logger = lazy_import("pybamm.logger", "get_new_logger") - -settings = lazy_import("pybamm.settings","settings") - -Citations = lazy_import("pybamm.citations", "Citations") -citations = lazy_import("pybamm.citations", "citations") -print_citations = lazy_import("pybamm.citations", "print_citations") - # # Classes for the Expression Tree # From 9c43ac67af011b0f785f2dda8eaf81f532a884e4 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sun, 21 Jan 2024 09:36:17 +0530 Subject: [PATCH 19/26] Generate every `__init__` using [mkinit](https://github.com/Erotemic/mkinit) --- pybamm/__init__.py | 1300 ++++++++++++++++- pybamm/discretisations/__init__.py | 17 + pybamm/experiment/__init__.py | 36 + pybamm/experiment/step/__init__.py | 36 +- pybamm/expression_tree/__init__.py | 344 +++++ pybamm/expression_tree/operations/__init__.py | 52 + pybamm/expression_tree/printing/__init__.py | 25 + pybamm/geometry/__init__.py | 55 + pybamm/input/__init__.py | 261 ++++ pybamm/input/parameters/__init__.py | 265 ++++ pybamm/input/parameters/ecm/__init__.py | 28 + pybamm/input/parameters/lead_acid/__init__.py | 30 + .../input/parameters/lithium_ion/__init__.py | 313 ++++ pybamm/meshes/__init__.py | 46 + pybamm/models/__init__.py | 404 +++++ pybamm/models/full_battery_models/__init__.py | 92 ++ .../equivalent_circuit/__init__.py | 23 +- .../full_battery_models/lead_acid/__init__.py | 33 +- .../lithium_ion/__init__.py | 106 +- pybamm/models/submodels/__init__.py | 364 +++++ .../submodels/active_material/__init__.py | 34 +- .../models/submodels/convection/__init__.py | 44 +- .../convection/through_cell/__init__.py | 34 +- .../convection/transverse/__init__.py | 34 +- .../submodels/current_collector/__init__.py | 44 +- pybamm/models/submodels/electrode/__init__.py | 39 +- .../submodels/electrode/ohm/__init__.py | 48 +- .../electrolyte_conductivity/__init__.py | 63 +- .../surface_potential_form/__init__.py | 41 +- .../electrolyte_diffusion/__init__.py | 35 +- .../equivalent_circuit_elements/__init__.py | 39 +- .../submodels/external_circuit/__init__.py | 46 +- pybamm/models/submodels/interface/__init__.py | 113 +- .../interface_utilisation/__init__.py | 34 +- .../submodels/interface/kinetics/__init__.py | 77 +- .../kinetics/inverse_kinetics/__init__.py | 20 + .../interface/lithium_plating/__init__.py | 28 +- .../open_circuit_potential/__init__.py | 34 +- .../submodels/interface/sei/__init__.py | 38 +- .../submodels/oxygen_diffusion/__init__.py | 34 +- pybamm/models/submodels/particle/__init__.py | 46 +- .../submodels/particle_mechanics/__init__.py | 34 +- pybamm/models/submodels/porosity/__init__.py | 34 +- pybamm/models/submodels/thermal/__init__.py | 41 +- .../submodels/thermal/pouch_cell/__init__.py | 29 +- .../transport_efficiency/__init__.py | 23 +- pybamm/parameters/__init__.py | 112 +- pybamm/plotting/__init__.py | 45 + pybamm/solvers/__init__.py | 93 ++ pybamm/solvers/c_solvers/__init__.py | 10 + pybamm/spatial_methods/__init__.py | 35 + 51 files changed, 5057 insertions(+), 154 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 6944886a86..415c0e7b1c 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -258,4 +258,1302 @@ # # Remove any imported modules, so we don't expose them as part of pybamm # -del sys +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'batch_study', + 'callbacks', + 'citations', + 'discretisations', + 'doc_utils', + 'experiment', + 'expression_tree', + 'geometry', + 'input', + 'install_odes', + 'logger', + 'meshes', + 'models', + 'parameters', + 'parameters_cli', + 'plotting', + 'settings', + 'simulation', + 'solvers', + 'spatial_methods', + 'util', + 'version', + }, + submod_attrs={ + 'batch_study': [ + 'BatchStudy', + ], + 'callbacks': [ + 'Callback', + 'CallbackList', + 'LoggingCallback', + 'callback_loop_decorator', + 'setup_callbacks', + ], + 'citations': [ + 'Citations', + 'citations', + 'print_citations', + ], + 'discretisations': [ + 'Discretisation', + 'discretisation', + 'has_bc_of_form', + ], + 'doc_utils': [ + 'copy_parameter_doc_from_parent', + 'doc_extend_parent', + ], + 'experiment': [ + 'BaseTermination', + 'CrateTermination', + 'CurrentTermination', + 'CustomTermination', + 'Experiment', + 'VoltageTermination', + 'c_rate', + 'current', + 'experiment', + 'power', + 'resistance', + 'rest', + 'step', + 'step_termination', + 'steps', + 'string', + 'voltage', + ], + 'expression_tree': [ + 'AbsoluteValue', + 'Addition', + 'Arcsinh', + 'Arctan', + 'Array', + 'BackwardIndefiniteIntegral', + 'BaseIndefiniteIntegral', + 'BinaryOperator', + 'BoundaryGradient', + 'BoundaryIntegral', + 'BoundaryMass', + 'BoundaryOperator', + 'BoundaryValue', + 'Broadcast', + 'CasadiConverter', + 'Ceiling', + 'Concatenation', + 'ConcatenationVariable', + 'Cos', + 'Cosh', + 'CustomPrint', + 'DOMAIN_LEVELS', + 'DefiniteIntegralVector', + 'DeltaFunction', + 'DiscretisationError', + 'Divergence', + 'Division', + 'DomainConcatenation', + 'DomainError', + 'Downwind', + 'EMPTY_DOMAINS', + 'EqualHeaviside', + 'Equality', + 'Erf', + 'EvaluateAt', + 'EvaluatorJax', + 'EvaluatorJaxJacobian', + 'EvaluatorJaxSensitivities', + 'EvaluatorPython', + 'Exp', + 'ExplicitTimeIntegral', + 'Floor', + 'FullBroadcast', + 'FullBroadcastToEdges', + 'Function', + 'FunctionParameter', + 'GREEK_LETTERS', + 'GeometryError', + 'Gradient', + 'GradientSquared', + 'IndefiniteIntegral', + 'IndependentVariable', + 'Index', + 'Inner', + 'InputParameter', + 'Integral', + 'Interpolant', + 'Jacobian', + 'JaxCooMatrix', + 'KNOWN_COORD_SYS', + 'Laplacian', + 'Latexify', + 'Log', + 'Mass', + 'Matrix', + 'MatrixMultiplication', + 'Max', + 'Maximum', + 'Min', + 'Minimum', + 'ModelError', + 'ModelWarning', + 'Modulo', + 'Multiplication', + 'Negate', + 'NotConstant', + 'NotEqualHeaviside', + 'NumpyConcatenation', + 'OptionError', + 'OptionWarning', + 'PRINT_NAME_OVERRIDES', + 'Parameter', + 'Power', + 'PrimaryBroadcast', + 'PrimaryBroadcastToEdges', + 'RAverage', + 'Scalar', + 'SecondaryBroadcast', + 'SecondaryBroadcastToEdges', + 'Serialise', + 'ShapeError', + 'Sign', + 'Sin', + 'Sinh', + 'SizeAverage', + 'SolverError', + 'SolverWarning', + 'SparseStack', + 'SpatialOperator', + 'SpatialVariable', + 'SpatialVariableEdge', + 'SpecificFunction', + 'Sqrt', + 'StateVector', + 'StateVectorBase', + 'StateVectorDot', + 'Subtraction', + 'Symbol', + 'SymbolUnpacker', + 'Tanh', + 'TertiaryBroadcast', + 'TertiaryBroadcastToEdges', + 'Time', + 'UnaryOperator', + 'Upwind', + 'UpwindDownwind', + 'Variable', + 'VariableBase', + 'VariableDot', + 'Vector', + 'XAverage', + 'YZAverage', + 'ZAverage', + 'add', + 'arcsinh', + 'arctan', + 'array', + 'averages', + 'binary_operators', + 'boundary_gradient', + 'boundary_value', + 'broadcasts', + 'concatenation', + 'concatenations', + 'convert_to_casadi', + 'cos', + 'cosh', + 'create_jax_coo_matrix', + 'create_object_of_size', + 'custom_print_func', + 'div', + 'divide', + 'domain_concatenation', + 'domain_size', + 'downwind', + 'erf', + 'erfc', + 'evaluate_for_shape_using_domain', + 'evaluate_python', + 'exceptions', + 'exp', + 'find_symbols', + 'full_like', + 'functions', + 'get_rng_min_max_name', + 'grad', + 'grad_squared', + 'id_to_python_variable', + 'independent_variable', + 'inner', + 'input_parameter', + 'interpolant', + 'intersect', + 'is_constant', + 'is_matrix_minus_one', + 'is_matrix_one', + 'is_matrix_x', + 'is_matrix_zero', + 'is_scalar', + 'is_scalar_minus_one', + 'is_scalar_one', + 'is_scalar_x', + 'is_scalar_zero', + 'jacobian', + 'laplacian', + 'latexify', + 'linspace', + 'log', + 'log10', + 'matmul', + 'matrix', + 'maximum', + 'meshgrid', + 'minimum', + 'multiply', + 'numpy_concatenation', + 'ones_like', + 'operations', + 'parameter', + 'prettify_print_name', + 'print_name', + 'printing', + 'r_average', + 'scalar', + 'sech', + 'serialise', + 'sigmoid', + 'sign', + 'simplified_concatenation', + 'simplified_domain_concatenation', + 'simplified_function', + 'simplified_numpy_concatenation', + 'simplified_power', + 'simplify_if_constant', + 'sin', + 'sinh', + 'size_average', + 'smooth_absolute_value', + 'smooth_max', + 'smooth_min', + 'softminus', + 'softplus', + 'source', + 'sqrt', + 'state_vector', + 'substrings', + 'subtract', + 'surf', + 'symbol', + 'sympy_overrides', + 't', + 'tanh', + 'to_python', + 'unary_operators', + 'unpack_symbols', + 'upwind', + 'variable', + 'vector', + 'x_average', + 'xyz_average', + 'yz_average', + 'z_average', + 'zeros_like', + ], + 'geometry': [ + 'Geometry', + 'R_n', + 'R_n_edge', + 'R_p', + 'R_p_edge', + 'battery_geometry', + 'geometry', + 'r_macro', + 'r_macro_edge', + 'r_n', + 'r_n_edge', + 'r_n_prim', + 'r_n_sec', + 'r_p', + 'r_p_edge', + 'r_p_prim', + 'r_p_sec', + 'standard_spatial_vars', + 'whole_cell', + 'x', + 'x_edge', + 'x_n', + 'x_n_edge', + 'x_p', + 'x_p_edge', + 'x_s', + 'x_s_edge', + 'y', + 'y_edge', + 'z', + 'z_edge', + ], + 'input': [ + 'Ai2020', + 'Chen2020', + 'Chen2020_composite', + 'Ecker2015', + 'Ecker2015_graphite_halfcell', + 'LFP_electrolyte_exchange_current_density_kashkooli2017', + 'LFP_ocp_Afshar2017', + 'MSMR_example_set', + 'Marquis2019', + 'Mohtat2020', + 'NCA_Kim2011', + 'NMC_diffusivity_PeymanMPM', + 'NMC_electrolyte_exchange_current_density_PeymanMPM', + 'NMC_entropic_change_PeymanMPM', + 'NMC_ocp_PeymanMPM', + 'OKane2022', + 'OKane2022_graphite_SiOx_halfcell', + 'ORegan2022', + 'Prada2013', + 'Ramadass2004', + 'SEI_limited_dead_lithium_OKane2022', + 'Sulzer2019', + 'Xu2019', + 'aluminium_heat_capacity_CRC', + 'c1', + 'c1_data', + 'conductivity_Gu1997', + 'copper_heat_capacity_CRC', + 'copper_thermal_conductivity_CRC', + 'cracking_rate_Ai2020', + 'dUdT', + 'dUdT_data', + 'darken_thermodynamic_factor_Chapman1968', + 'diffusivity_Gu1997', + 'dlnf_dlnc_Ai2020', + 'ecm', + 'electrolyte_TDF_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_TDF_base_Landesfeind2019', + 'electrolyte_conductivity_Ai2020', + 'electrolyte_conductivity_Capiglia1999', + 'electrolyte_conductivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_conductivity_Ecker2015', + 'electrolyte_conductivity_Kim2011', + 'electrolyte_conductivity_Nyman2008', + 'electrolyte_conductivity_Nyman2008_arrhenius', + 'electrolyte_conductivity_PeymanMPM', + 'electrolyte_conductivity_Prada2013', + 'electrolyte_conductivity_Ramadass2004', + 'electrolyte_conductivity_Valoen2005', + 'electrolyte_conductivity_base_Landesfeind2019', + 'electrolyte_diffusivity_Ai2020', + 'electrolyte_diffusivity_Capiglia1999', + 'electrolyte_diffusivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_diffusivity_Ecker2015', + 'electrolyte_diffusivity_Kim2011', + 'electrolyte_diffusivity_Nyman2008', + 'electrolyte_diffusivity_Nyman2008_arrhenius', + 'electrolyte_diffusivity_PeymanMPM', + 'electrolyte_diffusivity_Ramadass2004', + 'electrolyte_diffusivity_Valoen2005', + 'electrolyte_diffusivity_base_Landesfeind2019', + 'electrolyte_transference_number_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_transference_number_base_Landesfeind2019', + 'example_set', + 'get_parameter_values', + 'graphite_LGM50_diffusivity_Chen2020', + 'graphite_LGM50_diffusivity_ORegan2022', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'graphite_LGM50_entropic_change_ORegan2022', + 'graphite_LGM50_heat_capacity_ORegan2022', + 'graphite_LGM50_ocp_Chen2020', + 'graphite_LGM50_ocp_Chen2020_data', + 'graphite_LGM50_thermal_conductivity_ORegan2022', + 'graphite_cracking_rate_Ai2020', + 'graphite_diffusivity_Dualfoil1998', + 'graphite_diffusivity_Ecker2015', + 'graphite_diffusivity_Kim2011', + 'graphite_diffusivity_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Dualfoil1998', + 'graphite_electrolyte_exchange_current_density_Ecker2015', + 'graphite_electrolyte_exchange_current_density_Kim2011', + 'graphite_electrolyte_exchange_current_density_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Ramadass2004', + 'graphite_entropic_change_Moura2016', + 'graphite_entropic_change_PeymanMPM', + 'graphite_entropy_Enertech_Ai2020_function', + 'graphite_mcmb2528_diffusivity_Dualfoil1998', + 'graphite_mcmb2528_ocp_Dualfoil1998', + 'graphite_ocp_Ecker2015', + 'graphite_ocp_Enertech_Ai2020', + 'graphite_ocp_Enertech_Ai2020_data', + 'graphite_ocp_Kim2011', + 'graphite_ocp_PeymanMPM', + 'graphite_ocp_Ramadass2004', + 'graphite_volume_change_Ai2020', + 'lead_acid', + 'lead_dioxide_exchange_current_density_Sulzer2019', + 'lead_dioxide_ocp_Bode1977', + 'lead_exchange_current_density_Sulzer2019', + 'lead_ocp_Bode1977', + 'li_metal_electrolyte_exchange_current_density_Xu2019', + 'lico2_cracking_rate_Ai2020', + 'lico2_diffusivity_Dualfoil1998', + 'lico2_diffusivity_Ramadass2004', + 'lico2_electrolyte_exchange_current_density_Dualfoil1998', + 'lico2_electrolyte_exchange_current_density_Ramadass2004', + 'lico2_entropic_change_Ai2020_function', + 'lico2_entropic_change_Moura2016', + 'lico2_ocp_Ai2020', + 'lico2_ocp_Ai2020_data', + 'lico2_ocp_Dualfoil1998', + 'lico2_ocp_Ramadass2004', + 'lico2_volume_change_Ai2020', + 'lithium_ion', + 'nca_diffusivity_Kim2011', + 'nca_electrolyte_exchange_current_density_Kim2011', + 'nca_ocp_Kim2011', + 'nco_diffusivity_Ecker2015', + 'nco_electrolyte_exchange_current_density_Ecker2015', + 'nco_ocp_Ecker2015', + 'nmc_LGM50_diffusivity_Chen2020', + 'nmc_LGM50_diffusivity_ORegan2022', + 'nmc_LGM50_electrolyte_exchange_current_density_Chen2020', + 'nmc_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'nmc_LGM50_electronic_conductivity_ORegan2022', + 'nmc_LGM50_entropic_change_ORegan2022', + 'nmc_LGM50_heat_capacity_ORegan2022', + 'nmc_LGM50_ocp_Chen2020', + 'nmc_LGM50_thermal_conductivity_ORegan2022', + 'nmc_electrolyte_exchange_current_density_Xu2019', + 'nmc_ocp_Xu2019', + 'ocv', + 'ocv_data', + 'oxygen_exchange_current_density_Sulzer2019', + 'parameters', + 'plating_exchange_current_density_OKane2020', + 'r0', + 'r0_data', + 'r1', + 'r1_data', + 'separator_LGM50_heat_capacity_ORegan2022', + 'silicon_LGM50_electrolyte_exchange_current_density_Chen2020', + 'silicon_ocp_delithiation_Mark2016', + 'silicon_ocp_lithiation_Mark2016', + 'stripping_exchange_current_density_OKane2020', + 'volume_change_Ai2020', + ], + 'install_odes': [ + 'NO_WGET', + 'SUNDIALS_VERSION', + 'download_extract_library', + 'install_sundials', + 'main', + 'update_LD_LIBRARY_PATH', + ], + 'logger': [ + 'FORMAT', + 'LOG_FORMATTER', + 'get_log_level_func', + 'get_new_logger', + 'logger', + 'new_levels', + 'set_logging_level', + ], + 'meshes': [ + 'Chebyshev1DSubMesh', + 'Exponential1DSubMesh', + 'Mesh', + 'MeshGenerator', + 'ScikitChebyshev2DSubMesh', + 'ScikitExponential2DSubMesh', + 'ScikitSubMesh2D', + 'ScikitUniform2DSubMesh', + 'SpectralVolume1DSubMesh', + 'SubMesh', + 'SubMesh0D', + 'SubMesh1D', + 'Uniform1DSubMesh', + 'UserSupplied1DSubMesh', + 'UserSupplied2DSubMesh', + 'meshes', + 'one_dimensional_submeshes', + 'scikit_fem_submeshes', + 'zero_dimensional_submesh', + ], + 'models': [ + 'AlternativeEffectiveResistance2D', + 'AsymmetricButlerVolmer', + 'BaseBatteryModel', + 'BaseEffectiveResistance', + 'BaseElectrode', + 'BaseElectrolyteConductivity', + 'BaseElectrolyteDiffusion', + 'BaseInterface', + 'BaseKinetics', + 'BaseLeadingOrderSurfaceForm', + 'BaseMechanics', + 'BaseModel', + 'BaseOpenCircuitPotential', + 'BaseParticle', + 'BasePlating', + 'BasePotentialPair', + 'BaseSubModel', + 'BaseThermal', + 'BaseThroughCellModel', + 'BaseTransverseModel', + 'BasicDFN', + 'BasicDFNComposite', + 'BasicDFNHalfCell', + 'BasicFull', + 'BasicSPM', + 'BatteryModelDomainOptions', + 'BatteryModelOptions', + 'BatteryModelPhaseOptions', + 'BoundaryConditionsDict', + 'Bruggeman', + 'CCCVFunctionControl', + 'Composite', + 'CompositeAlgebraic', + 'CompositeDifferential', + 'Constant', + 'ConstantConcentration', + 'ConstantSEI', + 'CrackPropagation', + 'CurrentCollector1D', + 'CurrentCollector2D', + 'CurrentDriven', + 'CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', + 'CurrentSigmoidOpenCircuitPotential', + 'DFN', + 'DiffusionLimited', + 'EffectiveResistance', + 'ElectrodeSOHHalfCell', + 'ElectrodeSOHSolver', + 'EquationDict', + 'Event', + 'EventType', + 'Explicit', + 'ExplicitCurrentControl', + 'ExplicitPowerControl', + 'ExplicitResistanceControl', + 'FickianDiffusion', + 'ForwardTafel', + 'Full', + 'FullAlgebraic', + 'FullDifferential', + 'FunctionControl', + 'Integrated', + 'InverseButlerVolmer', + 'Isothermal', + 'LOQS', + 'LeadingOrder', + 'LeadingOrderAlgebraic', + 'LeadingOrderDifferential', + 'Linear', + 'LithiumMetalBaseModel', + 'LithiumMetalExplicit', + 'LithiumMetalSurfaceForm', + 'LossActiveMaterial', + 'Lumped', + 'MPM', + 'MSMR', + 'MSMRButlerVolmer', + 'MSMRDiffusion', + 'MSMROpenCircuitPotential', + 'Marcus', + 'MarcusHushChidsey', + 'NaturalNumberOption', + 'NewmanTobias', + 'NoConvection', + 'NoMechanics', + 'NoOxygen', + 'NoPlating', + 'NoReaction', + 'NoSEI', + 'OCVElement', + 'OneDimensionalX', + 'OperatingModes', + 'Plating', + 'PolynomialProfile', + 'PotentialPair1plus1D', + 'PotentialPair2plus1D', + 'PowerFunctionControl', + 'RCElement', + 'ReactionDriven', + 'ReactionDrivenODE', + 'ResistanceFunctionControl', + 'ResistorElement', + 'SEIGrowth', + 'SPM', + 'SPMe', + 'SingleOpenCircuitPotential', + 'SurfaceForm', + 'SwellingOnly', + 'SymmetricButlerVolmer', + 'ThermalSubModel', + 'Thevenin', + 'Total', + 'TotalConcentration', + 'TotalInterfacialCurrent', + 'TotalMainKinetics', + 'TotalSEI', + 'Uniform', + 'VoltageFunctionControl', + 'VoltageModel', + 'XAveragedPolynomialProfile', + 'Yang2017', + 'active_material', + 'base_active_material', + 'base_battery_model', + 'base_convection', + 'base_current_collector', + 'base_electrode', + 'base_electrolyte_conductivity', + 'base_electrolyte_diffusion', + 'base_external_circuit', + 'base_interface', + 'base_kinetics', + 'base_lead_acid_model', + 'base_lithium_ion_model', + 'base_mechanics', + 'base_model', + 'base_ocp', + 'base_ohm', + 'base_oxygen_diffusion', + 'base_particle', + 'base_plating', + 'base_porosity', + 'base_sei', + 'base_submodel', + 'base_thermal', + 'base_through_cell_convection', + 'base_transport_efficiency', + 'base_transverse_convection', + 'base_utilisation', + 'basic_dfn', + 'basic_dfn_composite', + 'basic_dfn_half_cell', + 'basic_full', + 'basic_spm', + 'bruggeman_transport_efficiency', + 'butler_volmer', + 'calculate_theoretical_energy', + 'composite_conductivity', + 'composite_ohm', + 'composite_surface_form_conductivity', + 'constant_active_material', + 'constant_concentration', + 'constant_porosity', + 'constant_sei', + 'constant_utilisation', + 'convection', + 'crack_propagation', + 'current_collector', + 'current_driven_utilisation', + 'current_sigmoid_ocp', + 'dfn', + 'diffusion_limited', + 'ecm_model_options', + 'effective_resistance_current_collector', + 'electrode', + 'electrode_soh', + 'electrode_soh_half_cell', + 'electrolyte_conductivity', + 'electrolyte_diffusion', + 'equivalent_circuit', + 'equivalent_circuit_elements', + 'event', + 'explicit_control_external_circuit', + 'explicit_convection', + 'explicit_surface_form_conductivity', + 'external_circuit', + 'fickian_diffusion', + 'find_symbol_in_dict', + 'find_symbol_in_model', + 'find_symbol_in_tree', + 'full', + 'full_battery_models', + 'full_conductivity', + 'full_convection', + 'full_diffusion', + 'full_ohm', + 'full_oxygen_diffusion', + 'full_surface_form_conductivity', + 'full_utilisation', + 'function_control_external_circuit', + 'get_initial_ocps', + 'get_initial_stoichiometries', + 'get_initial_stoichiometry_half_cell', + 'get_min_max_ocps', + 'get_min_max_stoichiometries', + 'homogeneous_current_collector', + 'integrated_conductivity', + 'interface', + 'interface_utilisation', + 'inverse_butler_volmer', + 'inverse_kinetics', + 'isothermal', + 'kinetics', + 'lead_acid', + 'leading_ohm', + 'leading_order_conductivity', + 'leading_order_diffusion', + 'leading_oxygen_diffusion', + 'leading_surface_form_conductivity', + 'li_metal', + 'linear', + 'lithium_ion', + 'lithium_plating', + 'load_model', + 'loqs', + 'loss_active_material', + 'lumped', + 'marcus', + 'mpm', + 'msmr', + 'msmr_butler_volmer', + 'msmr_diffusion', + 'msmr_ocp', + 'newman_tobias', + 'no_convection', + 'no_mechanics', + 'no_oxygen', + 'no_plating', + 'no_reaction', + 'no_sei', + 'ocv_element', + 'ohm', + 'open_circuit_potential', + 'oxygen_diffusion', + 'particle', + 'particle_mechanics', + 'plating', + 'polynomial_profile', + 'porosity', + 'potential_pair', + 'pouch_cell', + 'pouch_cell_1D_current_collectors', + 'pouch_cell_2D_current_collectors', + 'rc_element', + 'reaction_driven_porosity', + 'reaction_driven_porosity_ode', + 'represents_positive_integer', + 'resistor_element', + 'sei', + 'sei_growth', + 'single_ocp', + 'spm', + 'spme', + 'submodels', + 'surface_form_ohm', + 'surface_potential_form', + 'swelling_only', + 'tafel', + 'theoretical_energy_integral', + 'thermal', + 'thevenin', + 'through_cell', + 'total_active_material', + 'total_interfacial_current', + 'total_main_kinetics', + 'total_particle_concentration', + 'total_sei', + 'transport_efficiency', + 'transverse', + 'uniform_convection', + 'voltage_model', + 'x_averaged_polynomial_profile', + 'x_full', + ], + 'parameters': [ + 'BaseParameters', + 'Domain', + 'DomainGeometricParameters', + 'DomainLeadAcidParameters', + 'DomainLithiumIonParameters', + 'DomainThermalParameters', + 'EcmParameters', + 'ElectricalParameters', + 'F', + 'GeometricParameters', + 'LeadAcidParameters', + 'LithiumIonParameters', + 'NullParameters', + 'ParameterSets', + 'ParameterValues', + 'ParticleGeometricParameters', + 'ParticleLithiumIonParameters', + 'PhaseLeadAcidParameters', + 'R', + 'ThermalParameters', + 'base_parameters', + 'bpx', + 'cell', + 'constants', + 'ecm_parameters', + 'electrical_parameters', + 'electrolyte', + 'experiment', + 'geometric_parameters', + 'get_size_distribution_parameters', + 'k_b', + 'lead_acid_parameters', + 'lithium_ion_parameters', + 'lognormal', + 'negative_current_collector', + 'negative_electrode', + 'parameter_sets', + 'parameter_values', + 'positive_current_collector', + 'positive_electrode', + 'preamble', + 'process_1D_data', + 'process_2D_data', + 'process_2D_data_csv', + 'process_3D_data_csv', + 'process_parameter_data', + 'q_e', + 'separator', + 'size_distribution_parameters', + 'thermal_parameters', + ], + 'parameters_cli': [ + 'add_parameter', + 'edit_parameter', + 'raise_error', + 'remove_parameter', + ], + 'plotting': [ + 'LoopList', + 'QuickPlot', + 'QuickPlotAxes', + 'ax_max', + 'ax_min', + 'close_plots', + 'dynamic_plot', + 'plot', + 'plot2D', + 'plot_summary_variables', + 'plot_voltage_components', + 'quick_plot', + 'split_long_string', + ], + 'settings': [ + 'Settings', + 'settings', + ], + 'simulation': [ + 'Simulation', + 'is_notebook', + 'load_sim', + ], + 'solvers': [ + 'AlgebraicSolver', + 'BaseSolver', + 'CasadiAlgebraicSolver', + 'CasadiSolver', + 'DummySolver', + 'EmptySolution', + 'IDAKLUSolver', + 'JaxSolver', + 'LRUDict', + 'NumpyEncoder', + 'ProcessedVariable', + 'ProcessedVariableComputed', + 'ScikitsDaeSolver', + 'ScikitsOdeSolver', + 'ScipySolver', + 'Solution', + 'algebraic_solver', + 'base_solver', + 'c_solvers', + 'casadi_algebraic_solver', + 'casadi_solver', + 'dummy_solver', + 'have_idaklu', + 'have_scikits_odes', + 'idaklu_solver', + 'idaklu_spec', + 'jax_bdf_integrate', + 'jax_bdf_solver', + 'jax_solver', + 'lrudict', + 'make_cycle_solution', + 'process', + 'processed_variable', + 'processed_variable_computed', + 'scikits_dae_solver', + 'scikits_ode_solver', + 'scikits_odes_spec', + 'scipy_solver', + 'solution', + ], + 'spatial_methods': [ + 'FiniteVolume', + 'ScikitFiniteElement', + 'SpatialMethod', + 'SpectralVolume', + 'ZeroDimensionalSpatialMethod', + 'finite_volume', + 'scikit_finite_element', + 'spatial_method', + 'spectral_volume', + 'zero_dimensional_method', + ], + 'util': [ + 'FuzzyDict', + 'JAXLIB_VERSION', + 'JAX_VERSION', + 'Timer', + 'TimerTime', + 'get_git_commit_info', + 'get_parameters_filepath', + 'have_jax', + 'have_optional_dependency', + 'install_jax', + 'is_constant_and_can_evaluate', + 'is_jax_compatible', + 'lazy_import', + 'load', + 'rmse', + 'root_dir', + ], + }, +) + +__all__ = ['ABSOLUTE_PATH', 'AbsoluteValue', 'Addition', 'Ai2020', + 'AlgebraicSolver', 'AlternativeEffectiveResistance2D', 'Arcsinh', + 'Arctan', 'Array', 'AsymmetricButlerVolmer', + 'BackwardIndefiniteIntegral', 'BaseBatteryModel', + 'BaseEffectiveResistance', 'BaseElectrode', + 'BaseElectrolyteConductivity', 'BaseElectrolyteDiffusion', + 'BaseIndefiniteIntegral', 'BaseInterface', 'BaseKinetics', + 'BaseLeadingOrderSurfaceForm', 'BaseMechanics', 'BaseModel', + 'BaseOpenCircuitPotential', 'BaseParameters', 'BaseParticle', + 'BasePlating', 'BasePotentialPair', 'BaseSolver', 'BaseSubModel', + 'BaseTermination', 'BaseThermal', 'BaseThroughCellModel', + 'BaseTransverseModel', 'BasicDFN', 'BasicDFNComposite', + 'BasicDFNHalfCell', 'BasicFull', 'BasicSPM', 'BatchStudy', + 'BatteryModelDomainOptions', 'BatteryModelOptions', + 'BatteryModelPhaseOptions', 'BinaryOperator', + 'BoundaryConditionsDict', 'BoundaryGradient', 'BoundaryIntegral', + 'BoundaryMass', 'BoundaryOperator', 'BoundaryValue', 'Broadcast', + 'Bruggeman', 'CCCVFunctionControl', 'Callback', 'CallbackList', + 'CasadiAlgebraicSolver', 'CasadiConverter', 'CasadiSolver', + 'Ceiling', 'Chebyshev1DSubMesh', 'Chen2020', 'Chen2020_composite', + 'Citations', 'Composite', 'CompositeAlgebraic', + 'CompositeDifferential', 'Concatenation', 'ConcatenationVariable', + 'Constant', 'ConstantConcentration', 'ConstantSEI', 'Cos', 'Cosh', + 'CrackPropagation', 'CrateTermination', 'CurrentCollector1D', + 'CurrentCollector2D', 'CurrentDriven', + 'CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', + 'CurrentSigmoidOpenCircuitPotential', 'CurrentTermination', + 'CustomPrint', 'CustomTermination', 'DFN', 'DOMAIN_LEVELS', + 'DefiniteIntegralVector', 'DeltaFunction', 'DiffusionLimited', + 'Discretisation', 'DiscretisationError', 'Divergence', 'Division', + 'Domain', 'DomainConcatenation', 'DomainError', + 'DomainGeometricParameters', 'DomainLeadAcidParameters', + 'DomainLithiumIonParameters', 'DomainThermalParameters', 'Downwind', + 'DummySolver', 'EMPTY_DOMAINS', 'Ecker2015', + 'Ecker2015_graphite_halfcell', 'EcmParameters', + 'EffectiveResistance', 'ElectricalParameters', + 'ElectrodeSOHHalfCell', 'ElectrodeSOHSolver', 'EmptySolution', + 'EqualHeaviside', 'Equality', 'EquationDict', 'Erf', 'EvaluateAt', + 'EvaluatorJax', 'EvaluatorJaxJacobian', 'EvaluatorJaxSensitivities', + 'EvaluatorPython', 'Event', 'EventType', 'Exp', 'Experiment', + 'Explicit', 'ExplicitCurrentControl', 'ExplicitPowerControl', + 'ExplicitResistanceControl', 'ExplicitTimeIntegral', + 'Exponential1DSubMesh', 'F', 'FLOAT_FORMAT', 'FORMAT', + 'FickianDiffusion', 'FiniteVolume', 'Floor', 'ForwardTafel', 'Full', + 'FullAlgebraic', 'FullBroadcast', 'FullBroadcastToEdges', + 'FullDifferential', 'Function', 'FunctionControl', + 'FunctionParameter', 'FuzzyDict', 'GREEK_LETTERS', + 'GeometricParameters', 'Geometry', 'GeometryError', 'Gradient', + 'GradientSquared', 'IDAKLUSolver', 'IndefiniteIntegral', + 'IndependentVariable', 'Index', 'Inner', 'InputParameter', + 'Integral', 'Integrated', 'Interpolant', 'InverseButlerVolmer', + 'Isothermal', 'JAXLIB_VERSION', 'JAX_VERSION', 'Jacobian', + 'JaxCooMatrix', 'JaxSolver', 'KNOWN_COORD_SYS', + 'LFP_electrolyte_exchange_current_density_kashkooli2017', + 'LFP_ocp_Afshar2017', 'LOG_FORMATTER', 'LOQS', 'LRUDict', + 'Laplacian', 'Latexify', 'LeadAcidParameters', 'LeadingOrder', + 'LeadingOrderAlgebraic', 'LeadingOrderDifferential', 'Linear', + 'LithiumIonParameters', 'LithiumMetalBaseModel', + 'LithiumMetalExplicit', 'LithiumMetalSurfaceForm', 'Log', + 'LoggingCallback', 'LoopList', 'LossActiveMaterial', 'Lumped', + 'MPM', 'MSMR', 'MSMRButlerVolmer', 'MSMRDiffusion', + 'MSMROpenCircuitPotential', 'MSMR_example_set', 'Marcus', + 'MarcusHushChidsey', 'Marquis2019', 'Mass', 'Matrix', + 'MatrixMultiplication', 'Max', 'Maximum', 'Mesh', 'MeshGenerator', + 'Min', 'Minimum', 'ModelError', 'ModelWarning', 'Modulo', + 'Mohtat2020', 'Multiplication', 'NCA_Kim2011', + 'NMC_diffusivity_PeymanMPM', + 'NMC_electrolyte_exchange_current_density_PeymanMPM', + 'NMC_entropic_change_PeymanMPM', 'NMC_ocp_PeymanMPM', 'NO_WGET', + 'NaturalNumberOption', 'Negate', 'NewmanTobias', 'NoConvection', + 'NoMechanics', 'NoOxygen', 'NoPlating', 'NoReaction', 'NoSEI', + 'NotConstant', 'NotEqualHeaviside', 'NullParameters', + 'NumpyConcatenation', 'NumpyEncoder', 'OCVElement', 'OKane2022', + 'OKane2022_graphite_SiOx_halfcell', 'ORegan2022', 'OneDimensionalX', + 'OperatingModes', 'OptionError', 'OptionWarning', 'PARAMETER_PATH', + 'PRINT_NAME_OVERRIDES', 'Parameter', 'ParameterSets', + 'ParameterValues', 'ParticleGeometricParameters', + 'ParticleLithiumIonParameters', 'PhaseLeadAcidParameters', + 'Plating', 'PolynomialProfile', 'PotentialPair1plus1D', + 'PotentialPair2plus1D', 'Power', 'PowerFunctionControl', + 'Prada2013', 'PrimaryBroadcast', 'PrimaryBroadcastToEdges', + 'ProcessedVariable', 'ProcessedVariableComputed', 'QuickPlot', + 'QuickPlotAxes', 'R', 'RAverage', 'RCElement', 'R_n', 'R_n_edge', + 'R_p', 'R_p_edge', 'Ramadass2004', 'ReactionDriven', + 'ReactionDrivenODE', 'ResistanceFunctionControl', 'ResistorElement', + 'SEIGrowth', 'SEI_limited_dead_lithium_OKane2022', 'SPM', 'SPMe', + 'SUNDIALS_VERSION', 'Scalar', 'ScikitChebyshev2DSubMesh', + 'ScikitExponential2DSubMesh', 'ScikitFiniteElement', + 'ScikitSubMesh2D', 'ScikitUniform2DSubMesh', 'ScikitsDaeSolver', + 'ScikitsOdeSolver', 'ScipySolver', 'SecondaryBroadcast', + 'SecondaryBroadcastToEdges', 'Serialise', 'Settings', 'ShapeError', + 'Sign', 'Simulation', 'Sin', 'SingleOpenCircuitPotential', 'Sinh', + 'SizeAverage', 'Solution', 'SolverError', 'SolverWarning', + 'SparseStack', 'SpatialMethod', 'SpatialOperator', + 'SpatialVariable', 'SpatialVariableEdge', 'SpecificFunction', + 'SpectralVolume', 'SpectralVolume1DSubMesh', 'Sqrt', 'StateVector', + 'StateVectorBase', 'StateVectorDot', 'SubMesh', 'SubMesh0D', + 'SubMesh1D', 'Subtraction', 'Sulzer2019', 'SurfaceForm', + 'SwellingOnly', 'Symbol', 'SymbolUnpacker', 'SymmetricButlerVolmer', + 'Tanh', 'TertiaryBroadcast', 'TertiaryBroadcastToEdges', + 'ThermalParameters', 'ThermalSubModel', 'Thevenin', 'Time', 'Timer', + 'TimerTime', 'Total', 'TotalConcentration', + 'TotalInterfacialCurrent', 'TotalMainKinetics', 'TotalSEI', + 'UnaryOperator', 'Uniform', 'Uniform1DSubMesh', 'Upwind', + 'UpwindDownwind', 'UserSupplied1DSubMesh', 'UserSupplied2DSubMesh', + 'Variable', 'VariableBase', 'VariableDot', 'Vector', + 'VoltageFunctionControl', 'VoltageModel', 'VoltageTermination', + 'XAverage', 'XAveragedPolynomialProfile', 'Xu2019', 'YZAverage', + 'Yang2017', 'ZAverage', 'ZeroDimensionalSpatialMethod', + 'active_material', 'add', 'add_parameter', 'algebraic_solver', + 'aluminium_heat_capacity_CRC', 'arcsinh', 'arctan', 'array', + 'averages', 'ax_max', 'ax_min', 'base_active_material', + 'base_battery_model', 'base_convection', 'base_current_collector', + 'base_electrode', 'base_electrolyte_conductivity', + 'base_electrolyte_diffusion', 'base_external_circuit', + 'base_interface', 'base_kinetics', 'base_lead_acid_model', + 'base_lithium_ion_model', 'base_mechanics', 'base_model', + 'base_ocp', 'base_ohm', 'base_oxygen_diffusion', 'base_parameters', + 'base_particle', 'base_plating', 'base_porosity', 'base_sei', + 'base_solver', 'base_submodel', 'base_thermal', + 'base_through_cell_convection', 'base_transport_efficiency', + 'base_transverse_convection', 'base_utilisation', 'basic_dfn', + 'basic_dfn_composite', 'basic_dfn_half_cell', 'basic_full', + 'basic_spm', 'batch_study', 'battery_geometry', 'binary_operators', + 'boundary_gradient', 'boundary_value', 'bpx', 'broadcasts', + 'bruggeman_transport_efficiency', 'butler_volmer', 'c1', 'c1_data', + 'c_rate', 'c_solvers', 'calculate_theoretical_energy', + 'callback_loop_decorator', 'callbacks', 'casadi_algebraic_solver', + 'casadi_solver', 'cell', 'citations', 'close_plots', + 'composite_conductivity', 'composite_ohm', + 'composite_surface_form_conductivity', 'concatenation', + 'concatenations', 'conductivity_Gu1997', 'constant_active_material', + 'constant_concentration', 'constant_porosity', 'constant_sei', + 'constant_utilisation', 'constants', 'convection', + 'convert_to_casadi', 'copper_heat_capacity_CRC', + 'copper_thermal_conductivity_CRC', 'copy_parameter_doc_from_parent', + 'cos', 'cosh', 'crack_propagation', 'cracking_rate_Ai2020', + 'create_jax_coo_matrix', 'create_object_of_size', 'current', + 'current_collector', 'current_driven_utilisation', + 'current_sigmoid_ocp', 'custom_print_func', 'dUdT', 'dUdT_data', + 'darken_thermodynamic_factor_Chapman1968', 'dfn', + 'diffusion_limited', 'diffusivity_Gu1997', 'discretisation', + 'discretisations', 'div', 'divide', 'dlnf_dlnc_Ai2020', + 'doc_extend_parent', 'doc_utils', 'domain_concatenation', + 'domain_size', 'download_extract_library', 'downwind', + 'dummy_solver', 'dynamic_plot', 'ecm', 'ecm_model_options', + 'ecm_parameters', 'edit_parameter', + 'effective_resistance_current_collector', 'electrical_parameters', + 'electrode', 'electrode_soh', 'electrode_soh_half_cell', + 'electrolyte', 'electrolyte_TDF_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_TDF_base_Landesfeind2019', 'electrolyte_conductivity', + 'electrolyte_conductivity_Ai2020', + 'electrolyte_conductivity_Capiglia1999', + 'electrolyte_conductivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_conductivity_Ecker2015', + 'electrolyte_conductivity_Kim2011', + 'electrolyte_conductivity_Nyman2008', + 'electrolyte_conductivity_Nyman2008_arrhenius', + 'electrolyte_conductivity_PeymanMPM', + 'electrolyte_conductivity_Prada2013', + 'electrolyte_conductivity_Ramadass2004', + 'electrolyte_conductivity_Valoen2005', + 'electrolyte_conductivity_base_Landesfeind2019', + 'electrolyte_diffusion', 'electrolyte_diffusivity_Ai2020', + 'electrolyte_diffusivity_Capiglia1999', + 'electrolyte_diffusivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_diffusivity_Ecker2015', + 'electrolyte_diffusivity_Kim2011', + 'electrolyte_diffusivity_Nyman2008', + 'electrolyte_diffusivity_Nyman2008_arrhenius', + 'electrolyte_diffusivity_PeymanMPM', + 'electrolyte_diffusivity_Ramadass2004', + 'electrolyte_diffusivity_Valoen2005', + 'electrolyte_diffusivity_base_Landesfeind2019', + 'electrolyte_transference_number_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_transference_number_base_Landesfeind2019', + 'equivalent_circuit', 'equivalent_circuit_elements', 'erf', 'erfc', + 'evaluate_for_shape_using_domain', 'evaluate_python', 'event', + 'example_set', 'exceptions', 'exp', 'experiment', + 'explicit_control_external_circuit', 'explicit_convection', + 'explicit_surface_form_conductivity', 'expression_tree', + 'external_circuit', 'fickian_diffusion', 'find_symbol_in_dict', + 'find_symbol_in_model', 'find_symbol_in_tree', 'find_symbols', + 'finite_volume', 'full', 'full_battery_models', 'full_conductivity', + 'full_convection', 'full_diffusion', 'full_like', 'full_ohm', + 'full_oxygen_diffusion', 'full_surface_form_conductivity', + 'full_utilisation', 'function_control_external_circuit', + 'functions', 'geometric_parameters', 'geometry', + 'get_git_commit_info', 'get_initial_ocps', + 'get_initial_stoichiometries', + 'get_initial_stoichiometry_half_cell', 'get_log_level_func', + 'get_min_max_ocps', 'get_min_max_stoichiometries', 'get_new_logger', + 'get_parameter_values', 'get_parameters_filepath', + 'get_rng_min_max_name', 'get_size_distribution_parameters', 'grad', + 'grad_squared', 'graphite_LGM50_diffusivity_Chen2020', + 'graphite_LGM50_diffusivity_ORegan2022', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'graphite_LGM50_entropic_change_ORegan2022', + 'graphite_LGM50_heat_capacity_ORegan2022', + 'graphite_LGM50_ocp_Chen2020', 'graphite_LGM50_ocp_Chen2020_data', + 'graphite_LGM50_thermal_conductivity_ORegan2022', + 'graphite_cracking_rate_Ai2020', + 'graphite_diffusivity_Dualfoil1998', + 'graphite_diffusivity_Ecker2015', 'graphite_diffusivity_Kim2011', + 'graphite_diffusivity_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Dualfoil1998', + 'graphite_electrolyte_exchange_current_density_Ecker2015', + 'graphite_electrolyte_exchange_current_density_Kim2011', + 'graphite_electrolyte_exchange_current_density_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Ramadass2004', + 'graphite_entropic_change_Moura2016', + 'graphite_entropic_change_PeymanMPM', + 'graphite_entropy_Enertech_Ai2020_function', + 'graphite_mcmb2528_diffusivity_Dualfoil1998', + 'graphite_mcmb2528_ocp_Dualfoil1998', 'graphite_ocp_Ecker2015', + 'graphite_ocp_Enertech_Ai2020', 'graphite_ocp_Enertech_Ai2020_data', + 'graphite_ocp_Kim2011', 'graphite_ocp_PeymanMPM', + 'graphite_ocp_Ramadass2004', 'graphite_volume_change_Ai2020', + 'has_bc_of_form', 'have_idaklu', 'have_jax', + 'have_optional_dependency', 'have_scikits_odes', + 'homogeneous_current_collector', 'id_to_python_variable', + 'idaklu_solver', 'idaklu_spec', 'independent_variable', 'inner', + 'input', 'input_parameter', 'install_jax', 'install_odes', + 'install_sundials', 'integrated_conductivity', 'interface', + 'interface_utilisation', 'interpolant', 'intersect', + 'inverse_butler_volmer', 'inverse_kinetics', 'is_constant', + 'is_constant_and_can_evaluate', 'is_jax_compatible', + 'is_matrix_minus_one', 'is_matrix_one', 'is_matrix_x', + 'is_matrix_zero', 'is_notebook', 'is_scalar', 'is_scalar_minus_one', + 'is_scalar_one', 'is_scalar_x', 'is_scalar_zero', 'isothermal', + 'jacobian', 'jax_bdf_integrate', 'jax_bdf_solver', 'jax_solver', + 'k_b', 'kinetics', 'laplacian', 'latexify', 'lazy_import', + 'lead_acid', 'lead_acid_parameters', + 'lead_dioxide_exchange_current_density_Sulzer2019', + 'lead_dioxide_ocp_Bode1977', + 'lead_exchange_current_density_Sulzer2019', 'lead_ocp_Bode1977', + 'leading_ohm', 'leading_order_conductivity', + 'leading_order_diffusion', 'leading_oxygen_diffusion', + 'leading_surface_form_conductivity', 'li_metal', + 'li_metal_electrolyte_exchange_current_density_Xu2019', + 'lico2_cracking_rate_Ai2020', 'lico2_diffusivity_Dualfoil1998', + 'lico2_diffusivity_Ramadass2004', + 'lico2_electrolyte_exchange_current_density_Dualfoil1998', + 'lico2_electrolyte_exchange_current_density_Ramadass2004', + 'lico2_entropic_change_Ai2020_function', + 'lico2_entropic_change_Moura2016', 'lico2_ocp_Ai2020', + 'lico2_ocp_Ai2020_data', 'lico2_ocp_Dualfoil1998', + 'lico2_ocp_Ramadass2004', 'lico2_volume_change_Ai2020', 'linear', + 'linspace', 'lithium_ion', 'lithium_ion_parameters', + 'lithium_plating', 'load', 'load_model', 'load_sim', 'log', 'log10', + 'logger', 'lognormal', 'loqs', 'loss_active_material', 'lrudict', + 'lumped', 'main', 'make_cycle_solution', 'marcus', 'matmul', + 'matrix', 'maximum', 'meshes', 'meshgrid', 'minimum', 'models', + 'mpm', 'msmr', 'msmr_butler_volmer', 'msmr_diffusion', 'msmr_ocp', + 'multiply', 'nca_diffusivity_Kim2011', + 'nca_electrolyte_exchange_current_density_Kim2011', + 'nca_ocp_Kim2011', 'nco_diffusivity_Ecker2015', + 'nco_electrolyte_exchange_current_density_Ecker2015', + 'nco_ocp_Ecker2015', 'negative_current_collector', + 'negative_electrode', 'new_levels', 'newman_tobias', + 'nmc_LGM50_diffusivity_Chen2020', + 'nmc_LGM50_diffusivity_ORegan2022', + 'nmc_LGM50_electrolyte_exchange_current_density_Chen2020', + 'nmc_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'nmc_LGM50_electronic_conductivity_ORegan2022', + 'nmc_LGM50_entropic_change_ORegan2022', + 'nmc_LGM50_heat_capacity_ORegan2022', 'nmc_LGM50_ocp_Chen2020', + 'nmc_LGM50_thermal_conductivity_ORegan2022', + 'nmc_electrolyte_exchange_current_density_Xu2019', 'nmc_ocp_Xu2019', + 'no_convection', 'no_mechanics', 'no_oxygen', 'no_plating', + 'no_reaction', 'no_sei', 'numpy_concatenation', 'ocv', 'ocv_data', + 'ocv_element', 'ohm', 'one_dimensional_submeshes', 'ones_like', + 'open_circuit_potential', 'operations', 'oxygen_diffusion', + 'oxygen_exchange_current_density_Sulzer2019', 'parameter', + 'parameter_sets', 'parameter_values', 'parameters', + 'parameters_cli', 'particle', 'particle_mechanics', 'plating', + 'plating_exchange_current_density_OKane2020', 'plot', 'plot2D', + 'plot_summary_variables', 'plot_voltage_components', 'plotting', + 'polynomial_profile', 'porosity', 'positive_current_collector', + 'positive_electrode', 'potential_pair', 'pouch_cell', + 'pouch_cell_1D_current_collectors', + 'pouch_cell_2D_current_collectors', 'power', 'preamble', + 'prettify_print_name', 'print_citations', 'print_name', 'printing', + 'process', 'process_1D_data', 'process_2D_data', + 'process_2D_data_csv', 'process_3D_data_csv', + 'process_parameter_data', 'processed_variable', + 'processed_variable_computed', 'q_e', 'quick_plot', 'r0', 'r0_data', + 'r1', 'r1_data', 'r_average', 'r_macro', 'r_macro_edge', 'r_n', + 'r_n_edge', 'r_n_prim', 'r_n_sec', 'r_p', 'r_p_edge', 'r_p_prim', + 'r_p_sec', 'raise_error', 'rc_element', 'reaction_driven_porosity', + 'reaction_driven_porosity_ode', 'remove_parameter', + 'represents_positive_integer', 'resistance', 'resistor_element', + 'rest', 'rmse', 'root_dir', 'scalar', 'scikit_fem_submeshes', + 'scikit_finite_element', 'scikits_dae_solver', 'scikits_ode_solver', + 'scikits_odes_spec', 'scipy_solver', 'script_path', 'sech', 'sei', + 'sei_growth', 'separator', + 'separator_LGM50_heat_capacity_ORegan2022', 'serialise', + 'set_logging_level', 'settings', 'setup_callbacks', 'sigmoid', + 'sign', + 'silicon_LGM50_electrolyte_exchange_current_density_Chen2020', + 'silicon_ocp_delithiation_Mark2016', + 'silicon_ocp_lithiation_Mark2016', 'simplified_concatenation', + 'simplified_domain_concatenation', 'simplified_function', + 'simplified_numpy_concatenation', 'simplified_power', + 'simplify_if_constant', 'simulation', 'sin', 'single_ocp', 'sinh', + 'size_average', 'size_distribution_parameters', + 'smooth_absolute_value', 'smooth_max', 'smooth_min', 'softminus', + 'softplus', 'solution', 'solvers', 'source', 'spatial_method', + 'spatial_methods', 'spectral_volume', 'split_long_string', 'spm', + 'spme', 'sqrt', 'standard_spatial_vars', 'state_vector', 'step', + 'step_termination', 'steps', 'string', + 'stripping_exchange_current_density_OKane2020', 'submodels', + 'substrings', 'subtract', 'surf', 'surface_form_ohm', + 'surface_potential_form', 'swelling_only', 'symbol', + 'sympy_overrides', 't', 'tafel', 'tanh', + 'theoretical_energy_integral', 'thermal', 'thermal_parameters', + 'thevenin', 'through_cell', 'to_python', 'total_active_material', + 'total_interfacial_current', 'total_main_kinetics', + 'total_particle_concentration', 'total_sei', 'transport_efficiency', + 'transverse', 'unary_operators', 'uniform_convection', + 'unpack_symbols', 'update_LD_LIBRARY_PATH', 'upwind', 'util', + 'variable', 'vector', 'version', 'voltage', 'voltage_model', + 'volume_change_Ai2020', 'whole_cell', 'x', 'x_average', + 'x_averaged_polynomial_profile', 'x_edge', 'x_full', 'x_n', + 'x_n_edge', 'x_p', 'x_p_edge', 'x_s', 'x_s_edge', 'xyz_average', + 'y', 'y_edge', 'yz_average', 'z', 'z_average', 'z_edge', + 'zero_dimensional_method', 'zero_dimensional_submesh', 'zeros_like'] diff --git a/pybamm/discretisations/__init__.py b/pybamm/discretisations/__init__.py index e69de29bb2..cd3e5befb1 100644 --- a/pybamm/discretisations/__init__.py +++ b/pybamm/discretisations/__init__.py @@ -0,0 +1,17 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'discretisation', + }, + submod_attrs={ + 'discretisation': [ + 'Discretisation', + 'has_bc_of_form', + ], + }, +) + +__all__ = ['Discretisation', 'discretisation', 'has_bc_of_form'] diff --git a/pybamm/experiment/__init__.py b/pybamm/experiment/__init__.py index e69de29bb2..8fc2bf3442 100644 --- a/pybamm/experiment/__init__.py +++ b/pybamm/experiment/__init__.py @@ -0,0 +1,36 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'experiment', + 'step', + }, + submod_attrs={ + 'experiment': [ + 'Experiment', + ], + 'step': [ + 'BaseTermination', + 'CrateTermination', + 'CurrentTermination', + 'CustomTermination', + 'VoltageTermination', + 'c_rate', + 'current', + 'power', + 'resistance', + 'rest', + 'step_termination', + 'steps', + 'string', + 'voltage', + ], + }, +) + +__all__ = ['BaseTermination', 'CrateTermination', 'CurrentTermination', + 'CustomTermination', 'Experiment', 'VoltageTermination', 'c_rate', + 'current', 'experiment', 'power', 'resistance', 'rest', 'step', + 'step_termination', 'steps', 'string', 'voltage'] diff --git a/pybamm/experiment/step/__init__.py b/pybamm/experiment/step/__init__.py index e3b9ff8bd0..37ad3a1fbc 100644 --- a/pybamm/experiment/step/__init__.py +++ b/pybamm/experiment/step/__init__.py @@ -1,3 +1,33 @@ -from .steps import * -from .steps import _Step -from .step_termination import * +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'step_termination', + 'steps', + }, + submod_attrs={ + 'step_termination': [ + 'BaseTermination', + 'CrateTermination', + 'CurrentTermination', + 'CustomTermination', + 'VoltageTermination', + ], + 'steps': [ + 'c_rate', + 'current', + 'power', + 'resistance', + 'rest', + 'string', + 'voltage', + ], + }, +) + +__all__ = ['BaseTermination', 'CrateTermination', 'CurrentTermination', + 'CustomTermination', 'VoltageTermination', 'c_rate', 'current', + 'power', 'resistance', 'rest', 'step_termination', 'steps', + 'string', 'voltage'] diff --git a/pybamm/expression_tree/__init__.py b/pybamm/expression_tree/__init__.py index e69de29bb2..b73f4ccf7a 100644 --- a/pybamm/expression_tree/__init__.py +++ b/pybamm/expression_tree/__init__.py @@ -0,0 +1,344 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'array', + 'averages', + 'binary_operators', + 'broadcasts', + 'concatenations', + 'exceptions', + 'functions', + 'independent_variable', + 'input_parameter', + 'interpolant', + 'matrix', + 'operations', + 'parameter', + 'printing', + 'scalar', + 'state_vector', + 'symbol', + 'unary_operators', + 'variable', + 'vector', + }, + submod_attrs={ + 'array': [ + 'Array', + 'linspace', + 'meshgrid', + ], + 'averages': [ + 'RAverage', + 'SizeAverage', + 'XAverage', + 'YZAverage', + 'ZAverage', + 'r_average', + 'size_average', + 'x_average', + 'xyz_average', + 'yz_average', + 'z_average', + ], + 'binary_operators': [ + 'Addition', + 'BinaryOperator', + 'Division', + 'EqualHeaviside', + 'Equality', + 'Inner', + 'MatrixMultiplication', + 'Maximum', + 'Minimum', + 'Modulo', + 'Multiplication', + 'NotEqualHeaviside', + 'Power', + 'Subtraction', + 'add', + 'divide', + 'inner', + 'matmul', + 'maximum', + 'minimum', + 'multiply', + 'sigmoid', + 'simplified_power', + 'smooth_max', + 'smooth_min', + 'softminus', + 'softplus', + 'source', + 'subtract', + ], + 'broadcasts': [ + 'Broadcast', + 'FullBroadcast', + 'FullBroadcastToEdges', + 'PrimaryBroadcast', + 'PrimaryBroadcastToEdges', + 'SecondaryBroadcast', + 'SecondaryBroadcastToEdges', + 'TertiaryBroadcast', + 'TertiaryBroadcastToEdges', + 'full_like', + 'ones_like', + 'zeros_like', + ], + 'concatenations': [ + 'Concatenation', + 'ConcatenationVariable', + 'DomainConcatenation', + 'NumpyConcatenation', + 'SparseStack', + 'concatenation', + 'domain_concatenation', + 'intersect', + 'numpy_concatenation', + 'simplified_concatenation', + 'simplified_domain_concatenation', + 'simplified_numpy_concatenation', + 'substrings', + ], + 'exceptions': [ + 'DiscretisationError', + 'DomainError', + 'GeometryError', + 'ModelError', + 'ModelWarning', + 'OptionError', + 'OptionWarning', + 'ShapeError', + 'SolverError', + 'SolverWarning', + ], + 'functions': [ + 'Arcsinh', + 'Arctan', + 'Cos', + 'Cosh', + 'Erf', + 'Exp', + 'Function', + 'Log', + 'Max', + 'Min', + 'Sin', + 'Sinh', + 'SpecificFunction', + 'Sqrt', + 'Tanh', + 'arcsinh', + 'arctan', + 'cos', + 'cosh', + 'erf', + 'erfc', + 'exp', + 'log', + 'log10', + 'sech', + 'simplified_function', + 'sin', + 'sinh', + 'sqrt', + 'tanh', + ], + 'independent_variable': [ + 'IndependentVariable', + 'KNOWN_COORD_SYS', + 'SpatialVariable', + 'SpatialVariableEdge', + 'Time', + 't', + ], + 'input_parameter': [ + 'InputParameter', + ], + 'interpolant': [ + 'Interpolant', + ], + 'matrix': [ + 'Matrix', + ], + 'operations': [ + 'CasadiConverter', + 'EvaluatorJax', + 'EvaluatorJaxJacobian', + 'EvaluatorJaxSensitivities', + 'EvaluatorPython', + 'Jacobian', + 'JaxCooMatrix', + 'Latexify', + 'Serialise', + 'SymbolUnpacker', + 'convert_to_casadi', + 'create_jax_coo_matrix', + 'evaluate_python', + 'find_symbols', + 'get_rng_min_max_name', + 'id_to_python_variable', + 'is_scalar', + 'jacobian', + 'latexify', + 'serialise', + 'to_python', + 'unpack_symbols', + ], + 'parameter': [ + 'FunctionParameter', + 'Parameter', + ], + 'printing': [ + 'CustomPrint', + 'GREEK_LETTERS', + 'PRINT_NAME_OVERRIDES', + 'custom_print_func', + 'prettify_print_name', + 'print_name', + 'sympy_overrides', + ], + 'scalar': [ + 'Scalar', + ], + 'state_vector': [ + 'StateVector', + 'StateVectorBase', + 'StateVectorDot', + ], + 'symbol': [ + 'DOMAIN_LEVELS', + 'EMPTY_DOMAINS', + 'Symbol', + 'create_object_of_size', + 'domain_size', + 'evaluate_for_shape_using_domain', + 'is_constant', + 'is_matrix_minus_one', + 'is_matrix_one', + 'is_matrix_x', + 'is_matrix_zero', + 'is_scalar_minus_one', + 'is_scalar_one', + 'is_scalar_x', + 'is_scalar_zero', + 'simplify_if_constant', + ], + 'unary_operators': [ + 'AbsoluteValue', + 'BackwardIndefiniteIntegral', + 'BaseIndefiniteIntegral', + 'BoundaryGradient', + 'BoundaryIntegral', + 'BoundaryMass', + 'BoundaryOperator', + 'BoundaryValue', + 'Ceiling', + 'DefiniteIntegralVector', + 'DeltaFunction', + 'Divergence', + 'Downwind', + 'EvaluateAt', + 'ExplicitTimeIntegral', + 'Floor', + 'Gradient', + 'GradientSquared', + 'IndefiniteIntegral', + 'Index', + 'Integral', + 'Laplacian', + 'Mass', + 'Negate', + 'NotConstant', + 'Sign', + 'SpatialOperator', + 'UnaryOperator', + 'Upwind', + 'UpwindDownwind', + 'boundary_gradient', + 'boundary_value', + 'div', + 'downwind', + 'grad', + 'grad_squared', + 'laplacian', + 'sign', + 'smooth_absolute_value', + 'surf', + 'upwind', + ], + 'variable': [ + 'Variable', + 'VariableBase', + 'VariableDot', + ], + 'vector': [ + 'Vector', + ], + }, +) + +__all__ = ['AbsoluteValue', 'Addition', 'Arcsinh', 'Arctan', 'Array', + 'BackwardIndefiniteIntegral', 'BaseIndefiniteIntegral', + 'BinaryOperator', 'BoundaryGradient', 'BoundaryIntegral', + 'BoundaryMass', 'BoundaryOperator', 'BoundaryValue', 'Broadcast', + 'CasadiConverter', 'Ceiling', 'Concatenation', + 'ConcatenationVariable', 'Cos', 'Cosh', 'CustomPrint', + 'DOMAIN_LEVELS', 'DefiniteIntegralVector', 'DeltaFunction', + 'DiscretisationError', 'Divergence', 'Division', + 'DomainConcatenation', 'DomainError', 'Downwind', 'EMPTY_DOMAINS', + 'EqualHeaviside', 'Equality', 'Erf', 'EvaluateAt', 'EvaluatorJax', + 'EvaluatorJaxJacobian', 'EvaluatorJaxSensitivities', + 'EvaluatorPython', 'Exp', 'ExplicitTimeIntegral', 'Floor', + 'FullBroadcast', 'FullBroadcastToEdges', 'Function', + 'FunctionParameter', 'GREEK_LETTERS', 'GeometryError', 'Gradient', + 'GradientSquared', 'IndefiniteIntegral', 'IndependentVariable', + 'Index', 'Inner', 'InputParameter', 'Integral', 'Interpolant', + 'Jacobian', 'JaxCooMatrix', 'KNOWN_COORD_SYS', 'Laplacian', + 'Latexify', 'Log', 'Mass', 'Matrix', 'MatrixMultiplication', 'Max', + 'Maximum', 'Min', 'Minimum', 'ModelError', 'ModelWarning', 'Modulo', + 'Multiplication', 'Negate', 'NotConstant', 'NotEqualHeaviside', + 'NumpyConcatenation', 'OptionError', 'OptionWarning', + 'PRINT_NAME_OVERRIDES', 'Parameter', 'Power', 'PrimaryBroadcast', + 'PrimaryBroadcastToEdges', 'RAverage', 'Scalar', + 'SecondaryBroadcast', 'SecondaryBroadcastToEdges', 'Serialise', + 'ShapeError', 'Sign', 'Sin', 'Sinh', 'SizeAverage', 'SolverError', + 'SolverWarning', 'SparseStack', 'SpatialOperator', + 'SpatialVariable', 'SpatialVariableEdge', 'SpecificFunction', + 'Sqrt', 'StateVector', 'StateVectorBase', 'StateVectorDot', + 'Subtraction', 'Symbol', 'SymbolUnpacker', 'Tanh', + 'TertiaryBroadcast', 'TertiaryBroadcastToEdges', 'Time', + 'UnaryOperator', 'Upwind', 'UpwindDownwind', 'Variable', + 'VariableBase', 'VariableDot', 'Vector', 'XAverage', 'YZAverage', + 'ZAverage', 'add', 'arcsinh', 'arctan', 'array', 'averages', + 'binary_operators', 'boundary_gradient', 'boundary_value', + 'broadcasts', 'concatenation', 'concatenations', + 'convert_to_casadi', 'cos', 'cosh', 'create_jax_coo_matrix', + 'create_object_of_size', 'custom_print_func', 'div', 'divide', + 'domain_concatenation', 'domain_size', 'downwind', 'erf', 'erfc', + 'evaluate_for_shape_using_domain', 'evaluate_python', 'exceptions', + 'exp', 'find_symbols', 'full_like', 'functions', + 'get_rng_min_max_name', 'grad', 'grad_squared', + 'id_to_python_variable', 'independent_variable', 'inner', + 'input_parameter', 'interpolant', 'intersect', 'is_constant', + 'is_matrix_minus_one', 'is_matrix_one', 'is_matrix_x', + 'is_matrix_zero', 'is_scalar', 'is_scalar_minus_one', + 'is_scalar_one', 'is_scalar_x', 'is_scalar_zero', 'jacobian', + 'laplacian', 'latexify', 'linspace', 'log', 'log10', 'matmul', + 'matrix', 'maximum', 'meshgrid', 'minimum', 'multiply', + 'numpy_concatenation', 'ones_like', 'operations', 'parameter', + 'prettify_print_name', 'print_name', 'printing', 'r_average', + 'scalar', 'sech', 'serialise', 'sigmoid', 'sign', + 'simplified_concatenation', 'simplified_domain_concatenation', + 'simplified_function', 'simplified_numpy_concatenation', + 'simplified_power', 'simplify_if_constant', 'sin', 'sinh', + 'size_average', 'smooth_absolute_value', 'smooth_max', 'smooth_min', + 'softminus', 'softplus', 'source', 'sqrt', 'state_vector', + 'substrings', 'subtract', 'surf', 'symbol', 'sympy_overrides', 't', + 'tanh', 'to_python', 'unary_operators', 'unpack_symbols', 'upwind', + 'variable', 'vector', 'x_average', 'xyz_average', 'yz_average', + 'z_average', 'zeros_like'] diff --git a/pybamm/expression_tree/operations/__init__.py b/pybamm/expression_tree/operations/__init__.py index e69de29bb2..25f3999bf8 100644 --- a/pybamm/expression_tree/operations/__init__.py +++ b/pybamm/expression_tree/operations/__init__.py @@ -0,0 +1,52 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'convert_to_casadi', + 'evaluate_python', + 'jacobian', + 'latexify', + 'serialise', + 'unpack_symbols', + }, + submod_attrs={ + 'convert_to_casadi': [ + 'CasadiConverter', + ], + 'evaluate_python': [ + 'EvaluatorJax', + 'EvaluatorJaxJacobian', + 'EvaluatorJaxSensitivities', + 'EvaluatorPython', + 'JaxCooMatrix', + 'create_jax_coo_matrix', + 'find_symbols', + 'id_to_python_variable', + 'is_scalar', + 'to_python', + ], + 'jacobian': [ + 'Jacobian', + ], + 'latexify': [ + 'Latexify', + 'get_rng_min_max_name', + ], + 'serialise': [ + 'Serialise', + ], + 'unpack_symbols': [ + 'SymbolUnpacker', + ], + }, +) + +__all__ = ['CasadiConverter', 'EvaluatorJax', 'EvaluatorJaxJacobian', + 'EvaluatorJaxSensitivities', 'EvaluatorPython', 'Jacobian', + 'JaxCooMatrix', 'Latexify', 'Serialise', 'SymbolUnpacker', + 'convert_to_casadi', 'create_jax_coo_matrix', 'evaluate_python', + 'find_symbols', 'get_rng_min_max_name', 'id_to_python_variable', + 'is_scalar', 'jacobian', 'latexify', 'serialise', 'to_python', + 'unpack_symbols'] diff --git a/pybamm/expression_tree/printing/__init__.py b/pybamm/expression_tree/printing/__init__.py index e69de29bb2..58832a6eb6 100644 --- a/pybamm/expression_tree/printing/__init__.py +++ b/pybamm/expression_tree/printing/__init__.py @@ -0,0 +1,25 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'print_name', + 'sympy_overrides', + }, + submod_attrs={ + 'print_name': [ + 'GREEK_LETTERS', + 'PRINT_NAME_OVERRIDES', + 'prettify_print_name', + ], + 'sympy_overrides': [ + 'CustomPrint', + 'custom_print_func', + ], + }, +) + +__all__ = ['CustomPrint', 'GREEK_LETTERS', 'PRINT_NAME_OVERRIDES', + 'custom_print_func', 'prettify_print_name', 'print_name', + 'sympy_overrides'] diff --git a/pybamm/geometry/__init__.py b/pybamm/geometry/__init__.py index e69de29bb2..7456e6aaf1 100644 --- a/pybamm/geometry/__init__.py +++ b/pybamm/geometry/__init__.py @@ -0,0 +1,55 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'battery_geometry', + 'geometry', + 'standard_spatial_vars', + }, + submod_attrs={ + 'battery_geometry': [ + 'battery_geometry', + ], + 'geometry': [ + 'Geometry', + ], + 'standard_spatial_vars': [ + 'R_n', + 'R_n_edge', + 'R_p', + 'R_p_edge', + 'r_macro', + 'r_macro_edge', + 'r_n', + 'r_n_edge', + 'r_n_prim', + 'r_n_sec', + 'r_p', + 'r_p_edge', + 'r_p_prim', + 'r_p_sec', + 'whole_cell', + 'x', + 'x_edge', + 'x_n', + 'x_n_edge', + 'x_p', + 'x_p_edge', + 'x_s', + 'x_s_edge', + 'y', + 'y_edge', + 'z', + 'z_edge', + ], + }, +) + +__all__ = ['Geometry', 'R_n', 'R_n_edge', 'R_p', 'R_p_edge', + 'battery_geometry', 'geometry', 'r_macro', 'r_macro_edge', 'r_n', + 'r_n_edge', 'r_n_prim', 'r_n_sec', 'r_p', 'r_p_edge', 'r_p_prim', + 'r_p_sec', 'standard_spatial_vars', 'whole_cell', 'x', 'x_edge', + 'x_n', 'x_n_edge', 'x_p', 'x_p_edge', 'x_s', 'x_s_edge', 'y', + 'y_edge', 'z', 'z_edge'] diff --git a/pybamm/input/__init__.py b/pybamm/input/__init__.py index e69de29bb2..1b3c9bcfb5 100644 --- a/pybamm/input/__init__.py +++ b/pybamm/input/__init__.py @@ -0,0 +1,261 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'parameters', + }, + submod_attrs={ + 'parameters': [ + 'Ai2020', + 'Chen2020', + 'Chen2020_composite', + 'Ecker2015', + 'Ecker2015_graphite_halfcell', + 'LFP_electrolyte_exchange_current_density_kashkooli2017', + 'LFP_ocp_Afshar2017', + 'MSMR_example_set', + 'Marquis2019', + 'Mohtat2020', + 'NCA_Kim2011', + 'NMC_diffusivity_PeymanMPM', + 'NMC_electrolyte_exchange_current_density_PeymanMPM', + 'NMC_entropic_change_PeymanMPM', + 'NMC_ocp_PeymanMPM', + 'OKane2022', + 'OKane2022_graphite_SiOx_halfcell', + 'ORegan2022', + 'Prada2013', + 'Ramadass2004', + 'SEI_limited_dead_lithium_OKane2022', + 'Sulzer2019', + 'Xu2019', + 'aluminium_heat_capacity_CRC', + 'c1', + 'c1_data', + 'conductivity_Gu1997', + 'copper_heat_capacity_CRC', + 'copper_thermal_conductivity_CRC', + 'cracking_rate_Ai2020', + 'dUdT', + 'dUdT_data', + 'darken_thermodynamic_factor_Chapman1968', + 'diffusivity_Gu1997', + 'dlnf_dlnc_Ai2020', + 'ecm', + 'electrolyte_TDF_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_TDF_base_Landesfeind2019', + 'electrolyte_conductivity_Ai2020', + 'electrolyte_conductivity_Capiglia1999', + 'electrolyte_conductivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_conductivity_Ecker2015', + 'electrolyte_conductivity_Kim2011', + 'electrolyte_conductivity_Nyman2008', + 'electrolyte_conductivity_Nyman2008_arrhenius', + 'electrolyte_conductivity_PeymanMPM', + 'electrolyte_conductivity_Prada2013', + 'electrolyte_conductivity_Ramadass2004', + 'electrolyte_conductivity_Valoen2005', + 'electrolyte_conductivity_base_Landesfeind2019', + 'electrolyte_diffusivity_Ai2020', + 'electrolyte_diffusivity_Capiglia1999', + 'electrolyte_diffusivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_diffusivity_Ecker2015', + 'electrolyte_diffusivity_Kim2011', + 'electrolyte_diffusivity_Nyman2008', + 'electrolyte_diffusivity_Nyman2008_arrhenius', + 'electrolyte_diffusivity_PeymanMPM', + 'electrolyte_diffusivity_Ramadass2004', + 'electrolyte_diffusivity_Valoen2005', + 'electrolyte_diffusivity_base_Landesfeind2019', + 'electrolyte_transference_number_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_transference_number_base_Landesfeind2019', + 'example_set', + 'get_parameter_values', + 'graphite_LGM50_diffusivity_Chen2020', + 'graphite_LGM50_diffusivity_ORegan2022', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'graphite_LGM50_entropic_change_ORegan2022', + 'graphite_LGM50_heat_capacity_ORegan2022', + 'graphite_LGM50_ocp_Chen2020', + 'graphite_LGM50_ocp_Chen2020_data', + 'graphite_LGM50_thermal_conductivity_ORegan2022', + 'graphite_cracking_rate_Ai2020', + 'graphite_diffusivity_Dualfoil1998', + 'graphite_diffusivity_Ecker2015', + 'graphite_diffusivity_Kim2011', + 'graphite_diffusivity_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Dualfoil1998', + 'graphite_electrolyte_exchange_current_density_Ecker2015', + 'graphite_electrolyte_exchange_current_density_Kim2011', + 'graphite_electrolyte_exchange_current_density_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Ramadass2004', + 'graphite_entropic_change_Moura2016', + 'graphite_entropic_change_PeymanMPM', + 'graphite_entropy_Enertech_Ai2020_function', + 'graphite_mcmb2528_diffusivity_Dualfoil1998', + 'graphite_mcmb2528_ocp_Dualfoil1998', + 'graphite_ocp_Ecker2015', + 'graphite_ocp_Enertech_Ai2020', + 'graphite_ocp_Enertech_Ai2020_data', + 'graphite_ocp_Kim2011', + 'graphite_ocp_PeymanMPM', + 'graphite_ocp_Ramadass2004', + 'graphite_volume_change_Ai2020', + 'lead_acid', + 'lead_dioxide_exchange_current_density_Sulzer2019', + 'lead_dioxide_ocp_Bode1977', + 'lead_exchange_current_density_Sulzer2019', + 'lead_ocp_Bode1977', + 'li_metal_electrolyte_exchange_current_density_Xu2019', + 'lico2_cracking_rate_Ai2020', + 'lico2_diffusivity_Dualfoil1998', + 'lico2_diffusivity_Ramadass2004', + 'lico2_electrolyte_exchange_current_density_Dualfoil1998', + 'lico2_electrolyte_exchange_current_density_Ramadass2004', + 'lico2_entropic_change_Ai2020_function', + 'lico2_entropic_change_Moura2016', + 'lico2_ocp_Ai2020', + 'lico2_ocp_Ai2020_data', + 'lico2_ocp_Dualfoil1998', + 'lico2_ocp_Ramadass2004', + 'lico2_volume_change_Ai2020', + 'lithium_ion', + 'nca_diffusivity_Kim2011', + 'nca_electrolyte_exchange_current_density_Kim2011', + 'nca_ocp_Kim2011', + 'nco_diffusivity_Ecker2015', + 'nco_electrolyte_exchange_current_density_Ecker2015', + 'nco_ocp_Ecker2015', + 'nmc_LGM50_diffusivity_Chen2020', + 'nmc_LGM50_diffusivity_ORegan2022', + 'nmc_LGM50_electrolyte_exchange_current_density_Chen2020', + 'nmc_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'nmc_LGM50_electronic_conductivity_ORegan2022', + 'nmc_LGM50_entropic_change_ORegan2022', + 'nmc_LGM50_heat_capacity_ORegan2022', + 'nmc_LGM50_ocp_Chen2020', + 'nmc_LGM50_thermal_conductivity_ORegan2022', + 'nmc_electrolyte_exchange_current_density_Xu2019', + 'nmc_ocp_Xu2019', + 'ocv', + 'ocv_data', + 'oxygen_exchange_current_density_Sulzer2019', + 'plating_exchange_current_density_OKane2020', + 'r0', + 'r0_data', + 'r1', + 'r1_data', + 'separator_LGM50_heat_capacity_ORegan2022', + 'silicon_LGM50_electrolyte_exchange_current_density_Chen2020', + 'silicon_ocp_delithiation_Mark2016', + 'silicon_ocp_lithiation_Mark2016', + 'stripping_exchange_current_density_OKane2020', + 'volume_change_Ai2020', + ], + }, +) + +__all__ = ['Ai2020', 'Chen2020', 'Chen2020_composite', 'Ecker2015', + 'Ecker2015_graphite_halfcell', + 'LFP_electrolyte_exchange_current_density_kashkooli2017', + 'LFP_ocp_Afshar2017', 'MSMR_example_set', 'Marquis2019', + 'Mohtat2020', 'NCA_Kim2011', 'NMC_diffusivity_PeymanMPM', + 'NMC_electrolyte_exchange_current_density_PeymanMPM', + 'NMC_entropic_change_PeymanMPM', 'NMC_ocp_PeymanMPM', 'OKane2022', + 'OKane2022_graphite_SiOx_halfcell', 'ORegan2022', 'Prada2013', + 'Ramadass2004', 'SEI_limited_dead_lithium_OKane2022', 'Sulzer2019', + 'Xu2019', 'aluminium_heat_capacity_CRC', 'c1', 'c1_data', + 'conductivity_Gu1997', 'copper_heat_capacity_CRC', + 'copper_thermal_conductivity_CRC', 'cracking_rate_Ai2020', 'dUdT', + 'dUdT_data', 'darken_thermodynamic_factor_Chapman1968', + 'diffusivity_Gu1997', 'dlnf_dlnc_Ai2020', 'ecm', + 'electrolyte_TDF_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_TDF_base_Landesfeind2019', + 'electrolyte_conductivity_Ai2020', + 'electrolyte_conductivity_Capiglia1999', + 'electrolyte_conductivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_conductivity_Ecker2015', + 'electrolyte_conductivity_Kim2011', + 'electrolyte_conductivity_Nyman2008', + 'electrolyte_conductivity_Nyman2008_arrhenius', + 'electrolyte_conductivity_PeymanMPM', + 'electrolyte_conductivity_Prada2013', + 'electrolyte_conductivity_Ramadass2004', + 'electrolyte_conductivity_Valoen2005', + 'electrolyte_conductivity_base_Landesfeind2019', + 'electrolyte_diffusivity_Ai2020', + 'electrolyte_diffusivity_Capiglia1999', + 'electrolyte_diffusivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_diffusivity_Ecker2015', + 'electrolyte_diffusivity_Kim2011', + 'electrolyte_diffusivity_Nyman2008', + 'electrolyte_diffusivity_Nyman2008_arrhenius', + 'electrolyte_diffusivity_PeymanMPM', + 'electrolyte_diffusivity_Ramadass2004', + 'electrolyte_diffusivity_Valoen2005', + 'electrolyte_diffusivity_base_Landesfeind2019', + 'electrolyte_transference_number_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_transference_number_base_Landesfeind2019', + 'example_set', 'get_parameter_values', + 'graphite_LGM50_diffusivity_Chen2020', + 'graphite_LGM50_diffusivity_ORegan2022', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'graphite_LGM50_entropic_change_ORegan2022', + 'graphite_LGM50_heat_capacity_ORegan2022', + 'graphite_LGM50_ocp_Chen2020', 'graphite_LGM50_ocp_Chen2020_data', + 'graphite_LGM50_thermal_conductivity_ORegan2022', + 'graphite_cracking_rate_Ai2020', + 'graphite_diffusivity_Dualfoil1998', + 'graphite_diffusivity_Ecker2015', 'graphite_diffusivity_Kim2011', + 'graphite_diffusivity_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Dualfoil1998', + 'graphite_electrolyte_exchange_current_density_Ecker2015', + 'graphite_electrolyte_exchange_current_density_Kim2011', + 'graphite_electrolyte_exchange_current_density_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Ramadass2004', + 'graphite_entropic_change_Moura2016', + 'graphite_entropic_change_PeymanMPM', + 'graphite_entropy_Enertech_Ai2020_function', + 'graphite_mcmb2528_diffusivity_Dualfoil1998', + 'graphite_mcmb2528_ocp_Dualfoil1998', 'graphite_ocp_Ecker2015', + 'graphite_ocp_Enertech_Ai2020', 'graphite_ocp_Enertech_Ai2020_data', + 'graphite_ocp_Kim2011', 'graphite_ocp_PeymanMPM', + 'graphite_ocp_Ramadass2004', 'graphite_volume_change_Ai2020', + 'lead_acid', 'lead_dioxide_exchange_current_density_Sulzer2019', + 'lead_dioxide_ocp_Bode1977', + 'lead_exchange_current_density_Sulzer2019', 'lead_ocp_Bode1977', + 'li_metal_electrolyte_exchange_current_density_Xu2019', + 'lico2_cracking_rate_Ai2020', 'lico2_diffusivity_Dualfoil1998', + 'lico2_diffusivity_Ramadass2004', + 'lico2_electrolyte_exchange_current_density_Dualfoil1998', + 'lico2_electrolyte_exchange_current_density_Ramadass2004', + 'lico2_entropic_change_Ai2020_function', + 'lico2_entropic_change_Moura2016', 'lico2_ocp_Ai2020', + 'lico2_ocp_Ai2020_data', 'lico2_ocp_Dualfoil1998', + 'lico2_ocp_Ramadass2004', 'lico2_volume_change_Ai2020', + 'lithium_ion', 'nca_diffusivity_Kim2011', + 'nca_electrolyte_exchange_current_density_Kim2011', + 'nca_ocp_Kim2011', 'nco_diffusivity_Ecker2015', + 'nco_electrolyte_exchange_current_density_Ecker2015', + 'nco_ocp_Ecker2015', 'nmc_LGM50_diffusivity_Chen2020', + 'nmc_LGM50_diffusivity_ORegan2022', + 'nmc_LGM50_electrolyte_exchange_current_density_Chen2020', + 'nmc_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'nmc_LGM50_electronic_conductivity_ORegan2022', + 'nmc_LGM50_entropic_change_ORegan2022', + 'nmc_LGM50_heat_capacity_ORegan2022', 'nmc_LGM50_ocp_Chen2020', + 'nmc_LGM50_thermal_conductivity_ORegan2022', + 'nmc_electrolyte_exchange_current_density_Xu2019', 'nmc_ocp_Xu2019', + 'ocv', 'ocv_data', 'oxygen_exchange_current_density_Sulzer2019', + 'parameters', 'plating_exchange_current_density_OKane2020', 'r0', + 'r0_data', 'r1', 'r1_data', + 'separator_LGM50_heat_capacity_ORegan2022', + 'silicon_LGM50_electrolyte_exchange_current_density_Chen2020', + 'silicon_ocp_delithiation_Mark2016', + 'silicon_ocp_lithiation_Mark2016', + 'stripping_exchange_current_density_OKane2020', + 'volume_change_Ai2020'] diff --git a/pybamm/input/parameters/__init__.py b/pybamm/input/parameters/__init__.py index e69de29bb2..92bab2a5b0 100644 --- a/pybamm/input/parameters/__init__.py +++ b/pybamm/input/parameters/__init__.py @@ -0,0 +1,265 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'ecm', + 'lead_acid', + 'lithium_ion', + }, + submod_attrs={ + 'ecm': [ + 'c1', + 'c1_data', + 'dUdT', + 'dUdT_data', + 'example_set', + 'get_parameter_values', + 'ocv', + 'ocv_data', + 'r0', + 'r0_data', + 'r1', + 'r1_data', + ], + 'lead_acid': [ + 'Sulzer2019', + 'conductivity_Gu1997', + 'darken_thermodynamic_factor_Chapman1968', + 'diffusivity_Gu1997', + 'get_parameter_values', + 'lead_dioxide_exchange_current_density_Sulzer2019', + 'lead_dioxide_ocp_Bode1977', + 'lead_exchange_current_density_Sulzer2019', + 'lead_ocp_Bode1977', + 'oxygen_exchange_current_density_Sulzer2019', + ], + 'lithium_ion': [ + 'Ai2020', + 'Chen2020', + 'Chen2020_composite', + 'Ecker2015', + 'Ecker2015_graphite_halfcell', + 'LFP_electrolyte_exchange_current_density_kashkooli2017', + 'LFP_ocp_Afshar2017', + 'MSMR_example_set', + 'Marquis2019', + 'Mohtat2020', + 'NCA_Kim2011', + 'NMC_diffusivity_PeymanMPM', + 'NMC_electrolyte_exchange_current_density_PeymanMPM', + 'NMC_entropic_change_PeymanMPM', + 'NMC_ocp_PeymanMPM', + 'OKane2022', + 'OKane2022_graphite_SiOx_halfcell', + 'ORegan2022', + 'Prada2013', + 'Ramadass2004', + 'SEI_limited_dead_lithium_OKane2022', + 'Xu2019', + 'aluminium_heat_capacity_CRC', + 'copper_heat_capacity_CRC', + 'copper_thermal_conductivity_CRC', + 'cracking_rate_Ai2020', + 'dlnf_dlnc_Ai2020', + 'electrolyte_TDF_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_TDF_base_Landesfeind2019', + 'electrolyte_conductivity_Ai2020', + 'electrolyte_conductivity_Capiglia1999', + 'electrolyte_conductivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_conductivity_Ecker2015', + 'electrolyte_conductivity_Kim2011', + 'electrolyte_conductivity_Nyman2008', + 'electrolyte_conductivity_Nyman2008_arrhenius', + 'electrolyte_conductivity_PeymanMPM', + 'electrolyte_conductivity_Prada2013', + 'electrolyte_conductivity_Ramadass2004', + 'electrolyte_conductivity_Valoen2005', + 'electrolyte_conductivity_base_Landesfeind2019', + 'electrolyte_diffusivity_Ai2020', + 'electrolyte_diffusivity_Capiglia1999', + 'electrolyte_diffusivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_diffusivity_Ecker2015', + 'electrolyte_diffusivity_Kim2011', + 'electrolyte_diffusivity_Nyman2008', + 'electrolyte_diffusivity_Nyman2008_arrhenius', + 'electrolyte_diffusivity_PeymanMPM', + 'electrolyte_diffusivity_Ramadass2004', + 'electrolyte_diffusivity_Valoen2005', + 'electrolyte_diffusivity_base_Landesfeind2019', + 'electrolyte_transference_number_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_transference_number_base_Landesfeind2019', + 'get_parameter_values', + 'graphite_LGM50_diffusivity_Chen2020', + 'graphite_LGM50_diffusivity_ORegan2022', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'graphite_LGM50_entropic_change_ORegan2022', + 'graphite_LGM50_heat_capacity_ORegan2022', + 'graphite_LGM50_ocp_Chen2020', + 'graphite_LGM50_ocp_Chen2020_data', + 'graphite_LGM50_thermal_conductivity_ORegan2022', + 'graphite_cracking_rate_Ai2020', + 'graphite_diffusivity_Dualfoil1998', + 'graphite_diffusivity_Ecker2015', + 'graphite_diffusivity_Kim2011', + 'graphite_diffusivity_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Dualfoil1998', + 'graphite_electrolyte_exchange_current_density_Ecker2015', + 'graphite_electrolyte_exchange_current_density_Kim2011', + 'graphite_electrolyte_exchange_current_density_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Ramadass2004', + 'graphite_entropic_change_Moura2016', + 'graphite_entropic_change_PeymanMPM', + 'graphite_entropy_Enertech_Ai2020_function', + 'graphite_mcmb2528_diffusivity_Dualfoil1998', + 'graphite_mcmb2528_ocp_Dualfoil1998', + 'graphite_ocp_Ecker2015', + 'graphite_ocp_Enertech_Ai2020', + 'graphite_ocp_Enertech_Ai2020_data', + 'graphite_ocp_Kim2011', + 'graphite_ocp_PeymanMPM', + 'graphite_ocp_Ramadass2004', + 'graphite_volume_change_Ai2020', + 'li_metal_electrolyte_exchange_current_density_Xu2019', + 'lico2_cracking_rate_Ai2020', + 'lico2_diffusivity_Dualfoil1998', + 'lico2_diffusivity_Ramadass2004', + 'lico2_electrolyte_exchange_current_density_Dualfoil1998', + 'lico2_electrolyte_exchange_current_density_Ramadass2004', + 'lico2_entropic_change_Ai2020_function', + 'lico2_entropic_change_Moura2016', + 'lico2_ocp_Ai2020', + 'lico2_ocp_Ai2020_data', + 'lico2_ocp_Dualfoil1998', + 'lico2_ocp_Ramadass2004', + 'lico2_volume_change_Ai2020', + 'nca_diffusivity_Kim2011', + 'nca_electrolyte_exchange_current_density_Kim2011', + 'nca_ocp_Kim2011', + 'nco_diffusivity_Ecker2015', + 'nco_electrolyte_exchange_current_density_Ecker2015', + 'nco_ocp_Ecker2015', + 'nmc_LGM50_diffusivity_Chen2020', + 'nmc_LGM50_diffusivity_ORegan2022', + 'nmc_LGM50_electrolyte_exchange_current_density_Chen2020', + 'nmc_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'nmc_LGM50_electronic_conductivity_ORegan2022', + 'nmc_LGM50_entropic_change_ORegan2022', + 'nmc_LGM50_heat_capacity_ORegan2022', + 'nmc_LGM50_ocp_Chen2020', + 'nmc_LGM50_thermal_conductivity_ORegan2022', + 'nmc_electrolyte_exchange_current_density_Xu2019', + 'nmc_ocp_Xu2019', + 'plating_exchange_current_density_OKane2020', + 'separator_LGM50_heat_capacity_ORegan2022', + 'silicon_LGM50_electrolyte_exchange_current_density_Chen2020', + 'silicon_ocp_delithiation_Mark2016', + 'silicon_ocp_lithiation_Mark2016', + 'stripping_exchange_current_density_OKane2020', + 'volume_change_Ai2020', + ], + }, +) + +__all__ = ['Ai2020', 'Chen2020', 'Chen2020_composite', 'Ecker2015', + 'Ecker2015_graphite_halfcell', + 'LFP_electrolyte_exchange_current_density_kashkooli2017', + 'LFP_ocp_Afshar2017', 'MSMR_example_set', 'Marquis2019', + 'Mohtat2020', 'NCA_Kim2011', 'NMC_diffusivity_PeymanMPM', + 'NMC_electrolyte_exchange_current_density_PeymanMPM', + 'NMC_entropic_change_PeymanMPM', 'NMC_ocp_PeymanMPM', 'OKane2022', + 'OKane2022_graphite_SiOx_halfcell', 'ORegan2022', 'Prada2013', + 'Ramadass2004', 'SEI_limited_dead_lithium_OKane2022', 'Sulzer2019', + 'Xu2019', 'aluminium_heat_capacity_CRC', 'c1', 'c1_data', + 'conductivity_Gu1997', 'copper_heat_capacity_CRC', + 'copper_thermal_conductivity_CRC', 'cracking_rate_Ai2020', 'dUdT', + 'dUdT_data', 'darken_thermodynamic_factor_Chapman1968', + 'diffusivity_Gu1997', 'dlnf_dlnc_Ai2020', 'ecm', + 'electrolyte_TDF_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_TDF_base_Landesfeind2019', + 'electrolyte_conductivity_Ai2020', + 'electrolyte_conductivity_Capiglia1999', + 'electrolyte_conductivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_conductivity_Ecker2015', + 'electrolyte_conductivity_Kim2011', + 'electrolyte_conductivity_Nyman2008', + 'electrolyte_conductivity_Nyman2008_arrhenius', + 'electrolyte_conductivity_PeymanMPM', + 'electrolyte_conductivity_Prada2013', + 'electrolyte_conductivity_Ramadass2004', + 'electrolyte_conductivity_Valoen2005', + 'electrolyte_conductivity_base_Landesfeind2019', + 'electrolyte_diffusivity_Ai2020', + 'electrolyte_diffusivity_Capiglia1999', + 'electrolyte_diffusivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_diffusivity_Ecker2015', + 'electrolyte_diffusivity_Kim2011', + 'electrolyte_diffusivity_Nyman2008', + 'electrolyte_diffusivity_Nyman2008_arrhenius', + 'electrolyte_diffusivity_PeymanMPM', + 'electrolyte_diffusivity_Ramadass2004', + 'electrolyte_diffusivity_Valoen2005', + 'electrolyte_diffusivity_base_Landesfeind2019', + 'electrolyte_transference_number_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_transference_number_base_Landesfeind2019', + 'example_set', 'get_parameter_values', + 'graphite_LGM50_diffusivity_Chen2020', + 'graphite_LGM50_diffusivity_ORegan2022', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'graphite_LGM50_entropic_change_ORegan2022', + 'graphite_LGM50_heat_capacity_ORegan2022', + 'graphite_LGM50_ocp_Chen2020', 'graphite_LGM50_ocp_Chen2020_data', + 'graphite_LGM50_thermal_conductivity_ORegan2022', + 'graphite_cracking_rate_Ai2020', + 'graphite_diffusivity_Dualfoil1998', + 'graphite_diffusivity_Ecker2015', 'graphite_diffusivity_Kim2011', + 'graphite_diffusivity_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Dualfoil1998', + 'graphite_electrolyte_exchange_current_density_Ecker2015', + 'graphite_electrolyte_exchange_current_density_Kim2011', + 'graphite_electrolyte_exchange_current_density_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Ramadass2004', + 'graphite_entropic_change_Moura2016', + 'graphite_entropic_change_PeymanMPM', + 'graphite_entropy_Enertech_Ai2020_function', + 'graphite_mcmb2528_diffusivity_Dualfoil1998', + 'graphite_mcmb2528_ocp_Dualfoil1998', 'graphite_ocp_Ecker2015', + 'graphite_ocp_Enertech_Ai2020', 'graphite_ocp_Enertech_Ai2020_data', + 'graphite_ocp_Kim2011', 'graphite_ocp_PeymanMPM', + 'graphite_ocp_Ramadass2004', 'graphite_volume_change_Ai2020', + 'lead_acid', 'lead_dioxide_exchange_current_density_Sulzer2019', + 'lead_dioxide_ocp_Bode1977', + 'lead_exchange_current_density_Sulzer2019', 'lead_ocp_Bode1977', + 'li_metal_electrolyte_exchange_current_density_Xu2019', + 'lico2_cracking_rate_Ai2020', 'lico2_diffusivity_Dualfoil1998', + 'lico2_diffusivity_Ramadass2004', + 'lico2_electrolyte_exchange_current_density_Dualfoil1998', + 'lico2_electrolyte_exchange_current_density_Ramadass2004', + 'lico2_entropic_change_Ai2020_function', + 'lico2_entropic_change_Moura2016', 'lico2_ocp_Ai2020', + 'lico2_ocp_Ai2020_data', 'lico2_ocp_Dualfoil1998', + 'lico2_ocp_Ramadass2004', 'lico2_volume_change_Ai2020', + 'lithium_ion', 'nca_diffusivity_Kim2011', + 'nca_electrolyte_exchange_current_density_Kim2011', + 'nca_ocp_Kim2011', 'nco_diffusivity_Ecker2015', + 'nco_electrolyte_exchange_current_density_Ecker2015', + 'nco_ocp_Ecker2015', 'nmc_LGM50_diffusivity_Chen2020', + 'nmc_LGM50_diffusivity_ORegan2022', + 'nmc_LGM50_electrolyte_exchange_current_density_Chen2020', + 'nmc_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'nmc_LGM50_electronic_conductivity_ORegan2022', + 'nmc_LGM50_entropic_change_ORegan2022', + 'nmc_LGM50_heat_capacity_ORegan2022', 'nmc_LGM50_ocp_Chen2020', + 'nmc_LGM50_thermal_conductivity_ORegan2022', + 'nmc_electrolyte_exchange_current_density_Xu2019', 'nmc_ocp_Xu2019', + 'ocv', 'ocv_data', 'oxygen_exchange_current_density_Sulzer2019', + 'plating_exchange_current_density_OKane2020', 'r0', 'r0_data', 'r1', + 'r1_data', 'separator_LGM50_heat_capacity_ORegan2022', + 'silicon_LGM50_electrolyte_exchange_current_density_Chen2020', + 'silicon_ocp_delithiation_Mark2016', + 'silicon_ocp_lithiation_Mark2016', + 'stripping_exchange_current_density_OKane2020', + 'volume_change_Ai2020'] diff --git a/pybamm/input/parameters/ecm/__init__.py b/pybamm/input/parameters/ecm/__init__.py index e69de29bb2..ab4af0968c 100644 --- a/pybamm/input/parameters/ecm/__init__.py +++ b/pybamm/input/parameters/ecm/__init__.py @@ -0,0 +1,28 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'example_set', + }, + submod_attrs={ + 'example_set': [ + 'c1', + 'c1_data', + 'dUdT', + 'dUdT_data', + 'get_parameter_values', + 'ocv', + 'ocv_data', + 'r0', + 'r0_data', + 'r1', + 'r1_data', + ], + }, +) + +__all__ = ['c1', 'c1_data', 'dUdT', 'dUdT_data', 'example_set', + 'get_parameter_values', 'ocv', 'ocv_data', 'r0', 'r0_data', 'r1', + 'r1_data'] diff --git a/pybamm/input/parameters/lead_acid/__init__.py b/pybamm/input/parameters/lead_acid/__init__.py index e69de29bb2..37a64a6016 100644 --- a/pybamm/input/parameters/lead_acid/__init__.py +++ b/pybamm/input/parameters/lead_acid/__init__.py @@ -0,0 +1,30 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'Sulzer2019', + }, + submod_attrs={ + 'Sulzer2019': [ + 'conductivity_Gu1997', + 'darken_thermodynamic_factor_Chapman1968', + 'diffusivity_Gu1997', + 'get_parameter_values', + 'lead_dioxide_exchange_current_density_Sulzer2019', + 'lead_dioxide_ocp_Bode1977', + 'lead_exchange_current_density_Sulzer2019', + 'lead_ocp_Bode1977', + 'oxygen_exchange_current_density_Sulzer2019', + ], + }, +) + +__all__ = ['Sulzer2019', 'conductivity_Gu1997', + 'darken_thermodynamic_factor_Chapman1968', 'diffusivity_Gu1997', + 'get_parameter_values', + 'lead_dioxide_exchange_current_density_Sulzer2019', + 'lead_dioxide_ocp_Bode1977', + 'lead_exchange_current_density_Sulzer2019', 'lead_ocp_Bode1977', + 'oxygen_exchange_current_density_Sulzer2019'] diff --git a/pybamm/input/parameters/lithium_ion/__init__.py b/pybamm/input/parameters/lithium_ion/__init__.py index e69de29bb2..5e60e464c5 100644 --- a/pybamm/input/parameters/lithium_ion/__init__.py +++ b/pybamm/input/parameters/lithium_ion/__init__.py @@ -0,0 +1,313 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'Ai2020', + 'Chen2020', + 'Chen2020_composite', + 'Ecker2015', + 'Ecker2015_graphite_halfcell', + 'MSMR_example_set', + 'Marquis2019', + 'Mohtat2020', + 'NCA_Kim2011', + 'OKane2022', + 'OKane2022_graphite_SiOx_halfcell', + 'ORegan2022', + 'Prada2013', + 'Ramadass2004', + 'Xu2019', + }, + submod_attrs={ + 'Ai2020': [ + 'dlnf_dlnc_Ai2020', + 'electrolyte_conductivity_Ai2020', + 'electrolyte_diffusivity_Ai2020', + 'get_parameter_values', + 'graphite_cracking_rate_Ai2020', + 'graphite_diffusivity_Dualfoil1998', + 'graphite_electrolyte_exchange_current_density_Dualfoil1998', + 'graphite_entropy_Enertech_Ai2020_function', + 'graphite_ocp_Enertech_Ai2020', + 'graphite_ocp_Enertech_Ai2020_data', + 'graphite_volume_change_Ai2020', + 'lico2_cracking_rate_Ai2020', + 'lico2_diffusivity_Dualfoil1998', + 'lico2_electrolyte_exchange_current_density_Dualfoil1998', + 'lico2_entropic_change_Ai2020_function', + 'lico2_ocp_Ai2020', + 'lico2_ocp_Ai2020_data', + 'lico2_volume_change_Ai2020', + ], + 'Chen2020': [ + 'electrolyte_conductivity_Nyman2008', + 'electrolyte_diffusivity_Nyman2008', + 'get_parameter_values', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_LGM50_ocp_Chen2020', + 'nmc_LGM50_electrolyte_exchange_current_density_Chen2020', + 'nmc_LGM50_ocp_Chen2020', + ], + 'Chen2020_composite': [ + 'electrolyte_conductivity_Nyman2008', + 'electrolyte_diffusivity_Nyman2008', + 'get_parameter_values', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_ocp_Enertech_Ai2020', + 'graphite_ocp_Enertech_Ai2020_data', + 'nmc_LGM50_electrolyte_exchange_current_density_Chen2020', + 'nmc_LGM50_ocp_Chen2020', + 'silicon_LGM50_electrolyte_exchange_current_density_Chen2020', + 'silicon_ocp_delithiation_Mark2016', + 'silicon_ocp_lithiation_Mark2016', + ], + 'Ecker2015': [ + 'electrolyte_conductivity_Ecker2015', + 'electrolyte_diffusivity_Ecker2015', + 'get_parameter_values', + 'graphite_diffusivity_Ecker2015', + 'graphite_electrolyte_exchange_current_density_Ecker2015', + 'graphite_ocp_Ecker2015', + 'nco_diffusivity_Ecker2015', + 'nco_electrolyte_exchange_current_density_Ecker2015', + 'nco_ocp_Ecker2015', + ], + 'Ecker2015_graphite_halfcell': [ + 'electrolyte_conductivity_Ecker2015', + 'electrolyte_diffusivity_Ecker2015', + 'get_parameter_values', + 'graphite_diffusivity_Ecker2015', + 'graphite_electrolyte_exchange_current_density_Ecker2015', + 'graphite_ocp_Ecker2015', + 'li_metal_electrolyte_exchange_current_density_Xu2019', + ], + 'MSMR_example_set': [ + 'electrolyte_conductivity_Nyman2008', + 'electrolyte_diffusivity_Nyman2008', + 'get_parameter_values', + ], + 'Marquis2019': [ + 'electrolyte_conductivity_Capiglia1999', + 'electrolyte_diffusivity_Capiglia1999', + 'get_parameter_values', + 'graphite_electrolyte_exchange_current_density_Dualfoil1998', + 'graphite_entropic_change_Moura2016', + 'graphite_mcmb2528_diffusivity_Dualfoil1998', + 'graphite_mcmb2528_ocp_Dualfoil1998', + 'lico2_diffusivity_Dualfoil1998', + 'lico2_electrolyte_exchange_current_density_Dualfoil1998', + 'lico2_entropic_change_Moura2016', + 'lico2_ocp_Dualfoil1998', + ], + 'Mohtat2020': [ + 'NMC_diffusivity_PeymanMPM', + 'NMC_electrolyte_exchange_current_density_PeymanMPM', + 'NMC_entropic_change_PeymanMPM', + 'NMC_ocp_PeymanMPM', + 'electrolyte_conductivity_PeymanMPM', + 'electrolyte_diffusivity_PeymanMPM', + 'get_parameter_values', + 'graphite_diffusivity_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_PeymanMPM', + 'graphite_entropic_change_PeymanMPM', + 'graphite_ocp_PeymanMPM', + ], + 'NCA_Kim2011': [ + 'electrolyte_conductivity_Kim2011', + 'electrolyte_diffusivity_Kim2011', + 'get_parameter_values', + 'graphite_diffusivity_Kim2011', + 'graphite_electrolyte_exchange_current_density_Kim2011', + 'graphite_ocp_Kim2011', + 'nca_diffusivity_Kim2011', + 'nca_electrolyte_exchange_current_density_Kim2011', + 'nca_ocp_Kim2011', + ], + 'OKane2022': [ + 'SEI_limited_dead_lithium_OKane2022', + 'cracking_rate_Ai2020', + 'electrolyte_conductivity_Nyman2008_arrhenius', + 'electrolyte_diffusivity_Nyman2008_arrhenius', + 'get_parameter_values', + 'graphite_LGM50_diffusivity_Chen2020', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_LGM50_ocp_Chen2020', + 'graphite_LGM50_ocp_Chen2020_data', + 'graphite_cracking_rate_Ai2020', + 'graphite_volume_change_Ai2020', + 'nmc_LGM50_diffusivity_Chen2020', + 'nmc_LGM50_electrolyte_exchange_current_density_Chen2020', + 'nmc_LGM50_ocp_Chen2020', + 'plating_exchange_current_density_OKane2020', + 'stripping_exchange_current_density_OKane2020', + 'volume_change_Ai2020', + ], + 'OKane2022_graphite_SiOx_halfcell': [ + 'SEI_limited_dead_lithium_OKane2022', + 'electrolyte_conductivity_Nyman2008_arrhenius', + 'electrolyte_diffusivity_Nyman2008_arrhenius', + 'get_parameter_values', + 'graphite_LGM50_diffusivity_Chen2020', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_LGM50_ocp_Chen2020', + 'graphite_LGM50_ocp_Chen2020_data', + 'graphite_cracking_rate_Ai2020', + 'graphite_volume_change_Ai2020', + 'li_metal_electrolyte_exchange_current_density_Xu2019', + 'plating_exchange_current_density_OKane2020', + 'stripping_exchange_current_density_OKane2020', + ], + 'ORegan2022': [ + 'aluminium_heat_capacity_CRC', + 'copper_heat_capacity_CRC', + 'copper_thermal_conductivity_CRC', + 'electrolyte_TDF_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_TDF_base_Landesfeind2019', + 'electrolyte_conductivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_conductivity_base_Landesfeind2019', + 'electrolyte_diffusivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_diffusivity_base_Landesfeind2019', + 'electrolyte_transference_number_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_transference_number_base_Landesfeind2019', + 'get_parameter_values', + 'graphite_LGM50_diffusivity_ORegan2022', + 'graphite_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'graphite_LGM50_entropic_change_ORegan2022', + 'graphite_LGM50_heat_capacity_ORegan2022', + 'graphite_LGM50_ocp_Chen2020', + 'graphite_LGM50_thermal_conductivity_ORegan2022', + 'nmc_LGM50_diffusivity_ORegan2022', + 'nmc_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'nmc_LGM50_electronic_conductivity_ORegan2022', + 'nmc_LGM50_entropic_change_ORegan2022', + 'nmc_LGM50_heat_capacity_ORegan2022', + 'nmc_LGM50_ocp_Chen2020', + 'nmc_LGM50_thermal_conductivity_ORegan2022', + 'separator_LGM50_heat_capacity_ORegan2022', + ], + 'Prada2013': [ + 'LFP_electrolyte_exchange_current_density_kashkooli2017', + 'LFP_ocp_Afshar2017', + 'electrolyte_conductivity_Prada2013', + 'get_parameter_values', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_LGM50_ocp_Chen2020', + ], + 'Ramadass2004': [ + 'electrolyte_conductivity_Ramadass2004', + 'electrolyte_diffusivity_Ramadass2004', + 'get_parameter_values', + 'graphite_electrolyte_exchange_current_density_Ramadass2004', + 'graphite_entropic_change_Moura2016', + 'graphite_mcmb2528_diffusivity_Dualfoil1998', + 'graphite_ocp_Ramadass2004', + 'lico2_diffusivity_Ramadass2004', + 'lico2_electrolyte_exchange_current_density_Ramadass2004', + 'lico2_entropic_change_Moura2016', + 'lico2_ocp_Ramadass2004', + ], + 'Xu2019': [ + 'electrolyte_conductivity_Valoen2005', + 'electrolyte_diffusivity_Valoen2005', + 'get_parameter_values', + 'li_metal_electrolyte_exchange_current_density_Xu2019', + 'nmc_electrolyte_exchange_current_density_Xu2019', + 'nmc_ocp_Xu2019', + ], + }, +) + +__all__ = ['Ai2020', 'Chen2020', 'Chen2020_composite', 'Ecker2015', + 'Ecker2015_graphite_halfcell', + 'LFP_electrolyte_exchange_current_density_kashkooli2017', + 'LFP_ocp_Afshar2017', 'MSMR_example_set', 'Marquis2019', + 'Mohtat2020', 'NCA_Kim2011', 'NMC_diffusivity_PeymanMPM', + 'NMC_electrolyte_exchange_current_density_PeymanMPM', + 'NMC_entropic_change_PeymanMPM', 'NMC_ocp_PeymanMPM', 'OKane2022', + 'OKane2022_graphite_SiOx_halfcell', 'ORegan2022', 'Prada2013', + 'Ramadass2004', 'SEI_limited_dead_lithium_OKane2022', 'Xu2019', + 'aluminium_heat_capacity_CRC', 'copper_heat_capacity_CRC', + 'copper_thermal_conductivity_CRC', 'cracking_rate_Ai2020', + 'dlnf_dlnc_Ai2020', 'electrolyte_TDF_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_TDF_base_Landesfeind2019', + 'electrolyte_conductivity_Ai2020', + 'electrolyte_conductivity_Capiglia1999', + 'electrolyte_conductivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_conductivity_Ecker2015', + 'electrolyte_conductivity_Kim2011', + 'electrolyte_conductivity_Nyman2008', + 'electrolyte_conductivity_Nyman2008_arrhenius', + 'electrolyte_conductivity_PeymanMPM', + 'electrolyte_conductivity_Prada2013', + 'electrolyte_conductivity_Ramadass2004', + 'electrolyte_conductivity_Valoen2005', + 'electrolyte_conductivity_base_Landesfeind2019', + 'electrolyte_diffusivity_Ai2020', + 'electrolyte_diffusivity_Capiglia1999', + 'electrolyte_diffusivity_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_diffusivity_Ecker2015', + 'electrolyte_diffusivity_Kim2011', + 'electrolyte_diffusivity_Nyman2008', + 'electrolyte_diffusivity_Nyman2008_arrhenius', + 'electrolyte_diffusivity_PeymanMPM', + 'electrolyte_diffusivity_Ramadass2004', + 'electrolyte_diffusivity_Valoen2005', + 'electrolyte_diffusivity_base_Landesfeind2019', + 'electrolyte_transference_number_EC_EMC_3_7_Landesfeind2019', + 'electrolyte_transference_number_base_Landesfeind2019', + 'get_parameter_values', 'graphite_LGM50_diffusivity_Chen2020', + 'graphite_LGM50_diffusivity_ORegan2022', + 'graphite_LGM50_electrolyte_exchange_current_density_Chen2020', + 'graphite_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'graphite_LGM50_entropic_change_ORegan2022', + 'graphite_LGM50_heat_capacity_ORegan2022', + 'graphite_LGM50_ocp_Chen2020', 'graphite_LGM50_ocp_Chen2020_data', + 'graphite_LGM50_thermal_conductivity_ORegan2022', + 'graphite_cracking_rate_Ai2020', + 'graphite_diffusivity_Dualfoil1998', + 'graphite_diffusivity_Ecker2015', 'graphite_diffusivity_Kim2011', + 'graphite_diffusivity_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Dualfoil1998', + 'graphite_electrolyte_exchange_current_density_Ecker2015', + 'graphite_electrolyte_exchange_current_density_Kim2011', + 'graphite_electrolyte_exchange_current_density_PeymanMPM', + 'graphite_electrolyte_exchange_current_density_Ramadass2004', + 'graphite_entropic_change_Moura2016', + 'graphite_entropic_change_PeymanMPM', + 'graphite_entropy_Enertech_Ai2020_function', + 'graphite_mcmb2528_diffusivity_Dualfoil1998', + 'graphite_mcmb2528_ocp_Dualfoil1998', 'graphite_ocp_Ecker2015', + 'graphite_ocp_Enertech_Ai2020', 'graphite_ocp_Enertech_Ai2020_data', + 'graphite_ocp_Kim2011', 'graphite_ocp_PeymanMPM', + 'graphite_ocp_Ramadass2004', 'graphite_volume_change_Ai2020', + 'li_metal_electrolyte_exchange_current_density_Xu2019', + 'lico2_cracking_rate_Ai2020', 'lico2_diffusivity_Dualfoil1998', + 'lico2_diffusivity_Ramadass2004', + 'lico2_electrolyte_exchange_current_density_Dualfoil1998', + 'lico2_electrolyte_exchange_current_density_Ramadass2004', + 'lico2_entropic_change_Ai2020_function', + 'lico2_entropic_change_Moura2016', 'lico2_ocp_Ai2020', + 'lico2_ocp_Ai2020_data', 'lico2_ocp_Dualfoil1998', + 'lico2_ocp_Ramadass2004', 'lico2_volume_change_Ai2020', + 'nca_diffusivity_Kim2011', + 'nca_electrolyte_exchange_current_density_Kim2011', + 'nca_ocp_Kim2011', 'nco_diffusivity_Ecker2015', + 'nco_electrolyte_exchange_current_density_Ecker2015', + 'nco_ocp_Ecker2015', 'nmc_LGM50_diffusivity_Chen2020', + 'nmc_LGM50_diffusivity_ORegan2022', + 'nmc_LGM50_electrolyte_exchange_current_density_Chen2020', + 'nmc_LGM50_electrolyte_exchange_current_density_ORegan2022', + 'nmc_LGM50_electronic_conductivity_ORegan2022', + 'nmc_LGM50_entropic_change_ORegan2022', + 'nmc_LGM50_heat_capacity_ORegan2022', 'nmc_LGM50_ocp_Chen2020', + 'nmc_LGM50_thermal_conductivity_ORegan2022', + 'nmc_electrolyte_exchange_current_density_Xu2019', 'nmc_ocp_Xu2019', + 'plating_exchange_current_density_OKane2020', + 'separator_LGM50_heat_capacity_ORegan2022', + 'silicon_LGM50_electrolyte_exchange_current_density_Chen2020', + 'silicon_ocp_delithiation_Mark2016', + 'silicon_ocp_lithiation_Mark2016', + 'stripping_exchange_current_density_OKane2020', + 'volume_change_Ai2020'] diff --git a/pybamm/meshes/__init__.py b/pybamm/meshes/__init__.py index e69de29bb2..4eaf2f9488 100644 --- a/pybamm/meshes/__init__.py +++ b/pybamm/meshes/__init__.py @@ -0,0 +1,46 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'meshes', + 'one_dimensional_submeshes', + 'scikit_fem_submeshes', + 'zero_dimensional_submesh', + }, + submod_attrs={ + 'meshes': [ + 'Mesh', + 'MeshGenerator', + 'SubMesh', + ], + 'one_dimensional_submeshes': [ + 'Chebyshev1DSubMesh', + 'Exponential1DSubMesh', + 'SpectralVolume1DSubMesh', + 'SubMesh1D', + 'Uniform1DSubMesh', + 'UserSupplied1DSubMesh', + ], + 'scikit_fem_submeshes': [ + 'ScikitChebyshev2DSubMesh', + 'ScikitExponential2DSubMesh', + 'ScikitSubMesh2D', + 'ScikitUniform2DSubMesh', + 'UserSupplied2DSubMesh', + ], + 'zero_dimensional_submesh': [ + 'SubMesh0D', + ], + }, +) + +__all__ = ['Chebyshev1DSubMesh', 'Exponential1DSubMesh', 'Mesh', + 'MeshGenerator', 'ScikitChebyshev2DSubMesh', + 'ScikitExponential2DSubMesh', 'ScikitSubMesh2D', + 'ScikitUniform2DSubMesh', 'SpectralVolume1DSubMesh', 'SubMesh', + 'SubMesh0D', 'SubMesh1D', 'Uniform1DSubMesh', + 'UserSupplied1DSubMesh', 'UserSupplied2DSubMesh', 'meshes', + 'one_dimensional_submeshes', 'scikit_fem_submeshes', + 'zero_dimensional_submesh'] diff --git a/pybamm/models/__init__.py b/pybamm/models/__init__.py index e69de29bb2..673ec220de 100644 --- a/pybamm/models/__init__.py +++ b/pybamm/models/__init__.py @@ -0,0 +1,404 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_model', + 'event', + 'full_battery_models', + 'submodels', + }, + submod_attrs={ + 'base_model': [ + 'BaseModel', + 'BoundaryConditionsDict', + 'EquationDict', + 'find_symbol_in_dict', + 'find_symbol_in_model', + 'find_symbol_in_tree', + 'load_model', + ], + 'event': [ + 'Event', + 'EventType', + ], + 'full_battery_models': [ + 'BaseBatteryModel', + 'BaseModel', + 'BasicDFN', + 'BasicDFNComposite', + 'BasicDFNHalfCell', + 'BasicFull', + 'BasicSPM', + 'BatteryModelDomainOptions', + 'BatteryModelOptions', + 'BatteryModelPhaseOptions', + 'DFN', + 'ElectrodeSOHHalfCell', + 'ElectrodeSOHSolver', + 'Full', + 'LOQS', + 'MPM', + 'MSMR', + 'NaturalNumberOption', + 'NewmanTobias', + 'OperatingModes', + 'SPM', + 'SPMe', + 'Thevenin', + 'Yang2017', + 'base_battery_model', + 'base_lead_acid_model', + 'base_lithium_ion_model', + 'basic_dfn', + 'basic_dfn_composite', + 'basic_dfn_half_cell', + 'basic_full', + 'basic_spm', + 'calculate_theoretical_energy', + 'dfn', + 'ecm_model_options', + 'electrode_soh', + 'electrode_soh_half_cell', + 'equivalent_circuit', + 'full', + 'get_initial_ocps', + 'get_initial_stoichiometries', + 'get_initial_stoichiometry_half_cell', + 'get_min_max_ocps', + 'get_min_max_stoichiometries', + 'lead_acid', + 'lithium_ion', + 'loqs', + 'mpm', + 'msmr', + 'newman_tobias', + 'represents_positive_integer', + 'spm', + 'spme', + 'theoretical_energy_integral', + 'thevenin', + ], + 'submodels': [ + 'AlternativeEffectiveResistance2D', + 'AsymmetricButlerVolmer', + 'BaseEffectiveResistance', + 'BaseElectrode', + 'BaseElectrolyteConductivity', + 'BaseElectrolyteDiffusion', + 'BaseInterface', + 'BaseKinetics', + 'BaseLeadingOrderSurfaceForm', + 'BaseMechanics', + 'BaseModel', + 'BaseOpenCircuitPotential', + 'BaseParticle', + 'BasePlating', + 'BasePotentialPair', + 'BaseSubModel', + 'BaseThermal', + 'BaseThroughCellModel', + 'BaseTransverseModel', + 'Bruggeman', + 'CCCVFunctionControl', + 'Composite', + 'CompositeAlgebraic', + 'CompositeDifferential', + 'Constant', + 'ConstantConcentration', + 'ConstantSEI', + 'CrackPropagation', + 'CurrentCollector1D', + 'CurrentCollector2D', + 'CurrentDriven', + 'CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', + 'CurrentSigmoidOpenCircuitPotential', + 'DiffusionLimited', + 'EffectiveResistance', + 'Explicit', + 'ExplicitCurrentControl', + 'ExplicitPowerControl', + 'ExplicitResistanceControl', + 'FickianDiffusion', + 'ForwardTafel', + 'Full', + 'FullAlgebraic', + 'FullDifferential', + 'FunctionControl', + 'Integrated', + 'InverseButlerVolmer', + 'Isothermal', + 'LeadingOrder', + 'LeadingOrderAlgebraic', + 'LeadingOrderDifferential', + 'Linear', + 'LithiumMetalBaseModel', + 'LithiumMetalExplicit', + 'LithiumMetalSurfaceForm', + 'LossActiveMaterial', + 'Lumped', + 'MSMRButlerVolmer', + 'MSMRDiffusion', + 'MSMROpenCircuitPotential', + 'Marcus', + 'MarcusHushChidsey', + 'NoConvection', + 'NoMechanics', + 'NoOxygen', + 'NoPlating', + 'NoReaction', + 'NoSEI', + 'OCVElement', + 'OneDimensionalX', + 'Plating', + 'PolynomialProfile', + 'PotentialPair1plus1D', + 'PotentialPair2plus1D', + 'PowerFunctionControl', + 'RCElement', + 'ReactionDriven', + 'ReactionDrivenODE', + 'ResistanceFunctionControl', + 'ResistorElement', + 'SEIGrowth', + 'SingleOpenCircuitPotential', + 'SurfaceForm', + 'SwellingOnly', + 'SymmetricButlerVolmer', + 'ThermalSubModel', + 'Total', + 'TotalConcentration', + 'TotalInterfacialCurrent', + 'TotalMainKinetics', + 'TotalSEI', + 'Uniform', + 'VoltageFunctionControl', + 'VoltageModel', + 'XAveragedPolynomialProfile', + 'active_material', + 'base_active_material', + 'base_convection', + 'base_current_collector', + 'base_electrode', + 'base_electrolyte_conductivity', + 'base_electrolyte_diffusion', + 'base_external_circuit', + 'base_interface', + 'base_kinetics', + 'base_mechanics', + 'base_ocp', + 'base_ohm', + 'base_oxygen_diffusion', + 'base_particle', + 'base_plating', + 'base_porosity', + 'base_sei', + 'base_submodel', + 'base_thermal', + 'base_through_cell_convection', + 'base_transport_efficiency', + 'base_transverse_convection', + 'base_utilisation', + 'bruggeman_transport_efficiency', + 'butler_volmer', + 'composite_conductivity', + 'composite_ohm', + 'composite_surface_form_conductivity', + 'constant_active_material', + 'constant_concentration', + 'constant_porosity', + 'constant_sei', + 'constant_utilisation', + 'convection', + 'crack_propagation', + 'current_collector', + 'current_driven_utilisation', + 'current_sigmoid_ocp', + 'diffusion_limited', + 'effective_resistance_current_collector', + 'electrode', + 'electrolyte_conductivity', + 'electrolyte_diffusion', + 'equivalent_circuit_elements', + 'explicit_control_external_circuit', + 'explicit_convection', + 'explicit_surface_form_conductivity', + 'external_circuit', + 'fickian_diffusion', + 'full_conductivity', + 'full_convection', + 'full_diffusion', + 'full_ohm', + 'full_oxygen_diffusion', + 'full_surface_form_conductivity', + 'full_utilisation', + 'function_control_external_circuit', + 'homogeneous_current_collector', + 'integrated_conductivity', + 'interface', + 'interface_utilisation', + 'inverse_butler_volmer', + 'inverse_kinetics', + 'isothermal', + 'kinetics', + 'leading_ohm', + 'leading_order_conductivity', + 'leading_order_diffusion', + 'leading_oxygen_diffusion', + 'leading_surface_form_conductivity', + 'li_metal', + 'linear', + 'lithium_plating', + 'loss_active_material', + 'lumped', + 'marcus', + 'msmr_butler_volmer', + 'msmr_diffusion', + 'msmr_ocp', + 'no_convection', + 'no_mechanics', + 'no_oxygen', + 'no_plating', + 'no_reaction', + 'no_sei', + 'ocv_element', + 'ohm', + 'open_circuit_potential', + 'oxygen_diffusion', + 'particle', + 'particle_mechanics', + 'plating', + 'polynomial_profile', + 'porosity', + 'potential_pair', + 'pouch_cell', + 'pouch_cell_1D_current_collectors', + 'pouch_cell_2D_current_collectors', + 'rc_element', + 'reaction_driven_porosity', + 'reaction_driven_porosity_ode', + 'resistor_element', + 'sei', + 'sei_growth', + 'single_ocp', + 'surface_form_ohm', + 'surface_potential_form', + 'swelling_only', + 'tafel', + 'thermal', + 'through_cell', + 'total_active_material', + 'total_interfacial_current', + 'total_main_kinetics', + 'total_particle_concentration', + 'total_sei', + 'transport_efficiency', + 'transverse', + 'uniform_convection', + 'voltage_model', + 'x_averaged_polynomial_profile', + 'x_full', + ], + }, +) + +__all__ = ['AlternativeEffectiveResistance2D', 'AsymmetricButlerVolmer', + 'BaseBatteryModel', 'BaseEffectiveResistance', 'BaseElectrode', + 'BaseElectrolyteConductivity', 'BaseElectrolyteDiffusion', + 'BaseInterface', 'BaseKinetics', 'BaseLeadingOrderSurfaceForm', + 'BaseMechanics', 'BaseModel', 'BaseOpenCircuitPotential', + 'BaseParticle', 'BasePlating', 'BasePotentialPair', 'BaseSubModel', + 'BaseThermal', 'BaseThroughCellModel', 'BaseTransverseModel', + 'BasicDFN', 'BasicDFNComposite', 'BasicDFNHalfCell', 'BasicFull', + 'BasicSPM', 'BatteryModelDomainOptions', 'BatteryModelOptions', + 'BatteryModelPhaseOptions', 'BoundaryConditionsDict', 'Bruggeman', + 'CCCVFunctionControl', 'Composite', 'CompositeAlgebraic', + 'CompositeDifferential', 'Constant', 'ConstantConcentration', + 'ConstantSEI', 'CrackPropagation', 'CurrentCollector1D', + 'CurrentCollector2D', 'CurrentDriven', + 'CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', + 'CurrentSigmoidOpenCircuitPotential', 'DFN', 'DiffusionLimited', + 'EffectiveResistance', 'ElectrodeSOHHalfCell', 'ElectrodeSOHSolver', + 'EquationDict', 'Event', 'EventType', 'Explicit', + 'ExplicitCurrentControl', 'ExplicitPowerControl', + 'ExplicitResistanceControl', 'FickianDiffusion', 'ForwardTafel', + 'Full', 'FullAlgebraic', 'FullDifferential', 'FunctionControl', + 'Integrated', 'InverseButlerVolmer', 'Isothermal', 'LOQS', + 'LeadingOrder', 'LeadingOrderAlgebraic', 'LeadingOrderDifferential', + 'Linear', 'LithiumMetalBaseModel', 'LithiumMetalExplicit', + 'LithiumMetalSurfaceForm', 'LossActiveMaterial', 'Lumped', 'MPM', + 'MSMR', 'MSMRButlerVolmer', 'MSMRDiffusion', + 'MSMROpenCircuitPotential', 'Marcus', 'MarcusHushChidsey', + 'NaturalNumberOption', 'NewmanTobias', 'NoConvection', + 'NoMechanics', 'NoOxygen', 'NoPlating', 'NoReaction', 'NoSEI', + 'OCVElement', 'OneDimensionalX', 'OperatingModes', 'Plating', + 'PolynomialProfile', 'PotentialPair1plus1D', 'PotentialPair2plus1D', + 'PowerFunctionControl', 'RCElement', 'ReactionDriven', + 'ReactionDrivenODE', 'ResistanceFunctionControl', 'ResistorElement', + 'SEIGrowth', 'SPM', 'SPMe', 'SingleOpenCircuitPotential', + 'SurfaceForm', 'SwellingOnly', 'SymmetricButlerVolmer', + 'ThermalSubModel', 'Thevenin', 'Total', 'TotalConcentration', + 'TotalInterfacialCurrent', 'TotalMainKinetics', 'TotalSEI', + 'Uniform', 'VoltageFunctionControl', 'VoltageModel', + 'XAveragedPolynomialProfile', 'Yang2017', 'active_material', + 'base_active_material', 'base_battery_model', 'base_convection', + 'base_current_collector', 'base_electrode', + 'base_electrolyte_conductivity', 'base_electrolyte_diffusion', + 'base_external_circuit', 'base_interface', 'base_kinetics', + 'base_lead_acid_model', 'base_lithium_ion_model', 'base_mechanics', + 'base_model', 'base_ocp', 'base_ohm', 'base_oxygen_diffusion', + 'base_particle', 'base_plating', 'base_porosity', 'base_sei', + 'base_submodel', 'base_thermal', 'base_through_cell_convection', + 'base_transport_efficiency', 'base_transverse_convection', + 'base_utilisation', 'basic_dfn', 'basic_dfn_composite', + 'basic_dfn_half_cell', 'basic_full', 'basic_spm', + 'bruggeman_transport_efficiency', 'butler_volmer', + 'calculate_theoretical_energy', 'composite_conductivity', + 'composite_ohm', 'composite_surface_form_conductivity', + 'constant_active_material', 'constant_concentration', + 'constant_porosity', 'constant_sei', 'constant_utilisation', + 'convection', 'crack_propagation', 'current_collector', + 'current_driven_utilisation', 'current_sigmoid_ocp', 'dfn', + 'diffusion_limited', 'ecm_model_options', + 'effective_resistance_current_collector', 'electrode', + 'electrode_soh', 'electrode_soh_half_cell', + 'electrolyte_conductivity', 'electrolyte_diffusion', + 'equivalent_circuit', 'equivalent_circuit_elements', 'event', + 'explicit_control_external_circuit', 'explicit_convection', + 'explicit_surface_form_conductivity', 'external_circuit', + 'fickian_diffusion', 'find_symbol_in_dict', 'find_symbol_in_model', + 'find_symbol_in_tree', 'full', 'full_battery_models', + 'full_conductivity', 'full_convection', 'full_diffusion', + 'full_ohm', 'full_oxygen_diffusion', + 'full_surface_form_conductivity', 'full_utilisation', + 'function_control_external_circuit', 'get_initial_ocps', + 'get_initial_stoichiometries', + 'get_initial_stoichiometry_half_cell', 'get_min_max_ocps', + 'get_min_max_stoichiometries', 'homogeneous_current_collector', + 'integrated_conductivity', 'interface', 'interface_utilisation', + 'inverse_butler_volmer', 'inverse_kinetics', 'isothermal', + 'kinetics', 'lead_acid', 'leading_ohm', + 'leading_order_conductivity', 'leading_order_diffusion', + 'leading_oxygen_diffusion', 'leading_surface_form_conductivity', + 'li_metal', 'linear', 'lithium_ion', 'lithium_plating', + 'load_model', 'loqs', 'loss_active_material', 'lumped', 'marcus', + 'mpm', 'msmr', 'msmr_butler_volmer', 'msmr_diffusion', 'msmr_ocp', + 'newman_tobias', 'no_convection', 'no_mechanics', 'no_oxygen', + 'no_plating', 'no_reaction', 'no_sei', 'ocv_element', 'ohm', + 'open_circuit_potential', 'oxygen_diffusion', 'particle', + 'particle_mechanics', 'plating', 'polynomial_profile', 'porosity', + 'potential_pair', 'pouch_cell', 'pouch_cell_1D_current_collectors', + 'pouch_cell_2D_current_collectors', 'rc_element', + 'reaction_driven_porosity', 'reaction_driven_porosity_ode', + 'represents_positive_integer', 'resistor_element', 'sei', + 'sei_growth', 'single_ocp', 'spm', 'spme', 'submodels', + 'surface_form_ohm', 'surface_potential_form', 'swelling_only', + 'tafel', 'theoretical_energy_integral', 'thermal', 'thevenin', + 'through_cell', 'total_active_material', + 'total_interfacial_current', 'total_main_kinetics', + 'total_particle_concentration', 'total_sei', 'transport_efficiency', + 'transverse', 'uniform_convection', 'voltage_model', + 'x_averaged_polynomial_profile', 'x_full'] diff --git a/pybamm/models/full_battery_models/__init__.py b/pybamm/models/full_battery_models/__init__.py index e69de29bb2..1e9edaed65 100644 --- a/pybamm/models/full_battery_models/__init__.py +++ b/pybamm/models/full_battery_models/__init__.py @@ -0,0 +1,92 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_battery_model', + 'equivalent_circuit', + 'lead_acid', + 'lithium_ion', + }, + submod_attrs={ + 'base_battery_model': [ + 'BaseBatteryModel', + 'BatteryModelDomainOptions', + 'BatteryModelOptions', + 'BatteryModelPhaseOptions', + 'represents_positive_integer', + ], + 'equivalent_circuit': [ + 'NaturalNumberOption', + 'OperatingModes', + 'Thevenin', + 'ecm_model_options', + 'thevenin', + ], + 'lead_acid': [ + 'BaseModel', + 'BasicFull', + 'Full', + 'LOQS', + 'base_lead_acid_model', + 'basic_full', + 'full', + 'loqs', + ], + 'lithium_ion': [ + 'BaseModel', + 'BasicDFN', + 'BasicDFNComposite', + 'BasicDFNHalfCell', + 'BasicSPM', + 'DFN', + 'ElectrodeSOHHalfCell', + 'ElectrodeSOHSolver', + 'MPM', + 'MSMR', + 'NewmanTobias', + 'SPM', + 'SPMe', + 'Yang2017', + 'base_lithium_ion_model', + 'basic_dfn', + 'basic_dfn_composite', + 'basic_dfn_half_cell', + 'basic_spm', + 'calculate_theoretical_energy', + 'dfn', + 'electrode_soh', + 'electrode_soh_half_cell', + 'get_initial_ocps', + 'get_initial_stoichiometries', + 'get_initial_stoichiometry_half_cell', + 'get_min_max_ocps', + 'get_min_max_stoichiometries', + 'mpm', + 'msmr', + 'newman_tobias', + 'spm', + 'spme', + 'theoretical_energy_integral', + ], + }, +) + +__all__ = ['BaseBatteryModel', 'BaseModel', 'BasicDFN', 'BasicDFNComposite', + 'BasicDFNHalfCell', 'BasicFull', 'BasicSPM', + 'BatteryModelDomainOptions', 'BatteryModelOptions', + 'BatteryModelPhaseOptions', 'DFN', 'ElectrodeSOHHalfCell', + 'ElectrodeSOHSolver', 'Full', 'LOQS', 'MPM', 'MSMR', + 'NaturalNumberOption', 'NewmanTobias', 'OperatingModes', 'SPM', + 'SPMe', 'Thevenin', 'Yang2017', 'base_battery_model', + 'base_lead_acid_model', 'base_lithium_ion_model', 'basic_dfn', + 'basic_dfn_composite', 'basic_dfn_half_cell', 'basic_full', + 'basic_spm', 'calculate_theoretical_energy', 'dfn', + 'ecm_model_options', 'electrode_soh', 'electrode_soh_half_cell', + 'equivalent_circuit', 'full', 'get_initial_ocps', + 'get_initial_stoichiometries', + 'get_initial_stoichiometry_half_cell', 'get_min_max_ocps', + 'get_min_max_stoichiometries', 'lead_acid', 'lithium_ion', 'loqs', + 'mpm', 'msmr', 'newman_tobias', 'represents_positive_integer', + 'spm', 'spme', 'theoretical_energy_integral', 'thevenin'] diff --git a/pybamm/models/full_battery_models/equivalent_circuit/__init__.py b/pybamm/models/full_battery_models/equivalent_circuit/__init__.py index c4bf7d5a56..5f33c7c2a3 100644 --- a/pybamm/models/full_battery_models/equivalent_circuit/__init__.py +++ b/pybamm/models/full_battery_models/equivalent_circuit/__init__.py @@ -1 +1,22 @@ -from .thevenin import * +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'ecm_model_options', + 'thevenin', + }, + submod_attrs={ + 'ecm_model_options': [ + 'NaturalNumberOption', + 'OperatingModes', + ], + 'thevenin': [ + 'Thevenin', + ], + }, +) + +__all__ = ['NaturalNumberOption', 'OperatingModes', 'Thevenin', + 'ecm_model_options', 'thevenin'] diff --git a/pybamm/models/full_battery_models/lead_acid/__init__.py b/pybamm/models/full_battery_models/lead_acid/__init__.py index 5895bddeb4..5ea04d5287 100644 --- a/pybamm/models/full_battery_models/lead_acid/__init__.py +++ b/pybamm/models/full_battery_models/lead_acid/__init__.py @@ -1,7 +1,32 @@ # # Root of the lead-acid models module. # -from .base_lead_acid_model import BaseModel -from .loqs import LOQS -from .full import Full -from .basic_full import BasicFull +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_lead_acid_model', + 'basic_full', + 'full', + 'loqs', + }, + submod_attrs={ + 'base_lead_acid_model': [ + 'BaseModel', + ], + 'basic_full': [ + 'BasicFull', + ], + 'full': [ + 'Full', + ], + 'loqs': [ + 'LOQS', + ], + }, +) + +__all__ = ['BaseModel', 'BasicFull', 'Full', 'LOQS', 'base_lead_acid_model', + 'basic_full', 'full', 'loqs'] diff --git a/pybamm/models/full_battery_models/lithium_ion/__init__.py b/pybamm/models/full_battery_models/lithium_ion/__init__.py index 4afb23f493..7158aa92ea 100644 --- a/pybamm/models/full_battery_models/lithium_ion/__init__.py +++ b/pybamm/models/full_battery_models/lithium_ion/__init__.py @@ -1,26 +1,88 @@ # # Root of the lithium-ion models module. # -from .base_lithium_ion_model import BaseModel -from .electrode_soh import ( - ElectrodeSOHSolver, - get_initial_stoichiometries, - get_min_max_stoichiometries, - get_initial_ocps, - get_min_max_ocps, +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'Yang2017', + 'base_lithium_ion_model', + 'basic_dfn', + 'basic_dfn_composite', + 'basic_dfn_half_cell', + 'basic_spm', + 'dfn', + 'electrode_soh', + 'electrode_soh_half_cell', + 'mpm', + 'msmr', + 'newman_tobias', + 'spm', + 'spme', + }, + submod_attrs={ + 'Yang2017': [ + 'Yang2017', + ], + 'base_lithium_ion_model': [ + 'BaseModel', + ], + 'basic_dfn': [ + 'BasicDFN', + ], + 'basic_dfn_composite': [ + 'BasicDFNComposite', + ], + 'basic_dfn_half_cell': [ + 'BasicDFNHalfCell', + ], + 'basic_spm': [ + 'BasicSPM', + ], + 'dfn': [ + 'DFN', + ], + 'electrode_soh': [ + 'ElectrodeSOHSolver', + 'calculate_theoretical_energy', + 'get_initial_ocps', + 'get_initial_stoichiometries', + 'get_min_max_ocps', + 'get_min_max_stoichiometries', + 'theoretical_energy_integral', + ], + 'electrode_soh_half_cell': [ + 'ElectrodeSOHHalfCell', + 'get_initial_stoichiometry_half_cell', + 'get_min_max_stoichiometries', + ], + 'mpm': [ + 'MPM', + ], + 'msmr': [ + 'MSMR', + ], + 'newman_tobias': [ + 'NewmanTobias', + ], + 'spm': [ + 'SPM', + ], + 'spme': [ + 'SPMe', + ], + }, ) -from .electrode_soh_half_cell import ( - ElectrodeSOHHalfCell, - get_initial_stoichiometry_half_cell -) -from .spm import SPM -from .spme import SPMe -from .dfn import DFN -from .newman_tobias import NewmanTobias -from .basic_dfn import BasicDFN -from .basic_spm import BasicSPM -from .basic_dfn_half_cell import BasicDFNHalfCell -from .basic_dfn_composite import BasicDFNComposite -from .Yang2017 import Yang2017 -from .mpm import MPM -from .msmr import MSMR + +__all__ = ['BaseModel', 'BasicDFN', 'BasicDFNComposite', 'BasicDFNHalfCell', + 'BasicSPM', 'DFN', 'ElectrodeSOHHalfCell', 'ElectrodeSOHSolver', + 'MPM', 'MSMR', 'NewmanTobias', 'SPM', 'SPMe', 'Yang2017', + 'base_lithium_ion_model', 'basic_dfn', 'basic_dfn_composite', + 'basic_dfn_half_cell', 'basic_spm', 'calculate_theoretical_energy', + 'dfn', 'electrode_soh', 'electrode_soh_half_cell', + 'get_initial_ocps', 'get_initial_stoichiometries', + 'get_initial_stoichiometry_half_cell', 'get_min_max_ocps', + 'get_min_max_stoichiometries', 'mpm', 'msmr', 'newman_tobias', + 'spm', 'spme', 'theoretical_energy_integral'] diff --git a/pybamm/models/submodels/__init__.py b/pybamm/models/submodels/__init__.py index e69de29bb2..4414273280 100644 --- a/pybamm/models/submodels/__init__.py +++ b/pybamm/models/submodels/__init__.py @@ -0,0 +1,364 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'active_material', + 'base_submodel', + 'convection', + 'current_collector', + 'electrode', + 'electrolyte_conductivity', + 'electrolyte_diffusion', + 'equivalent_circuit_elements', + 'external_circuit', + 'interface', + 'oxygen_diffusion', + 'particle', + 'particle_mechanics', + 'porosity', + 'thermal', + 'transport_efficiency', + }, + submod_attrs={ + 'active_material': [ + 'BaseModel', + 'Constant', + 'LossActiveMaterial', + 'Total', + 'base_active_material', + 'constant_active_material', + 'loss_active_material', + 'total_active_material', + ], + 'base_submodel': [ + 'BaseSubModel', + ], + 'convection': [ + 'BaseModel', + 'BaseThroughCellModel', + 'BaseTransverseModel', + 'Explicit', + 'Full', + 'NoConvection', + 'Uniform', + 'base_convection', + 'base_through_cell_convection', + 'base_transverse_convection', + 'explicit_convection', + 'full_convection', + 'no_convection', + 'through_cell', + 'transverse', + 'uniform_convection', + ], + 'current_collector': [ + 'AlternativeEffectiveResistance2D', + 'BaseEffectiveResistance', + 'BaseModel', + 'BasePotentialPair', + 'EffectiveResistance', + 'PotentialPair1plus1D', + 'PotentialPair2plus1D', + 'Uniform', + 'base_current_collector', + 'effective_resistance_current_collector', + 'homogeneous_current_collector', + 'potential_pair', + ], + 'electrode': [ + 'BaseElectrode', + 'BaseModel', + 'Composite', + 'Full', + 'LeadingOrder', + 'LithiumMetalBaseModel', + 'LithiumMetalExplicit', + 'LithiumMetalSurfaceForm', + 'SurfaceForm', + 'base_electrode', + 'base_ohm', + 'composite_ohm', + 'full_ohm', + 'leading_ohm', + 'li_metal', + 'ohm', + 'surface_form_ohm', + ], + 'electrolyte_conductivity': [ + 'BaseElectrolyteConductivity', + 'BaseLeadingOrderSurfaceForm', + 'BaseModel', + 'Composite', + 'CompositeAlgebraic', + 'CompositeDifferential', + 'Explicit', + 'Full', + 'FullAlgebraic', + 'FullDifferential', + 'Integrated', + 'LeadingOrder', + 'LeadingOrderAlgebraic', + 'LeadingOrderDifferential', + 'base_electrolyte_conductivity', + 'composite_conductivity', + 'composite_surface_form_conductivity', + 'explicit_surface_form_conductivity', + 'full_conductivity', + 'full_surface_form_conductivity', + 'integrated_conductivity', + 'leading_order_conductivity', + 'leading_surface_form_conductivity', + 'surface_potential_form', + ], + 'electrolyte_diffusion': [ + 'BaseElectrolyteDiffusion', + 'ConstantConcentration', + 'Full', + 'LeadingOrder', + 'base_electrolyte_diffusion', + 'constant_concentration', + 'full_diffusion', + 'leading_order_diffusion', + ], + 'equivalent_circuit_elements': [ + 'OCVElement', + 'RCElement', + 'ResistorElement', + 'ThermalSubModel', + 'VoltageModel', + 'ocv_element', + 'rc_element', + 'resistor_element', + 'thermal', + 'voltage_model', + ], + 'external_circuit': [ + 'BaseModel', + 'CCCVFunctionControl', + 'ExplicitCurrentControl', + 'ExplicitPowerControl', + 'ExplicitResistanceControl', + 'FunctionControl', + 'PowerFunctionControl', + 'ResistanceFunctionControl', + 'VoltageFunctionControl', + 'base_external_circuit', + 'explicit_control_external_circuit', + 'function_control_external_circuit', + ], + 'interface': [ + 'AsymmetricButlerVolmer', + 'BaseInterface', + 'BaseKinetics', + 'BaseModel', + 'BaseOpenCircuitPotential', + 'BasePlating', + 'Constant', + 'ConstantSEI', + 'CurrentDriven', + 'CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', + 'CurrentSigmoidOpenCircuitPotential', + 'DiffusionLimited', + 'ForwardTafel', + 'Full', + 'InverseButlerVolmer', + 'Linear', + 'MSMRButlerVolmer', + 'MSMROpenCircuitPotential', + 'Marcus', + 'MarcusHushChidsey', + 'NoPlating', + 'NoReaction', + 'NoSEI', + 'Plating', + 'SEIGrowth', + 'SingleOpenCircuitPotential', + 'SymmetricButlerVolmer', + 'TotalInterfacialCurrent', + 'TotalMainKinetics', + 'TotalSEI', + 'base_interface', + 'base_kinetics', + 'base_ocp', + 'base_plating', + 'base_sei', + 'base_utilisation', + 'butler_volmer', + 'constant_sei', + 'constant_utilisation', + 'current_driven_utilisation', + 'current_sigmoid_ocp', + 'diffusion_limited', + 'full_utilisation', + 'interface_utilisation', + 'inverse_butler_volmer', + 'inverse_kinetics', + 'kinetics', + 'linear', + 'lithium_plating', + 'marcus', + 'msmr_butler_volmer', + 'msmr_ocp', + 'no_plating', + 'no_reaction', + 'no_sei', + 'open_circuit_potential', + 'plating', + 'sei', + 'sei_growth', + 'single_ocp', + 'tafel', + 'total_interfacial_current', + 'total_main_kinetics', + 'total_sei', + ], + 'oxygen_diffusion': [ + 'BaseModel', + 'Full', + 'LeadingOrder', + 'NoOxygen', + 'base_oxygen_diffusion', + 'full_oxygen_diffusion', + 'leading_oxygen_diffusion', + 'no_oxygen', + ], + 'particle': [ + 'BaseParticle', + 'FickianDiffusion', + 'MSMRDiffusion', + 'PolynomialProfile', + 'TotalConcentration', + 'XAveragedPolynomialProfile', + 'base_particle', + 'fickian_diffusion', + 'msmr_diffusion', + 'polynomial_profile', + 'total_particle_concentration', + 'x_averaged_polynomial_profile', + ], + 'particle_mechanics': [ + 'BaseMechanics', + 'CrackPropagation', + 'NoMechanics', + 'SwellingOnly', + 'base_mechanics', + 'crack_propagation', + 'no_mechanics', + 'swelling_only', + ], + 'porosity': [ + 'BaseModel', + 'Constant', + 'ReactionDriven', + 'ReactionDrivenODE', + 'base_porosity', + 'constant_porosity', + 'reaction_driven_porosity', + 'reaction_driven_porosity_ode', + ], + 'thermal': [ + 'BaseThermal', + 'CurrentCollector1D', + 'CurrentCollector2D', + 'Isothermal', + 'Lumped', + 'OneDimensionalX', + 'base_thermal', + 'isothermal', + 'lumped', + 'pouch_cell', + 'pouch_cell_1D_current_collectors', + 'pouch_cell_2D_current_collectors', + 'x_full', + ], + 'transport_efficiency': [ + 'BaseModel', + 'Bruggeman', + 'base_transport_efficiency', + 'bruggeman_transport_efficiency', + ], + }, +) + +__all__ = ['AlternativeEffectiveResistance2D', 'AsymmetricButlerVolmer', + 'BaseEffectiveResistance', 'BaseElectrode', + 'BaseElectrolyteConductivity', 'BaseElectrolyteDiffusion', + 'BaseInterface', 'BaseKinetics', 'BaseLeadingOrderSurfaceForm', + 'BaseMechanics', 'BaseModel', 'BaseOpenCircuitPotential', + 'BaseParticle', 'BasePlating', 'BasePotentialPair', 'BaseSubModel', + 'BaseThermal', 'BaseThroughCellModel', 'BaseTransverseModel', + 'Bruggeman', 'CCCVFunctionControl', 'Composite', + 'CompositeAlgebraic', 'CompositeDifferential', 'Constant', + 'ConstantConcentration', 'ConstantSEI', 'CrackPropagation', + 'CurrentCollector1D', 'CurrentCollector2D', 'CurrentDriven', + 'CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', + 'CurrentSigmoidOpenCircuitPotential', 'DiffusionLimited', + 'EffectiveResistance', 'Explicit', 'ExplicitCurrentControl', + 'ExplicitPowerControl', 'ExplicitResistanceControl', + 'FickianDiffusion', 'ForwardTafel', 'Full', 'FullAlgebraic', + 'FullDifferential', 'FunctionControl', 'Integrated', + 'InverseButlerVolmer', 'Isothermal', 'LeadingOrder', + 'LeadingOrderAlgebraic', 'LeadingOrderDifferential', 'Linear', + 'LithiumMetalBaseModel', 'LithiumMetalExplicit', + 'LithiumMetalSurfaceForm', 'LossActiveMaterial', 'Lumped', + 'MSMRButlerVolmer', 'MSMRDiffusion', 'MSMROpenCircuitPotential', + 'Marcus', 'MarcusHushChidsey', 'NoConvection', 'NoMechanics', + 'NoOxygen', 'NoPlating', 'NoReaction', 'NoSEI', 'OCVElement', + 'OneDimensionalX', 'Plating', 'PolynomialProfile', + 'PotentialPair1plus1D', 'PotentialPair2plus1D', + 'PowerFunctionControl', 'RCElement', 'ReactionDriven', + 'ReactionDrivenODE', 'ResistanceFunctionControl', 'ResistorElement', + 'SEIGrowth', 'SingleOpenCircuitPotential', 'SurfaceForm', + 'SwellingOnly', 'SymmetricButlerVolmer', 'ThermalSubModel', 'Total', + 'TotalConcentration', 'TotalInterfacialCurrent', + 'TotalMainKinetics', 'TotalSEI', 'Uniform', + 'VoltageFunctionControl', 'VoltageModel', + 'XAveragedPolynomialProfile', 'active_material', + 'base_active_material', 'base_convection', 'base_current_collector', + 'base_electrode', 'base_electrolyte_conductivity', + 'base_electrolyte_diffusion', 'base_external_circuit', + 'base_interface', 'base_kinetics', 'base_mechanics', 'base_ocp', + 'base_ohm', 'base_oxygen_diffusion', 'base_particle', + 'base_plating', 'base_porosity', 'base_sei', 'base_submodel', + 'base_thermal', 'base_through_cell_convection', + 'base_transport_efficiency', 'base_transverse_convection', + 'base_utilisation', 'bruggeman_transport_efficiency', + 'butler_volmer', 'composite_conductivity', 'composite_ohm', + 'composite_surface_form_conductivity', 'constant_active_material', + 'constant_concentration', 'constant_porosity', 'constant_sei', + 'constant_utilisation', 'convection', 'crack_propagation', + 'current_collector', 'current_driven_utilisation', + 'current_sigmoid_ocp', 'diffusion_limited', + 'effective_resistance_current_collector', 'electrode', + 'electrolyte_conductivity', 'electrolyte_diffusion', + 'equivalent_circuit_elements', 'explicit_control_external_circuit', + 'explicit_convection', 'explicit_surface_form_conductivity', + 'external_circuit', 'fickian_diffusion', 'full_conductivity', + 'full_convection', 'full_diffusion', 'full_ohm', + 'full_oxygen_diffusion', 'full_surface_form_conductivity', + 'full_utilisation', 'function_control_external_circuit', + 'homogeneous_current_collector', 'integrated_conductivity', + 'interface', 'interface_utilisation', 'inverse_butler_volmer', + 'inverse_kinetics', 'isothermal', 'kinetics', 'leading_ohm', + 'leading_order_conductivity', 'leading_order_diffusion', + 'leading_oxygen_diffusion', 'leading_surface_form_conductivity', + 'li_metal', 'linear', 'lithium_plating', 'loss_active_material', + 'lumped', 'marcus', 'msmr_butler_volmer', 'msmr_diffusion', + 'msmr_ocp', 'no_convection', 'no_mechanics', 'no_oxygen', + 'no_plating', 'no_reaction', 'no_sei', 'ocv_element', 'ohm', + 'open_circuit_potential', 'oxygen_diffusion', 'particle', + 'particle_mechanics', 'plating', 'polynomial_profile', 'porosity', + 'potential_pair', 'pouch_cell', 'pouch_cell_1D_current_collectors', + 'pouch_cell_2D_current_collectors', 'rc_element', + 'reaction_driven_porosity', 'reaction_driven_porosity_ode', + 'resistor_element', 'sei', 'sei_growth', 'single_ocp', + 'surface_form_ohm', 'surface_potential_form', 'swelling_only', + 'tafel', 'thermal', 'through_cell', 'total_active_material', + 'total_interfacial_current', 'total_main_kinetics', + 'total_particle_concentration', 'total_sei', 'transport_efficiency', + 'transverse', 'uniform_convection', 'voltage_model', + 'x_averaged_polynomial_profile', 'x_full'] diff --git a/pybamm/models/submodels/active_material/__init__.py b/pybamm/models/submodels/active_material/__init__.py index cb263eb4ff..9cc3e5dd72 100644 --- a/pybamm/models/submodels/active_material/__init__.py +++ b/pybamm/models/submodels/active_material/__init__.py @@ -1,4 +1,30 @@ -from .base_active_material import BaseModel -from .constant_active_material import Constant -from .loss_active_material import LossActiveMaterial -from .total_active_material import Total +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_active_material', + 'constant_active_material', + 'loss_active_material', + 'total_active_material', + }, + submod_attrs={ + 'base_active_material': [ + 'BaseModel', + ], + 'constant_active_material': [ + 'Constant', + ], + 'loss_active_material': [ + 'LossActiveMaterial', + ], + 'total_active_material': [ + 'Total', + ], + }, +) + +__all__ = ['BaseModel', 'Constant', 'LossActiveMaterial', 'Total', + 'base_active_material', 'constant_active_material', + 'loss_active_material', 'total_active_material'] diff --git a/pybamm/models/submodels/convection/__init__.py b/pybamm/models/submodels/convection/__init__.py index cc0a0d086d..099421e2bd 100644 --- a/pybamm/models/submodels/convection/__init__.py +++ b/pybamm/models/submodels/convection/__init__.py @@ -1,2 +1,42 @@ -from .base_convection import BaseModel -from . import through_cell, transverse +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_convection', + 'through_cell', + 'transverse', + }, + submod_attrs={ + 'base_convection': [ + 'BaseModel', + ], + 'through_cell': [ + 'BaseThroughCellModel', + 'Explicit', + 'Full', + 'NoConvection', + 'base_through_cell_convection', + 'explicit_convection', + 'full_convection', + 'no_convection', + ], + 'transverse': [ + 'BaseTransverseModel', + 'Full', + 'NoConvection', + 'Uniform', + 'base_transverse_convection', + 'full_convection', + 'no_convection', + 'uniform_convection', + ], + }, +) + +__all__ = ['BaseModel', 'BaseThroughCellModel', 'BaseTransverseModel', + 'Explicit', 'Full', 'NoConvection', 'Uniform', 'base_convection', + 'base_through_cell_convection', 'base_transverse_convection', + 'explicit_convection', 'full_convection', 'no_convection', + 'through_cell', 'transverse', 'uniform_convection'] diff --git a/pybamm/models/submodels/convection/through_cell/__init__.py b/pybamm/models/submodels/convection/through_cell/__init__.py index ddcd5b9e9b..287c0ac9ed 100644 --- a/pybamm/models/submodels/convection/through_cell/__init__.py +++ b/pybamm/models/submodels/convection/through_cell/__init__.py @@ -1,4 +1,30 @@ -from .base_through_cell_convection import BaseThroughCellModel -from .no_convection import NoConvection -from .explicit_convection import Explicit -from .full_convection import Full +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_through_cell_convection', + 'explicit_convection', + 'full_convection', + 'no_convection', + }, + submod_attrs={ + 'base_through_cell_convection': [ + 'BaseThroughCellModel', + ], + 'explicit_convection': [ + 'Explicit', + ], + 'full_convection': [ + 'Full', + ], + 'no_convection': [ + 'NoConvection', + ], + }, +) + +__all__ = ['BaseThroughCellModel', 'Explicit', 'Full', 'NoConvection', + 'base_through_cell_convection', 'explicit_convection', + 'full_convection', 'no_convection'] diff --git a/pybamm/models/submodels/convection/transverse/__init__.py b/pybamm/models/submodels/convection/transverse/__init__.py index c2b2292168..b09962d075 100644 --- a/pybamm/models/submodels/convection/transverse/__init__.py +++ b/pybamm/models/submodels/convection/transverse/__init__.py @@ -1,4 +1,30 @@ -from .base_transverse_convection import BaseTransverseModel -from .no_convection import NoConvection -from .uniform_convection import Uniform -from .full_convection import Full +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_transverse_convection', + 'full_convection', + 'no_convection', + 'uniform_convection', + }, + submod_attrs={ + 'base_transverse_convection': [ + 'BaseTransverseModel', + ], + 'full_convection': [ + 'Full', + ], + 'no_convection': [ + 'NoConvection', + ], + 'uniform_convection': [ + 'Uniform', + ], + }, +) + +__all__ = ['BaseTransverseModel', 'Full', 'NoConvection', 'Uniform', + 'base_transverse_convection', 'full_convection', 'no_convection', + 'uniform_convection'] diff --git a/pybamm/models/submodels/current_collector/__init__.py b/pybamm/models/submodels/current_collector/__init__.py index b721f14394..d00fd94d97 100644 --- a/pybamm/models/submodels/current_collector/__init__.py +++ b/pybamm/models/submodels/current_collector/__init__.py @@ -1,12 +1,36 @@ -from .base_current_collector import BaseModel +import lazy_loader -from .homogeneous_current_collector import Uniform -from .effective_resistance_current_collector import ( - EffectiveResistance, - AlternativeEffectiveResistance2D, -) -from .potential_pair import ( - BasePotentialPair, - PotentialPair1plus1D, - PotentialPair2plus1D, + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_current_collector', + 'effective_resistance_current_collector', + 'homogeneous_current_collector', + 'potential_pair', + }, + submod_attrs={ + 'base_current_collector': [ + 'BaseModel', + ], + 'effective_resistance_current_collector': [ + 'AlternativeEffectiveResistance2D', + 'BaseEffectiveResistance', + 'EffectiveResistance', + ], + 'homogeneous_current_collector': [ + 'Uniform', + ], + 'potential_pair': [ + 'BasePotentialPair', + 'PotentialPair1plus1D', + 'PotentialPair2plus1D', + ], + }, ) + +__all__ = ['AlternativeEffectiveResistance2D', 'BaseEffectiveResistance', + 'BaseModel', 'BasePotentialPair', 'EffectiveResistance', + 'PotentialPair1plus1D', 'PotentialPair2plus1D', 'Uniform', + 'base_current_collector', 'effective_resistance_current_collector', + 'homogeneous_current_collector', 'potential_pair'] diff --git a/pybamm/models/submodels/electrode/__init__.py b/pybamm/models/submodels/electrode/__init__.py index ce60b7e1e7..76072d0510 100644 --- a/pybamm/models/submodels/electrode/__init__.py +++ b/pybamm/models/submodels/electrode/__init__.py @@ -1,2 +1,37 @@ -from .base_electrode import BaseElectrode -from . import ohm +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_electrode', + 'ohm', + }, + submod_attrs={ + 'base_electrode': [ + 'BaseElectrode', + ], + 'ohm': [ + 'BaseModel', + 'Composite', + 'Full', + 'LeadingOrder', + 'LithiumMetalBaseModel', + 'LithiumMetalExplicit', + 'LithiumMetalSurfaceForm', + 'SurfaceForm', + 'base_ohm', + 'composite_ohm', + 'full_ohm', + 'leading_ohm', + 'li_metal', + 'surface_form_ohm', + ], + }, +) + +__all__ = ['BaseElectrode', 'BaseModel', 'Composite', 'Full', 'LeadingOrder', + 'LithiumMetalBaseModel', 'LithiumMetalExplicit', + 'LithiumMetalSurfaceForm', 'SurfaceForm', 'base_electrode', + 'base_ohm', 'composite_ohm', 'full_ohm', 'leading_ohm', 'li_metal', + 'ohm', 'surface_form_ohm'] diff --git a/pybamm/models/submodels/electrode/ohm/__init__.py b/pybamm/models/submodels/electrode/ohm/__init__.py index c25ece8717..d3fec55969 100644 --- a/pybamm/models/submodels/electrode/ohm/__init__.py +++ b/pybamm/models/submodels/electrode/ohm/__init__.py @@ -1,6 +1,42 @@ -from .base_ohm import BaseModel -from .composite_ohm import Composite -from .full_ohm import Full -from .leading_ohm import LeadingOrder -from .surface_form_ohm import SurfaceForm -from .li_metal import LithiumMetalExplicit, LithiumMetalSurfaceForm +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_ohm', + 'composite_ohm', + 'full_ohm', + 'leading_ohm', + 'li_metal', + 'surface_form_ohm', + }, + submod_attrs={ + 'base_ohm': [ + 'BaseModel', + ], + 'composite_ohm': [ + 'Composite', + ], + 'full_ohm': [ + 'Full', + ], + 'leading_ohm': [ + 'LeadingOrder', + ], + 'li_metal': [ + 'LithiumMetalBaseModel', + 'LithiumMetalExplicit', + 'LithiumMetalSurfaceForm', + ], + 'surface_form_ohm': [ + 'SurfaceForm', + ], + }, +) + +__all__ = ['BaseModel', 'Composite', 'Full', 'LeadingOrder', + 'LithiumMetalBaseModel', 'LithiumMetalExplicit', + 'LithiumMetalSurfaceForm', 'SurfaceForm', 'base_ohm', + 'composite_ohm', 'full_ohm', 'leading_ohm', 'li_metal', + 'surface_form_ohm'] diff --git a/pybamm/models/submodels/electrolyte_conductivity/__init__.py b/pybamm/models/submodels/electrolyte_conductivity/__init__.py index 04925ea890..2f1983564e 100644 --- a/pybamm/models/submodels/electrolyte_conductivity/__init__.py +++ b/pybamm/models/submodels/electrolyte_conductivity/__init__.py @@ -1,7 +1,58 @@ -from .base_electrolyte_conductivity import BaseElectrolyteConductivity -from .leading_order_conductivity import LeadingOrder -from .composite_conductivity import Composite -from .full_conductivity import Full -from .integrated_conductivity import Integrated +import lazy_loader -from . import surface_potential_form + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_electrolyte_conductivity', + 'composite_conductivity', + 'full_conductivity', + 'integrated_conductivity', + 'leading_order_conductivity', + 'surface_potential_form', + }, + submod_attrs={ + 'base_electrolyte_conductivity': [ + 'BaseElectrolyteConductivity', + ], + 'composite_conductivity': [ + 'Composite', + ], + 'full_conductivity': [ + 'Full', + ], + 'integrated_conductivity': [ + 'Integrated', + ], + 'leading_order_conductivity': [ + 'LeadingOrder', + ], + 'surface_potential_form': [ + 'BaseLeadingOrderSurfaceForm', + 'BaseModel', + 'CompositeAlgebraic', + 'CompositeDifferential', + 'Explicit', + 'FullAlgebraic', + 'FullDifferential', + 'LeadingOrderAlgebraic', + 'LeadingOrderDifferential', + 'composite_surface_form_conductivity', + 'explicit_surface_form_conductivity', + 'full_surface_form_conductivity', + 'leading_surface_form_conductivity', + ], + }, +) + +__all__ = ['BaseElectrolyteConductivity', 'BaseLeadingOrderSurfaceForm', + 'BaseModel', 'Composite', 'CompositeAlgebraic', + 'CompositeDifferential', 'Explicit', 'Full', 'FullAlgebraic', + 'FullDifferential', 'Integrated', 'LeadingOrder', + 'LeadingOrderAlgebraic', 'LeadingOrderDifferential', + 'base_electrolyte_conductivity', 'composite_conductivity', + 'composite_surface_form_conductivity', + 'explicit_surface_form_conductivity', 'full_conductivity', + 'full_surface_form_conductivity', 'integrated_conductivity', + 'leading_order_conductivity', 'leading_surface_form_conductivity', + 'surface_potential_form'] diff --git a/pybamm/models/submodels/electrolyte_conductivity/surface_potential_form/__init__.py b/pybamm/models/submodels/electrolyte_conductivity/surface_potential_form/__init__.py index 2af47138c8..0c459175bc 100644 --- a/pybamm/models/submodels/electrolyte_conductivity/surface_potential_form/__init__.py +++ b/pybamm/models/submodels/electrolyte_conductivity/surface_potential_form/__init__.py @@ -14,4 +14,43 @@ ) # Explicit model -from .explicit_surface_form_conductivity import Explicit +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'composite_surface_form_conductivity', + 'explicit_surface_form_conductivity', + 'full_surface_form_conductivity', + 'leading_surface_form_conductivity', + }, + submod_attrs={ + 'composite_surface_form_conductivity': [ + 'BaseModel', + 'CompositeAlgebraic', + 'CompositeDifferential', + ], + 'explicit_surface_form_conductivity': [ + 'Explicit', + ], + 'full_surface_form_conductivity': [ + 'BaseModel', + 'FullAlgebraic', + 'FullDifferential', + ], + 'leading_surface_form_conductivity': [ + 'BaseLeadingOrderSurfaceForm', + 'LeadingOrderAlgebraic', + 'LeadingOrderDifferential', + ], + }, +) + +__all__ = ['BaseLeadingOrderSurfaceForm', 'BaseModel', 'CompositeAlgebraic', + 'CompositeDifferential', 'Explicit', 'FullAlgebraic', + 'FullDifferential', 'LeadingOrderAlgebraic', + 'LeadingOrderDifferential', 'composite_surface_form_conductivity', + 'explicit_surface_form_conductivity', + 'full_surface_form_conductivity', + 'leading_surface_form_conductivity'] diff --git a/pybamm/models/submodels/electrolyte_diffusion/__init__.py b/pybamm/models/submodels/electrolyte_diffusion/__init__.py index 5636b77fea..b73c6e7549 100644 --- a/pybamm/models/submodels/electrolyte_diffusion/__init__.py +++ b/pybamm/models/submodels/electrolyte_diffusion/__init__.py @@ -1,4 +1,31 @@ -from .base_electrolyte_diffusion import BaseElectrolyteDiffusion -from .leading_order_diffusion import LeadingOrder -from .full_diffusion import Full -from .constant_concentration import ConstantConcentration +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_electrolyte_diffusion', + 'constant_concentration', + 'full_diffusion', + 'leading_order_diffusion', + }, + submod_attrs={ + 'base_electrolyte_diffusion': [ + 'BaseElectrolyteDiffusion', + ], + 'constant_concentration': [ + 'ConstantConcentration', + ], + 'full_diffusion': [ + 'Full', + ], + 'leading_order_diffusion': [ + 'LeadingOrder', + ], + }, +) + +__all__ = ['BaseElectrolyteDiffusion', 'ConstantConcentration', 'Full', + 'LeadingOrder', 'base_electrolyte_diffusion', + 'constant_concentration', 'full_diffusion', + 'leading_order_diffusion'] diff --git a/pybamm/models/submodels/equivalent_circuit_elements/__init__.py b/pybamm/models/submodels/equivalent_circuit_elements/__init__.py index a4e76cc5b8..f39863e64a 100644 --- a/pybamm/models/submodels/equivalent_circuit_elements/__init__.py +++ b/pybamm/models/submodels/equivalent_circuit_elements/__init__.py @@ -1,5 +1,34 @@ -from .ocv_element import OCVElement -from .resistor_element import ResistorElement -from .rc_element import RCElement -from .thermal import ThermalSubModel -from .voltage_model import VoltageModel +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'ocv_element', + 'rc_element', + 'resistor_element', + 'thermal', + 'voltage_model', + }, + submod_attrs={ + 'ocv_element': [ + 'OCVElement', + ], + 'rc_element': [ + 'RCElement', + ], + 'resistor_element': [ + 'ResistorElement', + ], + 'thermal': [ + 'ThermalSubModel', + ], + 'voltage_model': [ + 'VoltageModel', + ], + }, +) + +__all__ = ['OCVElement', 'RCElement', 'ResistorElement', 'ThermalSubModel', + 'VoltageModel', 'ocv_element', 'rc_element', 'resistor_element', + 'thermal', 'voltage_model'] diff --git a/pybamm/models/submodels/external_circuit/__init__.py b/pybamm/models/submodels/external_circuit/__init__.py index bd71790295..9ff0bfaa21 100644 --- a/pybamm/models/submodels/external_circuit/__init__.py +++ b/pybamm/models/submodels/external_circuit/__init__.py @@ -1,13 +1,35 @@ -from .base_external_circuit import BaseModel -from .explicit_control_external_circuit import ( - ExplicitCurrentControl, - ExplicitPowerControl, - ExplicitResistanceControl, -) -from .function_control_external_circuit import ( - FunctionControl, - VoltageFunctionControl, - PowerFunctionControl, - ResistanceFunctionControl, - CCCVFunctionControl, +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_external_circuit', + 'explicit_control_external_circuit', + 'function_control_external_circuit', + }, + submod_attrs={ + 'base_external_circuit': [ + 'BaseModel', + ], + 'explicit_control_external_circuit': [ + 'ExplicitCurrentControl', + 'ExplicitPowerControl', + 'ExplicitResistanceControl', + ], + 'function_control_external_circuit': [ + 'CCCVFunctionControl', + 'FunctionControl', + 'PowerFunctionControl', + 'ResistanceFunctionControl', + 'VoltageFunctionControl', + ], + }, ) + +__all__ = ['BaseModel', 'CCCVFunctionControl', 'ExplicitCurrentControl', + 'ExplicitPowerControl', 'ExplicitResistanceControl', + 'FunctionControl', 'PowerFunctionControl', + 'ResistanceFunctionControl', 'VoltageFunctionControl', + 'base_external_circuit', 'explicit_control_external_circuit', + 'function_control_external_circuit'] diff --git a/pybamm/models/submodels/interface/__init__.py b/pybamm/models/submodels/interface/__init__.py index 1a3ffd6876..d405a144df 100644 --- a/pybamm/models/submodels/interface/__init__.py +++ b/pybamm/models/submodels/interface/__init__.py @@ -1,2 +1,111 @@ -from .base_interface import BaseInterface -from .total_interfacial_current import TotalInterfacialCurrent +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_interface', + 'interface_utilisation', + 'kinetics', + 'lithium_plating', + 'open_circuit_potential', + 'sei', + 'total_interfacial_current', + }, + submod_attrs={ + 'base_interface': [ + 'BaseInterface', + ], + 'interface_utilisation': [ + 'BaseModel', + 'Constant', + 'CurrentDriven', + 'Full', + 'base_utilisation', + 'constant_utilisation', + 'current_driven_utilisation', + 'full_utilisation', + ], + 'kinetics': [ + 'AsymmetricButlerVolmer', + 'BaseKinetics', + 'CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', + 'DiffusionLimited', + 'ForwardTafel', + 'InverseButlerVolmer', + 'Linear', + 'MSMRButlerVolmer', + 'Marcus', + 'MarcusHushChidsey', + 'NoReaction', + 'SymmetricButlerVolmer', + 'TotalMainKinetics', + 'base_kinetics', + 'butler_volmer', + 'diffusion_limited', + 'inverse_butler_volmer', + 'inverse_kinetics', + 'linear', + 'marcus', + 'msmr_butler_volmer', + 'no_reaction', + 'tafel', + 'total_main_kinetics', + ], + 'lithium_plating': [ + 'BasePlating', + 'NoPlating', + 'Plating', + 'base_plating', + 'no_plating', + 'plating', + ], + 'open_circuit_potential': [ + 'BaseOpenCircuitPotential', + 'CurrentSigmoidOpenCircuitPotential', + 'MSMROpenCircuitPotential', + 'SingleOpenCircuitPotential', + 'base_ocp', + 'current_sigmoid_ocp', + 'msmr_ocp', + 'single_ocp', + ], + 'sei': [ + 'BaseModel', + 'ConstantSEI', + 'NoSEI', + 'SEIGrowth', + 'TotalSEI', + 'base_sei', + 'constant_sei', + 'no_sei', + 'sei_growth', + 'total_sei', + ], + 'total_interfacial_current': [ + 'TotalInterfacialCurrent', + ], + }, +) + +__all__ = ['AsymmetricButlerVolmer', 'BaseInterface', 'BaseKinetics', + 'BaseModel', 'BaseOpenCircuitPotential', 'BasePlating', 'Constant', + 'ConstantSEI', 'CurrentDriven', 'CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', + 'CurrentSigmoidOpenCircuitPotential', 'DiffusionLimited', + 'ForwardTafel', 'Full', 'InverseButlerVolmer', 'Linear', + 'MSMRButlerVolmer', 'MSMROpenCircuitPotential', 'Marcus', + 'MarcusHushChidsey', 'NoPlating', 'NoReaction', 'NoSEI', 'Plating', + 'SEIGrowth', 'SingleOpenCircuitPotential', 'SymmetricButlerVolmer', + 'TotalInterfacialCurrent', 'TotalMainKinetics', 'TotalSEI', + 'base_interface', 'base_kinetics', 'base_ocp', 'base_plating', + 'base_sei', 'base_utilisation', 'butler_volmer', 'constant_sei', + 'constant_utilisation', 'current_driven_utilisation', + 'current_sigmoid_ocp', 'diffusion_limited', 'full_utilisation', + 'interface_utilisation', 'inverse_butler_volmer', + 'inverse_kinetics', 'kinetics', 'linear', 'lithium_plating', + 'marcus', 'msmr_butler_volmer', 'msmr_ocp', 'no_plating', + 'no_reaction', 'no_sei', 'open_circuit_potential', 'plating', 'sei', + 'sei_growth', 'single_ocp', 'tafel', 'total_interfacial_current', + 'total_main_kinetics', 'total_sei'] diff --git a/pybamm/models/submodels/interface/interface_utilisation/__init__.py b/pybamm/models/submodels/interface/interface_utilisation/__init__.py index f13ee19d6b..fdb4360ebd 100644 --- a/pybamm/models/submodels/interface/interface_utilisation/__init__.py +++ b/pybamm/models/submodels/interface/interface_utilisation/__init__.py @@ -1,4 +1,30 @@ -from .base_utilisation import BaseModel -from .full_utilisation import Full -from .constant_utilisation import Constant -from .current_driven_utilisation import CurrentDriven +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_utilisation', + 'constant_utilisation', + 'current_driven_utilisation', + 'full_utilisation', + }, + submod_attrs={ + 'base_utilisation': [ + 'BaseModel', + ], + 'constant_utilisation': [ + 'Constant', + ], + 'current_driven_utilisation': [ + 'CurrentDriven', + ], + 'full_utilisation': [ + 'Full', + ], + }, +) + +__all__ = ['BaseModel', 'Constant', 'CurrentDriven', 'Full', + 'base_utilisation', 'constant_utilisation', + 'current_driven_utilisation', 'full_utilisation'] diff --git a/pybamm/models/submodels/interface/kinetics/__init__.py b/pybamm/models/submodels/interface/kinetics/__init__.py index d99ec56783..0bc938b1ff 100644 --- a/pybamm/models/submodels/interface/kinetics/__init__.py +++ b/pybamm/models/submodels/interface/kinetics/__init__.py @@ -1,14 +1,65 @@ -from .base_kinetics import BaseKinetics -from .total_main_kinetics import TotalMainKinetics -from .butler_volmer import SymmetricButlerVolmer, AsymmetricButlerVolmer -from .linear import Linear -from .marcus import Marcus, MarcusHushChidsey -from .tafel import ForwardTafel # , BackwardTafel -from .no_reaction import NoReaction -from .msmr_butler_volmer import MSMRButlerVolmer -from .diffusion_limited import DiffusionLimited -from .inverse_kinetics.inverse_butler_volmer import ( - InverseButlerVolmer, - CurrentForInverseButlerVolmer, - CurrentForInverseButlerVolmerLithiumMetal, +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_kinetics', + 'butler_volmer', + 'diffusion_limited', + 'inverse_kinetics', + 'linear', + 'marcus', + 'msmr_butler_volmer', + 'no_reaction', + 'tafel', + 'total_main_kinetics', + }, + submod_attrs={ + 'base_kinetics': [ + 'BaseKinetics', + ], + 'butler_volmer': [ + 'AsymmetricButlerVolmer', + 'SymmetricButlerVolmer', + ], + 'diffusion_limited': [ + 'DiffusionLimited', + ], + 'inverse_kinetics': [ + 'CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', + 'InverseButlerVolmer', + 'inverse_butler_volmer', + ], + 'linear': [ + 'Linear', + ], + 'marcus': [ + 'Marcus', + 'MarcusHushChidsey', + ], + 'msmr_butler_volmer': [ + 'MSMRButlerVolmer', + ], + 'no_reaction': [ + 'NoReaction', + ], + 'tafel': [ + 'ForwardTafel', + ], + 'total_main_kinetics': [ + 'TotalMainKinetics', + ], + }, ) + +__all__ = ['AsymmetricButlerVolmer', 'BaseKinetics', + 'CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', 'DiffusionLimited', + 'ForwardTafel', 'InverseButlerVolmer', 'Linear', 'MSMRButlerVolmer', + 'Marcus', 'MarcusHushChidsey', 'NoReaction', + 'SymmetricButlerVolmer', 'TotalMainKinetics', 'base_kinetics', + 'butler_volmer', 'diffusion_limited', 'inverse_butler_volmer', + 'inverse_kinetics', 'linear', 'marcus', 'msmr_butler_volmer', + 'no_reaction', 'tafel', 'total_main_kinetics'] diff --git a/pybamm/models/submodels/interface/kinetics/inverse_kinetics/__init__.py b/pybamm/models/submodels/interface/kinetics/inverse_kinetics/__init__.py index e69de29bb2..cbf2e4cfc5 100644 --- a/pybamm/models/submodels/interface/kinetics/inverse_kinetics/__init__.py +++ b/pybamm/models/submodels/interface/kinetics/inverse_kinetics/__init__.py @@ -0,0 +1,20 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'inverse_butler_volmer', + }, + submod_attrs={ + 'inverse_butler_volmer': [ + 'CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', + 'InverseButlerVolmer', + ], + }, +) + +__all__ = ['CurrentForInverseButlerVolmer', + 'CurrentForInverseButlerVolmerLithiumMetal', 'InverseButlerVolmer', + 'inverse_butler_volmer'] diff --git a/pybamm/models/submodels/interface/lithium_plating/__init__.py b/pybamm/models/submodels/interface/lithium_plating/__init__.py index cea178158d..1a9da70ae2 100644 --- a/pybamm/models/submodels/interface/lithium_plating/__init__.py +++ b/pybamm/models/submodels/interface/lithium_plating/__init__.py @@ -1,3 +1,25 @@ -from .base_plating import BasePlating -from .no_plating import NoPlating -from .plating import Plating +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_plating', + 'no_plating', + 'plating', + }, + submod_attrs={ + 'base_plating': [ + 'BasePlating', + ], + 'no_plating': [ + 'NoPlating', + ], + 'plating': [ + 'Plating', + ], + }, +) + +__all__ = ['BasePlating', 'NoPlating', 'Plating', 'base_plating', 'no_plating', + 'plating'] diff --git a/pybamm/models/submodels/interface/open_circuit_potential/__init__.py b/pybamm/models/submodels/interface/open_circuit_potential/__init__.py index 5f8a409bba..76d5a9d2b4 100644 --- a/pybamm/models/submodels/interface/open_circuit_potential/__init__.py +++ b/pybamm/models/submodels/interface/open_circuit_potential/__init__.py @@ -1,4 +1,30 @@ -from .base_ocp import BaseOpenCircuitPotential -from .single_ocp import SingleOpenCircuitPotential -from .current_sigmoid_ocp import CurrentSigmoidOpenCircuitPotential -from .msmr_ocp import MSMROpenCircuitPotential +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_ocp', + 'current_sigmoid_ocp', + 'msmr_ocp', + 'single_ocp', + }, + submod_attrs={ + 'base_ocp': [ + 'BaseOpenCircuitPotential', + ], + 'current_sigmoid_ocp': [ + 'CurrentSigmoidOpenCircuitPotential', + ], + 'msmr_ocp': [ + 'MSMROpenCircuitPotential', + ], + 'single_ocp': [ + 'SingleOpenCircuitPotential', + ], + }, +) + +__all__ = ['BaseOpenCircuitPotential', 'CurrentSigmoidOpenCircuitPotential', + 'MSMROpenCircuitPotential', 'SingleOpenCircuitPotential', + 'base_ocp', 'current_sigmoid_ocp', 'msmr_ocp', 'single_ocp'] diff --git a/pybamm/models/submodels/interface/sei/__init__.py b/pybamm/models/submodels/interface/sei/__init__.py index 5f151daf0e..b7ae8ff2c5 100644 --- a/pybamm/models/submodels/interface/sei/__init__.py +++ b/pybamm/models/submodels/interface/sei/__init__.py @@ -1,5 +1,33 @@ -from .base_sei import BaseModel -from .total_sei import TotalSEI -from .no_sei import NoSEI -from .constant_sei import ConstantSEI -from .sei_growth import SEIGrowth +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_sei', + 'constant_sei', + 'no_sei', + 'sei_growth', + 'total_sei', + }, + submod_attrs={ + 'base_sei': [ + 'BaseModel', + ], + 'constant_sei': [ + 'ConstantSEI', + ], + 'no_sei': [ + 'NoSEI', + ], + 'sei_growth': [ + 'SEIGrowth', + ], + 'total_sei': [ + 'TotalSEI', + ], + }, +) + +__all__ = ['BaseModel', 'ConstantSEI', 'NoSEI', 'SEIGrowth', 'TotalSEI', + 'base_sei', 'constant_sei', 'no_sei', 'sei_growth', 'total_sei'] diff --git a/pybamm/models/submodels/oxygen_diffusion/__init__.py b/pybamm/models/submodels/oxygen_diffusion/__init__.py index a5161f93f9..1682ba39e1 100644 --- a/pybamm/models/submodels/oxygen_diffusion/__init__.py +++ b/pybamm/models/submodels/oxygen_diffusion/__init__.py @@ -1,4 +1,30 @@ -from .base_oxygen_diffusion import BaseModel -from .leading_oxygen_diffusion import LeadingOrder -from .full_oxygen_diffusion import Full -from .no_oxygen import NoOxygen +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_oxygen_diffusion', + 'full_oxygen_diffusion', + 'leading_oxygen_diffusion', + 'no_oxygen', + }, + submod_attrs={ + 'base_oxygen_diffusion': [ + 'BaseModel', + ], + 'full_oxygen_diffusion': [ + 'Full', + ], + 'leading_oxygen_diffusion': [ + 'LeadingOrder', + ], + 'no_oxygen': [ + 'NoOxygen', + ], + }, +) + +__all__ = ['BaseModel', 'Full', 'LeadingOrder', 'NoOxygen', + 'base_oxygen_diffusion', 'full_oxygen_diffusion', + 'leading_oxygen_diffusion', 'no_oxygen'] diff --git a/pybamm/models/submodels/particle/__init__.py b/pybamm/models/submodels/particle/__init__.py index 237b2c19c8..2167c36124 100644 --- a/pybamm/models/submodels/particle/__init__.py +++ b/pybamm/models/submodels/particle/__init__.py @@ -1,6 +1,40 @@ -from .base_particle import BaseParticle -from .fickian_diffusion import FickianDiffusion -from .polynomial_profile import PolynomialProfile -from .x_averaged_polynomial_profile import XAveragedPolynomialProfile -from .total_particle_concentration import TotalConcentration -from .msmr_diffusion import MSMRDiffusion +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_particle', + 'fickian_diffusion', + 'msmr_diffusion', + 'polynomial_profile', + 'total_particle_concentration', + 'x_averaged_polynomial_profile', + }, + submod_attrs={ + 'base_particle': [ + 'BaseParticle', + ], + 'fickian_diffusion': [ + 'FickianDiffusion', + ], + 'msmr_diffusion': [ + 'MSMRDiffusion', + ], + 'polynomial_profile': [ + 'PolynomialProfile', + ], + 'total_particle_concentration': [ + 'TotalConcentration', + ], + 'x_averaged_polynomial_profile': [ + 'XAveragedPolynomialProfile', + ], + }, +) + +__all__ = ['BaseParticle', 'FickianDiffusion', 'MSMRDiffusion', + 'PolynomialProfile', 'TotalConcentration', + 'XAveragedPolynomialProfile', 'base_particle', 'fickian_diffusion', + 'msmr_diffusion', 'polynomial_profile', + 'total_particle_concentration', 'x_averaged_polynomial_profile'] diff --git a/pybamm/models/submodels/particle_mechanics/__init__.py b/pybamm/models/submodels/particle_mechanics/__init__.py index 9b89a95d55..7820df488e 100644 --- a/pybamm/models/submodels/particle_mechanics/__init__.py +++ b/pybamm/models/submodels/particle_mechanics/__init__.py @@ -1,4 +1,30 @@ -from .base_mechanics import BaseMechanics -from .crack_propagation import CrackPropagation -from .swelling_only import SwellingOnly -from .no_mechanics import NoMechanics +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_mechanics', + 'crack_propagation', + 'no_mechanics', + 'swelling_only', + }, + submod_attrs={ + 'base_mechanics': [ + 'BaseMechanics', + ], + 'crack_propagation': [ + 'CrackPropagation', + ], + 'no_mechanics': [ + 'NoMechanics', + ], + 'swelling_only': [ + 'SwellingOnly', + ], + }, +) + +__all__ = ['BaseMechanics', 'CrackPropagation', 'NoMechanics', 'SwellingOnly', + 'base_mechanics', 'crack_propagation', 'no_mechanics', + 'swelling_only'] diff --git a/pybamm/models/submodels/porosity/__init__.py b/pybamm/models/submodels/porosity/__init__.py index de09dca46c..cddefa2eee 100644 --- a/pybamm/models/submodels/porosity/__init__.py +++ b/pybamm/models/submodels/porosity/__init__.py @@ -1,4 +1,30 @@ -from .base_porosity import BaseModel -from .constant_porosity import Constant -from .reaction_driven_porosity import ReactionDriven -from .reaction_driven_porosity_ode import ReactionDrivenODE +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_porosity', + 'constant_porosity', + 'reaction_driven_porosity', + 'reaction_driven_porosity_ode', + }, + submod_attrs={ + 'base_porosity': [ + 'BaseModel', + ], + 'constant_porosity': [ + 'Constant', + ], + 'reaction_driven_porosity': [ + 'ReactionDriven', + ], + 'reaction_driven_porosity_ode': [ + 'ReactionDrivenODE', + ], + }, +) + +__all__ = ['BaseModel', 'Constant', 'ReactionDriven', 'ReactionDrivenODE', + 'base_porosity', 'constant_porosity', 'reaction_driven_porosity', + 'reaction_driven_porosity_ode'] diff --git a/pybamm/models/submodels/thermal/__init__.py b/pybamm/models/submodels/thermal/__init__.py index 056a555e3f..5520fe6464 100644 --- a/pybamm/models/submodels/thermal/__init__.py +++ b/pybamm/models/submodels/thermal/__init__.py @@ -1,4 +1,37 @@ -from .base_thermal import BaseThermal -from .isothermal import Isothermal -from .lumped import Lumped -from . import pouch_cell +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_thermal', + 'isothermal', + 'lumped', + 'pouch_cell', + }, + submod_attrs={ + 'base_thermal': [ + 'BaseThermal', + ], + 'isothermal': [ + 'Isothermal', + ], + 'lumped': [ + 'Lumped', + ], + 'pouch_cell': [ + 'CurrentCollector1D', + 'CurrentCollector2D', + 'OneDimensionalX', + 'pouch_cell_1D_current_collectors', + 'pouch_cell_2D_current_collectors', + 'x_full', + ], + }, +) + +__all__ = ['BaseThermal', 'CurrentCollector1D', 'CurrentCollector2D', + 'Isothermal', 'Lumped', 'OneDimensionalX', 'base_thermal', + 'isothermal', 'lumped', 'pouch_cell', + 'pouch_cell_1D_current_collectors', + 'pouch_cell_2D_current_collectors', 'x_full'] diff --git a/pybamm/models/submodels/thermal/pouch_cell/__init__.py b/pybamm/models/submodels/thermal/pouch_cell/__init__.py index 7d0ddedbdf..45261fd39c 100644 --- a/pybamm/models/submodels/thermal/pouch_cell/__init__.py +++ b/pybamm/models/submodels/thermal/pouch_cell/__init__.py @@ -1,3 +1,26 @@ -from .x_full import OneDimensionalX -from .pouch_cell_1D_current_collectors import CurrentCollector1D -from .pouch_cell_2D_current_collectors import CurrentCollector2D +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'pouch_cell_1D_current_collectors', + 'pouch_cell_2D_current_collectors', + 'x_full', + }, + submod_attrs={ + 'pouch_cell_1D_current_collectors': [ + 'CurrentCollector1D', + ], + 'pouch_cell_2D_current_collectors': [ + 'CurrentCollector2D', + ], + 'x_full': [ + 'OneDimensionalX', + ], + }, +) + +__all__ = ['CurrentCollector1D', 'CurrentCollector2D', 'OneDimensionalX', + 'pouch_cell_1D_current_collectors', + 'pouch_cell_2D_current_collectors', 'x_full'] diff --git a/pybamm/models/submodels/transport_efficiency/__init__.py b/pybamm/models/submodels/transport_efficiency/__init__.py index 13fbe8487d..cba210f36d 100644 --- a/pybamm/models/submodels/transport_efficiency/__init__.py +++ b/pybamm/models/submodels/transport_efficiency/__init__.py @@ -1,2 +1,21 @@ -from .base_transport_efficiency import BaseModel -from .bruggeman_transport_efficiency import Bruggeman +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_transport_efficiency', + 'bruggeman_transport_efficiency', + }, + submod_attrs={ + 'base_transport_efficiency': [ + 'BaseModel', + ], + 'bruggeman_transport_efficiency': [ + 'Bruggeman', + ], + }, +) + +__all__ = ['BaseModel', 'Bruggeman', 'base_transport_efficiency', + 'bruggeman_transport_efficiency'] diff --git a/pybamm/parameters/__init__.py b/pybamm/parameters/__init__.py index cf81b82fdd..34b71c42dd 100644 --- a/pybamm/parameters/__init__.py +++ b/pybamm/parameters/__init__.py @@ -1,6 +1,108 @@ -from .process_parameter_data import ( - process_1D_data, - process_2D_data, - process_2D_data_csv, - process_3D_data_csv, +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'base_parameters', + 'bpx', + 'constants', + 'ecm_parameters', + 'electrical_parameters', + 'geometric_parameters', + 'lead_acid_parameters', + 'lithium_ion_parameters', + 'parameter_sets', + 'parameter_values', + 'process_parameter_data', + 'size_distribution_parameters', + 'thermal_parameters', + }, + submod_attrs={ + 'base_parameters': [ + 'BaseParameters', + 'NullParameters', + ], + 'bpx': [ + 'Domain', + 'cell', + 'electrolyte', + 'experiment', + 'negative_current_collector', + 'negative_electrode', + 'positive_current_collector', + 'positive_electrode', + 'preamble', + 'separator', + ], + 'constants': [ + 'F', + 'R', + 'k_b', + 'q_e', + ], + 'ecm_parameters': [ + 'EcmParameters', + ], + 'electrical_parameters': [ + 'ElectricalParameters', + 'electrical_parameters', + ], + 'geometric_parameters': [ + 'DomainGeometricParameters', + 'GeometricParameters', + 'ParticleGeometricParameters', + 'geometric_parameters', + ], + 'lead_acid_parameters': [ + 'DomainLeadAcidParameters', + 'LeadAcidParameters', + 'PhaseLeadAcidParameters', + ], + 'lithium_ion_parameters': [ + 'DomainLithiumIonParameters', + 'LithiumIonParameters', + 'ParticleLithiumIonParameters', + ], + 'parameter_sets': [ + 'ParameterSets', + 'parameter_sets', + ], + 'parameter_values': [ + 'ParameterValues', + ], + 'process_parameter_data': [ + 'process_1D_data', + 'process_2D_data', + 'process_2D_data_csv', + 'process_3D_data_csv', + ], + 'size_distribution_parameters': [ + 'get_size_distribution_parameters', + 'lognormal', + ], + 'thermal_parameters': [ + 'DomainThermalParameters', + 'ThermalParameters', + 'thermal_parameters', + ], + }, ) + +__all__ = ['BaseParameters', 'Domain', 'DomainGeometricParameters', + 'DomainLeadAcidParameters', 'DomainLithiumIonParameters', + 'DomainThermalParameters', 'EcmParameters', 'ElectricalParameters', + 'F', 'GeometricParameters', 'LeadAcidParameters', + 'LithiumIonParameters', 'NullParameters', 'ParameterSets', + 'ParameterValues', 'ParticleGeometricParameters', + 'ParticleLithiumIonParameters', 'PhaseLeadAcidParameters', 'R', + 'ThermalParameters', 'base_parameters', 'bpx', 'cell', 'constants', + 'ecm_parameters', 'electrical_parameters', 'electrolyte', + 'experiment', 'geometric_parameters', + 'get_size_distribution_parameters', 'k_b', 'lead_acid_parameters', + 'lithium_ion_parameters', 'lognormal', 'negative_current_collector', + 'negative_electrode', 'parameter_sets', 'parameter_values', + 'positive_current_collector', 'positive_electrode', 'preamble', + 'process_1D_data', 'process_2D_data', 'process_2D_data_csv', + 'process_3D_data_csv', 'process_parameter_data', 'q_e', 'separator', + 'size_distribution_parameters', 'thermal_parameters'] diff --git a/pybamm/plotting/__init__.py b/pybamm/plotting/__init__.py index e69de29bb2..4216ee936b 100644 --- a/pybamm/plotting/__init__.py +++ b/pybamm/plotting/__init__.py @@ -0,0 +1,45 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'dynamic_plot', + 'plot', + 'plot2D', + 'plot_summary_variables', + 'plot_voltage_components', + 'quick_plot', + }, + submod_attrs={ + 'dynamic_plot': [ + 'dynamic_plot', + ], + 'plot': [ + 'plot', + ], + 'plot2D': [ + 'plot2D', + ], + 'plot_summary_variables': [ + 'plot_summary_variables', + ], + 'plot_voltage_components': [ + 'plot_voltage_components', + ], + 'quick_plot': [ + 'LoopList', + 'QuickPlot', + 'QuickPlotAxes', + 'ax_max', + 'ax_min', + 'close_plots', + 'split_long_string', + ], + }, +) + +__all__ = ['LoopList', 'QuickPlot', 'QuickPlotAxes', 'ax_max', 'ax_min', + 'close_plots', 'dynamic_plot', 'plot', 'plot2D', + 'plot_summary_variables', 'plot_voltage_components', 'quick_plot', + 'split_long_string'] diff --git a/pybamm/solvers/__init__.py b/pybamm/solvers/__init__.py index e69de29bb2..c2db7619bf 100644 --- a/pybamm/solvers/__init__.py +++ b/pybamm/solvers/__init__.py @@ -0,0 +1,93 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'algebraic_solver', + 'base_solver', + 'c_solvers', + 'casadi_algebraic_solver', + 'casadi_solver', + 'dummy_solver', + 'idaklu_solver', + 'jax_bdf_solver', + 'jax_solver', + 'lrudict', + 'processed_variable', + 'processed_variable_computed', + 'scikits_dae_solver', + 'scikits_ode_solver', + 'scipy_solver', + 'solution', + }, + submod_attrs={ + 'algebraic_solver': [ + 'AlgebraicSolver', + ], + 'base_solver': [ + 'BaseSolver', + 'process', + ], + 'casadi_algebraic_solver': [ + 'CasadiAlgebraicSolver', + ], + 'casadi_solver': [ + 'CasadiSolver', + ], + 'dummy_solver': [ + 'DummySolver', + ], + 'idaklu_solver': [ + 'IDAKLUSolver', + 'have_idaklu', + 'idaklu_spec', + ], + 'jax_bdf_solver': [ + 'jax_bdf_integrate', + ], + 'jax_solver': [ + 'JaxSolver', + ], + 'lrudict': [ + 'LRUDict', + ], + 'processed_variable': [ + 'ProcessedVariable', + ], + 'processed_variable_computed': [ + 'ProcessedVariableComputed', + ], + 'scikits_dae_solver': [ + 'ScikitsDaeSolver', + 'scikits_odes_spec', + ], + 'scikits_ode_solver': [ + 'ScikitsOdeSolver', + 'have_scikits_odes', + 'scikits_odes_spec', + ], + 'scipy_solver': [ + 'ScipySolver', + ], + 'solution': [ + 'EmptySolution', + 'NumpyEncoder', + 'Solution', + 'make_cycle_solution', + ], + }, +) + +__all__ = ['AlgebraicSolver', 'BaseSolver', 'CasadiAlgebraicSolver', + 'CasadiSolver', 'DummySolver', 'EmptySolution', 'IDAKLUSolver', + 'JaxSolver', 'LRUDict', 'NumpyEncoder', 'ProcessedVariable', + 'ProcessedVariableComputed', 'ScikitsDaeSolver', 'ScikitsOdeSolver', + 'ScipySolver', 'Solution', 'algebraic_solver', 'base_solver', + 'c_solvers', 'casadi_algebraic_solver', 'casadi_solver', + 'dummy_solver', 'have_idaklu', 'have_scikits_odes', 'idaklu_solver', + 'idaklu_spec', 'jax_bdf_integrate', 'jax_bdf_solver', 'jax_solver', + 'lrudict', 'make_cycle_solution', 'process', 'processed_variable', + 'processed_variable_computed', 'scikits_dae_solver', + 'scikits_ode_solver', 'scikits_odes_spec', 'scipy_solver', + 'solution'] diff --git a/pybamm/solvers/c_solvers/__init__.py b/pybamm/solvers/c_solvers/__init__.py index e69de29bb2..8f929a7c1c 100644 --- a/pybamm/solvers/c_solvers/__init__.py +++ b/pybamm/solvers/c_solvers/__init__.py @@ -0,0 +1,10 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={}, + submod_attrs={}, +) + +__all__ = [] diff --git a/pybamm/spatial_methods/__init__.py b/pybamm/spatial_methods/__init__.py index e69de29bb2..105a0ee293 100644 --- a/pybamm/spatial_methods/__init__.py +++ b/pybamm/spatial_methods/__init__.py @@ -0,0 +1,35 @@ +import lazy_loader + + +__getattr__, __dir__, __all__ = lazy_loader.attach( + __name__, + submodules={ + 'finite_volume', + 'scikit_finite_element', + 'spatial_method', + 'spectral_volume', + 'zero_dimensional_method', + }, + submod_attrs={ + 'finite_volume': [ + 'FiniteVolume', + ], + 'scikit_finite_element': [ + 'ScikitFiniteElement', + ], + 'spatial_method': [ + 'SpatialMethod', + ], + 'spectral_volume': [ + 'SpectralVolume', + ], + 'zero_dimensional_method': [ + 'ZeroDimensionalSpatialMethod', + ], + }, +) + +__all__ = ['FiniteVolume', 'ScikitFiniteElement', 'SpatialMethod', + 'SpectralVolume', 'ZeroDimensionalSpatialMethod', 'finite_volume', + 'scikit_finite_element', 'spatial_method', 'spectral_volume', + 'zero_dimensional_method'] From 94a6a9eb142f15aeba1555fd1d9d5918f7ebf694 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sun, 21 Jan 2024 10:15:22 +0530 Subject: [PATCH 20/26] Remove existing imports --- pybamm/__init__.py | 227 --------------------------------------------- 1 file changed, 227 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 415c0e7b1c..c7dcd2c481 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -13,8 +13,6 @@ # Version info # from pybamm.version import __version__ -from pybamm.util import lazy_import -import lazy_loader as lazy # # Constants @@ -33,231 +31,6 @@ os.getcwd(), os.path.join(root_dir(), "pybamm", "input", "parameters"), ] - - -__getattr__, __dir__, __all__ = lazy.attach( - __name__, - submod_attrs={ - # - # Utility classes and methods - # - 'util': ['Timer', 'TimerTime', 'FuzzyDict', - 'root_dir', 'rmse', 'load', 'is_constant_and_can_evaluate', - 'get_parameters_filepath', 'have_jax', 'install_jax', - 'have_optional_dependency', 'is_jax_compatible', 'get_git_commit_info'], - 'logger': ['logger', 'set_logging_level', 'get_new_logger'], - 'settings': ['settings'], - 'citations': ['Citations', 'citations', 'print_citations'] - } -) - -# -# Classes for the Expression Tree -# -from .expression_tree.symbol import * -from .expression_tree.binary_operators import * -from .expression_tree.concatenations import * -from .expression_tree.array import Array, linspace, meshgrid -from .expression_tree.matrix import Matrix -from .expression_tree.unary_operators import * -from .expression_tree.averages import * -from .expression_tree.averages import _BaseAverage -from .expression_tree.broadcasts import * -from .expression_tree.functions import * -from .expression_tree.interpolant import Interpolant -from .expression_tree.input_parameter import InputParameter -from .expression_tree.parameter import Parameter, FunctionParameter -from .expression_tree.scalar import Scalar -from .expression_tree.variable import * -from .expression_tree.independent_variable import * -from .expression_tree.independent_variable import t -from .expression_tree.vector import Vector -from .expression_tree.state_vector import StateVectorBase, StateVector, StateVectorDot - -from .expression_tree.exceptions import * - -# Operations -from .expression_tree.operations.evaluate_python import ( - find_symbols, - id_to_python_variable, - to_python, - EvaluatorPython, -) - -from .expression_tree.operations.evaluate_python import EvaluatorJax -from .expression_tree.operations.evaluate_python import JaxCooMatrix - -from .expression_tree.operations.jacobian import Jacobian -from .expression_tree.operations.convert_to_casadi import CasadiConverter -from .expression_tree.operations.unpack_symbols import SymbolUnpacker - -# -# Model classes -# -from .models.base_model import BaseModel -from .models.event import Event -from .models.event import EventType - -# Battery models -from .models.full_battery_models.base_battery_model import ( - BaseBatteryModel, - BatteryModelOptions, -) - -from .models.full_battery_models import lead_acid -from .models.full_battery_models import lithium_ion -from .models.full_battery_models import equivalent_circuit - -# -# Submodel classes -# -from .models.submodels.base_submodel import BaseSubModel - -from .models.submodels import ( - active_material, - convection, - current_collector, - electrolyte_conductivity, - electrolyte_diffusion, - electrode, - external_circuit, - interface, - oxygen_diffusion, - particle, - porosity, - thermal, - transport_efficiency, - particle_mechanics, - equivalent_circuit_elements, -) - -from .models.submodels.interface import kinetics -from .models.submodels.interface import sei -from .models.submodels.interface import lithium_plating -from .models.submodels.interface import interface_utilisation -from .models.submodels.interface import open_circuit_potential - -# -# Geometry -# -from .geometry.geometry import Geometry -from .geometry.battery_geometry import battery_geometry - -from .expression_tree.independent_variable import KNOWN_COORD_SYS -from .geometry import standard_spatial_vars - -# -# Parameter classes and methods -# -from .parameters.parameter_values import ParameterValues -from .parameters import constants -from .parameters.geometric_parameters import geometric_parameters, GeometricParameters -from .parameters.electrical_parameters import ( - electrical_parameters, - ElectricalParameters, -) -from .parameters.thermal_parameters import thermal_parameters, ThermalParameters -from .parameters.lithium_ion_parameters import LithiumIonParameters -from .parameters.lead_acid_parameters import LeadAcidParameters -from .parameters.ecm_parameters import EcmParameters -from .parameters.size_distribution_parameters import * -from .parameters.parameter_sets import parameter_sets -from .parameters_cli import add_parameter, remove_parameter, edit_parameter - -# -# Mesh and Discretisation classes -# -from .discretisations.discretisation import Discretisation -from .discretisations.discretisation import has_bc_of_form -from .meshes.meshes import Mesh, SubMesh, MeshGenerator -from .meshes.zero_dimensional_submesh import SubMesh0D -from .meshes.one_dimensional_submeshes import ( - SubMesh1D, - Uniform1DSubMesh, - Exponential1DSubMesh, - Chebyshev1DSubMesh, - UserSupplied1DSubMesh, - SpectralVolume1DSubMesh, -) -from .meshes.scikit_fem_submeshes import ( - ScikitSubMesh2D, - ScikitUniform2DSubMesh, - ScikitExponential2DSubMesh, - ScikitChebyshev2DSubMesh, - UserSupplied2DSubMesh, -) - -# -# Serialisation -# -from .models.base_model import load_model - -# -# Spatial Methods -# -from .spatial_methods.spatial_method import SpatialMethod -from .spatial_methods.zero_dimensional_method import ZeroDimensionalSpatialMethod -from .spatial_methods.finite_volume import FiniteVolume -from .spatial_methods.spectral_volume import SpectralVolume -from .spatial_methods.scikit_finite_element import ScikitFiniteElement - -# -# Solver classes -# -from .solvers.solution import Solution, EmptySolution, make_cycle_solution -from .solvers.processed_variable import ProcessedVariable -from .solvers.processed_variable_computed import ProcessedVariableComputed -from .solvers.base_solver import BaseSolver -from .solvers.dummy_solver import DummySolver -from .solvers.algebraic_solver import AlgebraicSolver -from .solvers.casadi_solver import CasadiSolver -from .solvers.casadi_algebraic_solver import CasadiAlgebraicSolver -from .solvers.scikits_dae_solver import ScikitsDaeSolver -from .solvers.scikits_ode_solver import ScikitsOdeSolver, have_scikits_odes -from .solvers.scipy_solver import ScipySolver - -from .solvers.jax_solver import JaxSolver -from .solvers.jax_bdf_solver import jax_bdf_integrate - -IDAKLUSolver = lazy_import("pybamm.solvers.idaklu_solver","IDAKLUSolver") -have_idaklu = lazy_import("pybamm.solvers.idaklu_solver", "have_idaklu") - -# -# Experiments -# -from .experiment.experiment import Experiment -from . import experiment -from .experiment import step - - -# -# Plotting -# -from .plotting.quick_plot import QuickPlot, close_plots, QuickPlotAxes -from .plotting.plot import plot -from .plotting.plot2D import plot2D -from .plotting.plot_voltage_components import plot_voltage_components -from .plotting.plot_summary_variables import plot_summary_variables -from .plotting.dynamic_plot import dynamic_plot - -# -# Simulation -# -from .simulation import Simulation, load_sim, is_notebook - -# -# Batch Study -# -from .batch_study import BatchStudy - -# -# Callbacks -# -from . import callbacks - -# -# Remove any imported modules, so we don't expose them as part of pybamm -# import lazy_loader From 4d0d480a3062df24ddeeb4edf04bea2b48f01114 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sun, 21 Jan 2024 10:47:47 +0530 Subject: [PATCH 21/26] Defined `lazy_import` function is now redundant --- pybamm/__init__.py | 3 +-- pybamm/util.py | 53 ---------------------------------------------- 2 files changed, 1 insertion(+), 55 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index c7dcd2c481..cfb056c6e4 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -993,7 +993,6 @@ 'install_jax', 'is_constant_and_can_evaluate', 'is_jax_compatible', - 'lazy_import', 'load', 'rmse', 'root_dir', @@ -1234,7 +1233,7 @@ 'is_matrix_zero', 'is_notebook', 'is_scalar', 'is_scalar_minus_one', 'is_scalar_one', 'is_scalar_x', 'is_scalar_zero', 'isothermal', 'jacobian', 'jax_bdf_integrate', 'jax_bdf_solver', 'jax_solver', - 'k_b', 'kinetics', 'laplacian', 'latexify', 'lazy_import', + 'k_b', 'kinetics', 'laplacian', 'latexify', 'lead_acid', 'lead_acid_parameters', 'lead_dioxide_exchange_current_density_Sulzer2019', 'lead_dioxide_ocp_Bode1977', diff --git a/pybamm/util.py b/pybamm/util.py index 6dd60c05a0..8f76566171 100644 --- a/pybamm/util.py +++ b/pybamm/util.py @@ -368,56 +368,3 @@ def have_optional_dependency(module_name, attribute=None): except ModuleNotFoundError: # Raise an ModuleNotFoundError if the module or attribute is not available raise ModuleNotFoundError(err_msg) - - -def lazy_import(name, attribute=None): - """ - Lazily import a module or attribute. - - This function finds the module specification, creates a LazyLoader for the - loader, creates a module from the specification, updates the sys.modules - dictionary, and finally, executes the module. If an attribute is specified, - it checks if it's available. If attribute is set to '*', it imports all - attributes using wildcard. - - Parameters: - - name (str): The name of the module to import. - - attribute (str, optional): The name of the attribute to import. - If set to '*', all attributes will be imported. - - Returns: - - module or attribute: The lazily imported module or attribute. - """ - try: - # Try to find the module specification - spec = importlib.util.find_spec(name) - loader = importlib.util.LazyLoader(spec.loader) - spec.loader = loader - - # Create a module from the specification - module = importlib.util.module_from_spec(spec) - sys.modules[name] = module - - # Execute the module - loader.exec_module(module) - - if attribute: - if attribute == "*": - # If attribute is set to '*', import all attributes using wildcard - return module - elif hasattr(module, attribute): - # If a specific attribute is specified, check if it's available - imported_attribute = getattr(module, attribute) - return imported_attribute # Return the imported attribute - else: - # Raise an AttributeError if the attribute is not available - raise AttributeError( - f"Attribute '{attribute}' not found in module '{name}'" - ) - else: - # Return the entire module if no attribute is specified - return module - - except ModuleNotFoundError: - # If the module is not available, raise an exception - raise ModuleNotFoundError(f"Module '{name}' not found.") From 1c0d832cacb7cc38a820ca442551b00ab3b3c51b Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sun, 21 Jan 2024 11:52:52 +0530 Subject: [PATCH 22/26] `.logger`, `.settings`, `.citations` causing CI issues --- pybamm/__init__.py | 41 ++++++++++++----------------------------- 1 file changed, 12 insertions(+), 29 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index cfb056c6e4..d07faa707a 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -31,6 +31,11 @@ os.getcwd(), os.path.join(root_dir(), "pybamm", "input", "parameters"), ] + +from .logger import logger, set_logging_level, get_new_logger +from .settings import settings +from .citations import Citations, citations, print_citations + import lazy_loader @@ -39,7 +44,6 @@ submodules={ 'batch_study', 'callbacks', - 'citations', 'discretisations', 'doc_utils', 'experiment', @@ -47,13 +51,11 @@ 'geometry', 'input', 'install_odes', - 'logger', 'meshes', 'models', 'parameters', 'parameters_cli', 'plotting', - 'settings', 'simulation', 'solvers', 'spatial_methods', @@ -71,11 +73,6 @@ 'callback_loop_decorator', 'setup_callbacks', ], - 'citations': [ - 'Citations', - 'citations', - 'print_citations', - ], 'discretisations': [ 'Discretisation', 'discretisation', @@ -529,15 +526,6 @@ 'main', 'update_LD_LIBRARY_PATH', ], - 'logger': [ - 'FORMAT', - 'LOG_FORMATTER', - 'get_log_level_func', - 'get_new_logger', - 'logger', - 'new_levels', - 'set_logging_level', - ], 'meshes': [ 'Chebyshev1DSubMesh', 'Exponential1DSubMesh', @@ -918,10 +906,6 @@ 'quick_plot', 'split_long_string', ], - 'settings': [ - 'Settings', - 'settings', - ], 'simulation': [ 'Simulation', 'is_notebook', @@ -1020,7 +1004,7 @@ 'Bruggeman', 'CCCVFunctionControl', 'Callback', 'CallbackList', 'CasadiAlgebraicSolver', 'CasadiConverter', 'CasadiSolver', 'Ceiling', 'Chebyshev1DSubMesh', 'Chen2020', 'Chen2020_composite', - 'Citations', 'Composite', 'CompositeAlgebraic', + 'Composite', 'CompositeAlgebraic', 'CompositeDifferential', 'Concatenation', 'ConcatenationVariable', 'Constant', 'ConstantConcentration', 'ConstantSEI', 'Cos', 'Cosh', 'CrackPropagation', 'CrateTermination', 'CurrentCollector1D', @@ -1091,7 +1075,7 @@ 'ScikitExponential2DSubMesh', 'ScikitFiniteElement', 'ScikitSubMesh2D', 'ScikitUniform2DSubMesh', 'ScikitsDaeSolver', 'ScikitsOdeSolver', 'ScipySolver', 'SecondaryBroadcast', - 'SecondaryBroadcastToEdges', 'Serialise', 'Settings', 'ShapeError', + 'SecondaryBroadcastToEdges', 'Serialise', 'ShapeError', 'Sign', 'Simulation', 'Sin', 'SingleOpenCircuitPotential', 'Sinh', 'SizeAverage', 'Solution', 'SolverError', 'SolverWarning', 'SparseStack', 'SpatialMethod', 'SpatialOperator', @@ -1129,7 +1113,7 @@ 'bruggeman_transport_efficiency', 'butler_volmer', 'c1', 'c1_data', 'c_rate', 'c_solvers', 'calculate_theoretical_energy', 'callback_loop_decorator', 'callbacks', 'casadi_algebraic_solver', - 'casadi_solver', 'cell', 'citations', 'close_plots', + 'casadi_solver', 'cell', 'close_plots', 'composite_conductivity', 'composite_ohm', 'composite_surface_form_conductivity', 'concatenation', 'concatenations', 'conductivity_Gu1997', 'constant_active_material', @@ -1192,7 +1176,7 @@ 'get_git_commit_info', 'get_initial_ocps', 'get_initial_stoichiometries', 'get_initial_stoichiometry_half_cell', 'get_log_level_func', - 'get_min_max_ocps', 'get_min_max_stoichiometries', 'get_new_logger', + 'get_min_max_ocps', 'get_min_max_stoichiometries', 'get_parameter_values', 'get_parameters_filepath', 'get_rng_min_max_name', 'get_size_distribution_parameters', 'grad', 'grad_squared', 'graphite_LGM50_diffusivity_Chen2020', @@ -1252,7 +1236,7 @@ 'lico2_ocp_Ramadass2004', 'lico2_volume_change_Ai2020', 'linear', 'linspace', 'lithium_ion', 'lithium_ion_parameters', 'lithium_plating', 'load', 'load_model', 'load_sim', 'log', 'log10', - 'logger', 'lognormal', 'loqs', 'loss_active_material', 'lrudict', + 'lognormal', 'loqs', 'loss_active_material', 'lrudict', 'lumped', 'main', 'make_cycle_solution', 'marcus', 'matmul', 'matrix', 'maximum', 'meshes', 'meshgrid', 'minimum', 'models', 'mpm', 'msmr', 'msmr_butler_volmer', 'msmr_diffusion', 'msmr_ocp', @@ -1284,7 +1268,7 @@ 'positive_electrode', 'potential_pair', 'pouch_cell', 'pouch_cell_1D_current_collectors', 'pouch_cell_2D_current_collectors', 'power', 'preamble', - 'prettify_print_name', 'print_citations', 'print_name', 'printing', + 'prettify_print_name', 'print_name', 'printing', 'process', 'process_1D_data', 'process_2D_data', 'process_2D_data_csv', 'process_3D_data_csv', 'process_parameter_data', 'processed_variable', @@ -1299,8 +1283,7 @@ 'scikits_odes_spec', 'scipy_solver', 'script_path', 'sech', 'sei', 'sei_growth', 'separator', 'separator_LGM50_heat_capacity_ORegan2022', 'serialise', - 'set_logging_level', 'settings', 'setup_callbacks', 'sigmoid', - 'sign', + 'setup_callbacks', 'sigmoid', 'sign', 'silicon_LGM50_electrolyte_exchange_current_density_Chen2020', 'silicon_ocp_delithiation_Mark2016', 'silicon_ocp_lithiation_Mark2016', 'simplified_concatenation', From fb660ec54bb63d3a1b540fdd62c78a3c08c882cc Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sun, 21 Jan 2024 12:23:49 +0530 Subject: [PATCH 23/26] Resolve error causing imports --- pybamm/__init__.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index d07faa707a..0b383ea92b 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -36,6 +36,9 @@ from .settings import settings from .citations import Citations, citations, print_citations +from .models.base_model import BaseModel +from .geometry.battery_geometry import battery_geometry + import lazy_loader @@ -342,7 +345,6 @@ 'R_n_edge', 'R_p', 'R_p_edge', - 'battery_geometry', 'geometry', 'r_macro', 'r_macro_edge', @@ -559,7 +561,6 @@ 'BaseKinetics', 'BaseLeadingOrderSurfaceForm', 'BaseMechanics', - 'BaseModel', 'BaseOpenCircuitPotential', 'BaseParticle', 'BasePlating', @@ -991,7 +992,7 @@ 'BaseEffectiveResistance', 'BaseElectrode', 'BaseElectrolyteConductivity', 'BaseElectrolyteDiffusion', 'BaseIndefiniteIntegral', 'BaseInterface', 'BaseKinetics', - 'BaseLeadingOrderSurfaceForm', 'BaseMechanics', 'BaseModel', + 'BaseLeadingOrderSurfaceForm', 'BaseMechanics', 'BaseOpenCircuitPotential', 'BaseParameters', 'BaseParticle', 'BasePlating', 'BasePotentialPair', 'BaseSolver', 'BaseSubModel', 'BaseTermination', 'BaseThermal', 'BaseThroughCellModel', @@ -1108,7 +1109,7 @@ 'base_through_cell_convection', 'base_transport_efficiency', 'base_transverse_convection', 'base_utilisation', 'basic_dfn', 'basic_dfn_composite', 'basic_dfn_half_cell', 'basic_full', - 'basic_spm', 'batch_study', 'battery_geometry', 'binary_operators', + 'basic_spm', 'batch_study', 'binary_operators', 'boundary_gradient', 'boundary_value', 'bpx', 'broadcasts', 'bruggeman_transport_efficiency', 'butler_volmer', 'c1', 'c1_data', 'c_rate', 'c_solvers', 'calculate_theoretical_energy', From c7e3da2eda7803da31a1f7da10f601dab32732c9 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sun, 21 Jan 2024 15:26:11 +0530 Subject: [PATCH 24/26] Set `EAGER_IMPORT` blank for tests --- noxfile.py | 1 + 1 file changed, 1 insertion(+) diff --git a/noxfile.py b/noxfile.py index fb1216be62..821945fe5d 100644 --- a/noxfile.py +++ b/noxfile.py @@ -16,6 +16,7 @@ PYBAMM_ENV = { "SUNDIALS_INST": f"{homedir}/.local", "LD_LIBRARY_PATH": f"{homedir}/.local/lib", + "EAGER_IMPORT": "", } VENV_DIR = Path("./venv").resolve() From 074616e3ac53a7f3912f552f49a994c8088fe751 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sun, 21 Jan 2024 17:43:08 +0530 Subject: [PATCH 25/26] Manage to fix import atleeast --- pybamm/__init__.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 0b383ea92b..7ba5c58c03 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -32,12 +32,37 @@ os.path.join(root_dir(), "pybamm", "input", "parameters"), ] +from .util import Timer, TimerTime, FuzzyDict, have_jax from .logger import logger, set_logging_level, get_new_logger from .settings import settings from .citations import Citations, citations, print_citations from .models.base_model import BaseModel from .geometry.battery_geometry import battery_geometry +from .models.full_battery_models.base_battery_model import ( + BaseBatteryModel, + BatteryModelOptions, +) +from .expression_tree.symbol import Symbol +from .expression_tree import (SpatialOperator, + Concatenation, + is_scalar_zero, + is_scalar_one, + is_scalar_minus_one, + is_scalar_minus_one, + is_matrix_zero, + is_matrix_one, + is_matrix_minus_one, + Integral, + Function, + Array, + ) +from .expression_tree import * +from .expression_tree.broadcasts import Broadcast +from .expression_tree.binary_operators import * +from .expression_tree.parameter import Parameter +from .parameters.geometric_parameters import geometric_parameters, GeometricParameters +from .expression_tree.averages import _BaseAverage import lazy_loader From ec571baf6edd83dcaa38f3806eafe986bc116457 Mon Sep 17 00:00:00 2001 From: "arjxn.py" Date: Sun, 21 Jan 2024 19:21:00 +0530 Subject: [PATCH 26/26] Resolve Min, Max & other imports causing failures --- pybamm/__init__.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 7ba5c58c03..e2347d5bb7 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -63,6 +63,10 @@ from .expression_tree.parameter import Parameter from .parameters.geometric_parameters import geometric_parameters, GeometricParameters from .expression_tree.averages import _BaseAverage +from .expression_tree import Min, Max + +from .parameters import thermal_parameters +from .plotting import dynamic_plot import lazy_loader @@ -909,7 +913,6 @@ 'q_e', 'separator', 'size_distribution_parameters', - 'thermal_parameters', ], 'parameters_cli': [ 'add_parameter', @@ -1326,7 +1329,7 @@ 'substrings', 'subtract', 'surf', 'surface_form_ohm', 'surface_potential_form', 'swelling_only', 'symbol', 'sympy_overrides', 't', 'tafel', 'tanh', - 'theoretical_energy_integral', 'thermal', 'thermal_parameters', + 'theoretical_energy_integral', 'thermal', 'thevenin', 'through_cell', 'to_python', 'total_active_material', 'total_interfacial_current', 'total_main_kinetics', 'total_particle_concentration', 'total_sei', 'transport_efficiency',