diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 2fc6b76539..ac470783b2 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ ci: repos: - repo: https://github.com/astral-sh/ruff-pre-commit - rev: "v0.6.9" + rev: "v0.7.0" hooks: - id: ruff args: [--fix, --show-fixes] diff --git a/CHANGELOG.md b/CHANGELOG.md index 303f4cb48f..bf376c1a13 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ ## Features +- Adds support to `pybamm.Experiment` for the `output_variables` option in the `IDAKLUSolver`. ([#4534](https://github.com/pybamm-team/PyBaMM/pull/4534)) - Adds an option "voltage as a state" that can be "false" (default) or "true". If "true" adds an explicit algebraic equation for the voltage. ([#4507](https://github.com/pybamm-team/PyBaMM/pull/4507)) - Improved `QuickPlot` accuracy for simulations with Hermite interpolation. ([#4483](https://github.com/pybamm-team/PyBaMM/pull/4483)) - Added Hermite interpolation to the (`IDAKLUSolver`) that improves the accuracy and performance of post-processing variables. ([#4464](https://github.com/pybamm-team/PyBaMM/pull/4464)) @@ -20,7 +21,7 @@ - Removed the `start_step_offset` setting and disabled minimum `dt` warnings for drive cycles with the (`IDAKLUSolver`). ([#4416](https://github.com/pybamm-team/PyBaMM/pull/4416)) ## Bug Fixes - +- Fixed bug in post-processing solutions with infeasible experiments using the (`IDAKLUSolver`). ([#4541](https://github.com/pybamm-team/PyBaMM/pull/4541)) - Disabled IREE on MacOS due to compatibility issues and added the CasADI path to the environment to resolve issues on MacOS and Linux. Windows users may still experience issues with interpolation. ([#4528](https://github.com/pybamm-team/PyBaMM/pull/4528)) diff --git a/docs/source/api/index.rst b/docs/source/api/index.rst index 33be0235a7..4667752157 100644 --- a/docs/source/api/index.rst +++ b/docs/source/api/index.rst @@ -9,10 +9,10 @@ API documentation :Release: |version| :Date: |today| -This reference manual details functions, modules, and objects -included in PyBaMM, describing what they are and what they do. +This reference manual details the classes, functions, modules, and objects included in PyBaMM, describing what they are and what they do. For a high-level introduction to PyBaMM, see the :ref:`user guide ` and the :ref:`examples `. + .. toctree:: :maxdepth: 2 diff --git a/docs/source/api/util.rst b/docs/source/api/util.rst index 824ec6126d..9cf8d09470 100644 --- a/docs/source/api/util.rst +++ b/docs/source/api/util.rst @@ -19,3 +19,5 @@ Utility functions .. autofunction:: pybamm.has_jax .. autofunction:: pybamm.is_jax_compatible + +.. autofunction:: pybamm.set_logging_level diff --git a/docs/source/examples/notebooks/getting_started/tutorial-4-setting-parameter-values.ipynb b/docs/source/examples/notebooks/getting_started/tutorial-4-setting-parameter-values.ipynb index a35a81932f..02206d4210 100644 --- a/docs/source/examples/notebooks/getting_started/tutorial-4-setting-parameter-values.ipynb +++ b/docs/source/examples/notebooks/getting_started/tutorial-4-setting-parameter-values.ipynb @@ -25,18 +25,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n", - "\u001B[1m[\u001B[0m\u001B[34;49mnotice\u001B[0m\u001B[1;39;49m]\u001B[0m\u001B[39;49m A new release of pip is available: \u001B[0m\u001B[31;49m23.3.1\u001B[0m\u001B[39;49m -> \u001B[0m\u001B[32;49m24.0\u001B[0m\n", - "\u001B[1m[\u001B[0m\u001B[34;49mnotice\u001B[0m\u001B[1;39;49m]\u001B[0m\u001B[39;49m To update, run: \u001B[0m\u001B[32;49mpip install --upgrade pip\u001B[0m\n", "Note: you may need to restart the kernel to use updated packages.\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n" - ] } ], "source": [ @@ -74,7 +64,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The parameter values are stored in a dictionary" + "The parameter values are stored in a dictionary-like object of class [`pybamm.ParameterValues`](https://docs.pybamm.org/en/latest/source/api/parameters/parameter_values.html). " ] }, { @@ -98,8 +88,8 @@ " 'EC initial concentration in electrolyte [mol.m-3]': 4541.0,\n", " 'Electrode height [m]': 0.065,\n", " 'Electrode width [m]': 1.58,\n", - " 'Electrolyte conductivity [S.m-1]': ,\n", - " 'Electrolyte diffusivity [m2.s-1]': ,\n", + " 'Electrolyte conductivity [S.m-1]': ,\n", + " 'Electrolyte diffusivity [m2.s-1]': ,\n", " 'Electron charge [C]': 1.602176634e-19,\n", " 'Faraday constant [C.mol-1]': 96485.33212,\n", " 'Ideal gas constant [J.K-1.mol-1]': 8.314462618,\n", @@ -125,14 +115,14 @@ " 'Negative current collector thickness [m]': 1.2e-05,\n", " 'Negative electrode Bruggeman coefficient (electrode)': 0,\n", " 'Negative electrode Bruggeman coefficient (electrolyte)': 1.5,\n", - " 'Negative electrode OCP [V]': ,\n", + " 'Negative electrode OCP [V]': ,\n", " 'Negative electrode OCP entropic change [V.K-1]': 0.0,\n", " 'Negative electrode active material volume fraction': 0.75,\n", " 'Negative electrode charge transfer coefficient': 0.5,\n", " 'Negative electrode conductivity [S.m-1]': 215.0,\n", " 'Negative electrode density [kg.m-3]': 1657.0,\n", " 'Negative electrode double-layer capacity [F.m-2]': 0.2,\n", - " 'Negative electrode exchange-current density [A.m-2]': ,\n", + " 'Negative electrode exchange-current density [A.m-2]': ,\n", " 'Negative electrode porosity': 0.25,\n", " 'Negative electrode reaction-driven LAM factor [m3.mol-1]': 0.0,\n", " 'Negative electrode specific heat capacity [J.kg-1.K-1]': 700.0,\n", @@ -155,14 +145,14 @@ " 'Positive current collector thickness [m]': 1.6e-05,\n", " 'Positive electrode Bruggeman coefficient (electrode)': 0,\n", " 'Positive electrode Bruggeman coefficient (electrolyte)': 1.5,\n", - " 'Positive electrode OCP [V]': ,\n", + " 'Positive electrode OCP [V]': ,\n", " 'Positive electrode OCP entropic change [V.K-1]': 0.0,\n", " 'Positive electrode active material volume fraction': 0.665,\n", " 'Positive electrode charge transfer coefficient': 0.5,\n", " 'Positive electrode conductivity [S.m-1]': 0.18,\n", " 'Positive electrode density [kg.m-3]': 3262.0,\n", " 'Positive electrode double-layer capacity [F.m-2]': 0.2,\n", - " 'Positive electrode exchange-current density [A.m-2]': ,\n", + " 'Positive electrode exchange-current density [A.m-2]': ,\n", " 'Positive electrode porosity': 0.335,\n", " 'Positive electrode reaction-driven LAM factor [m3.mol-1]': 0.0,\n", " 'Positive electrode specific heat capacity [J.kg-1.K-1]': 700.0,\n", @@ -243,8 +233,8 @@ "output_type": "stream", "text": [ "EC initial concentration in electrolyte [mol.m-3]\t4541.0\n", - "Electrolyte conductivity [S.m-1]\t\n", - "Electrolyte diffusivity [m2.s-1]\t\n", + "Electrolyte conductivity [S.m-1]\t\n", + "Electrolyte diffusivity [m2.s-1]\t\n", "Initial concentration in electrolyte [mol.m-3]\t1000.0\n", "Negative electrode Bruggeman coefficient (electrolyte)\t1.5\n", "Positive electrode Bruggeman coefficient (electrolyte)\t1.5\n", @@ -274,12 +264,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2ac62159d85445f0b021b8800750726f", + "model_id": "5dd5facebda342afa83dca4f0838788c", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=3555.448018330181, step=35.55448018330181), …" + "interactive(children=(FloatSlider(value=0.0, description='t', max=3555.448018679505, step=35.55448018679505), …" ] }, "metadata": {}, @@ -288,7 +278,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -324,55 +314,58 @@ "name": "stdout", "output_type": "stream", "text": [ - "| Parameter | Type of parameter |\n", - "| ========================================================= | =========================================================================================================================================================================================================== |\n", - "| Maximum concentration in positive electrode [mol.m-3] | Parameter |\n", - "| Maximum concentration in negative electrode [mol.m-3] | Parameter |\n", - "| Nominal cell capacity [A.h] | Parameter |\n", - "| Electrode width [m] | Parameter |\n", - "| Positive electrode Bruggeman coefficient (electrode) | Parameter |\n", - "| Faraday constant [C.mol-1] | Parameter |\n", - "| Number of electrodes connected in parallel to make a cell | Parameter |\n", - "| Negative electrode Bruggeman coefficient (electrode) | Parameter |\n", - "| Initial concentration in electrolyte [mol.m-3] | Parameter |\n", - "| Electrode height [m] | Parameter |\n", - "| Lower voltage cut-off [V] | Parameter |\n", - "| Upper voltage cut-off [V] | Parameter |\n", - "| Negative electrode Bruggeman coefficient (electrolyte) | Parameter |\n", - "| Separator Bruggeman coefficient (electrolyte) | Parameter |\n", - "| Number of cells connected in series to make a battery | Parameter |\n", - "| Ideal gas constant [J.K-1.mol-1] | Parameter |\n", - "| Positive electrode thickness [m] | Parameter |\n", - "| Reference temperature [K] | Parameter |\n", - "| Initial temperature [K] | Parameter |\n", - "| Positive electrode Bruggeman coefficient (electrolyte) | Parameter |\n", - "| Negative electrode thickness [m] | Parameter |\n", - "| Separator thickness [m] | Parameter |\n", - "| Electrolyte conductivity [S.m-1] | FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Temperature [K]' |\n", - "| Positive electrode OCP [V] | FunctionParameter with inputs(s) 'Positive particle stoichiometry' |\n", - "| Negative particle radius [m] | FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' |\n", - "| Positive electrode OCP entropic change [V.K-1] | FunctionParameter with inputs(s) 'Positive particle stoichiometry', 'Maximum positive particle surface concentration [mol.m-3]' |\n", - "| Negative electrode porosity | FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' |\n", - "| Positive particle radius [m] | FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' |\n", - "| Positive electrode active material volume fraction | FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' |\n", - "| Ambient temperature [K] | FunctionParameter with inputs(s) 'Distance across electrode width [m]', 'Distance across electrode height [m]', 'Time [s]' |\n", - "| Initial concentration in positive electrode [mol.m-3] | FunctionParameter with inputs(s) 'Radial distance (r) [m]', 'Through-cell distance (x) [m]' |\n", - "| Cation transference number | FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Temperature [K]' |\n", - "| Negative electrode OCP [V] | FunctionParameter with inputs(s) 'Negative particle stoichiometry' |\n", - "| Negative particle diffusivity [m2.s-1] | FunctionParameter with inputs(s) 'Negative particle stoichiometry', 'Temperature [K]' |\n", - "| Thermodynamic factor | FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Temperature [K]' |\n", - "| Positive electrode exchange-current density [A.m-2] | FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Positive particle surface concentration [mol.m-3]', 'Maximum positive particle surface concentration [mol.m-3]', 'Temperature [K]' |\n", - "| Negative electrode active material volume fraction | FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' |\n", - "| Positive particle diffusivity [m2.s-1] | FunctionParameter with inputs(s) 'Positive particle stoichiometry', 'Temperature [K]' |\n", - "| Positive electrode porosity | FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' |\n", - "| Positive electrode conductivity [S.m-1] | FunctionParameter with inputs(s) 'Temperature [K]' |\n", - "| Initial concentration in negative electrode [mol.m-3] | FunctionParameter with inputs(s) 'Radial distance (r) [m]', 'Through-cell distance (x) [m]' |\n", - "| Negative electrode OCP entropic change [V.K-1] | FunctionParameter with inputs(s) 'Negative particle stoichiometry', 'Maximum negative particle surface concentration [mol.m-3]' |\n", - "| Current function [A] | FunctionParameter with inputs(s) 'Time [s]' |\n", - "| Electrolyte diffusivity [m2.s-1] | FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Temperature [K]' |\n", - "| Separator porosity | FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' |\n", - "| Negative electrode exchange-current density [A.m-2] | FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Negative particle surface concentration [mol.m-3]', 'Maximum negative particle surface concentration [mol.m-3]', 'Temperature [K]' |\n", - "| Negative electrode conductivity [S.m-1] | FunctionParameter with inputs(s) 'Temperature [K]' |\n" + "┌───────────────────────────────────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐\n", + "│ Parameter │ Type of parameter │\n", + "├───────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤\n", + "│ Positive electrode Bruggeman coefficient (electrode) │ Parameter │\n", + "│ Faraday constant [C.mol-1] │ Parameter │\n", + "│ Separator Bruggeman coefficient (electrolyte) │ Parameter │\n", + "│ Reference temperature [K] │ Parameter │\n", + "│ Upper voltage cut-off [V] │ Parameter │\n", + "│ Lower voltage cut-off [V] │ Parameter │\n", + "│ Negative electrode thickness [m] │ Parameter │\n", + "│ Initial concentration in electrolyte [mol.m-3] │ Parameter │\n", + "│ Nominal cell capacity [A.h] │ Parameter │\n", + "│ Number of electrodes connected in parallel to make a cell │ Parameter │\n", + "│ Negative electrode Bruggeman coefficient (electrolyte) │ Parameter │\n", + "│ Separator thickness [m] │ Parameter │\n", + "│ Initial temperature [K] │ Parameter │\n", + "│ Maximum concentration in negative electrode [mol.m-3] │ Parameter │\n", + "│ Positive electrode Bruggeman coefficient (electrolyte) │ Parameter │\n", + "│ Positive electrode thickness [m] │ Parameter │\n", + "│ Ideal gas constant [J.K-1.mol-1] │ Parameter │\n", + "│ Maximum concentration in positive electrode [mol.m-3] │ Parameter │\n", + "│ Electrode height [m] │ Parameter │\n", + "│ Electrode width [m] │ Parameter │\n", + "│ Negative electrode Bruggeman coefficient (electrode) │ Parameter │\n", + "│ Number of cells connected in series to make a battery │ Parameter │\n", + "│ Negative electrode porosity │ FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' │\n", + "│ Positive particle radius [m] │ FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' │\n", + "│ Positive electrode OCP [V] │ FunctionParameter with inputs(s) 'Positive particle stoichiometry' │\n", + "│ Negative electrode OCP entropic change [V.K-1] │ FunctionParameter with inputs(s) 'Negative particle stoichiometry' │\n", + "│ Initial concentration in positive electrode [mol.m-3] │ FunctionParameter with inputs(s) 'Radial distance (r) [m]', 'Through-cell distance (x) [m]' │\n", + "│ Positive electrode conductivity [S.m-1] │ FunctionParameter with inputs(s) 'Temperature [K]' │\n", + "│ Negative electrode active material volume fraction │ FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' │\n", + "│ Negative particle diffusivity [m2.s-1] │ FunctionParameter with inputs(s) 'Negative particle stoichiometry', 'Temperature [K]' │\n", + "│ Initial concentration in negative electrode [mol.m-3] │ FunctionParameter with inputs(s) 'Radial distance (r) [m]', 'Through-cell distance (x) [m]' │\n", + "│ Positive electrode porosity │ FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' │\n", + "│ Positive electrode OCP entropic change [V.K-1] │ FunctionParameter with inputs(s) 'Positive particle stoichiometry' │\n", + "│ Electrolyte conductivity [S.m-1] │ FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Temperature [K]' │\n", + "│ Thermodynamic factor │ FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Temperature [K]' │\n", + "│ Electrolyte diffusivity [m2.s-1] │ FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Temperature [K]' │\n", + "│ Negative particle radius [m] │ FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' │\n", + "│ Negative electrode OCP [V] │ FunctionParameter with inputs(s) 'Negative particle stoichiometry' │\n", + "│ Cation transference number │ FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Temperature [K]' │\n", + "│ Ambient temperature [K] │ FunctionParameter with inputs(s) 'Distance across electrode width [m]', 'Distance across electrode height [m]', 'Time [s]' │\n", + "│ Current function [A] │ FunctionParameter with inputs(s) 'Time [s]' │\n", + "│ Negative electrode exchange-current density [A.m-2] │ FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Negative particle surface concentration [mol.m-3]', 'Maximum negative particle surface concentration [mol.m-3]', 'Temperature [K]' │\n", + "│ Negative electrode conductivity [S.m-1] │ FunctionParameter with inputs(s) 'Temperature [K]' │\n", + "│ Positive electrode exchange-current density [A.m-2] │ FunctionParameter with inputs(s) 'Electrolyte concentration [mol.m-3]', 'Positive particle surface concentration [mol.m-3]', 'Maximum positive particle surface concentration [mol.m-3]', 'Temperature [K]' │\n", + "│ Separator porosity │ FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' │\n", + "│ Positive electrode active material volume fraction │ FunctionParameter with inputs(s) 'Through-cell distance (x) [m]' │\n", + "│ Positive particle diffusivity [m2.s-1] │ FunctionParameter with inputs(s) 'Positive particle stoichiometry', 'Temperature [K]' │\n", + "└───────────────────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘\n", + "\n" ] } ], @@ -424,12 +417,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "29a3805ee040456bbe863a52cc423492", + "model_id": "48c0f7150c154399b1d56dadd90a41ad", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=1703.071841649571, step=17.03071841649571), …" + "interactive(children=(FloatSlider(value=0.0, description='t', max=1703.0716533945217, step=17.030716533945217)…" ] }, "metadata": {}, @@ -438,7 +431,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -510,7 +503,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f362d8ff79bc4b868f59470d58fdd9c6", + "model_id": "b8992b55090149ea932deb091190b655", "version_major": 2, "version_minor": 0 }, @@ -524,7 +517,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 11, @@ -539,6 +532,49 @@ "sim.plot([\"Current [A]\", \"Voltage [V]\"])" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Input parameters\n", + "\n", + "If the value of a parameter is expected to change often (e.g. running a parameter sweep) is is more convenient to set a parameter as an \"input parameter\". This is a placeholder that can be filled in with a numerical value when the model is solved.\n", + "\n", + "To set a parameter as an input parameter, we can set its value to the string `[input]` in the parameter values dictionary. For example, we can set the `Current function [A]` to be an input parameter and then run a parameter sweep over different current values like so:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "parameter_values[\"Current function [A]\"] = \"[input]\"\n", + "sim = pybamm.Simulation(model, parameter_values=parameter_values)\n", + "solns = []\n", + "for c in [0.1, 0.2, 0.3]:\n", + " soln = sim.solve([0, 3600], inputs={\"Current function [A]\": c})\n", + " plt.plot(soln[\"Time [s]\"].entries, soln[\"Voltage [V]\"].entries, label=f\"{c} A\")\n", + " solns.append(soln[\"Terminal voltage [V]\"].entries)\n", + "plt.xlabel(\"Time [s]\")\n", + "plt.ylabel(\"Terminal voltage [V]\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -550,7 +586,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -596,7 +632,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -604,10 +640,11 @@ "output_type": "stream", "text": [ "[1] Joel A. E. Andersson, Joris Gillis, Greg Horn, James B. Rawlings, and Moritz Diehl. CasADi – A software framework for nonlinear optimization and optimal control. Mathematical Programming Computation, 11(1):1–36, 2019. doi:10.1007/s12532-018-0139-4.\n", - "[2] Chang-Hui Chen, Ferran Brosa Planella, Kieran O'Regan, Dominika Gastol, W. Dhammika Widanage, and Emma Kendrick. Development of Experimental Techniques for Parameterization of Multi-scale Lithium-ion Battery Models. Journal of The Electrochemical Society, 167(8):080534, 2020. doi:10.1149/1945-7111/ab9050.\n", - "[3] Marc Doyle, Thomas F. Fuller, and John Newman. Modeling of galvanostatic charge and discharge of the lithium/polymer/insertion cell. Journal of the Electrochemical society, 140(6):1526–1533, 1993. doi:10.1149/1.2221597.\n", - "[4] Charles R. Harris, K. Jarrod Millman, Stéfan J. van der Walt, Ralf Gommers, Pauli Virtanen, David Cournapeau, Eric Wieser, Julian Taylor, Sebastian Berg, Nathaniel J. Smith, and others. Array programming with NumPy. Nature, 585(7825):357–362, 2020. doi:10.1038/s41586-020-2649-2.\n", - "[5] Valentin Sulzer, Scott G. Marquis, Robert Timms, Martin Robinson, and S. Jon Chapman. Python Battery Mathematical Modelling (PyBaMM). Journal of Open Research Software, 9(1):14, 2021. doi:10.5334/jors.309.\n", + "[2] Von DAG Bruggeman. Berechnung verschiedener physikalischer konstanten von heterogenen substanzen. i. dielektrizitätskonstanten und leitfähigkeiten der mischkörper aus isotropen substanzen. Annalen der physik, 416(7):636–664, 1935.\n", + "[3] Chang-Hui Chen, Ferran Brosa Planella, Kieran O'Regan, Dominika Gastol, W. Dhammika Widanage, and Emma Kendrick. Development of Experimental Techniques for Parameterization of Multi-scale Lithium-ion Battery Models. Journal of The Electrochemical Society, 167(8):080534, 2020. doi:10.1149/1945-7111/ab9050.\n", + "[4] Marc Doyle, Thomas F. Fuller, and John Newman. Modeling of galvanostatic charge and discharge of the lithium/polymer/insertion cell. Journal of the Electrochemical society, 140(6):1526–1533, 1993. doi:10.1149/1.2221597.\n", + "[5] Charles R. Harris, K. Jarrod Millman, Stéfan J. van der Walt, Ralf Gommers, Pauli Virtanen, David Cournapeau, Eric Wieser, Julian Taylor, Sebastian Berg, Nathaniel J. Smith, and others. Array programming with NumPy. Nature, 585(7825):357–362, 2020. doi:10.1038/s41586-020-2649-2.\n", + "[6] Valentin Sulzer, Scott G. Marquis, Robert Timms, Martin Robinson, and S. Jon Chapman. Python Battery Mathematical Modelling (PyBaMM). Journal of Open Research Software, 9(1):14, 2021. doi:10.5334/jors.309.\n", "\n" ] } @@ -619,7 +656,7 @@ ], "metadata": { "kernelspec": { - "display_name": "pybamm", + "display_name": "env", "language": "python", "name": "python3" }, @@ -633,7 +670,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.10.12" }, "toc": { "base_numbering": 1, @@ -647,11 +684,6 @@ "toc_position": {}, "toc_section_display": true, "toc_window_display": true - }, - "vscode": { - "interpreter": { - "hash": "1a781583db2df3c2e87436f6d22cce842c2e50a5670da93a3bd820b97dc43011" - } } }, "nbformat": 4, diff --git a/docs/source/examples/notebooks/parameterization/parameter-values.ipynb b/docs/source/examples/notebooks/parameterization/parameter-values.ipynb index b13084b166..12a2c439bf 100644 --- a/docs/source/examples/notebooks/parameterization/parameter-values.ipynb +++ b/docs/source/examples/notebooks/parameterization/parameter-values.ipynb @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -44,12 +44,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In `pybamm`, the object that sets parameter values for a model is the `ParameterValues` class, which extends `dict`. This takes the values of the parameters as input, which can be either a dictionary," + "In `pybamm`, the object that sets parameter values for a model is the [`ParameterValues`](https://docs.pybamm.org/en/latest/source/api/parameters/parameter_values.html) class, which extends `dict`. This takes the values of the parameters as input, which can be either a dictionary," ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -81,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -105,12 +105,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can input functions into the parameter value (note we bypass the check that the parameter already exists)" + "We can alter the values of parameters by updating the dictionary, by using the `update` method or by using the `[]` operator." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -121,10 +121,42 @@ " 'Electron charge [C]': 1.602176634e-19,\n", " 'Faraday constant [C.mol-1]': 96485.33212,\n", " 'Ideal gas constant [J.K-1.mol-1]': 8.314462618,\n", - " 'a': 1,\n", - " 'b': 2,\n", - " 'c': 3,\n", - " 'cube function': }\n" + " 'a': 2,\n", + " 'b': 3,\n", + " 'c': 4}\n" + ] + } + ], + "source": [ + "parameter_values[\"a\"] = 2\n", + "parameter_values.update({\"b\": 3, \"c\": 4})\n", + "print(f\"parameter values are {parameter_values}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Parameter values can either be numerical values, python functions or PyBaMM expressions. We can input functions into the parameter value like so (note we bypass the check that the parameter already exists):\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "parameter values are {'Boltzmann constant [J.K-1]': 1.380649e-23,\n", + " 'Electron charge [C]': 1.602176634e-19,\n", + " 'Faraday constant [C.mol-1]': 96485.33212,\n", + " 'Ideal gas constant [J.K-1.mol-1]': 8.314462618,\n", + " 'a': 2,\n", + " 'b': 3,\n", + " 'c': 4,\n", + " 'cube function': }\n" ] } ], @@ -141,19 +173,35 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Setting parameters for an expression" + "We can also use a PyBaMM expression to set the parameter value, allowing us to set parameters based on other parameters: " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "parameter_values.update({\"a\": pybamm.Parameter(\"b\") + pybamm.Parameter(\"c\")})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We represent parameters in models using the classes `Parameter` and `FunctionParameter`. These cannot be evaluated directly," + "## Setting parameters for a PyBaMM model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We represent parameters in models using the classes [`Parameter`](https://docs.pybamm.org/en/latest/source/api/expression_tree/parameter.html) and [`FunctionParameter`](https://docs.pybamm.org/en/latest/source/api/expression_tree/parameter.html#pybamm.FunctionParameter). These cannot be evaluated directly," ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 7, "metadata": { "tags": [ "raises-exception" @@ -190,14 +238,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "7.0 = 7.0\n" + "19.0 = 19.0\n" ] } ], @@ -208,14 +256,14 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1.0 = 1.0\n" + "343.0 = 343.0\n" ] } ], @@ -233,7 +281,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -279,12 +327,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -348,16 +396,16 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{Variable(0x5f4a102fc03b7b39, u, children=[], domains={}): Multiplication(-0x32ae6bc94fa07109, *, children=['-a', 'y[0:1]'], domains={})}" + "{Variable(-0x7fabcf6f713434a8, u, children=[], domains={}): Multiplication(0x26349e0ba31c22ee, *, children=['-a', 'y[0:1]'], domains={})}" ] }, - "execution_count": 21, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -378,7 +426,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -420,7 +468,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -443,7 +491,7 @@ ], "metadata": { "kernelspec": { - "display_name": "dev", + "display_name": "env", "language": "python", "name": "python3" }, @@ -457,7 +505,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.10.12" }, "toc": { "base_numbering": 1, @@ -471,11 +519,6 @@ "toc_position": {}, "toc_section_display": true, "toc_window_display": true - }, - "vscode": { - "interpreter": { - "hash": "bca2b99bfac80e18288b793d52fa0653ab9b5fe5d22e7b211c44eb982a41c00c" - } } }, "nbformat": 4, diff --git a/docs/source/user_guide/fundamentals/public_api.rst b/docs/source/user_guide/fundamentals/public_api.rst new file mode 100644 index 0000000000..6d73ecaec1 --- /dev/null +++ b/docs/source/user_guide/fundamentals/public_api.rst @@ -0,0 +1,74 @@ +---------- +Public API +---------- + +.. module:: pybamm + :noindex: + +PyBaMM is a Python package for mathematical modelling and simulation of battery systems. The main classes and functions that are intended to be used by the user are described in this document. +For a more detailed description of the classes and methods, see the :doc:`API reference `. + +Available PyBaMM models +----------------------- + +PyBaMM includes a number of pre-implemented models, which can be used as they are or modified to suit your needs. The main models are: + +- :class:`lithium_ion.SPM`: Single Particle Model +- :class:`lithium_ion.SPMe`: Single Particle Model with Electrolyte +- :class:`lithium_ion.DFN`: Doyle-Fuller-Newman + +The behaviour of the models can be modified by passing in an :class:`BatteryModelOptions` object when creating the model. + +Simulations +----------- + +:class:`Simulation` is a class that automates the process of setting up a model and solving it, and acts as the highest-level API to PyBaMM. +Pass at least a :class:`BaseModel` object, and optionally the experiment, solver, parameter values, and geometry objects described below to the :class:`Simulation` object. +Any of these optional arguments not provided will be supplied by the defaults specified in the model. + +Parameters +---------- + +PyBaMM models are parameterised by a set of parameters, which are stored in a :class:`ParameterValues` object. This object acts like a Python dictionary with a few extra PyBaMM specific features and methods. +Parameters in a model are represented as either :class:`Parameter` objects or :class:`FunctionParameter` objects, and the values in the :class:`ParameterValues` object replace these objects in the model before it is solved. +The values in the :class:`ParameterValues` object can be scalars, Python functions or expressions of type :class:`Symbol`. + +Experiments +----------- + +An :class:`Experiment` object represents an experimental protocol that can be used to simulate the behaviour of a battery. The particular protocol can be provided as a Python string, or as a sequences of +:class:`step.BaseStep` objects. + +Solvers +------- + +The two main solvers in PyBaMM are the :class:`CasadiSolver` and the :class:`IDAKLUSolver`. Both are wrappers around the Sundials suite of solvers, but the :class:`CasadiSolver` uses the CasADi library +whereas the :class:`IDAKLUSolver` is PyBaMM specific. Both solvers have many options that can be set to control the solver behaviour, see the documentation for each solver for more details. + +When a model is solved, the solution is returned as a :class:`Solution` object. + +Plotting +-------- + +A solution object can be plotted using the :meth:`Solution.plot` or :meth:`Simulation.plot` methods, which returns a :class:`QuickPlot` object. +Note that the arguments to the plotting methods of both classes are the same as :class:`QuickPlot`. + +Other plotting functions are the :func:`plot_voltage_components` and :func:`plot_summary_variables` functions, which correspond to the similarly named methods of the :class:`Solution` and :class:`Simulation` classes. + +Writing PyBaMM models +--------------------- + +Each PyBaMM model, and the custom models written by users, are written as a set of expressions that describe the model. Each of the expressions is a subclass of the :class:`Symbol` class, which represents a mathematical expression. + +If you wish to create a custom model, you can use the :class:`BaseModel` class as a starting point. + + +Discretisation +-------------- + +Each PyBaMM model contains continuous operators that must be discretised before they can be solved. This is done using a :class:`Discretisation` object, which takes a :class:`Mesh` object and a dictionary of :class:`SpatialMethod` objects. + +Logging +------- + +PyBaMM uses the Python logging module to log messages at different levels of severity. Use the :func:`pybamm.set_logging_level` function to set the logging level for PyBaMM. diff --git a/docs/source/user_guide/index.md b/docs/source/user_guide/index.md index f61d2fc253..b497ed1a01 100644 --- a/docs/source/user_guide/index.md +++ b/docs/source/user_guide/index.md @@ -22,6 +22,7 @@ maxdepth: 2 --- fundamentals/index fundamentals/battery_models +fundamentals/public_api ``` ```{toctree} diff --git a/src/pybamm/logger.py b/src/pybamm/logger.py index 7dcacb5237..460e264416 100644 --- a/src/pybamm/logger.py +++ b/src/pybamm/logger.py @@ -24,6 +24,17 @@ def func(self, message, *args, **kws): def set_logging_level(level): + """ + Set the logging level for PyBaMM + + Parameters + ---------- + + level: str + The logging level to set. Should be one of 'DEBUG', 'INFO', 'WARNING', + 'ERROR', 'CRITICAL' + + """ logger.setLevel(level) diff --git a/src/pybamm/solvers/base_solver.py b/src/pybamm/solvers/base_solver.py index a7fc79fe3a..19aab65407 100644 --- a/src/pybamm/solvers/base_solver.py +++ b/src/pybamm/solvers/base_solver.py @@ -1452,6 +1452,7 @@ def get_termination_reason(solution, events): solution.t_event, solution.y_event, solution.termination, + variables_returned=solution.variables_returned, ) event_sol.solve_time = 0 event_sol.integration_time = 0 diff --git a/src/pybamm/solvers/c_solvers/idaklu/observe.cpp b/src/pybamm/solvers/c_solvers/idaklu/observe.cpp index 8f1d90e55d..6661bdecc9 100644 --- a/src/pybamm/solvers/c_solvers/idaklu/observe.cpp +++ b/src/pybamm/solvers/c_solvers/idaklu/observe.cpp @@ -100,6 +100,11 @@ class TimeSeriesInterpolator { ) { for (size_t i = 0; i < ts_data_np.size(); i++) { const auto& t_data = ts_data_np[i].unchecked<1>(); + // Continue if there is no data + if (t_data.size() == 0) { + continue; + } + const realtype t_data_final = t_data(t_data.size() - 1); realtype t_interp_next = t_interp(i_interp); // Continue if the next interpolation point is beyond the final data point @@ -227,6 +232,10 @@ class TimeSeriesProcessor { int i_entries = 0; for (size_t i = 0; i < ts.size(); i++) { const auto& t = ts[i].unchecked<1>(); + // Continue if there is no data + if (t.size() == 0) { + continue; + } const auto& y = ys[i].unchecked<2>(); const auto input = inputs[i].data(); const auto func = *funcs[i]; diff --git a/src/pybamm/solvers/idaklu_solver.py b/src/pybamm/solvers/idaklu_solver.py index 80eaffebf4..484c1ed9b4 100644 --- a/src/pybamm/solvers/idaklu_solver.py +++ b/src/pybamm/solvers/idaklu_solver.py @@ -863,6 +863,7 @@ def _post_process_solution(self, sol, model, integration_time, inputs_dict): termination, all_sensitivities=yS_out, all_yps=yp, + variables_returned=bool(save_outputs_only), ) newsol.integration_time = integration_time diff --git a/src/pybamm/solvers/processed_variable.py b/src/pybamm/solvers/processed_variable.py index 12cf140b38..3de6e4bd50 100644 --- a/src/pybamm/solvers/processed_variable.py +++ b/src/pybamm/solvers/processed_variable.py @@ -133,19 +133,22 @@ def _setup_cpp_inputs(self, t, full_range): ys = self.all_ys yps = self.all_yps inputs = self.all_inputs_casadi - # Find the indices of the time points to observe - if full_range: - idxs = range(len(ts)) - else: - idxs = _find_ts_indices(ts, t) - if isinstance(idxs, list): - # Extract the time points and inputs - ts = [ts[idx] for idx in idxs] - ys = [ys[idx] for idx in idxs] - if self.hermite_interpolation: - yps = [yps[idx] for idx in idxs] - inputs = [self.all_inputs_casadi[idx] for idx in idxs] + # Remove all empty ts + idxs = np.where([ti.size > 0 for ti in ts])[0] + + # Find the indices of the time points to observe + if not full_range: + ts_nonempty = [ts[idx] for idx in idxs] + idxs_subset = _find_ts_indices(ts_nonempty, t) + idxs = idxs[idxs_subset] + + # Extract the time points and inputs + ts = [ts[idx] for idx in idxs] + ys = [ys[idx] for idx in idxs] + if self.hermite_interpolation: + yps = [yps[idx] for idx in idxs] + inputs = [self.all_inputs_casadi[idx] for idx in idxs] is_f_contiguous = _is_f_contiguous(ys) @@ -977,8 +980,4 @@ def _find_ts_indices(ts, t): if (t[-1] > ts[-1][-1]) and (len(indices) == 0 or indices[-1] != len(ts) - 1): indices.append(len(ts) - 1) - if len(indices) == len(ts): - # All indices are included - return range(len(ts)) - return indices diff --git a/src/pybamm/solvers/processed_variable_computed.py b/src/pybamm/solvers/processed_variable_computed.py index 4f0cccc8c3..befe6314b6 100644 --- a/src/pybamm/solvers/processed_variable_computed.py +++ b/src/pybamm/solvers/processed_variable_computed.py @@ -1,6 +1,7 @@ # -# Processed Variable class +# Processed Variable Computed class # +from __future__ import annotations import casadi import numpy as np import pybamm @@ -450,3 +451,27 @@ def sensitivities(self): if len(self.all_inputs[0]) == 0: return {} return self._sensitivities + + def _update( + self, other: pybamm.ProcessedVariableComputed, new_sol: pybamm.Solution + ) -> pybamm.ProcessedVariableComputed: + """ + Returns a new ProcessedVariableComputed object that is the result of appending + the data from other to this object. Used exclusively in running experiments, to + append the data from one cycle to the next. + + Parameters + ---------- + other : :class:`pybamm.ProcessedVariableComputed` + The other ProcessedVariableComputed object to append to this one + new_sol : :class:`pybamm.Solution` + The new solution object to be used to create the processed variables + """ + + bv = self.base_variables + other.base_variables + bvc = self.base_variables_casadi + other.base_variables_casadi + bvd = self.base_variables_data + other.base_variables_data + + new_var = self.__class__(bv, bvc, bvd, new_sol) + + return new_var diff --git a/src/pybamm/solvers/solution.py b/src/pybamm/solvers/solution.py index 1aa540ab3c..256d596fd4 100644 --- a/src/pybamm/solvers/solution.py +++ b/src/pybamm/solvers/solution.py @@ -62,6 +62,10 @@ class Solution: True if sensitivities included as the solution of the explicit forwards equations. False if no sensitivities included/wanted. Dict if sensitivities are provided as a dict of {parameter: [sensitivities]} pairs. + variables_returned: bool + Bool to indicate if `all_ys` contains the full state vector, or is empty because + only requested variables have been returned. True if `output_variables` is used + with a solver, otherwise False. """ @@ -76,6 +80,7 @@ def __init__( termination="final time", all_sensitivities=False, all_yps=None, + variables_returned=False, check_solution=True, ): if not isinstance(all_ts, list): @@ -93,6 +98,8 @@ def __init__( all_yps = [all_yps] self._all_yps = all_yps + self.variables_returned = variables_returned + # Set up inputs if not isinstance(all_inputs, list): all_inputs_copy = dict(all_inputs) @@ -460,9 +467,15 @@ def first_state(self): else: all_yps = self.all_yps[0][:, :1] + if not self.variables_returned: + all_ys = self.all_ys[0][:, :1] + else: + # Get first state from initial conditions as all_ys is empty + all_ys = self.all_models[0].y0full.reshape(-1, 1) + new_sol = Solution( self.all_ts[0][:1], - self.all_ys[0][:, :1], + all_ys, self.all_models[:1], self.all_inputs[:1], None, @@ -500,9 +513,15 @@ def last_state(self): else: all_yps = self.all_yps[-1][:, -1:] + if not self.variables_returned: + all_ys = self.all_ys[-1][:, -1:] + else: + # Get last state from y_event as all_ys is empty + all_ys = self.y_event.reshape(len(self.y_event), 1) + new_sol = Solution( self.all_ts[-1][-1:], - self.all_ys[-1][:, -1:], + all_ys, self.all_models[-1:], self.all_inputs[-1:], self.t_event, @@ -583,7 +602,7 @@ def _update_variable(self, variable): for i, (model, ys, inputs, var_pybamm) in enumerate( zip(self.all_models, self.all_ys, self.all_inputs, vars_pybamm) ): - if ys.size == 0 and var_pybamm.has_symbol_of_classes( + if self.variables_returned and var_pybamm.has_symbol_of_classes( pybamm.expression_tree.state_vector.StateVector ): raise KeyError( @@ -678,7 +697,7 @@ def __getitem__(self, key): Returns ------- - :class:`pybamm.ProcessedVariable` + :class:`pybamm.ProcessedVariable` or :class:`pybamm.ProcessedVariableComputed` A variable that can be evaluated at any time or spatial point. The underlying data for this variable is available in its attribute ".data" """ @@ -946,6 +965,7 @@ def __add__(self, other): other.termination, all_sensitivities=all_sensitivities, all_yps=all_yps, + variables_returned=other.variables_returned, ) new_sol.closest_event_idx = other.closest_event_idx @@ -962,6 +982,19 @@ def __add__(self, other): # Set sub_solutions new_sol._sub_solutions = self.sub_solutions + other.sub_solutions + # update variables which were derived at the solver stage + if other._variables and all( + isinstance(v, pybamm.ProcessedVariableComputed) + for v in other._variables.values() + ): + if not self._variables: + new_sol._variables = other._variables.copy() + else: + new_sol._variables = { + v: self._variables[v]._update(other._variables[v], new_sol) + for v in self._variables.keys() + } + return new_sol def __radd__(self, other): @@ -979,6 +1012,7 @@ def copy(self): self.termination, self._all_sensitivities, self.all_yps, + self.variables_returned, ) new_sol._all_inputs_casadi = self.all_inputs_casadi new_sol._sub_solutions = self.sub_solutions @@ -988,6 +1022,13 @@ def copy(self): new_sol.integration_time = self.integration_time new_sol.set_up_time = self.set_up_time + # copy over variables which were derived at the solver stage + if self._variables and all( + isinstance(v, pybamm.ProcessedVariableComputed) + for v in self._variables.values() + ): + new_sol._variables = self._variables.copy() + return new_sol def plot_voltage_components( @@ -1090,6 +1131,7 @@ def make_cycle_solution( sum_sols.termination, sum_sols._all_sensitivities, sum_sols.all_yps, + sum_sols.variables_returned, ) cycle_solution._all_inputs_casadi = sum_sols.all_inputs_casadi cycle_solution._sub_solutions = sum_sols.sub_solutions diff --git a/tests/integration/test_solvers/test_idaklu.py b/tests/integration/test_solvers/test_idaklu.py index 88faa80dde..3ee96a9ccb 100644 --- a/tests/integration/test_solvers/test_idaklu.py +++ b/tests/integration/test_solvers/test_idaklu.py @@ -152,3 +152,55 @@ def test_interpolation(self): # test that y[1:3] = to true solution true_solution = b_value * sol.t np.testing.assert_array_almost_equal(sol.y[1:3], true_solution) + + def test_with_experiments(self): + summary_vars = [] + sols = [] + for out_vars in [True, False]: + model = pybamm.lithium_ion.SPM() + + if out_vars: + output_variables = [ + "Discharge capacity [A.h]", # 0D variables + "Time [s]", + "Current [A]", + "Voltage [V]", + "Pressure [Pa]", # 1D variable + "Positive particle effective diffusivity [m2.s-1]", # 2D variable + ] + else: + output_variables = None + + solver = pybamm.IDAKLUSolver(output_variables=output_variables) + + experiment = pybamm.Experiment( + [ + ( + "Charge at 1C until 4.2 V", + "Hold at 4.2 V until C/50", + "Rest for 1 hour", + ) + ] + ) + + sim = pybamm.Simulation( + model, + experiment=experiment, + solver=solver, + ) + + sol = sim.solve() + sols.append(sol) + summary_vars.append(sol.summary_variables) + + # check computed variables are propegated sucessfully + np.testing.assert_array_equal( + sols[0]["Pressure [Pa]"].data, sols[1]["Pressure [Pa]"].data + ) + np.testing.assert_array_almost_equal( + sols[0]["Voltage [V]"].data, sols[1]["Voltage [V]"].data + ) + + # check summary variables are the same if output variables are specified + for var in summary_vars[0].keys(): + assert summary_vars[0][var] == summary_vars[1][var] diff --git a/tests/unit/test_solvers/test_idaklu_solver.py b/tests/unit/test_solvers/test_idaklu_solver.py index 39918d73a4..e4d6559e71 100644 --- a/tests/unit/test_solvers/test_idaklu_solver.py +++ b/tests/unit/test_solvers/test_idaklu_solver.py @@ -939,6 +939,9 @@ def construct_model(): with pytest.raises(KeyError): sol[varname].data + # Check Solution is marked + assert sol.variables_returned is True + # Mock a 1D current collector and initialise (none in the model) sol["x_s [m]"].domain = ["current collector"] sol["x_s [m]"].entries diff --git a/tests/unit/test_solvers/test_processed_variable_computed.py b/tests/unit/test_solvers/test_processed_variable_computed.py index 0fa46b4414..f28c053fd5 100644 --- a/tests/unit/test_solvers/test_processed_variable_computed.py +++ b/tests/unit/test_solvers/test_processed_variable_computed.py @@ -1,7 +1,7 @@ # # Tests for the Processed Variable Computed class # -# This class forms a container for variables (and sensitivities) calculted +# This class forms a container for variables (and sensitivities) calculated # by the idaklu solver, and does not possesses any capability to calculate # values itself since it does not have access to the full state vector # @@ -76,11 +76,12 @@ def test_processed_variable_0D(self): t_sol = np.array([0]) y_sol = np.array([1])[:, np.newaxis] var_casadi = to_casadi(var, y_sol) + sol = pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}) processed_var = pybamm.ProcessedVariableComputed( [var], [var_casadi], [y_sol], - pybamm.Solution(t_sol, y_sol, pybamm.BaseModel(), {}), + sol, ) # Assert that the processed variable is the same as the solution np.testing.assert_array_equal(processed_var.entries, y_sol[0]) @@ -94,6 +95,22 @@ def test_processed_variable_0D(self): processed_var.cumtrapz_ic = 1 processed_var.entries + # check _update + t_sol2 = np.array([1]) + y_sol2 = np.array([2])[:, np.newaxis] + var_casadi = to_casadi(var, y_sol2) + sol_2 = pybamm.Solution(t_sol2, y_sol2, pybamm.BaseModel(), {}) + processed_var2 = pybamm.ProcessedVariableComputed( + [var], + [var_casadi], + [y_sol2], + sol_2, + ) + + comb_sol = sol + sol_2 + comb_var = processed_var._update(processed_var2, comb_sol) + np.testing.assert_array_equal(comb_var.entries, np.append(y_sol, y_sol2)) + # check empty sensitivity works def test_processed_variable_0D_no_sensitivity(self): # without space @@ -217,6 +234,60 @@ def test_processed_variable_1D_unknown_domain(self): c_casadi = to_casadi(c, y_sol) pybamm.ProcessedVariableComputed([c], [c_casadi], [y_sol], solution) + def test_processed_variable_1D_update(self): + # variable 1 + var = pybamm.Variable("var", domain=["negative electrode", "separator"]) + x = pybamm.SpatialVariable("x", domain=["negative electrode", "separator"]) + + disc = tests.get_discretisation_for_testing() + disc.set_variable_slices([var]) + x_sol1 = disc.process_symbol(x).entries[:, 0] + var_sol1 = disc.process_symbol(var) + t_sol1 = np.linspace(0, 1) + y_sol1 = np.ones_like(x_sol1)[:, np.newaxis] * np.linspace(0, 5) + + var_casadi1 = to_casadi(var_sol1, y_sol1) + sol1 = pybamm.Solution(t_sol1, y_sol1, pybamm.BaseModel(), {}) + processed_var1 = pybamm.ProcessedVariableComputed( + [var_sol1], + [var_casadi1], + [y_sol1], + sol1, + ) + + # variable 2 ------------------- + var2 = pybamm.Variable("var2", domain=["negative electrode", "separator"]) + z = pybamm.SpatialVariable("z", domain=["negative electrode", "separator"]) + + disc = tests.get_discretisation_for_testing() + disc.set_variable_slices([var2]) + z_sol2 = disc.process_symbol(z).entries[:, 0] + var_sol2 = disc.process_symbol(var2) + t_sol2 = np.linspace(2, 3) + y_sol2 = np.ones_like(z_sol2)[:, np.newaxis] * np.linspace(5, 1) + + var_casadi2 = to_casadi(var_sol2, y_sol2) + sol2 = pybamm.Solution(t_sol2, y_sol2, pybamm.BaseModel(), {}) + var_2 = pybamm.ProcessedVariableComputed( + [var_sol2], + [var_casadi2], + [y_sol2], + sol2, + ) + + comb_sol = sol1 + sol2 + comb_var = processed_var1._update(var_2, comb_sol) + + # Ordering from idaklu with output_variables set is different to + # the full solver + y_sol1 = y_sol1.reshape((y_sol1.shape[1], y_sol1.shape[0])).transpose() + y_sol2 = y_sol2.reshape((y_sol2.shape[1], y_sol2.shape[0])).transpose() + + np.testing.assert_array_equal( + comb_var.entries, np.concatenate((y_sol1, y_sol2), axis=1) + ) + np.testing.assert_array_equal(comb_var.entries, comb_var.data) + def test_processed_variable_2D_x_r(self): var = pybamm.Variable( "var", diff --git a/tests/unit/test_solvers/test_solution.py b/tests/unit/test_solvers/test_solution.py index 2fb25f79a2..1ee652d7a1 100644 --- a/tests/unit/test_solvers/test_solution.py +++ b/tests/unit/test_solvers/test_solution.py @@ -174,6 +174,50 @@ def test_add_solutions_different_models(self): ): sol_sum.y + @pytest.mark.skipif( + not pybamm.has_idaklu(), reason="idaklu solver is not installed" + ) + def test_add_solutions_with_computed_variables(self): + model = pybamm.BaseModel() + u = pybamm.Variable("u") + v = pybamm.Variable("v") + model.rhs = {u: 1 * v} + model.algebraic = {v: 1 - v} + model.initial_conditions = {u: 0, v: 1} + model.variables = {"2u": 2 * u} + + disc = pybamm.Discretisation() + disc.process_model(model) + + # Set up first solution + t1 = np.linspace(0, 1, 50) + solver = pybamm.IDAKLUSolver(output_variables=["2u"]) + + sol1 = solver.solve(model, t1) + + # second solution + t2 = np.linspace(2, 3, 50) + sol2 = solver.solve(model, t2) + + sol_sum = sol1 + sol2 + + # check varaibles concat appropriately + assert sol_sum["2u"].data[0] == sol1["2u"].data[0] + assert sol_sum["2u"].data[-1] == sol2["2u"].data[-1] + # Check functions still work + sol_sum["2u"].unroll() + # check solution still tagged as 'variables_returned' + assert sol_sum.variables_returned is True + + # add a solution with computed variable to an empty solution + empty_sol = pybamm.Solution( + sol1.all_ts, sol1["2u"].base_variables_data, model, {u: 0, v: 1} + ) + + sol4 = empty_sol + sol2 + assert sol4["2u"] == sol2["2u"] + assert sol4.variables_returned is True + def test_copy(self): # Set up first solution t1 = [np.linspace(0, 1), np.linspace(1, 2, 5)] @@ -194,6 +238,34 @@ def test_copy(self): assert sol_copy.solve_time == sol1.solve_time assert sol_copy.integration_time == sol1.integration_time + @pytest.mark.skipif( + not pybamm.has_idaklu(), reason="idaklu solver is not installed" + ) + def test_copy_with_computed_variables(self): + model = pybamm.BaseModel() + u = pybamm.Variable("u") + v = pybamm.Variable("v") + model.rhs = {u: 1 * v} + model.algebraic = {v: 1 - v} + model.initial_conditions = {u: 0, v: 1} + model.variables = {"2u": 2 * u} + + disc = pybamm.Discretisation() + disc.process_model(model) + + # Set up first solution + t1 = np.linspace(0, 1, 50) + solver = pybamm.IDAKLUSolver(output_variables=["2u"]) + + sol1 = solver.solve(model, t1) + + sol2 = sol1.copy() + + assert ( + sol1._variables[k] == sol2._variables[k] for k in sol1._variables.keys() + ) + assert sol2.variables_returned is True + def test_last_state(self): # Set up first solution t1 = [np.linspace(0, 1), np.linspace(1, 2, 5)] @@ -214,6 +286,39 @@ def test_last_state(self): assert sol_last_state.solve_time == 0 assert sol_last_state.integration_time == 0 + @pytest.mark.skipif( + not pybamm.has_idaklu(), reason="idaklu solver is not installed" + ) + def test_first_last_state_empty_y(self): + # check that first and last state work when y is empty + # due to only variables being returned (required for experiments) + model = pybamm.BaseModel() + u = pybamm.Variable("u") + v = pybamm.Variable("v") + model.rhs = {u: 1 * v} + model.algebraic = {v: 1 - v} + model.initial_conditions = {u: 0, v: 1} + model.variables = {"2u": 2 * u, "4u": 4 * u} + model._summary_variables = {"4u": model.variables["4u"]} + + disc = pybamm.Discretisation() + disc.process_model(model) + + # Set up first solution + t1 = np.linspace(0, 1, 50) + solver = pybamm.IDAKLUSolver(output_variables=["2u"]) + + sol1 = solver.solve(model, t1) + + np.testing.assert_array_equal( + sol1.first_state.all_ys[0], np.array([[0.0], [1.0]]) + ) + # check summay variables not in the solve can be evaluated at the final timestep + # via 'last_state + np.testing.assert_array_almost_equal( + sol1.last_state["4u"].entries, np.array([4.0]) + ) + def test_cycles(self): model = pybamm.lithium_ion.SPM() experiment = pybamm.Experiment(