diff --git a/.gitignore b/.gitignore index 8131583954..68735399c8 100644 --- a/.gitignore +++ b/.gitignore @@ -5,11 +5,13 @@ /local/ *.DS_Store *.mat +*.csv -# don't ignore important .txt files +# don't ignore important .txt and .csv files !requirements* !LICENSE.txt !CMakeLists.txt +!input/**/*.csv # running files *.pyc diff --git a/.travis.yml b/.travis.yml index 9c65a5e069..b3f5ffb29a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -62,6 +62,7 @@ matrix: env: - PYTHON=3.7.4 - PYBAMM_UNIT=true + - PYBAMM_KLU=true if: type != cron - python: "3.7" addons: @@ -177,6 +178,8 @@ before_install: | brew update; # Per the `pyenv homebrew recommendations `_. brew install graphviz openssl readline; + # Other brew packages + brew install gcc cmake openblas suitesparse; # See https://docs.travis-ci.com/user/osx-ci-environment/#A-note-on-upgrading-packages. brew outdated pyenv || brew upgrade pyenv # virtualenv doesn't work without pyenv knowledge. venv in Python 3.3 diff --git a/CHANGELOG.md b/CHANGELOG.md index 4ab9fea930..5fca98a703 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,9 +2,16 @@ ## Features +- Added NCA parameter set ([#824](https://github.com/pybamm-team/PyBaMM/pull/824)) +- Added functionality to `Solution` that automatically gets `t_eval` from the data when simulating drive cycles and performs checks to ensure the output has the required resolution to accurately capture the input current ([#819](https://github.com/pybamm-team/PyBaMM/pull/819)) +- Added options to export a solution to matlab or csv ([#811](https://github.com/pybamm-team/PyBaMM/pull/811)) +- Allow porosity to vary in space ([#809](https://github.com/pybamm-team/PyBaMM/pull/809)) +- Added functionality to solve DAE models with non-smooth current inputs ([#808](https://github.com/pybamm-team/PyBaMM/pull/808)) +- Added functionality to simulate experiments and testing protocols ([#807](https://github.com/pybamm-team/PyBaMM/pull/807)) - Added fuzzy string matching for parameters and variables ([#796](https://github.com/pybamm-team/PyBaMM/pull/796)) - Changed ParameterValues to raise an error when a parameter that wasn't previously defined is updated ([#796](https://github.com/pybamm-team/PyBaMM/pull/796)) - Added some basic models (BasicSPM and BasicDFN) in order to clearly demonstrate the PyBaMM model structure for battery models ([#795](https://github.com/pybamm-team/PyBaMM/pull/795)) +- Allow initial conditions in the particle to depend on x ([#786](https://github.com/pybamm-team/PyBaMM/pull/786)) - Added the harmonic mean to the Finite Volume method, which is now used when computing fluxes ([#783](https://github.com/pybamm-team/PyBaMM/pull/783)) - Refactored `Solution` to make it a dictionary that contains all of the solution variables. This automatically creates `ProcessedVariable` objects when required, so that the solution can be obtained much more easily. ([#781](https://github.com/pybamm-team/PyBaMM/pull/781)) - Added notebook to explain broadcasts ([#776](https://github.com/pybamm-team/PyBaMM/pull/776)) @@ -46,6 +53,9 @@ ## Bug fixes +- Time for solver should now be given in seconds ([#832](https://github.com/pybamm-team/PyBaMM/pull/832)) +- Fixed a bug where the first line of the data wasn't loaded when parameters are loaded from data ([#819](https://github.com/pybamm-team/PyBaMM/pull/819)) +- Made `graphviz` an optional dependency ([#810](https://github.com/pybamm-team/PyBaMM/pull/810)) - Fixed examples to run with basic pip installation ([#800](https://github.com/pybamm-team/PyBaMM/pull/800)) - Added events for CasADi solver when stepping ([#800](https://github.com/pybamm-team/PyBaMM/pull/800)) - Improved implementation of broadcasts ([#776](https://github.com/pybamm-team/PyBaMM/pull/776)) @@ -59,10 +69,13 @@ - Added missing temperature dependence in electrolyte and interface submodels ([#698](https://github.com/pybamm-team/PyBaMM/pull/698)) - Fixed differentiation of functions that have more than one argument ([#687](https://github.com/pybamm-team/PyBaMM/pull/687)) - Added warning if `ProcessedVariable` is called outside its interpolation range ([#681](https://github.com/pybamm-team/PyBaMM/pull/681)) +- Updated installation instructions for Mac OS ([#680](https://github.com/pybamm-team/PyBaMM/pull/680)) - Improved the way `ProcessedVariable` objects are created in higher dimensions ([#581](https://github.com/pybamm-team/PyBaMM/pull/581)) ## Breaking changes +- Model events are now represented as a list of `pybamm.Event` ([#759](https://github.com/pybamm-team/PyBaMM/issues/759) +- Removed `ParameterValues.update_model`, whose functionality is now replaced by `InputParameter` ([#801](https://github.com/pybamm-team/PyBaMM/pull/801)) - Removed `Outer` and `Kron` nodes as no longer used ([#777](https://github.com/pybamm-team/PyBaMM/pull/777)) - Moved `results` to separate repositories ([#761](https://github.com/pybamm-team/PyBaMM/pull/761)) - The parameters "Bruggeman coefficient" must now be specified separately as "Bruggeman coefficient (electrolyte)" and "Bruggeman coefficient (electrode)" diff --git a/INSTALL-LINUX.md b/INSTALL-LINUX-MAC.md similarity index 83% rename from INSTALL-LINUX.md rename to INSTALL-LINUX-MAC.md index f0ee081c89..f4bdae732c 100644 --- a/INSTALL-LINUX.md +++ b/INSTALL-LINUX-MAC.md @@ -1,6 +1,7 @@ ## Prerequisites -To use and/or contribute to PyBaMM, you must have Python 3.6 or above installed. +To use and/or contribute to PyBaMM, you must have Python 3.6 or 3.7 installed (note that 3.8 is not yet supported). + To install Python 3 on Debian-based distribution (Debian, Ubuntu, Linux mint), open a terminal and run ```bash sudo apt update @@ -10,6 +11,18 @@ On Fedora or CentOS, you can use DNF or Yum. For example ```bash sudo dnf install python3 ``` +On Mac OS distributions, you can use `homebrew`. +First [install `brew`](https://docs.python-guide.org/starting/install3/osx/): + +```bash +ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" +``` + +then follow instructions in link on adding brew to path, and run + +```bash +brew install python3 +``` ## Install PyBaMM @@ -39,30 +52,26 @@ PyBaMM can be installed via pip: pip install pybamm ``` +PyBaMM's dependencies (such as `numpy`, `scipy`, etc) will be installed automatically when you install PyBaMM using `pip`. -PyBaMM has the following python libraries as dependencies: `numpy`, `scipy`, `pandas`, -`matplotlib`. These will be installed automatically when you install PyBaMM using `pip`, -following the instructions below. First, make sure you have activated your virtual -environment as above, and that you have the latest version of pip installed: +For an introduction to virtual environments, see (https://realpython.com/python-virtual-environments-a-primer/). + +### Developer install -Then navigate to the path where you downloaded PyBaMM to (you will already be in the -correct location if you followed the instructions above), and install both PyBaMM and -its dependencies by typing: +If you wish to contribute to PyBaMM, you should get the latest version from the GitHub repository. +To do so, you must have Git and graphviz installed. For instance run ```bash -pip install pybamm +sudo apt install git graphviz ``` -For an introduction to virtual environments, see (https://realpython.com/python-virtual-environments-a-primer/). -### developer install +on Debian-based distributions, or -If you wish to contribute to PyBaMM, you should get the latest version from the GitHub repository. -To do so, you must have Git installed. -For instance run ```bash -sudo apt install git +brew install git graphviz ``` -on Debian-based distributions. + +on Mac OS. To install PyBaMM, the first step is to get the code by cloning this repository @@ -70,7 +79,7 @@ To install PyBaMM, the first step is to get the code by cloning this repository git clone https://github.com/pybamm-team/PyBaMM.git cd PyBaMM ``` -Then, install PyBaMM as a develop per with [developer](CONTRIBUTING.md), use +Then, to install PyBaMM as a [developer](CONTRIBUTING.md), type ```bash pip install -e .[dev,docs] @@ -100,10 +109,10 @@ This can be done using `git`, running git clone https://github.com/pybamm-team/PyBaMM.git cd PyBaMM ``` -Alternatively, you can dowload the source code archive from [the PyBaMM GitHub repo](https://github.com/pybamm-team/PyBaMM.git) and extract it the location of your choice. +Alternatively, you can download the source code archive from [the PyBaMM GitHub repo](https://github.com/pybamm-team/PyBaMM.git) and extract it to the location of your choice. Ideally you should have the python package `wget` installed. -This allows for the automatic download of some of the dependencies has part of the installation process. +This allows for the automatic download of some of the dependencies that are part of the installation process. You can install it using (within your virtual environment) ```bash pip install wget @@ -113,7 +122,6 @@ pip install wget Users can install [scikits.odes](https://github.com/bmcage/odes) in order to use the wrapped SUNDIALS ODE and DAE [solvers](https://pybamm.readthedocs.io/en/latest/source/solvers/scikits_solvers.html). -The Sundials DAE solver is required to solve the DFN battery model in PyBaMM. Before installing scikits.odes, you need to have installed: @@ -139,7 +147,7 @@ Alternatively, you can specify a directory containing the source code of the Sun ```bash python setup.py install_odes --sundials-src= ``` -By default, the sundials are installed in a `sundials` directory located at the root of the PyBaMM package. +By default, sundials is installed in a `sundials` directory located at the root of the PyBaMM package. You can provide another location by using the `--sundials-inst=` option. If you are installing `scikits.odes` within a virtual environment, the `activate` script will be automatically @@ -147,7 +155,7 @@ updated to add the sundials installation directory to your `LD_LIBRARY_PATH`. This is required in order to use `scikits.odes`. As a consequence, after installation you should restart your virtual environment. -If you wish to install the scikits.odes outside of a virtual environment, your `.bashrc` will be modified instead. +If you wish to install `scikits.odes` outside of a virtual environment, your `.bashrc` will be modified instead. After installation you should therefore run ```bash source ~/.bashrc @@ -166,7 +174,7 @@ sparse solver. PyBaMM currently offers a direct interface to the sparse KLU solver within Sundials. #### Prerequisites -The requirements are the same than for the installation of `scikits.odes` (see previous section). +The requirements are the same as for the installation of `scikits.odes` (see previous section). Additionally, the [pybind11 GitHub repository](https://github.com/pybind/pybind11.git) should be located in `PyBaMM/third-party/`. First create a directory `third-party` and clone the repository: ```bash @@ -198,14 +206,13 @@ python -c "import pybamm; print(pybamm.have_idaklu()) ``` ### Install everything -It is possible to install both `scikits.odes` and KLU solver using the command +It is possible to install both `scikits.odes` and the KLU solver using the command ```bash python setup.py install_all ``` Note that options `--sundials-src`, `--sundials-inst` and `suitesparse-src` are still usable here. -You can make sure the install was successful by runing Finally, you can check your install by running ```bash python -c "import pybamm; print(pybamm.have_scikits_odes()) diff --git a/INSTALL-WINDOWS.md b/INSTALL-WINDOWS.md index 76a87100f1..608dfd63f8 100644 --- a/INSTALL-WINDOWS.md +++ b/INSTALL-WINDOWS.md @@ -18,7 +18,7 @@ To download the PyBaMM source code, you first need to install git, which you can typing ```bash -$ sudo apt install git-core +sudo apt install git-core ``` For easier integration with WSL, we recommend that you install PyBaMM in your *Windows* @@ -31,21 +31,21 @@ $ cd /mnt/c/Users/USER_NAME/Documents where USER_NAME is your username. Exact path to Windows documents may vary. Now use git to clone the PyBaMM repository: ```bash -$ git clone https://github.com/pybamm-team/PyBaMM.git +git clone https://github.com/pybamm-team/PyBaMM.git ``` This will create a new directly called `PyBaMM`, you can move to this directory in bash using the `cd` command: ```bash -$ cd PyBaMM +cd PyBaMM ``` If you are unfamiliar with the linux command line, you might find it useful to work through this [tutorial](https://tutorials.ubuntu.com/tutorial/command-line-for-beginners) provided by Ubuntu. Now head over and follow the installation instructions for PyBaMM for linux -[here](INSTALL-LINUX.md). +[here](INSTALL-LINUX-MAC.md). ## Use Visual Studio Code to run PyBaMM diff --git a/README.md b/README.md index 789f4eae29..e224145f59 100644 --- a/README.md +++ b/README.md @@ -35,7 +35,11 @@ For further examples, see the list of repositories that use PyBaMM [here](https: ### Linux -For instructions on installing PyBaMM on Debian-based distributions, please see [here](INSTALL-LINUX.md) +For instructions on installing PyBaMM on Debian-based distributions, please see [here](INSTALL-LINUX-MAC.md) + +### Mac OS + +For instructions on installing PyBaMM on Mac OS distributions, please see [here](INSTALL-LINUX-MAC.md) ### Windows diff --git a/docs/index.rst b/docs/index.rst index d991331d6c..7b59f96c41 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -30,6 +30,7 @@ Contents source/meshes/index source/spatial_methods/index source/solvers/index + source/experiments/index source/processed_variable source/util source/simulation diff --git a/docs/source/experiments/experiment.rst b/docs/source/experiments/experiment.rst new file mode 100644 index 0000000000..52db069f28 --- /dev/null +++ b/docs/source/experiments/experiment.rst @@ -0,0 +1,5 @@ +Base Experiment Class +===================== + +.. autoclass:: pybamm.Experiment + :members: diff --git a/docs/source/experiments/index.rst b/docs/source/experiments/index.rst new file mode 100644 index 0000000000..05dafa4867 --- /dev/null +++ b/docs/source/experiments/index.rst @@ -0,0 +1,8 @@ +Experiments +=========== + +Classes to help set operating conditions for some standard battery modelling experiments + +.. toctree:: + + experiment \ No newline at end of file diff --git a/docs/source/models/submodels/particle/fickian/base_fickian_particle.rst b/docs/source/models/submodels/particle/fickian/base_fickian_particle.rst deleted file mode 100644 index 3330e0f4ac..0000000000 --- a/docs/source/models/submodels/particle/fickian/base_fickian_particle.rst +++ /dev/null @@ -1,7 +0,0 @@ -Base Model -========== - -.. autoclass:: pybamm.particle.fickian.BaseModel - :members: - - diff --git a/docs/source/models/submodels/particle/fickian/index.rst b/docs/source/models/submodels/particle/fickian/index.rst index 189ec2d13b..a6f8c36ceb 100644 --- a/docs/source/models/submodels/particle/fickian/index.rst +++ b/docs/source/models/submodels/particle/fickian/index.rst @@ -3,7 +3,6 @@ Fickian .. toctree:: - base_fickian_particle fickian_many_particles fickian_single_particle diff --git a/docs/source/solvers/solution.rst b/docs/source/solvers/solution.rst index 3f6dc3040d..25a9977ec9 100644 --- a/docs/source/solvers/solution.rst +++ b/docs/source/solvers/solution.rst @@ -1,5 +1,8 @@ Solution ======== +.. autoclass:: pybamm._BaseSolution + :members: + .. autoclass:: pybamm.Solution :members: diff --git a/examples/notebooks/change-input-current.ipynb b/examples/notebooks/change-input-current.ipynb index 80a3d55318..4b6516f1d3 100644 --- a/examples/notebooks/change-input-current.ipynb +++ b/examples/notebooks/change-input-current.ipynb @@ -37,7 +37,7 @@ "os.chdir(pybamm.__path__[0]+'/..')\n", "\n", "# create the model\n", - "model = pybamm.lithium_ion.SPM()\n", + "model = pybamm.lithium_ion.DFN()\n", "\n", "# set the default model geometry\n", "geometry = model.default_geometry\n", @@ -66,12 +66,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "770ba7f159054c5bad11038ac7be3f72", + "model_id": "528740d94922483b86f14724fcfa32b8", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=0.003612040133779264, step=0.005), Output())…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=0.0006659775771737802, step=0.005), Output()…" ] }, "metadata": {}, @@ -91,9 +91,9 @@ "disc.process_model(model)\n", "\n", "# Solve the model at the given time points\n", - "solver = model.default_solver\n", + "solver = pybamm.CasadiSolver()\n", "n = 300\n", - "t_eval = np.linspace(0, 0.02, n)\n", + "t_eval = np.linspace(0, 500, n)\n", "solution = solver.solve(model, t_eval, inputs={\"Current function [A]\": 16})\n", "\n", "# plot\n", @@ -118,12 +118,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4625a91d401b456d8e43aae201f4a380", + "model_id": "2811c58f82064ae6b2e558d33c5551fd", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=0.02, step=0.005), Output()), _dom_classes=(…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=0.022125255063884477, step=0.005), Output())…" ] }, "metadata": {}, @@ -158,7 +158,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "88c9c957b666420e9cf6f615ff43817c", + "model_id": "8bad57c00aec41bd85c17bec2981a8da", "version_major": 2, "version_minor": 0 }, @@ -171,7 +171,7 @@ } ], "source": [ - "model = pybamm.lithium_ion.SPM()\n", + "model = pybamm.lithium_ion.DFN()\n", "\n", "# create geometry\n", "geometry = model.default_geometry\n", @@ -190,10 +190,7 @@ "disc.process_model(model)\n", "\n", "# simulate US06 drive cycle (duration 600 seconds)\n", - "tau = param.process_symbol(\n", - " pybamm.standard_parameters_lithium_ion.tau_discharge\n", - ").evaluate(0)\n", - "t_eval = np.linspace(0, 600 / tau, 600)\n", + "t_eval = np.linspace(0, 600, 600)\n", "solution = solver.solve(model, t_eval)\n", "\n", "# plot\n", @@ -282,7 +279,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a8b90dfe860644c68af15c7c07e3adeb", + "model_id": "47c47acd733b46428148e9dc7cdf373e", "version_major": 2, "version_minor": 0 }, @@ -304,9 +301,8 @@ "\n", "# Example: simulate for 30 seconds\n", "simulation_time = 30 # end time in seconds\n", - "tau = param.process_symbol(pybamm.standard_parameters_lithium_ion.tau_discharge).evaluate(0)\n", "npts = int(50 * simulation_time * omega) # need enough timesteps to resolve output\n", - "t_eval = np.linspace(0, simulation_time / tau, npts)\n", + "t_eval = np.linspace(0, simulation_time, npts)\n", "solution = model.default_solver.solve(model, t_eval)\n", "label = [\"Frequency: {} Hz\".format(omega)]\n", "\n", diff --git a/examples/notebooks/change-settings.ipynb b/examples/notebooks/change-settings.ipynb index 075a0e3188..d90ff14b18 100644 --- a/examples/notebooks/change-settings.ipynb +++ b/examples/notebooks/change-settings.ipynb @@ -28,18 +28,7 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/vsulzer/Documents/Energy_storage/PyBaMM/PyBaMM-env/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py:146: RuntimeWarning: invalid value encountered in greater_equal\n", - " up = (g <= 0) & (g_new >= 0)\n", - "/Users/vsulzer/Documents/Energy_storage/PyBaMM/PyBaMM-env/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py:147: RuntimeWarning: invalid value encountered in less_equal\n", - " down = (g >= 0) & (g_new <= 0)\n" - ] - } - ], + "outputs": [], "source": [ "import pybamm\n", "import numpy as np\n", @@ -70,7 +59,7 @@ "# Solve the model at the given time points\n", "solver = model.default_solver\n", "n = 100\n", - "t_eval = np.linspace(0, 0.2, n)\n", + "t_eval = np.linspace(0, 3600, n)\n", "solution = solver.solve(model, t_eval)" ] }, @@ -88,7 +77,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -127,7 +116,7 @@ { "data": { "text/plain": [ - ">" + ">" ] }, "execution_count": 3, @@ -175,8 +164,8 @@ "Typical current [A] 0.680616\n", "Negative electrode conductivity [S.m-1] 100.0\n", "Maximum concentration in negative electrode [mol.m-3] 24983.2619938437\n", - "Negative electrode diffusivity [m2.s-1] \n", - "Negative electrode OCP [V] \n", + "Negative electrode diffusivity [m2.s-1] \n", + "Negative electrode OCP [V] \n", "Negative electrode porosity 0.3\n", "Negative electrode active material volume fraction 0.7\n", "Negative particle radius [m] 1e-05\n", @@ -186,22 +175,21 @@ "Negative electrode Bruggeman coefficient (electrode) 1.5\n", "Negative electrode cation signed stoichiometry -1.0\n", "Negative electrode electrons in reaction 1.0\n", - "Negative electrode reference exchange-current density [A.m-2(m3.mol)1.5] 2e-05\n", "Reference OCP vs SHE in the negative electrode [V] nan\n", "Negative electrode charge transfer coefficient 0.5\n", "Negative electrode double-layer capacity [F.m-2] 0.2\n", "Negative electrode density [kg.m-3] 1657.0\n", "Negative electrode specific heat capacity [J.kg-1.K-1] 700.0\n", "Negative electrode thermal conductivity [W.m-1.K-1] 1.7\n", - "Negative electrode OCP entropic change [V.K-1] \n", + "Negative electrode OCP entropic change [V.K-1] \n", "Reference temperature [K] 298.15\n", - "Negative electrode reaction rate \n", + "Negative electrode reaction rate \n", "Negative reaction rate activation energy [J.mol-1] 37480.0\n", "Negative solid diffusion activation energy [J.mol-1] 42770.0\n", "Positive electrode conductivity [S.m-1] 10.0\n", "Maximum concentration in positive electrode [mol.m-3] 51217.9257309275\n", - "Positive electrode diffusivity [m2.s-1] \n", - "Positive electrode OCP [V] \n", + "Positive electrode diffusivity [m2.s-1] \n", + "Positive electrode OCP [V] \n", "Positive electrode porosity 0.3\n", "Positive electrode active material volume fraction 0.7\n", "Positive particle radius [m] 1e-05\n", @@ -211,15 +199,14 @@ "Positive electrode Bruggeman coefficient (electrode) 1.5\n", "Positive electrode cation signed stoichiometry -1.0\n", "Positive electrode electrons in reaction 1.0\n", - "Positive electrode reference exchange-current density [A.m-2(m3.mol)1.5] 6e-07\n", "Reference OCP vs SHE in the positive electrode [V] nan\n", "Positive electrode charge transfer coefficient 0.5\n", "Positive electrode double-layer capacity [F.m-2] 0.2\n", "Positive electrode density [kg.m-3] 3262.0\n", "Positive electrode specific heat capacity [J.kg-1.K-1] 700.0\n", "Positive electrode thermal conductivity [W.m-1.K-1] 2.1\n", - "Positive electrode OCP entropic change [V.K-1] \n", - "Positive electrode reaction rate \n", + "Positive electrode OCP entropic change [V.K-1] \n", + "Positive electrode reaction rate \n", "Positive reaction rate activation energy [J.mol-1] 39570.0\n", "Positive solid diffusion activation energy [J.mol-1] 18550.0\n", "Separator porosity 1.0\n", @@ -230,8 +217,8 @@ "Separator thermal conductivity [W.m-1.K-1] 0.16\n", "Typical electrolyte concentration [mol.m-3] 1000.0\n", "Cation transference number 0.4\n", - "Electrolyte diffusivity [m2.s-1] \n", - "Electrolyte conductivity [S.m-1] \n", + "Electrolyte diffusivity [m2.s-1] \n", + "Electrolyte conductivity [S.m-1] \n", "Electrolyte diffusion activation energy [J.mol-1] 37040.0\n", "Electrolyte conductivity activation energy [J.mol-1] 34700.0\n", "Heat transfer coefficient [W.m-2.K-1] 10.0\n", @@ -305,7 +292,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -420,7 +407,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -490,7 +477,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/examples/notebooks/compare-comsol-discharge-curve.ipynb b/examples/notebooks/compare-comsol-discharge-curve.ipynb index 3395742a43..848599f82d 100644 --- a/examples/notebooks/compare-comsol-discharge-curve.ipynb +++ b/examples/notebooks/compare-comsol-discharge-curve.ipynb @@ -140,15 +140,9 @@ " # update current density\n", " current = 24 * C_rate\n", "\n", - " # discharge timescale\n", - " tau = param.process_symbol(\n", - " pybamm.standard_parameters_lithium_ion.tau_discharge\n", - " ).evaluate(0, 0)\n", - "\n", " # solve model at comsol times\n", " solver = pybamm.CasadiSolver(mode=\"fast\")\n", - " t = comsol_time / tau\n", - " solution = solver.solve(model, t, inputs={\"Current function [A]\": current})\n", + " solution = solver.solve(model, comsol_time, inputs={\"Current function [A]\": current})\n", "\n", " # discharge capacity\n", " discharge_capacity = solution[\"Discharge capacity [A.h]\"]\n", diff --git a/examples/notebooks/models/DFN.ipynb b/examples/notebooks/models/DFN.ipynb index e59424b1d5..e32c93e5ee 100644 --- a/examples/notebooks/models/DFN.ipynb +++ b/examples/notebooks/models/DFN.ipynb @@ -155,7 +155,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -187,7 +187,7 @@ "source": [ "# solve model\n", "solver = model.default_solver\n", - "t_eval = np.linspace(0, 1, 300)\n", + "t_eval = np.linspace(0, 3600, 300) # time in seconds\n", "solution = solver.solve(model, t_eval)\n" ] }, @@ -206,12 +206,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7f5052f5e0654d749080b4360008678b", + "model_id": "564a7d77b9894de29f0e926ee1e0e2d6", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=0.15719063545150502, step=0.05), Output()), …" + "interactive(children=(FloatSlider(value=0.0, description='t', max=0.15930183645996823, step=0.05), Output()), …" ] }, "metadata": {}, @@ -284,7 +284,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/notebooks/models/SPM.ipynb b/examples/notebooks/models/SPM.ipynb index 38adbca976..ed78cad085 100644 --- a/examples/notebooks/models/SPM.ipynb +++ b/examples/notebooks/models/SPM.ipynb @@ -309,7 +309,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 11, @@ -359,23 +359,13 @@ "Solving using ScipySolver solver...\n", "Finished.\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/vsulzer/Documents/Energy_storage/PyBaMM/PyBaMM-env/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py:146: RuntimeWarning: invalid value encountered in greater_equal\n", - " up = (g <= 0) & (g_new >= 0)\n", - "/Users/vsulzer/Documents/Energy_storage/PyBaMM/PyBaMM-env/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py:147: RuntimeWarning: invalid value encountered in less_equal\n", - " down = (g >= 0) & (g_new <= 0)\n" - ] } ], "source": [ - "# Solve the model at the given time points\n", + "# Solve the model at the given time points (in seconds)\n", "solver = model.default_solver\n", "n = 250\n", - "t_eval = np.linspace(0, 1, n)\n", + "t_eval = np.linspace(0, 3600, n)\n", "print('Solving using',type(solver).__name__,'solver...')\n", "solution = solver.solve(model, t_eval)\n", "print('Finished.')" @@ -410,14 +400,6 @@ "\t- x_s [m]\n", "\t- x_p\n", "\t- x_p [m]\n", - "\t- Negative particle concentration\n", - "\t- Positive particle concentration\n", - "\t- Negative particle surface concentration\n", - "\t- Positive particle surface concentration\n", - "\t- Negative particle concentration [mol.m-3]\n", - "\t- Positive particle concentration [mol.m-3]\n", - "\t- Negative particle surface concentration [mol.m-3]\n", - "\t- Positive particle surface concentration [mol.m-3]\n", "\t- r_n\n", "\t- r_n [m]\n", "\t- r_p\n", @@ -469,16 +451,24 @@ "\t- Volume-averaged velocity\n", "\t- Volume-averaged velocity [m.s-1]\n", "\t- Electrolyte pressure\n", + "\t- Negative particle concentration\n", + "\t- Negative particle concentration [mol.m-3]\n", "\t- X-averaged negative particle concentration\n", "\t- X-averaged negative particle concentration [mol.m-3]\n", + "\t- Negative particle surface concentration\n", + "\t- Negative particle surface concentration [mol.m-3]\n", "\t- X-averaged negative particle surface concentration\n", "\t- X-averaged negative particle surface concentration [mol.m-3]\n", "\t- Negative electrode active volume fraction\n", "\t- Negative electrode volume-averaged concentration\n", "\t- Negative electrode volume-averaged concentration [mol.m-3]\n", "\t- Negative electrode average extent of lithiation\n", + "\t- Positive particle concentration\n", + "\t- Positive particle concentration [mol.m-3]\n", "\t- X-averaged positive particle concentration\n", "\t- X-averaged positive particle concentration [mol.m-3]\n", + "\t- Positive particle surface concentration\n", + "\t- Positive particle surface concentration [mol.m-3]\n", "\t- X-averaged positive particle surface concentration\n", "\t- X-averaged positive particle surface concentration [mol.m-3]\n", "\t- Positive electrode active volume fraction\n", @@ -599,13 +589,7 @@ "\t- Positive electrode interfacial current density [A.m-2]\n", "\t- X-averaged positive electrode interfacial current density [A.m-2]\n", "\t- Positive electrode interfacial current density per volume [A.m-3]\n", - "\t- X-averaged positive electrode interfacial current density per volume [A.m-3]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "\t- X-averaged positive electrode interfacial current density per volume [A.m-3]\n", "\t- X-averaged positive electrode total interfacial current density\n", "\t- X-averaged positive electrode total interfacial current density [A.m-2]\n", "\t- X-averaged positive electrode total interfacial current density per volume [A.m-3]\n", @@ -753,7 +737,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -799,7 +783,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "589cbb6815244b4487846913c0baf528", + "model_id": "af941ec6637443ad80198a75b4df53ef", "version_major": 2, "version_minor": 0 }, @@ -847,12 +831,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e19993690e8d4a5b88a9876f38a82491", + "model_id": "3efb4d7173ef48e29e089fad6cb6f8a7", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=1.0840475344777656, step=0.05), Output()), _…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=0.9999999999999999, step=0.05), Output()), _…" ] }, "metadata": {}, diff --git a/examples/notebooks/models/SPMe.ipynb b/examples/notebooks/models/SPMe.ipynb index e3a23b62d1..edbc5eaeb6 100644 --- a/examples/notebooks/models/SPMe.ipynb +++ b/examples/notebooks/models/SPMe.ipynb @@ -153,7 +153,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -185,7 +185,7 @@ "source": [ "# solve model\n", "solver = model.default_solver\n", - "t_eval = np.linspace(0, 1, 250)\n", + "t_eval = np.linspace(0, 3600, 250) # time in seconds\n", "solution = solver.solve(model, t_eval)\n" ] }, @@ -204,12 +204,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5181f9cd45ca4c7fb8122c20a058e634", + "model_id": "4b296e4b16c9438083c80708c52f8f1b", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=0.15662650602409636, step=0.05), Output()), …" + "interactive(children=(FloatSlider(value=0.0, description='t', max=0.15930183645996823, step=0.05), Output()), …" ] }, "metadata": {}, diff --git a/examples/notebooks/models/compare-lithium-ion.ipynb b/examples/notebooks/models/compare-lithium-ion.ipynb index 138f7eac80..6991752250 100644 --- a/examples/notebooks/models/compare-lithium-ion.ipynb +++ b/examples/notebooks/models/compare-lithium-ion.ipynb @@ -104,7 +104,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -249,16 +249,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Solved the Doyle-Fuller-Newman model in 2.609 seconds\n", - "Solved the Single Particle Model in 0.462 seconds\n", - "Solved the Single Particle Model with electrolyte in 0.491 seconds\n" + "Solved the Doyle-Fuller-Newman model in 2.037 seconds\n", + "Solved the Single Particle Model in 0.325 seconds\n", + "Solved the Single Particle Model with electrolyte in 0.398 seconds\n" ] } ], "source": [ "timer = pybamm.Timer()\n", "solutions = {}\n", - "t_eval = np.linspace(0, 0.15, 300)\n", + "t_eval = np.linspace(0, 3600, 300) # time in seconds\n", "solver = pybamm.CasadiSolver()\n", "for model_name, model in models.items():\n", " start = timer.time()\n", @@ -289,7 +289,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -345,12 +345,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "36cafdf1324c44b19fa3bf54a8e579cb", + "model_id": "ef5d5ce48a40490bb47a73be0c7b66b1", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=0.673927318840113, step=0.05), Output()), _d…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=0.6755852842809364, step=0.05), Output()), _…" ] }, "metadata": {}, @@ -385,12 +385,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fc6e5fae66414fdda8e177864e49cb02", + "model_id": "7b919c702a3940a0bddfccd55fca15a0", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=0.11652014391160832, step=0.05), Output()), …" + "interactive(children=(FloatSlider(value=0.0, description='t', max=0.11839464882943145, step=0.05), Output()), …" ] }, "metadata": {}, @@ -399,6 +399,8 @@ ], "source": [ "# update parameter values and solve again\n", + "# simulate for shorter time\n", + "t_eval = np.linspace(0,720,300)\n", "for model_name, model in models.items():\n", " solutions[model_name] = model.default_solver.solve(model, t_eval, inputs={\"Current function [A]\": 5})\n", "\n", diff --git a/examples/notebooks/models/lead-acid.ipynb b/examples/notebooks/models/lead-acid.ipynb index e021d96854..1922a8af59 100644 --- a/examples/notebooks/models/lead-acid.ipynb +++ b/examples/notebooks/models/lead-acid.ipynb @@ -265,16 +265,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Solved the LOQS model in 0.127 seconds\n", - "Solved the Composite model in 1.075 seconds\n", - "Solved the Full model in 1.143 seconds\n" + "Solved the LOQS model in 0.146 seconds\n", + "Solved the Composite model in 1.127 seconds\n", + "Solved the Full model in 1.102 seconds\n" ] } ], "source": [ "timer = pybamm.Timer()\n", "solutions = {}\n", - "t_eval = np.linspace(0, 0.5, 100)\n", + "t_eval = np.linspace(0, 3600 * 17, 100) # time in seconds\n", "solver = pybamm.CasadiSolver()\n", "for model in models:\n", " start = timer.time()\n", @@ -305,7 +305,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -343,12 +343,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a08ab3900db7448f81089148ae3ee749", + "model_id": "d3bad7c275604722af2babfb0a6cb2ee", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=16.38242960161448, step=0.05), Output()), _d…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=17.000000000000004, step=0.05), Output()), _…" ] }, "metadata": {}, @@ -379,12 +379,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "71e4761492ee47d6836cb51fd0882812", + "model_id": "762755a1960d42f4a9d14b60b6e3d68e", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=16.38242960161448, step=0.05), Output()), _d…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=0.9898989898989901, step=0.05), Output()), _…" ] }, "metadata": {}, @@ -392,6 +392,7 @@ } ], "source": [ + "t_eval = np.linspace(0, 3600, 100)\n", "for model in models:\n", " solutions[model] = solver.solve(model, t_eval, inputs={\"Current function [A]\": 20})\n", "\n", diff --git a/examples/notebooks/models/spm1.png b/examples/notebooks/models/spm1.png index 7fb2ae3614..8579d6db1e 100644 Binary files a/examples/notebooks/models/spm1.png and b/examples/notebooks/models/spm1.png differ diff --git a/examples/notebooks/models/spm2.png b/examples/notebooks/models/spm2.png index 309352dadd..155322eced 100644 Binary files a/examples/notebooks/models/spm2.png and b/examples/notebooks/models/spm2.png differ diff --git a/examples/notebooks/solution-data-and-processed-variables.ipynb b/examples/notebooks/solution-data-and-processed-variables.ipynb index 5b7156238c..45a687237d 100644 --- a/examples/notebooks/solution-data-and-processed-variables.ipynb +++ b/examples/notebooks/solution-data-and-processed-variables.ipynb @@ -22,12 +22,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a4a696fe41c840e194e4d1bca8282bfb", + "model_id": "038a9f3ebf4c4549aa098f7bab633c92", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=0.9353313389920834, step=0.05), Output()), _…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=0.9750000000000001, step=0.05), Output()), _…" ] }, "metadata": {}, @@ -61,8 +61,8 @@ "\n", "# solve model\n", "solver = model.default_solver\n", - "dt = 1e-3\n", - "t_eval = np.arange(0, 0.15, dt)\n", + "dt = 90\n", + "t_eval = np.arange(0, 3600, dt) # time in seconds\n", "solution = solver.solve(model, t_eval)\n", "\n", "quick_plot = pybamm.QuickPlot(solution)\n", @@ -106,7 +106,7 @@ { "data": { "text/plain": [ - "(20, 150)" + "(20, 40)" ] }, "execution_count": 3, @@ -126,7 +126,7 @@ { "data": { "text/plain": [ - "(150,)" + "(40,)" ] }, "execution_count": 4, @@ -172,7 +172,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -226,36 +226,11 @@ { "data": { "text/plain": [ - "array([0. , 0.00627739, 0.01255478, 0.01883217, 0.02510957,\n", - " 0.03138696, 0.03766435, 0.04394174, 0.05021913, 0.05649652,\n", - " 0.06277392, 0.06905131, 0.0753287 , 0.08160609, 0.08788348,\n", - " 0.09416087, 0.10043826, 0.10671566, 0.11299305, 0.11927044,\n", - " 0.12554783, 0.13182522, 0.13810261, 0.14438001, 0.1506574 ,\n", - " 0.15693479, 0.16321218, 0.16948957, 0.17576696, 0.18204435,\n", - " 0.18832175, 0.19459914, 0.20087653, 0.20715392, 0.21343131,\n", - " 0.2197087 , 0.2259861 , 0.23226349, 0.23854088, 0.24481827,\n", - " 0.25109566, 0.25737305, 0.26365044, 0.26992784, 0.27620523,\n", - " 0.28248262, 0.28876001, 0.2950374 , 0.30131479, 0.30759219,\n", - " 0.31386958, 0.32014697, 0.32642436, 0.33270175, 0.33897914,\n", - " 0.34525653, 0.35153393, 0.35781132, 0.36408871, 0.3703661 ,\n", - " 0.37664349, 0.38292088, 0.38919828, 0.39547567, 0.40175306,\n", - " 0.40803045, 0.41430784, 0.42058523, 0.42686262, 0.43314002,\n", - " 0.43941741, 0.4456948 , 0.45197219, 0.45824958, 0.46452697,\n", - " 0.47080437, 0.47708176, 0.48335915, 0.48963654, 0.49591393,\n", - " 0.50219132, 0.50846871, 0.51474611, 0.5210235 , 0.52730089,\n", - " 0.53357828, 0.53985567, 0.54613306, 0.55241046, 0.55868785,\n", - " 0.56496524, 0.57124263, 0.57752002, 0.58379741, 0.5900748 ,\n", - " 0.5963522 , 0.60262959, 0.60890698, 0.61518437, 0.62146176,\n", - " 0.62773915, 0.63401655, 0.64029394, 0.64657133, 0.65284872,\n", - " 0.65912611, 0.6654035 , 0.67168089, 0.67795829, 0.68423568,\n", - " 0.69051307, 0.69679046, 0.70306785, 0.70934524, 0.71562264,\n", - " 0.72190003, 0.72817742, 0.73445481, 0.7407322 , 0.74700959,\n", - " 0.75328698, 0.75956438, 0.76584177, 0.77211916, 0.77839655,\n", - " 0.78467394, 0.79095133, 0.79722873, 0.80350612, 0.80978351,\n", - " 0.8160609 , 0.82233829, 0.82861568, 0.83489307, 0.84117047,\n", - " 0.84744786, 0.85372525, 0.86000264, 0.86628003, 0.87255742,\n", - " 0.87883482, 0.88511221, 0.8913896 , 0.89766699, 0.90394438,\n", - " 0.91022177, 0.91649916, 0.92277656, 0.92905395, 0.93533134])" + "array([0. , 0.025, 0.05 , 0.075, 0.1 , 0.125, 0.15 , 0.175, 0.2 ,\n", + " 0.225, 0.25 , 0.275, 0.3 , 0.325, 0.35 , 0.375, 0.4 , 0.425,\n", + " 0.45 , 0.475, 0.5 , 0.525, 0.55 , 0.575, 0.6 , 0.625, 0.65 ,\n", + " 0.675, 0.7 , 0.725, 0.75 , 0.775, 0.8 , 0.825, 0.85 , 0.875,\n", + " 0.9 , 0.925, 0.95 , 0.975])" ] }, "execution_count": 8, @@ -282,23 +257,14 @@ { "data": { "text/plain": [ - "array([0. , 0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008,\n", - " 0.009, 0.01 , 0.011, 0.012, 0.013, 0.014, 0.015, 0.016, 0.017,\n", - " 0.018, 0.019, 0.02 , 0.021, 0.022, 0.023, 0.024, 0.025, 0.026,\n", - " 0.027, 0.028, 0.029, 0.03 , 0.031, 0.032, 0.033, 0.034, 0.035,\n", - " 0.036, 0.037, 0.038, 0.039, 0.04 , 0.041, 0.042, 0.043, 0.044,\n", - " 0.045, 0.046, 0.047, 0.048, 0.049, 0.05 , 0.051, 0.052, 0.053,\n", - " 0.054, 0.055, 0.056, 0.057, 0.058, 0.059, 0.06 , 0.061, 0.062,\n", - " 0.063, 0.064, 0.065, 0.066, 0.067, 0.068, 0.069, 0.07 , 0.071,\n", - " 0.072, 0.073, 0.074, 0.075, 0.076, 0.077, 0.078, 0.079, 0.08 ,\n", - " 0.081, 0.082, 0.083, 0.084, 0.085, 0.086, 0.087, 0.088, 0.089,\n", - " 0.09 , 0.091, 0.092, 0.093, 0.094, 0.095, 0.096, 0.097, 0.098,\n", - " 0.099, 0.1 , 0.101, 0.102, 0.103, 0.104, 0.105, 0.106, 0.107,\n", - " 0.108, 0.109, 0.11 , 0.111, 0.112, 0.113, 0.114, 0.115, 0.116,\n", - " 0.117, 0.118, 0.119, 0.12 , 0.121, 0.122, 0.123, 0.124, 0.125,\n", - " 0.126, 0.127, 0.128, 0.129, 0.13 , 0.131, 0.132, 0.133, 0.134,\n", - " 0.135, 0.136, 0.137, 0.138, 0.139, 0.14 , 0.141, 0.142, 0.143,\n", - " 0.144, 0.145, 0.146, 0.147, 0.148, 0.149])" + "array([0. , 0.00398255, 0.00796509, 0.01194764, 0.01593018,\n", + " 0.01991273, 0.02389528, 0.02787782, 0.03186037, 0.03584291,\n", + " 0.03982546, 0.04380801, 0.04779055, 0.0517731 , 0.05575564,\n", + " 0.05973819, 0.06372073, 0.06770328, 0.07168583, 0.07566837,\n", + " 0.07965092, 0.08363346, 0.08761601, 0.09159856, 0.0955811 ,\n", + " 0.09956365, 0.10354619, 0.10752874, 0.11151129, 0.11549383,\n", + " 0.11947638, 0.12345892, 0.12744147, 0.13142402, 0.13540656,\n", + " 0.13938911, 0.14337165, 0.1473542 , 0.15133674, 0.15531929])" ] }, "execution_count": 9, @@ -318,36 +284,11 @@ { "data": { "text/plain": [ - "array([0. , 0.00627739, 0.01255478, 0.01883217, 0.02510957,\n", - " 0.03138696, 0.03766435, 0.04394174, 0.05021913, 0.05649652,\n", - " 0.06277392, 0.06905131, 0.0753287 , 0.08160609, 0.08788348,\n", - " 0.09416087, 0.10043826, 0.10671566, 0.11299305, 0.11927044,\n", - " 0.12554783, 0.13182522, 0.13810261, 0.14438001, 0.1506574 ,\n", - " 0.15693479, 0.16321218, 0.16948957, 0.17576696, 0.18204435,\n", - " 0.18832175, 0.19459914, 0.20087653, 0.20715392, 0.21343131,\n", - " 0.2197087 , 0.2259861 , 0.23226349, 0.23854088, 0.24481827,\n", - " 0.25109566, 0.25737305, 0.26365044, 0.26992784, 0.27620523,\n", - " 0.28248262, 0.28876001, 0.2950374 , 0.30131479, 0.30759219,\n", - " 0.31386958, 0.32014697, 0.32642436, 0.33270175, 0.33897914,\n", - " 0.34525653, 0.35153393, 0.35781132, 0.36408871, 0.3703661 ,\n", - " 0.37664349, 0.38292088, 0.38919828, 0.39547567, 0.40175306,\n", - " 0.40803045, 0.41430784, 0.42058523, 0.42686262, 0.43314002,\n", - " 0.43941741, 0.4456948 , 0.45197219, 0.45824958, 0.46452697,\n", - " 0.47080437, 0.47708176, 0.48335915, 0.48963654, 0.49591393,\n", - " 0.50219132, 0.50846871, 0.51474611, 0.5210235 , 0.52730089,\n", - " 0.53357828, 0.53985567, 0.54613306, 0.55241046, 0.55868785,\n", - " 0.56496524, 0.57124263, 0.57752002, 0.58379741, 0.5900748 ,\n", - " 0.5963522 , 0.60262959, 0.60890698, 0.61518437, 0.62146176,\n", - " 0.62773915, 0.63401655, 0.64029394, 0.64657133, 0.65284872,\n", - " 0.65912611, 0.6654035 , 0.67168089, 0.67795829, 0.68423568,\n", - " 0.69051307, 0.69679046, 0.70306785, 0.70934524, 0.71562264,\n", - " 0.72190003, 0.72817742, 0.73445481, 0.7407322 , 0.74700959,\n", - " 0.75328698, 0.75956438, 0.76584177, 0.77211916, 0.77839655,\n", - " 0.78467394, 0.79095133, 0.79722873, 0.80350612, 0.80978351,\n", - " 0.8160609 , 0.82233829, 0.82861568, 0.83489307, 0.84117047,\n", - " 0.84744786, 0.85372525, 0.86000264, 0.86628003, 0.87255742,\n", - " 0.87883482, 0.88511221, 0.8913896 , 0.89766699, 0.90394438,\n", - " 0.91022177, 0.91649916, 0.92277656, 0.92905395, 0.93533134])" + "array([0. , 0.025, 0.05 , 0.075, 0.1 , 0.125, 0.15 , 0.175, 0.2 ,\n", + " 0.225, 0.25 , 0.275, 0.3 , 0.325, 0.35 , 0.375, 0.4 , 0.425,\n", + " 0.45 , 0.475, 0.5 , 0.525, 0.55 , 0.575, 0.6 , 0.625, 0.65 ,\n", + " 0.675, 0.7 , 0.725, 0.75 , 0.775, 0.8 , 0.825, 0.85 , 0.875,\n", + " 0.9 , 0.925, 0.95 , 0.975])" ] }, "execution_count": 10, @@ -374,7 +315,7 @@ { "data": { "text/plain": [ - "array(0.0031387)" + "array(0.0125)" ] }, "execution_count": 11, @@ -415,6 +356,37 @@ "solution[var](interp_t)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Saving the solution\n", + "\n", + "The solution can be saved in a number of ways:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# to a pickle file (default)\n", + "solution.save_data(\n", + " \"outputs.pickle\", [\"Time [h]\", \"Current [A]\", \"Terminal voltage [V]\", \"Electrolyte concentration [mol.m-3]\"]\n", + ")\n", + "# to a matlab file\n", + "solution.save_data(\n", + " \"outputs.mat\", \n", + " [\"Time [h]\", \"Current [A]\", \"Terminal voltage [V]\", \"Electrolyte concentration [mol.m-3]\"], \n", + " to_format=\"matlab\"\n", + ")\n", + "# to a csv file (time-dependent outputs only, no spatial dependence allowed)\n", + "solution.save_data(\n", + " \"outputs.csv\", [\"Time [h]\", \"Current [A]\", \"Terminal voltage [V]\"], to_format=\"csv\"\n", + ")" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -426,7 +398,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -434,30 +406,41 @@ "output_type": "stream", "text": [ "Time 0\n", - "[3.77057107 3.7384485 3.72393304 3.71095299 3.69929584 3.68896714\n", - " 3.67990351 3.67198691 3.66505857 3.65889901]\n", - "Time 0.05\n", - "[3.77057107 3.7384485 3.72393304 3.71095299 3.69929584 3.68896714\n", - " 3.67990351 3.67198691 3.66505857 3.65889901 3.6531217 3.64686147\n", - " 3.63836533 3.62648194 3.61471462 3.60677738 3.60170497 3.59781764\n", - " 3.59438503]\n", - "Time 0.1\n", - "[3.77057107 3.7384485 3.72393304 3.71095299 3.69929584 3.68896714\n", - " 3.67990351 3.67198691 3.66505857 3.65889901 3.6531217 3.64686147\n", - " 3.63836533 3.62648194 3.61471462 3.60677738 3.60170497 3.59781764\n", - " 3.59438503 3.59123681 3.58840351 3.58588895 3.58343102 3.58026052\n", - " 3.57495718 3.56514501 3.54544289 3.49856266]\n" + "[3.77057107 3.71259842]\n", + "Time 360\n", + "[3.77057107 3.71259842 3.68218919]\n", + "Time 720\n", + "[3.77057107 3.71259842 3.68218919 3.66127527]\n", + "Time 1080\n", + "[3.77057107 3.71259842 3.68218919 3.66127527 3.64328161]\n", + "Time 1440\n", + "[3.77057107 3.71259842 3.68218919 3.66127527 3.64328161 3.61159241]\n", + "Time 1800\n", + "[3.77057107 3.71259842 3.68218919 3.66127527 3.64328161 3.61159241\n", + " 3.59708908]\n", + "Time 2160\n", + "[3.77057107 3.71259842 3.68218919 3.66127527 3.64328161 3.61159241\n", + " 3.59708908 3.5882127 ]\n", + "Time 2520\n", + "[3.77057107 3.71259842 3.68218919 3.66127527 3.64328161 3.61159241\n", + " 3.59708908 3.5882127 3.58049537]\n", + "Time 2880\n", + "[3.77057107 3.71259842 3.68218919 3.66127527 3.64328161 3.61159241\n", + " 3.59708908 3.5882127 3.58049537 3.55052297]\n", + "Time 3240\n", + "[3.77057107 3.71259842 3.68218919 3.66127527 3.64328161 3.61159241\n", + " 3.59708908 3.5882127 3.58049537 3.55052297 3.14248086]\n" ] } ], "source": [ - "dt = 0.05\n", + "dt = 360\n", "time = 0\n", - "end_time = solution.t[-1]\n", + "end_time = solution[\"Time [s]\"].entries[-1]\n", "step_solver = model.default_solver\n", "step_solution = None\n", "while time < end_time:\n", - " step_solution = step_solver.step(step_solution, model, dt=dt, npts=10)\n", + " step_solution = step_solver.step(step_solution, model, dt=dt, npts=2)\n", " print('Time', time)\n", " print(step_solution[\"Terminal voltage [V]\"].entries)\n", " time += dt" @@ -472,22 +455,22 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3deXxU9dX48c/JIiEsgrIvSaQKihBQIqIWBETAYhUXIBo04BKXKtpWrJr+FJC0blWrtkK0CkosCFofRSqogOACGPIEFERQDPsjEDbDZpbz++PexEmY7JOZyeS8X6/7ysy93zv3TAhn7nxXUVWMMcaErrBAB2CMMaZuWaI3xpgQZ4neGGNCnCV6Y4wJcZbojTEmxEUEOoCyWrVqpXFxcYEOwxhj6pXVq1fvVdXW3o4FXaKPi4sjMzMz0GEYY0y9IiJbyjtmVTfGGBPiLNEbY0yIs0RvjDEhLujq6I2pT/Lz89m+fTvHjh0LdCimgYiKiqJTp05ERkZW+RxL9MbUwvbt22nWrBlxcXGISKDDMSFOVcnNzWX79u2cdtppVT4vdKpuMjIgLg7CwpyfGRmBjsg0AMeOHePUU0+1JG/8QkQ49dRTq/0NMjTu6DMyICUFjhxxnm/Z4jwHSEoKXFymQbAkb/ypJn9voXFHn5r6S5IvduSIs98YYxq40Ej0W7dWb78xxjQgoZHoY2Kqt9+YEJKWlsbZZ59NfHw8vXv3ZuXKlQAMHDiQbt260atXLy666CK+/fbbkv0xMTF4Ljo0cuRImjZtWq3rqiqDBw/m0KFDPnsvOTk5vPHGGyXPMzMzmTBhgs9e39/GjRvHvHnzanRuYmIimzZt8kkcoZHo09IgOrr0vuhoZ78xIeyLL75g/vz5ZGVlsXbtWj766CM6d+5ccjwjI4M1a9aQnJzMxIkTS/a3aNGCzz77DIADBw6wa9eual97wYIF9OrVi+bNm9f+jbjKJvqEhASee+45n71+fXLHHXfwxBNP+OS1QiPRJyVBejo/nRJLEUJ+h1hIT7eGWONX994LAwf6drv33oqvuWvXLlq1akWjRo0AaNWqFR06dDih3IABA/juu+9KnicmJjJ79mwA3n77ba6++upS5Z988knOO+884uPjeeSRR7xeOyMjgyuvvLLk+WuvvUZ8fDy9evXihhtuAJzEPXjwYOLj47nkkkvY6lanjhs3jgkTJnDhhRfSpUuXkrveBx54gOXLl9O7d2+eeeYZli5dyuWXXw7ApEmTuOmmmxg4cCBdunQp+QDIycmhR48eJXE89dRTTJo0CYDs7Gz69etHfHw8V111Ffv37wecbzXFc2rt3buX4okU161bR9++fenduzfx8fEn3FEXFhYybtw4evToQc+ePXnmmWcqvE6xDz74gFGjRpU893xfixYt4oILLuDcc89l1KhR5OXlAdC/f38++ugjCgoKvP7+qyM0Ej1AUhI5S3MIp4g5j+dYkjcNwtChQ9m2bRtdu3blzjvv5JNPPvFa7r333qNnz54lzy+55BKWLVtGYWEhs2fPZsyYMSXHFi1axKZNm1i1ahXZ2dmsXr2aZcuWnfCan332GX369AGcBDl16lQWL17MmjVr+Pvf/w7A3XffTXJyMmvXriUpKalUNcyuXbv49NNPmT9/Pg888AAAjz32GP379yc7O5vf//73J1xzw4YNLFy4kFWrVjF58mTy8/Mr/P3ceOONPP7446xdu5aePXsyefLkCstPmzaNe+65h+zsbDIzM+nUqVOp49nZ2ezYsYOvv/6ar776ivHjx1fpOkOGDGHlypUcPnwYgDlz5pCYmMjevXuZOnUqH330EVlZWSQkJPD0008DEBYWxumnn86aNWsqjLkqQqN7pat7d2jaFFasgLFjAx2NaWiefdb/12zatCmrV69m+fLlLFmyhDFjxvDYY48xbtw4AJKSkmjcuDFxcXE8//zzJeeFh4fz61//mtmzZ3P06FE8pwZftGgRixYt4pxzzgEgLy+PTZs2MWDAgFLX3rdvH82aNQNg8eLFjBo1ilatWgFwyimnAE7V0ttvvw3ADTfcwP33319y/siRIwkLC6N79+78+OOPVXq/I0aMoFGjRjRq1Ig2bdpUeN7Bgwc5cOAAF198MQDJycml7qq9ueCCC0hLS2P79u1cffXVnHHGGaWOd+nShc2bN3P33XczYsQIhg4dWqXrREREMHz4cN577z2uvfZa3n//fZ544gk++eQT1q9fz0UXXQTAzz//zAUXXFByXps2bdi5c2fJB2pNhVSiDw+H884Dty3KmAYhPDycgQMHMnDgQHr27MnMmTNLEn1GRgYJCQlez0tMTOSqq64qqeYopqo8+OCD3HbbbRVeNyIigqKiIsLCalYxUFzdVHzN6p4THh5OQUFBSRzFqjKYyPMcz/LXX389559/Pu+//z6/+c1vmD59OoMHDy453rJlS9asWcPChQuZNm0ab775Zkn1TWUSExN54YUXOOWUU0hISKBZs2aoKpdeein//ve/vZ5z7NgxGjduXKXXr0joVN24+vWD7Gw4ejTQkRhT97799ttS9cjZ2dnExsZW6dz+/fvz4IMPct1115XaP2zYMF555ZWSuuIdO3awe/fuE87v1q0bmzdvBmDw4MHMnTuX3NxcwLnbB7jwwgtL2gIyMjLo379/hTE1a9aMn376qUrxF2vbti27d+8mNzeX48ePM3/+fABOPvlkWrZsyfLlywF4/fXXS+664+LiWL16NUCpXjGbN2+mS5cuTJgwgSuvvJK1a9eWutbevXspKirimmuuYerUqWRlZVV4HU8XX3wxWVlZvPTSSyQmJgLQr18/Pvvss5L2k8OHD7Nx48aSczZu3Fiq/aGmQuqOHpxEX1AAWVngfhsyJmTl5eVx9913c+DAASIiIjj99NNJT0+v0rkiwn333XfC/qFDh/LNN9+UVCE0bdqUWbNm0aZNm1LlRowYwdKlSzn99NM5++yzSU1N5eKLLyY8PJxzzjmHGTNm8PzzzzN+/HiefPJJWrduzauvvlphTPHx8YSHh9OrVy/GjRtXUn1UkcjISB5++GH69u1Lx44dOfPMM0uOzZw5k9tvv50jR47QpUuXkuvfd999jB49mvT0dEaMGFFS/s033+T1118nMjKSdu3a8dBDD5W61o4dOxg/fnzJt4G//vWvFV7HU3h4OJdffjkzZsxg5syZALRu3ZoZM2Zw3XXXcfz4cQCmTp1K165d+fHHH2ncuDHt2rWr9HdQGanqVyZ/SUhI0NqsMPXjj9CuHUyaBOV0FjDGZ7755hvOOuusQIcRELt27eLGG2/kww8/DHQoIemZZ56hefPm3HzzzScc8/Z3JyKrVdVrPV3IVd20bQtDhzq9KytpkDfG1EL79u259dZbfTpgyvyiRYsWJCcn++S1Qi7RA0yYADt3gtvYb4ypI6NHj/bpgCnzi/HjxxMR4Zva9UoTvYhEicgqEVkjIutE5ISOqCLyjIhku9tGETngcazQ49i7Pom6EpddBqefDm5XXmOMadCq8nFxHBisqnkiEgl8KiL/VdUVxQVUtWRkg4jcDXi2oBxV1d4+i7gKwsLg7rvhnnvgyy+dLpfGGNNQVXpHr44892mku1XUgnsd4L1TqB+NGwcnnwwPPABB1t5sjDF+VaU6ehEJF5FsYDfwoap6HZIkIrHAacBij91RIpIpIitEZGQ556W4ZTL37NlTzbfgXfPm8NhjsHgxzJrlk5c0JigF8+yVzz77LEfKrhXhR7WZPbLYjBkzuOuuu2p07gsvvMArr7xSq+v7QpUSvaoWutUvnYC+IlJeD/5EYJ6qFnrsi3W7/FwPPCsiv/Ly+umqmqCqCa1bt67mWyhfSorTr/4PfwB3HIcxgeXjJS+DffbKQCf6QLvppptKTT0RKNXqdaOqB4AlwPByiiRSptpGVXe4PzcDSyldf1+nwsJg+nTYvx9uu82qcEyAFS95uWWL88dYvORlLZJ9sMxeefjwYUaMGEGvXr3o0aMHc+bM4bnnnmPnzp0MGjSIQYMGAeXP1BgXF8f9999Pz5496du3b0ms48aN4/bbbychIYGuXbuWjHotLCxk4sSJJTFOnz4dcL5l3HXXXXTr1o0hQ4Z4HdEL8Nxzz9G9e3fi4+NLRqnu27ePkSNHEh8fT79+/U4YFXvw4EFiY2NLBksdPnyYzp07k5+fz/fff8/w4cPp06cP/fv3Z8OGDQBER0cTFxfHqlWrvMbhN6pa4Qa0Blq4jxsDy4HLvZQ7E8jBHYTl7msJNHIftwI2Ad0rul6fPn3U1558UhVUn3rK5y9tGrj169dXvXBsrPOHWHaLja3x9X/66Sft1auXnnHGGXrHHXfo0qVLS45dfPHF+uWXX6qq6hNPPKGjR48u2b9ixQrt2bOnFhQU6KWXXqo//PCDNmnSRFVVFy5cqLfeeqsWFRVpYWGhjhgxQj/55JMTrh0TE6OHDh1SVdV58+bpLbfcUnLswIED7luO1T179qiq6p49e7R///6al5enqqqPPfaYTp48uaTc1KlTVVV15syZOmLECFVVTU5O1mHDhmlhYaFu3LhRO3bsqEePHtXp06fro48+qqqqx44d0z59+ujmzZv1rbfe0iFDhmhBQYHu2LFDTz75ZJ07d+4Jsbdv316PHTumqqr79+9XVdW77rpLJ02apKqqH3/8sfbq1UtVVV999VX93e9+p6qqV1xxhS5evFhVVWfPnq0333yzqqoOHjxYN27cqKqqK1as0EGDBpVca+rUqfqUj5OPt787IFPLyatV6XXTHpgpIuE43wDeVNX5IjLFfeHiLpOJwGz3gsXOAqaLSJF77mOqur6Gn0k19sc/OhOd/elPcM454DFHkTH+UwdLXgbL7JU9e/bkj3/8I3/605+4/PLLvc5ps2LFigpnaiyec+e6664rNUXx6NGjCQsL44wzzqBLly5s2LCBRYsWsXbt2pL694MHD7Jp0yaWLVvGddddR3h4OB06dCg1IZmn+Ph4kpKSGDlyJCNHOk2Hn376KW+99RbgzN2Tm5t7QvvDmDFjmDNnDoMGDWL27Nnceeed5OXl8fnnn5easbJ4OgNwZqAsvsMPlEoTvaquxUt1i6o+XOb5JC9lPgd6lt3vbyLwyivwzTdw9dWwfDn0DHhUpsGJiXGqa7ztr4VgmL2ya9euZGVlsWDBAv785z9zySWX8PDDpVJEpTM1ikilj4ufqyrPP/88w4YNK3VswYIFFcZc7P3332fZsmW89957pKWl8dVXX1XpvCuuuIKHHnqIffv2sXr1agYPHszhw4dp0aIF2dnZXs/x1QyUtRGSI2O9adYMFixw5qufNiCDgk5xPmsQM6ZK6mDJy2CZvXLnzp1ER0czduxYJk6cSFZWFlB6NsrKZmqcM2dOyU/PO/25c+dSVFTE999/z+bNm+nWrRvDhg3jxRdfLFl4ZOPGjRw+fJgBAwYwZ84cCgsL2bVrF0uWLDkh7qKiIrZt28agQYN4/PHHOXjwIHl5efTv358MNxcsXbqUVq1andDQ3LRpU8477zzuueceLr/8csLDw2nevDmnnXYac+fOBZwPNM/FQnw1A2VthNzslRWJiYHP78qg1YMpRBxwewIUN4iBrUpl6lbx31dqqlNdExPjJPla/N0Fy+yVX331FRMnTiQsLIzIyEhefPFFAFJSUhg+fDgdOnRgyZIl5c7UCLB//37i4+Np1KhRqbv+mJgY+vbty6FDh5g2bRpRUVHccsst5OTkcO6556KqtG7dmnfeeYerrrqKxYsX0717d2JiYkp9YBQrLCxk7NixHDx4EFVlwoQJtGjRomSpwvj4eKKjo0tmmCxrzJgxjBo1iqVLl5bsy8jI4I477mDq1Knk5+eTmJhIr169AGclrrLfmvyuvMr7QG110RhbSh00iJmGq1qNsSFm586dOmTIEJ+8lmejrafk5GSvjan1RVZWlo4dO9bnr1vdxtgGU3VTog4axIxpiGz2ysrt3buXRx99NNBhNKyqG6DcBrGCDjEN8JdhTO2MHj3aJ6+Tk5Pjdf+MGTN88vqBcumllwY6BKABNcaW8NIgdphoJuan8cMPAYrJ1GtqI/GMH9Xk763hJfqkJGdVkthYp99lbCw7J6UzMz+Jiy6Cr78OdICmPomKiiI3N9eSvfELVSU3N5eoqKhqnRdySwnW1NdfOytTHTvmdMPs18/vIZh6KD8/n+3bt3Ps2LFAh2IaiKioKDp16kRkZGSp/RUtJWjV0q4ePeDTT51kP2QI/Oc/ECTVayaIRUZGctpppwU6DGMq1PCqbirQpYuT7H/1KxgxAmo5u6kxxgQFS/RltGsHS5c6q1KNGQMf3+zbaWWNMcbfrOrGi5YtYdEi+MeFGfR7JQWwUbTGmPrL7ujL0aQJTDyQShPKLJpw5IgzhN0YY+oJS/QVkG02itYYU/9Zoq9IOdPHFnSo3bSyxhjjT5boK+JlFO0RopnwUxqrVwcoJmOMqSZL9BXxMop23+PpLGiZxIAB1v3SGFM/WKKvTFIS5ORAURHk5NDp/iRWroRevWDUKJgyxRYdN8YEN0v0NdC2LSxZAjfeCI884vS3P3Kk8vOMMSYQLNHXUKNGMGMGPPmkU4XTvz9s3x7oqIwx5kSW6GtBBO67D957DzZtgr+cncHx9nE2itYYE1RsZKwPjBgB61IzOPXBFBodslG0xpjgYnf0PtL5xVSi1UbRGmOCjyV6XylntKzaKFpjTIBZoveVckbRbpMYPvjAz7EYY4wHS/S+4mUUbVFUNP/smMZvfuP0ty8sDFBsxpgGzRK9r3gZRRv2cjoPb0hi7Finv/3QobBrV6ADNcY0NJUmehGJEpFVIrJGRNaJyGQvZZ4RkWx32ygiBzyOJYvIJndL9vUbCCplRtGSlER0NMycCf/6F3zxhTOi1qpyjDH+VJU7+uPAYFXtBfQGhotIqaWzVfX3qtpbVXsDzwNvA4jIKcAjwPlAX+AREWnpyzdQH4jATTfB6tXOClaXXQb33w8FM231KmNM3au0H72qKpDnPo10t4pmd7kOJ7kDDAM+VNV9ACLyITAc+HdNA67PzjoLVq6EP/4Rtj+ZQX5YChFF1u/eGFO3qlRHLyLhIpIN7MZJ3CvLKRcLnAYsdnd1BLZ5FNnu7muwGjeGf/4TXmqVSuMi63dvjKl7VUr0qlroVst0AvqKSI9yiiYC81S1Wv1LRCRFRDJFJHPPnj3VObXeapJrq1cZY/yjWr1uVPUAsASn+sWbREpXy+wAOns87+TuK/u66aqaoKoJrVu3rk5I9Vc5/e6PtLLVq4wxvlWVXjetRaSF+7gxcCmwwUu5M4GWwBceuxcCQ0WkpdsIO9TdZ7z0uz8q0dyyJ42bb4ZDhwIUlzEm5FTljr49sERE1gJf4tTRzxeRKSJyhUe5RGC223gLgNsI+6h73pfAlOKG2QbPS7/7yFfT6ZKaxIwZEB8PixYFOkhjTCgQDbLlkRISEjQzMzPQYQTUF1/A+PHw7beQnAx/+xucemqgozLGBDMRWa2qCd6O2cjYIHTBBZCd7XTAyciA7t3hi7sz0Ng463NvjKk2S/RBKioKpk51BlmlNMkg/oUUZOsWZ4Ha4j73luyNMVVgiT7IxcfDlMJUmmB97o0xNWOJvh6QbTbXvTGm5izR1wfl9LnfojGMHWszYhpjKmaJvj7w0udeG0fz5cg05s6Fbt3g6achPz9A8Rljgpol+vrAS597eSmdUf9JYt06+PWvnYnSzj4b3nkHNMNmxTTG/ML60YcAVXj/fZg4Ec7ZkMErYSlEeU6YFh3tfFDYrJjGhKyK+tFbog8hBQVwtG0czfZtOfFgbKyzGIoxJiTZgKkGIiICmu23HjrGmNIs0YeacnrobCOGhx+GAwe8HjbGhDBL9KHGSw+doqho/nNeGo8+Cl26wF//CocPByg+Y4zfWaIPNV566IS9nM49K5PIyoKLLoKHHnIS/lNPQV4eTq8c66VjTMiyxtgGaMUKePhh+PBDuLVJBi/8nMJJ+dZLx5j6zHrdGK9WroTTBsXR5qj10jGmvqso0Uf4OxgTPM4/HzhWfi8d8W84xpg6YnX0DV0F8+hcdRV8+qkzIMsYU39Zom/ovPXSaRzNqivTWLYM+veHfv1gzhxnQJY13BpT/1iib+i89dJ5KZ3R7ySxdSv84x+wbx8kJsK9bTL4eXyKs/CJLYBiTL1hjbGmUoWFMH8+9EuMo+0xa7g1JhjZFAimVsLD4coroe3xchput2zl0CE/B2WMqTJL9Kbqymu4JYaOHeH22+HLLz0ab60+35igYIneVJ23BVCioymYnMbVV8Nrr0Hfvs46twvGZqC3Wn2+McHAEr2pOm8LoKSnc/rDScyc6SxpOH06NGkC3TNSkaO2oLkxwcAaY02d0LAwxMvfloogRUUBiMiY0GaNscbvpIKBWL/+NfzrX1gDrjF+Yone1I1yBmKtHZNGbi7ccgu0awc33ACLF0PRLGu4Naau2Fw3pm4Uz3yZmgpbt0JMDGFpaVyRlMRvFVatghkz4N//hsJZGfSTFKLVrdMvbrj1fB1jTI1VWkcvIlHAMqARzgfDPFV9xEu50cAkQIE1qnq9u78Q+MottlVVr6joelZH37AcPQpFMXE02XviQKyizrGEbc3xf1DG1EO1nb3yODBYVfNEJBL4VET+q6orPC5wBvAgcJGq7heRNh7nH1XV3rV5AyZ0NW4M5Jaznu22rSQnw7hxMHCg09HHGFN9ldbRqyPPfRrpbmW/BtwK/ENV97vn7PZplCa0ldNwu79pDO+8A4MHQ/fu8PzzHg24NhjLmCqrUmOsiISLSDawG/hQVVeWKdIV6Coin4nIChEZ7nEsSkQy3f0jy3n9FLdM5p49e2r0Rkw95qXhluhoTp2Wxv/9H8ycCc2bw4QJ0LEjvDIkg6JbbDCWMVWmqlXegBbAEqBHmf3zgf/g3O2fBmwDWrjHOro/uwA5wK8qukafPn3UNECzZqnGxqqKOD9nzTqhyKpVqsnJqjnEqjopvvQWG+vfmI0JIkCmlpNXqz1gSkQeBo6o6lMe+6YBK1X1Vff5x8ADqvplmXNnAPNVdV55r2+NsaYyNhjLmBPVasCUiLQWkRbu48bApcCGMsXeAQa6ZVrhVOVsFpGWItLIY/9FwPoavg9jgPIHY+0Mj2HePFsRy5iyqlJH3x5YIiJrgS9x6ujni8gUESnuKrkQyBWR9ThVOxNVNRc4C8gUkTXu/sdU1RK9qR0vdfoFJ0Xz97ZpjBoFF17oLIFojHGVV6cTqM3q6E2VeKnTLyhQffll1Q4dnCr7kSNVv//ee1ljQg2+rKOva1ZHb2rryBF49ln461/hmuMZvEQKkfkeM2lGRzuzcNqoWxNCKqqjt0RvQtb27XBS1zjaHLXlD03oq+3IWGPqpU6dQI+VM+p2azn7jQlBNnulCWnl9dDJb+99vzGhyBK9CW1eeugcIZrbctN4440AxWSMn1miN6HNy/KHh59J59s+SSQlwa23wrFjgQ7SmLpljbGmQSoogIcfdnrm9O0Lb73l1OkbU1/ZUoLGlBERAX/5C7z9NqxfD336wCefBDoqY+qGJXrToF11lbPaVcuWcMkl8MGNGWhsnE1/bEKKda80Dd5ZZznJ/qVBGfR/PQXBljQ0ocXu6I3Bme/+D3tTacKR0geOHHHWvTWmHrNEb4xLttngKhOaLNEbU6ycwVV5p9jgKlO/WaI3ppiXwVXHwqJJyU3jnnsgPz9AcRlTS5bojSnmZXBV5Ix02t6bxHPPwbBhsHdvoIM0pvpswJQxVTBjBtx2G7Rp4/S4HDAg0BEZU5oNmDKmlsaNg88/h6goGDQIJk1yRtcaUx9Yojemivr0gawsp4Zn8mT4S48MCjrF2eAqE/RswJQx1dCsGbz2GtzaJIM+01KIsMFVph6wO3pjaqD/f1OJtsFVpp6wRG9MTZQziEq3bGXfPj/HYkwlLNEbUxPlDK7aQgxdujjTHx854rWIMX5nid6YmvAyuIroaMIfS2PAAHjoITj9dHj+eTh82D2ekeE02lrjrfEzS/TG1ISXwVWkp9P5T0m8+y4sXw6/+hVMmACdO8OcKzMoujXFabRV/aXx1pK98QMbMGVMHfr8c3j6afjbW3HEsuXEArGxkJPj97hM6KlowJR1rzSmDl14obNp2Fbwck+lW7ci/g/LNDBWdWOMH0h5jbcaQ69eMGUKrFvn1OoAVp9vfKrSRC8iUSKySkTWiMg6EZlcTrnRIrLeLfOGx/5kEdnkbsm+DN6YesNL421R42i+GZtG8+bOlAo9ekC3bvDa8AwKbrb6fOM7ldbRi4gATVQ1T0QigU+Be1R1hUeZM4A3gcGqul9E2qjqbhE5BcgEEnC+uK4G+qjq/vKuZ3X0JmRlZDgDqrZudbpnpqWVjKLdtQv+8x947z2Y9oH3+nyNiUW25Pg5aFNf1GpSM3XkuU8j3a3sp8OtwD+KE7iq7nb3DwM+VNV97rEPgeE1eA/G1H9JSU7Da1GR89NjqoT27eHOO+G//4UYKWcw1tatjBkDL74I69dbNY+puirV0YtIuIhkA7txEvfKMkW6Al1F5DMRWSEixcm8I7DNo9x2d1/Z108RkUwRydyzZ0/134UxIaS8+vzc6Bg+/9z5QDj7bGjbFv5+fgb5462ax1SsSoleVQtVtTfQCegrIj3KFIkAzgAGAtcBL4lIi6oGoarpqpqgqgmtW7eu6mnGhKZyBmO1Tk9j61b4/nv417/gssvgmtWpROafOOfO0T+kcuBAOa9v3wAanGp1r1TVAyKyBKf65WuPQ9uBlaqaD/wgIhtxEv8OnORfrBOwtDYBGxPyiqt0vNTnC9Cli7PddBPwuvdqnka7t9LkFDjrLKd75wUXOFu31RmE3Zbyy/wMNutmg1CVxtjWQL6b5BsDi4DHVXW+R5nhwHWqmiwirYD/BXrzSwPsuW7RLJzG2HKnfbLGWGOqIS7OSdZlHG0Ty9/uzuHzz2HFCtjvdn/YEhZHTJEN3ApFtV1hqj2wRETWAl/i1NHPF5EpInKFW2YhkCsi64ElwERVzXUT+qPueV8CUypK8saYaiqnmqfx02n8+Q2i59QAAA36SURBVM+wYIGzzu033zjVPZ2LvH8DKNqylSlTnPKlmsmsmick2BQIxtR3FXTbPEE53wB2RMTSuTCnpCdPbCzc2yaD32WnlG4DiI525vixap6gY2vGGhPKKui2eYJyvgF0nJHGgQOwdCk8+SScfz6M+l/vDb3770xl9mzYsAEKCz2O2d1/8FLVoNr69Omjxpg6NGuWamysqojzc9Ys7+VEVJ1Om6W2QqTkaePGqn37qr40aJb+HBldumx0dPmvXdUYTJUBmVpOXrWqG2OMd+VU82hMLGv+J4c1ayA729lmLvPeyJvbNJZZU3Po3t3p+9++PcgbGU5PnyNWJeRLFVXdWKI3xniXUfWErGFhiJdcUoQQTlHJ85NPhm+OxtH+52r2/KlOO0QDZdMUG2Oqr4L+/GVJTIzXu3+JieH/VjlTNhRvbf9Zfs+fG5Kcvv9nnun8POMMOGlumQ8c6/tfbXZHb4ypvWrc/ZdXJfRjVCznt80pdSg8HLZIHB0LrO9/ZazXjTGmbpWztKLXO+5yev60fTmNnBzIy4PVq2HWLHjgAWhfUP43gJtuctbl/ewz5zzAev94YXf0xhj/80Hf/x+jYunZLKdkgFdYGDwQk8Ej21M4qaDhNfRaY6wxpv6qoFpIr09i507IyoJVq+B3T8bR7viJHwrH2sYSsT2HiBBulbSqG2NM/VVBtZAIdOwIv/0tPPootPvZezXPST9upU0buPVWZ1BYUXFHoAZSzWN39MaY0FFONc/hVrHcNiyHd96Bw4edD4cnemWQuDiFsGOhUc1jd/TGmIahnIbeJs+mMWsW/Pgj/PvfcO65cNGC1NJJHpzqodRU/8XrJ5bojTGho5LeP02aQGIivPtuxUs2hhpL9MaY0FLFSd7KW7JxV0QMH39cd+EFgiV6Y0zD5KWap+CkaB4/OY0hQ+Dqq53en6HAEr0xpmHyUs0T8Uo6j29L4i9/gUWLnInY/vEPj1469ZT1ujHGGC9ycuC225yEP2QIvP46tGsX6KjKZ71ujDGmmuLi4IMPYPp0Z4qFSV0zONo2rl72uQ/hcWLGGFM7Is6g3N8cyODUB1Jo/FP9nEHT7uiNMaYSnf6ZSmOtv33uLdEbY0xlyul+U1/63FuiN8aYypTT535v45jSC6QHKUv0xhhTGS997vMjo7nnSBopKcHf/dISvTHGVMZLn/vIV9M5/f8l8cor8NBDgQ6wYtbrxhhjqiIp6YQeNpMVdu+Gxx93BlfdcEOAYquE3dEbY0wNiThLGQ4aBLfcAitWBDoi7yzRG2NMLURGwty50KkTjBkDBw4EOqITVZroRSRKRFaJyBoRWScik72UGScie0Qk291u8ThW6LH/XV+/AWOMCbRTT3Xmud+505k2IchmlqlSHf1xYLCq5olIJPCpiPxXVct+SZmjqnd5Of+oqvaudaTGGBPE+vaFqVPhgQfgsstg3LhAR/SLSu/o1ZHnPo10tyD7vDLGmMCbOBEuvhh+/3tnNatgUaU6ehEJF5FsYDfwoaqu9FLsGhFZKyLzRKSzx/4oEckUkRUiMtIXQRtjTDAKC4Np05zZEf7wh0BH84sqJXpVLXSrXzoBfUWkR5ki7wFxqhoPfAjM9DgW606deT3wrIj8quzri0iK+2GQuWfPnhq9EWOMCQZnngkPPgj6RvDMdlmtXjeqegBYAgwvsz9XVY+7T18G+ngc2+H+3AwsBc7x8rrpqpqgqgmtW7eu1hswxphg81BcBi9LCo13b3FaZotnuwxQsq9Kr5vWItLCfdwYuBTYUKZMe4+nVwDfuPtbikgj93Er4CJgvW9CN8aY4HTSpFSig2i2y6r0umkPzBSRcJwPhjdVdb6ITAEyVfVdYIKIXAEUAPuAce65ZwHTRaTIPfcxVbVEb4wJbeXNahmg2S5tKUFjjPG1uDinuqas2FhnjcI6YEsJGmOMP3mZ7VKjo539AWCJ3hhjfM1jtksVIYdYFiemB2zZQZu90hhj6kLxbJcKo/rCweXwTSGEh/s/FLujN8aYOiQC998PmzbB//xPYGKwRG+MMXXs6quhSxd49tnAXN8SvTHG1LHwcGe81PLlsHGj/69vid4YY/wgOdlJ+C+/7P9rW6I3xhg/aNcOfvtbmDkTfv7Zv9e2RG+MMX5yyy3OGrPz5/v3upbojTHGT4YNg44d4ZVX/HtdS/TGGOMnERHOurKLFsHBg/67riV6Y4zxo2uvhfx8eNePK2hbojfGGD86/3zo1AnmzfPfNS3RG2OMH4WFwTXXwMKFcOiQn67pn8sYY4wpdu21cPy4/3rfWKI3xhg/u/BC6NAB3nrLP9ezRG+MMX4WFgYjRsBHHzkNs3V+vbq/hDHGmLKGDXPq6FeurPtrWaI3xpgAGDzYubNfuLDur2WJ3hhjAqBlS6erpSV6Y4wJYcOGQWYm5ObW7XUs0RtjTIAMGwaqTqNsXbJEb4wxAXLeeU4VTl1X31iiN8aYAAkPd7pZ1nUXy4i6fXljjDEVee01ZwHxumR39MYYE0B1neTBEr0xxoQ8S/TGGBPiKk30IhIlIqtEZI2IrBORyV7KjBORPSKS7W63eBxLFpFN7pbs6zdgjDGmYlW5oz8ODFbVXkBvYLiI9PNSbo6q9na3lwFE5BTgEeB8oC/wiIi09FHsxhgTGjIyIC7OmRMhLs557kOVJnp15LlPI91Nq/j6w4APVXWfqu4HPgSG1yhSY4wJRRkZkJICW7Y4o6e2bHGe+zDZV6mOXkTCRSQb2I2TuL3Nt3aNiKwVkXki0tnd1xHY5lFmu7uv7OuniEimiGTu2bOnmm/BGGPqsdRUOHKk9L4jR5z9PlKlRK+qharaG+gE9BWRHmWKvAfEqWo8zl37zOoEoarpqpqgqgmtW7euzqnGGFO/bd1avf01UK1eN6p6AFhCmeoXVc1V1ePu05eBPu7jHUBnj6Kd3H3GGGMAYmKqt78GqtLrprWItHAfNwYuBTaUKdPe4+kVwDfu44XAUBFp6TbCDnX3GWOMAUhLg+jo0vuio539PlKVKRDaAzNFJBzng+FNVZ0vIlOATFV9F5ggIlcABcA+YByAqu4TkUeBL93XmqKq+3wWvTHG1HdJSc7P1FSnuiYmxknyxft9QFSr2oHGPxISEjQzMzPQYRhjTL0iIqtVNcHbMRsZa4wxIc4SvTHGhDhL9MYYE+Is0RtjTIizRG+MMSEu6HrdiMgeYEstXqIVsNdH4dSFYI8Pgj/GYI8PLEZfCPb4ILhijFVVr1MLBF2iry0RySyvi1EwCPb4IPhjDPb4wGL0hWCPD+pHjGBVN8YYE/Is0RtjTIgLxUSfHugAKhHs8UHwxxjs8YHF6AvBHh/UjxhDr47eGGNMaaF4R2+MMcaDJXpjjAlx9SbRi8hwEflWRL4TkQe8HG8kInPc4ytFJM7j2IPu/m9FZFiwxSgil4rIahH5yv05OJji8zgeIyJ5InJfXcRX2xhFJF5EvhCRde7vMiqYYhSRSBGZ6cb2jYg8GKD4BohIlogUiMi1ZY4li8gmd0uui/hqE6OI9Pb4N14rImOCKT6P481FZLuIvFAX8VWbqgb9BoQD3wNdgJOANUD3MmXuBKa5jxOBOe7j7m75RsBp7uuEB1mM5wAd3Mc9gB3BFJ/H8XnAXOC+IPx3jgDWAr3c56cG4b/z9cBs93E0kIOzBKe/44sD4oHXgGs99p8CbHZ/tnQftwzQ77C8GLsCZ7iPOwC7gBbBEp/H8b8DbwAv+Pr3V5OtvtzR9wW+U9XNqvozMBu4skyZK/llrdp5wCUiIu7+2ap6XFV/AL5zXy9oYlTV/1XVne7+dUBjEWkULPEBiMhI4Ac3vrpSmxiHAmtVdQ2ULG9ZGGQxKtBERCKAxsDPwCF/x6eqOaq6Figqc+4w4ENV3aeq+3HWfx6O79U4RlXdqKqb3Mc7gd2Arxears3vEBHpA7QFFvk4rhqrL4m+I7DN4/l2d5/XMqpaABzEuauryrmBjtHTNUCW/rIGb8DjE5GmwJ+AyT6OyWcx4tzpqYgsdL9S3x+EMc4DDuPchW4FnlLfr7hWm7/3YPq/UikR6Ytzx/29j+IqVuP4RCQM+BtQZ9WbNVGVpQSNn4jI2cDjOHenwWQS8Iyq5rk3+MEoAvg1cB5wBPhYnBV3Pg5sWKX0BQpxqhxaAstF5CNV3RzYsOofcdapfh1IVtUT7qoD6E5ggapuD6b/K/Xljn4H0NnjeSd3n9cy7lfjk4HcKp4b6BgRkU7Af4AbVdXXdyi1je984AkRyQHuBR4SkbuCLMbtwDJV3auqR4AFwLlBFuP1wAeqmq+qu4HPAF/Pk1Kbv/dg+r9SLhFpDrwPpKrqCh/HBrWL7wLgLvf/ylPAjSLymG/Dq4FANxJUZcO5W9uM05ha3Dhydpkyv6N0A9ib7uOzKd0Yu5m6aaSrTYwt3PJXB+PvsEyZSdRdY2xtfoctgSycRs4I4CNgRJDF+CfgVfdxE2A9EO/v+DzKzuDExtgf3N9lS/fxKYH4HVYQ40nAx8C9dfE3WNv4yhwbR5A0xgY8gGr88n8DbMSpj0t1900BrnAfR+H0CPkOWAV08Tg31T3vW+CyYIsR+DNO3W22x9YmWOIr8xqTqKNE74N/57E4jcVfA08EW4xAU3f/OpwkPzFA8Z2H8w3oMM43jXUe597kxv0dMD6Av0OvMbr/xvll/q/0Dpb4yrzGOIIk0dsUCMYYE+LqSx29McaYGrJEb4wxIc4SvTHGhDhL9MYYE+Is0RtjTIizRG+MMSHOEr0xxoS4/w/NrH5RQYBshwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -502,12 +485,19 @@ "voltage = solution[\"Terminal voltage [V]\"]\n", "step_voltage = step_solution[\"Terminal voltage [V]\"]\n", "plt.figure()\n", - "plt.plot(solution.t, voltage(solution.t), \"b-\", label=\"SPMe (continuous solve)\")\n", + "plt.plot(solution[\"Time [h]\"].entries, voltage(solution.t), \"b-\", label=\"SPMe (continuous solve)\")\n", "plt.plot(\n", - " step_solution.t, step_voltage(step_solution.t), \"ro\", label=\"SPMe (stepped solve)\"\n", + " step_solution[\"Time [h]\"].entries, step_voltage(step_solution.t), \"ro\", label=\"SPMe (stepped solve)\"\n", ")\n", "plt.legend()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/examples/notebooks/using-submodels.ipynb b/examples/notebooks/using-submodels.ipynb index 86939d2417..e04871cc3c 100644 --- a/examples/notebooks/using-submodels.ipynb +++ b/examples/notebooks/using-submodels.ipynb @@ -40,26 +40,7 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "ename": "DomainError", - "evalue": "Primary broadcast from current collector domain must be to electrode\n or separator", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mDomainError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpybamm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlithium_ion\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSPM\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/models/full_battery_models/lithium_ion/spm.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, options, name, build)\u001b[0m\n\u001b[1;32m 46\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mbuild\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 48\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuild_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 49\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 50\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mset_porosity_submodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/models/full_battery_models/base_battery_model.py\u001b[0m in \u001b[0;36mbuild_model\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 493\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuild_fundamental_and_external\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 494\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 495\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuild_coupled_variables\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 496\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 497\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuild_model_equations\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/models/full_battery_models/base_battery_model.py\u001b[0m in \u001b[0;36mbuild_coupled_variables\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 425\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 426\u001b[0m self.variables.update(\n\u001b[0;32m--> 427\u001b[0;31m \u001b[0msubmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_coupled_variables\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvariables\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 428\u001b[0m )\n\u001b[1;32m 429\u001b[0m \u001b[0msubmodels\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msubmodel_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/models/submodels/particle/fickian/fickian_single_particle.py\u001b[0m in \u001b[0;36mget_coupled_variables\u001b[0;34m(self, variables)\u001b[0m\n\u001b[1;32m 44\u001b[0m T_k_xav = pybamm.PrimaryBroadcast(\n\u001b[1;32m 45\u001b[0m \u001b[0mvariables\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"X-averaged \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdomain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" electrode temperature\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 46\u001b[0;31m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdomain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" particle\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 47\u001b[0m )\n\u001b[1;32m 48\u001b[0m \u001b[0mN_s_xav\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_flux_law\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc_s_xav\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT_k_xav\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/broadcasts.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, child, broadcast_domain, name)\u001b[0m\n\u001b[1;32m 85\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 86\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchild\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbroadcast_domain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 87\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchild\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbroadcast_domain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbroadcast_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"primary\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 88\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 89\u001b[0m def check_and_set_domains(\n", - "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/broadcasts.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, child, broadcast_domain, broadcast_auxiliary_domains, broadcast_type, name)\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0;31m# perform some basic checks and set attributes\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 54\u001b[0m domain, auxiliary_domains = self.check_and_set_domains(\n\u001b[0;32m---> 55\u001b[0;31m \u001b[0mchild\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbroadcast_type\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbroadcast_domain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbroadcast_auxiliary_domains\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 56\u001b[0m )\n\u001b[1;32m 57\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbroadcast_type\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbroadcast_type\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/Energy_storage/PyBaMM/pybamm/expression_tree/broadcasts.py\u001b[0m in \u001b[0;36mcheck_and_set_domains\u001b[0;34m(self, child, broadcast_type, broadcast_domain, broadcast_auxiliary_domains)\u001b[0m\n\u001b[1;32m 102\u001b[0m raise pybamm.DomainError(\n\u001b[1;32m 103\u001b[0m \"\"\"Primary broadcast from current collector domain must be to electrode\n\u001b[0;32m--> 104\u001b[0;31m or separator\"\"\"\n\u001b[0m\u001b[1;32m 105\u001b[0m )\n\u001b[1;32m 106\u001b[0m elif child.domain[0] in [\n", - "\u001b[0;31mDomainError\u001b[0m: Primary broadcast from current collector domain must be to electrode\n or separator" - ] - } - ], + "outputs": [], "source": [ "model = pybamm.lithium_ion.SPM()" ] @@ -73,9 +54,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "external circuit \n", + "porosity \n", + "electrolyte tortuosity \n", + "electrode tortuosity \n", + "convection \n", + "negative interface \n", + "positive interface \n", + "negative particle \n", + "positive particle \n", + "negative electrode \n", + "electrolyte conductivity \n", + "electrolyte diffusion \n", + "positive electrode \n", + "thermal \n", + "current collector \n" + ] + } + ], "source": [ "for name, submodel in model.submodels.items():\n", " print(name, submodel)" @@ -90,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -106,7 +109,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -122,9 +125,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "external circuit \n", + "porosity \n", + "electrolyte tortuosity \n", + "electrode tortuosity \n", + "convection \n", + "negative interface \n", + "positive interface \n", + "negative particle \n", + "positive particle \n", + "negative electrode \n", + "electrolyte conductivity \n", + "electrolyte diffusion \n", + "positive electrode \n", + "thermal \n", + "current collector \n" + ] + } + ], "source": [ "for name, submodel in model.submodels.items():\n", " print(name, submodel)" @@ -139,9 +164,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "model.rhs" ] @@ -155,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -171,9 +207,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{Variable(0x65ae5959b31807d6, Discharge capacity [A.h], children=[], domain=[], auxiliary_domains={}): Division(0x5f50eeb4014eba6e, /, children=['Current function [A] * 96485.33289 * Maximum concentration in negative electrode [mol.m-3] * Negative electrode thickness [m] + Separator thickness [m] + Positive electrode thickness [m] / function (absolute)', '3600.0'], domain=[], auxiliary_domains={}),\n", + " Variable(-0x399950b4aedd9f35, X-averaged negative particle surface concentration, children=[], domain=['current collector'], auxiliary_domains={}): Division(-0x34c10cfd67aea950, /, children=['-3.0 * broadcast(Current function [A] / Typical current [A] * function (sign)) / Negative electrode thickness [m] / Negative electrode thickness [m] + Separator thickness [m] + Positive electrode thickness [m]', 'Negative electrode surface area density [m-1] * Negative particle radius [m]'], domain=['current collector'], auxiliary_domains={}),\n", + " Variable(0x17f4b3f07723f4ba, X-averaged positive particle concentration, children=[], domain=['positive particle'], auxiliary_domains={'secondary': \"['current collector']\"}): Multiplication(0x25c2a4426903dac0, *, children=['-1.0 / Positive particle radius [m] ** 2.0 / Positive electrode diffusivity [m2.s-1] / 96485.33289 * Maximum concentration in negative electrode [mol.m-3] * Negative electrode thickness [m] + Separator thickness [m] + Positive electrode thickness [m] / function (absolute)', 'div(-Positive electrode diffusivity [m2.s-1] / Positive electrode diffusivity [m2.s-1] * grad(X-averaged positive particle concentration))'], domain=['positive particle'], auxiliary_domains={'secondary': \"['current collector']\"})}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "model.rhs" ] @@ -187,9 +236,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# create geometry\n", "geometry = model.default_geometry\n", @@ -207,14 +269,14 @@ "disc.process_model(model)\n", "\n", "# solve model\n", - "t_eval = np.linspace(0, 0.15, 100)\n", + "t_eval = np.linspace(0, 3600, 100)\n", "solution = model.default_solver.solve(model, t_eval)\n", "\n", "# extract voltage\n", "voltage = solution['Terminal voltage [V]']\n", "\n", "# plot\n", - "plt.plot(solution.t, voltage(solution.t))\n", + "plt.plot(solution[\"Time [h]\"](solution.t), voltage(solution.t))\n", "plt.xlabel(r'$t$')\n", "plt.ylabel('Terminal voltage')\n", "plt.show()" @@ -232,7 +294,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -250,7 +312,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -266,7 +328,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -283,7 +345,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -304,7 +366,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -325,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -346,7 +408,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -368,7 +430,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -384,7 +446,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -400,9 +462,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# process model and geometry\n", "param = model.default_parameter_values\n", @@ -417,7 +492,7 @@ "disc.process_model(model)\n", "\n", "# solve model\n", - "t_eval = np.linspace(0, 0.15, 100)\n", + "t_eval = np.linspace(0, 3600, 100)\n", "solver = pybamm.ScipySolver()\n", "solution = solver.solve(model, t_eval)\n", "\n", @@ -425,7 +500,7 @@ "voltage = solution['Terminal voltage [V]']\n", "\n", "# plot\n", - "plt.plot(solution.t, voltage(solution.t))\n", + "plt.plot(solution[\"Time [h]\"](solution.t), voltage(solution.t))\n", "plt.xlabel(r'$t$')\n", "plt.ylabel('Terminal voltage')\n", "plt.show()" diff --git a/examples/scripts/DFN.py b/examples/scripts/DFN.py index 4811df8a19..12eda03ae6 100644 --- a/examples/scripts/DFN.py +++ b/examples/scripts/DFN.py @@ -7,15 +7,15 @@ pybamm.set_logging_level("INFO") + # load model -model = pybamm.lithium_ion.DFN({"operating mode": "voltage"}) +model = pybamm.lithium_ion.DFN() # create geometry geometry = model.default_geometry # load parameter values and process model and geometry param = model.default_parameter_values -param.update({"Voltage function [V]": 4.1}, check_already_exists=False) param.process_model(model) param.process_geometry(geometry) @@ -29,7 +29,7 @@ disc.process_model(model) # solve model -t_eval = np.linspace(0, 0.2, 100) +t_eval = np.linspace(0, 3600, 100) solver = model.default_solver solver.rtol = 1e-3 solver.atol = 1e-6 diff --git a/examples/scripts/SPM_compare_particle_grid.py b/examples/scripts/SPM_compare_particle_grid.py index eb0d8f2a2d..691999fab5 100644 --- a/examples/scripts/SPM_compare_particle_grid.py +++ b/examples/scripts/SPM_compare_particle_grid.py @@ -49,7 +49,7 @@ # solve model solutions = [None] * len(models) -t_eval = np.linspace(0, 0.25, 100) +t_eval = np.linspace(0, 3600, 100) for i, model in enumerate(models): solutions[i] = model.default_solver.solve(model, t_eval) diff --git a/examples/scripts/SPMe.py b/examples/scripts/SPMe.py index ee87649a9c..364c7c0508 100644 --- a/examples/scripts/SPMe.py +++ b/examples/scripts/SPMe.py @@ -5,10 +5,11 @@ import pybamm import numpy as np -pybamm.set_logging_level("INFO") +pybamm.set_logging_level("DEBUG") # load model model = pybamm.lithium_ion.SPMe() +model.convert_to_format = "python" # create geometry geometry = model.default_geometry @@ -25,8 +26,8 @@ disc = pybamm.Discretisation(mesh, model.default_spatial_methods) disc.process_model(model) -# solve model -t_eval = np.linspace(0, 0.2, 100) +# solve model for 1 hour +t_eval = np.linspace(0, 3600, 100) solution = model.default_solver.solve(model, t_eval) # plot diff --git a/examples/scripts/SPMe_SOC.py b/examples/scripts/SPMe_SOC.py index 1d9942cfc3..b52418ef43 100644 --- a/examples/scripts/SPMe_SOC.py +++ b/examples/scripts/SPMe_SOC.py @@ -77,7 +77,7 @@ disc = pybamm.Discretisation(mesh, model.default_spatial_methods) disc.process_model(model) # solve model - t_eval = np.linspace(0, 0.2, 100) + t_eval = np.linspace(0, 3600, 100) sol = model.default_solver.solve(model, t_eval) xpext = sol["Positive electrode average extent of lithiation"] xnext = sol["Negative electrode average extent of lithiation"] diff --git a/examples/scripts/SPMe_step.py b/examples/scripts/SPMe_step.py index e1cf9a3e1f..0f21e92aae 100644 --- a/examples/scripts/SPMe_step.py +++ b/examples/scripts/SPMe_step.py @@ -26,12 +26,12 @@ disc.process_model(model) # solve model -t_eval = np.linspace(0, 0.2, 100) +t_eval = np.linspace(0, 3600, 100) solver = model.default_solver solution = solver.solve(model, t_eval) # step model -dt = 0.05 +dt = 500 time = 0 end_time = solution.t[-1] step_solver = model.default_solver diff --git a/examples/scripts/compare-dae-solver.py b/examples/scripts/compare-dae-solver.py index 9bf4dcabb3..8b3a467a26 100644 --- a/examples/scripts/compare-dae-solver.py +++ b/examples/scripts/compare-dae-solver.py @@ -24,7 +24,7 @@ disc.process_model(model) # solve model -t_eval = np.linspace(0, 0.25, 100) +t_eval = np.linspace(0, 3600, 100) casadi_sol = pybamm.CasadiSolver(atol=1e-8, rtol=1e-8).solve(model, t_eval) solutions = [casadi_sol] diff --git a/examples/scripts/compare_SPM_diffusion_models.py b/examples/scripts/compare_SPM_diffusion_models.py index bac771b7a2..6e0530e260 100644 --- a/examples/scripts/compare_SPM_diffusion_models.py +++ b/examples/scripts/compare_SPM_diffusion_models.py @@ -42,7 +42,7 @@ # solve model solutions = [None] * len(models) -t_eval = np.linspace(0, 0.25, 100) +t_eval = np.linspace(0, 3600, 100) for i, model in enumerate(models): solutions[i] = model.default_solver.solve(model, t_eval) diff --git a/examples/scripts/compare_comsol/compare_comsol_DFN.py b/examples/scripts/compare_comsol/compare_comsol_DFN.py index f11d26245f..682a848ccf 100644 --- a/examples/scripts/compare_comsol/compare_comsol_DFN.py +++ b/examples/scripts/compare_comsol/compare_comsol_DFN.py @@ -46,11 +46,8 @@ disc = pybamm.Discretisation(mesh, pybamm_model.default_spatial_methods) disc.process_model(pybamm_model) -# discharge timescale -tau = param.process_symbol(pybamm.standard_parameters_lithium_ion.tau_discharge) - # solve model at comsol times -time = comsol_variables["time"] / tau.evaluate(0) +time = comsol_variables["time"] pybamm_solution = pybamm.CasadiSolver(mode="fast").solve(pybamm_model, time) @@ -91,7 +88,7 @@ def myinterp(t): ) # Make sure to use dimensional time - fun = pybamm.Function(myinterp, pybamm.t * tau, name=variable_name + "_comsol") + fun = pybamm.Function(myinterp, pybamm.t, name=variable_name + "_comsol") fun.domain = domain fun.mesh = mesh.combine_submeshes(*domain) fun.secondary_mesh = None @@ -111,7 +108,7 @@ def myinterp(t): fill_value="extrapolate", bounds_error=False, ), - pybamm.t * tau, + pybamm.t, ) comsol_voltage.mesh = None comsol_voltage.secondary_mesh = None diff --git a/examples/scripts/compare_comsol/discharge_curve.py b/examples/scripts/compare_comsol/discharge_curve.py index 7205f4ac85..d400e1b54e 100644 --- a/examples/scripts/compare_comsol/discharge_curve.py +++ b/examples/scripts/compare_comsol/discharge_curve.py @@ -58,15 +58,8 @@ comsol_time = comsol_variables["time"] comsol_voltage = comsol_variables["voltage"] - # update current density - - # discharge timescale - tau = param.process_symbol( - pybamm.standard_parameters_lithium_ion.tau_discharge - ).evaluate(0, 0) - # solve model at comsol times - t = comsol_time / tau + t = comsol_time solution = pybamm.CasadiSolver(mode="fast").solve( model, t, inputs={"Current function [A]": current} ) diff --git a/examples/scripts/compare_lead_acid.py b/examples/scripts/compare_lead_acid.py index cac469e749..fe9ea46768 100644 --- a/examples/scripts/compare_lead_acid.py +++ b/examples/scripts/compare_lead_acid.py @@ -41,7 +41,7 @@ # solve model solutions = [None] * len(models) -t_eval = np.linspace(0, 1, 1000) +t_eval = np.linspace(0, 3600 * 2, 1000) for i, model in enumerate(models): solution = model.default_solver.solve(model, t_eval) solutions[i] = solution diff --git a/examples/scripts/compare_lead_acid_3D.py b/examples/scripts/compare_lead_acid_3D.py index 5b3f0e93bc..4828408b28 100644 --- a/examples/scripts/compare_lead_acid_3D.py +++ b/examples/scripts/compare_lead_acid_3D.py @@ -77,7 +77,7 @@ # solve model solutions = [None] * len(models) -t_eval = np.linspace(0, 3, 1000) +t_eval = np.linspace(0, 3600 * 15, 1000) for i, model in enumerate(models): solution = model.default_solver.solve(model, t_eval) solutions[i] = solution diff --git a/examples/scripts/compare_lithium_ion.py b/examples/scripts/compare_lithium_ion.py index 53459a036c..7f5dac6b58 100644 --- a/examples/scripts/compare_lithium_ion.py +++ b/examples/scripts/compare_lithium_ion.py @@ -26,7 +26,7 @@ # load parameter values and process models and geometry param = models[0].default_parameter_values -param["Current function [A]"] = 1.0 +param["Current function [A]"] = 1 for model in models: param.process_model(model) @@ -46,7 +46,7 @@ # solve model solutions = [None] * len(models) -t_eval = np.linspace(0, 0.3, 100) +t_eval = np.linspace(0, 3600, 100) for i, model in enumerate(models): solutions[i] = model.default_solver.solve(model, t_eval) diff --git a/examples/scripts/compare_lithium_ion_3D.py b/examples/scripts/compare_lithium_ion_3D.py index 1ef238e541..a28a5ebce3 100644 --- a/examples/scripts/compare_lithium_ion_3D.py +++ b/examples/scripts/compare_lithium_ion_3D.py @@ -50,7 +50,7 @@ # solve model solutions = [None] * len(models) -t_eval = np.linspace(0, 1, 1000) +t_eval = np.linspace(0, 3600, 1000) for i, model in enumerate(models): solution = model.default_solver.solve(model, t_eval) solutions[i] = solution diff --git a/examples/scripts/compare_lithium_ion_particle_distribution.py b/examples/scripts/compare_lithium_ion_particle_distribution.py index cbe9158a25..334682b035 100644 --- a/examples/scripts/compare_lithium_ion_particle_distribution.py +++ b/examples/scripts/compare_lithium_ion_particle_distribution.py @@ -59,7 +59,7 @@ def positive_distribution(x): # solve model solutions = [None] * len(models) -t_eval = np.linspace(0, 0.3, 100) +t_eval = np.linspace(0, 3600, 100) for i, model in enumerate(models): solutions[i] = model.default_solver.solve(model, t_eval) diff --git a/examples/scripts/custom_model.py b/examples/scripts/custom_model.py index a32894ebc3..5e6f084e2c 100644 --- a/examples/scripts/custom_model.py +++ b/examples/scripts/custom_model.py @@ -63,7 +63,7 @@ disc.process_model(model) # solve model -t_eval = np.linspace(0, 0.2, 100) +t_eval = np.linspace(0, 3600, 100) solver = pybamm.ScipySolver() solution = solver.solve(model, t_eval) diff --git a/examples/scripts/drive_cycle.py b/examples/scripts/drive_cycle.py new file mode 100644 index 0000000000..1e9c708dad --- /dev/null +++ b/examples/scripts/drive_cycle.py @@ -0,0 +1,17 @@ +# +# Simulate drive cycle loaded from csv file +# +import pybamm + +# load model and update parameters so the input current is the US06 drive cycle +model = pybamm.lithium_ion.DFN() +param = model.default_parameter_values +param["Current function [A]"] = "[current data]US06" + +# create and run simulation using the CasadiSolver in "fast" mode, remembering to +# pass in the updated parameters +sim = pybamm.Simulation( + model, parameter_values=param, solver=pybamm.CasadiSolver(mode="fast") +) +sim.solve() +sim.plot() diff --git a/examples/scripts/experimental_protocols/cccv.py b/examples/scripts/experimental_protocols/cccv.py new file mode 100644 index 0000000000..c20dc90b68 --- /dev/null +++ b/examples/scripts/experimental_protocols/cccv.py @@ -0,0 +1,64 @@ +# +# Constant-current constant-voltage charge +# +import pybamm +import matplotlib.pyplot as plt + +pybamm.set_logging_level("INFO") +experiment = pybamm.Experiment( + [ + "Discharge at C/10 for 13 hours or until 3.3 V", + "Rest for 1 hour", + "Charge at 1 A until 4.1 V", + "Hold at 4.1 V until 50 mA", + "Rest for 1 hour", + ] + * 3, + period="2 minutes", +) +model = pybamm.lithium_ion.DFN() # use {"thermal": "x-lumped"} for thermal effects +sim = pybamm.Simulation(model, experiment=experiment, solver=pybamm.CasadiSolver()) +sim.solve() + +# Plot voltages from the discharge segments only +fig, ax = plt.subplots() +for i in range(3): + # Extract sub solutions + sol = sim.solution.sub_solutions[i * 5] + # Extract variables + t = sol["Time [h]"].entries + V = sol["Terminal voltage [V]"].entries + # Plot + ax.plot(t - t[0], V, label="Discharge {}".format(i + 1)) + ax.set_xlabel("Time [h]") + ax.set_ylabel("Voltage [V]") + ax.set_xlim([0, 13]) +ax.legend() + +# Save time, voltage, current, discharge capacity and temperature to csv and matlab +# formats +sim.solution.save_data( + "output.mat", + [ + "Time [h]", + "Current [A]", + "Terminal voltage [V]", + "Discharge capacity [A.h]", + "X-averaged cell temperature [K]", + ], + to_format="matlab", +) +sim.solution.save_data( + "output.csv", + [ + "Time [h]", + "Current [A]", + "Terminal voltage [V]", + "Discharge capacity [A.h]", + "X-averaged cell temperature [K]", + ], + to_format="csv", +) + +# Show all plots +sim.plot() diff --git a/examples/scripts/experimental_protocols/cccv_lead_acid.py b/examples/scripts/experimental_protocols/cccv_lead_acid.py new file mode 100644 index 0000000000..4614fd514b --- /dev/null +++ b/examples/scripts/experimental_protocols/cccv_lead_acid.py @@ -0,0 +1,19 @@ +# +# Constant-current constant-voltage charge +# +import pybamm + +pybamm.set_logging_level("INFO") +experiment = pybamm.Experiment( + [ + "Discharge at C/2 until 11 V", + "Rest for 1 hour", + "Charge at C/2 until 14.5 V", + "Hold at 14.5 V until 200 mA", + "Rest for 1 hour", + ] +) +model = pybamm.lead_acid.Full() +sim = pybamm.Simulation(model, experiment=experiment, solver=pybamm.CasadiSolver()) +sim.solve() +sim.plot() diff --git a/examples/scripts/experimental_protocols/gitt.py b/examples/scripts/experimental_protocols/gitt.py new file mode 100644 index 0000000000..dfebc70965 --- /dev/null +++ b/examples/scripts/experimental_protocols/gitt.py @@ -0,0 +1,13 @@ +# +# GITT discharge +# +import pybamm + +pybamm.set_logging_level("INFO") +experiment = pybamm.Experiment( + ["Discharge at C/20 for 1 hour", "Rest for 1 hour"] * 20, +) +model = pybamm.lithium_ion.DFN() +sim = pybamm.Simulation(model, experiment=experiment, solver=pybamm.CasadiSolver()) +sim.solve() +sim.plot() diff --git a/examples/scripts/nca_parameters.py b/examples/scripts/nca_parameters.py new file mode 100644 index 0000000000..7e9100822e --- /dev/null +++ b/examples/scripts/nca_parameters.py @@ -0,0 +1,11 @@ +import pybamm as pb + +pb.set_logging_level("INFO") +model = pb.lithium_ion.DFN() + +chemistry = pb.parameter_sets.NCA_Kim2011 +parameter_values = pb.ParameterValues(chemistry=chemistry) + +sim = pb.Simulation(model, parameter_values=parameter_values, C_rate=1) +sim.solve() +sim.plot() diff --git a/examples/scripts/thermal_lithium_ion.py b/examples/scripts/thermal_lithium_ion.py index eb55ca07b7..f9766b4f0d 100644 --- a/examples/scripts/thermal_lithium_ion.py +++ b/examples/scripts/thermal_lithium_ion.py @@ -38,7 +38,7 @@ # solve model solutions = [None] * len(models) -t_eval = np.linspace(0, 0.25, 100) +t_eval = np.linspace(0, 3600, 100) for i, model in enumerate(models): solver = pybamm.ScipySolver(atol=1e-8, rtol=1e-8) solution = solver.solve(model, t_eval) diff --git a/input/parameters/lithium-ion/anodes/graphite_Kim2011/README.md b/input/parameters/lithium-ion/anodes/graphite_Kim2011/README.md new file mode 100644 index 0000000000..0105517f0b --- /dev/null +++ b/input/parameters/lithium-ion/anodes/graphite_Kim2011/README.md @@ -0,0 +1,7 @@ +# Graphite anode parameters + +Parameters for a graphite anode, from the paper + +> Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. (2011). Multi-domain modeling of lithium-ion batteries encompassing multi-physics in varied length scales. Journal of The Electrochemical Society, 158(8), A955-A969. + +Note, only an effective cell volumetric heat capacity is provided in the paper. We therefore used the values for the density and specific heat capacity reported in the Marquis2019 parameter set in each region and multiplied each density by the ratio of the volumetric heat capacity provided in smith to the calculated value. This ensures that the values produce the same effective cell volumetric heat capacity. This works fine for x-lumped thermal models but not for x-full thermal models. We do the same for the planar effective thermal conductivity. diff --git a/input/parameters/lithium-ion/anodes/graphite_Kim2011/graphite_diffusivity_Kim2011.py b/input/parameters/lithium-ion/anodes/graphite_Kim2011/graphite_diffusivity_Kim2011.py new file mode 100644 index 0000000000..11373e0f50 --- /dev/null +++ b/input/parameters/lithium-ion/anodes/graphite_Kim2011/graphite_diffusivity_Kim2011.py @@ -0,0 +1,37 @@ +from pybamm import exp + + +def graphite_diffusivity_Kim2011(sto, T, T_inf, E_D_s, R_g): + """ + Graphite diffusivity [1]. + + References + ---------- + .. [1] Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. + (2011). Multi-domain modeling of lithium-ion batteries encompassing + multi-physics in varied length scales. Journal of The Electrochemical + Society, 158(8), A955-A969. + + Parameters + ---------- + sto: :class: `numpy.Array` + Electrode stochiometry + T: :class: `numpy.Array` + Dimensional temperature + T_inf: double + Reference temperature + E_D_s: double + Solid diffusion activation energy + R_g: double + The ideal gas constant + + Returns + ------- + : double + Solid diffusivity + """ + + D_ref = 9 * 10 ** (-14) + arrhenius = exp(E_D_s / R_g * (1 / T_inf - 1 / T)) + + return D_ref * arrhenius diff --git a/input/parameters/lithium-ion/anodes/graphite_Kim2011/graphite_electrolyte_reaction_rate_Kim2011.py b/input/parameters/lithium-ion/anodes/graphite_Kim2011/graphite_electrolyte_reaction_rate_Kim2011.py new file mode 100644 index 0000000000..b942801b2d --- /dev/null +++ b/input/parameters/lithium-ion/anodes/graphite_Kim2011/graphite_electrolyte_reaction_rate_Kim2011.py @@ -0,0 +1,48 @@ +from pybamm import exp + + +def graphite_electrolyte_reaction_rate_Kim2011(T, T_inf, E_r, R_g): + """ + Reaction rate for Butler-Volmer reactions between graphite and LiPF6 in EC:DMC + [1]. + + References + ---------- + .. [1] Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. + (2011). Multi-domain modeling of lithium-ion batteries encompassing + multi-physics in varied length scales. Journal of The Electrochemical + Society, 158(8), A955-A969. + + Parameters + ---------- + T: :class: `numpy.Array` + Dimensional temperature + T_inf: double + Reference temperature + E_r: double + Reaction activation energy + R_g: double + The ideal gas constant + + Returns + ------- + :`numpy.Array` + Reaction rate + """ + + i0_ref = 36 # reference exchange current density at 100% SOC + sto = 0.36 # stochiometry at 100% SOC + c_s_n_max = 2.87 * 10 ** 4 # max electrode concentration + c_s_n_ref = sto * c_s_n_max # reference electrode concentration + c_e_ref = 1.2 * 10 ** 3 # reference electrolyte concentration + alpha = 0.5 # charge transfer coefficient + + m_ref = ( + 2 + * i0_ref + / (c_e_ref ** alpha * (c_s_n_max - c_s_n_ref) ** alpha * c_s_n_ref ** alpha) + ) + + arrhenius = exp(E_r / R_g * (1 / T_inf - 1 / T)) + + return m_ref * arrhenius diff --git a/input/parameters/lithium-ion/anodes/graphite_Kim2011/graphite_ocp_Kim2011.py b/input/parameters/lithium-ion/anodes/graphite_Kim2011/graphite_ocp_Kim2011.py new file mode 100644 index 0000000000..0cbab00dde --- /dev/null +++ b/input/parameters/lithium-ion/anodes/graphite_Kim2011/graphite_ocp_Kim2011.py @@ -0,0 +1,29 @@ +from pybamm import exp, tanh + + +def graphite_ocp_Kim2011(sto): + """ + Graphite Open Circuit Potential (OCP) as a function of the stochiometry [1]. + + References + ---------- + .. [1] Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. + (2011). Multi-domain modeling of lithium-ion batteries encompassing + multi-physics in varied length scales. Journal of The Electrochemical + Society, 158(8), A955-A969. + """ + + u_eq = ( + 0.124 + + 1.5 * exp(-70 * sto) + - 0.0351 * tanh((sto - 0.286) / 0.083) + - 0.0045 * tanh((sto - 0.9) / 0.119) + - 0.035 * tanh((sto - 0.99) / 0.05) + - 0.0147 * tanh((sto - 0.5) / 0.034) + - 0.102 * tanh((sto - 0.194) / 0.142) + - 0.022 * tanh((sto - 0.98) / 0.0164) + - 0.011 * tanh((sto - 0.124) / 0.0226) + + 0.0155 * tanh((sto - 0.105) / 0.029) + ) + + return u_eq diff --git a/input/parameters/lithium-ion/anodes/graphite_Kim2011/parameters.csv b/input/parameters/lithium-ion/anodes/graphite_Kim2011/parameters.csv new file mode 100644 index 0000000000..12af026ee2 --- /dev/null +++ b/input/parameters/lithium-ion/anodes/graphite_Kim2011/parameters.csv @@ -0,0 +1,38 @@ +Name [units],Value,Reference,Notes +# Empty rows and rows starting with ‘#’ will be ignored,,, +,,, +# Electrode properties,,, +Negative electrode conductivity [S.m-1],100,, +Maximum concentration in negative electrode [mol.m-3],2.87E4,, +Negative electrode diffusivity [m2.s-1],[function]graphite_diffusivity_Kim2011,, +Negative electrode OCP [V],[function]graphite_ocp_Kim2011, +,,, +# Microstructure,,, +Negative electrode porosity,0.4,, +Negative electrode active material volume fraction,0.51,, +Negative particle radius [m],5.083E-7,, +Negative particle distribution in x,1,, +Negative electrode surface area density [m-1],3.01E6,, +Negative electrode Bruggeman coefficient (electrolyte),2,, +Negative electrode Bruggeman coefficient (electrode),2,, +,,, +# Interfacial reactions,,, +Negative electrode cation signed stoichiometry,-1,, +Negative electrode electrons in reaction,1,, +Reference OCP vs SHE in the negative electrode [V],,, +Negative electrode charge transfer coefficient,0.5,, +Negative electrode double-layer capacity [F.m-2],0.2,Not reported in Kim2011, +,,, +# Density,,, +Negative electrode density [kg.m-3],2136.43638,1657 * 1.28934, +,,, +# Thermal parameters,,, +Negative electrode specific heat capacity [J.kg-1.K-1],700,, +Negative electrode thermal conductivity [W.m-1.K-1],1.1339,1.7 * 0.667, +Negative electrode OCP entropic change [V.K-1],0,, +,,, +# Activation energies,,, +Reference temperature [K],298.15,25C, +Negative electrode reaction rate,[function]graphite_electrolyte_reaction_rate_Kim2011,, +Negative reaction rate activation energy [J.mol-1],3E4,, +Negative solid diffusion activation energy [J.mol-1],4E3,, diff --git a/input/parameters/lithium-ion/anodes/graphite_mcmb2528_Marquis2019/parameters.csv b/input/parameters/lithium-ion/anodes/graphite_mcmb2528_Marquis2019/parameters.csv index 9a5fcbcd21..260a2f62e5 100644 --- a/input/parameters/lithium-ion/anodes/graphite_mcmb2528_Marquis2019/parameters.csv +++ b/input/parameters/lithium-ion/anodes/graphite_mcmb2528_Marquis2019/parameters.csv @@ -19,7 +19,6 @@ Negative electrode Bruggeman coefficient (electrode),1.5,Scott Moura FastDFN, # Interfacial reactions,,, Negative electrode cation signed stoichiometry,-1,, Negative electrode electrons in reaction,1,, -Negative electrode reference exchange-current density [A.m-2(m3.mol)1.5],2E-05,Scott Moura FastDFN,Be careful how we implement BV Reference OCP vs SHE in the negative electrode [V],,, Negative electrode charge transfer coefficient,0.5,Scott Moura FastDFN, Negative electrode double-layer capacity [F.m-2],0.2,, diff --git a/input/parameters/lithium-ion/cathodes/lico2_Marquis2019/parameters.csv b/input/parameters/lithium-ion/cathodes/lico2_Marquis2019/parameters.csv index 1eafb9b658..f906faad48 100644 --- a/input/parameters/lithium-ion/cathodes/lico2_Marquis2019/parameters.csv +++ b/input/parameters/lithium-ion/cathodes/lico2_Marquis2019/parameters.csv @@ -19,7 +19,6 @@ Positive electrode Bruggeman coefficient (electrode),1.5,Scott Moura FastDFN, # Interfacial reactions,,, Positive electrode cation signed stoichiometry,-1,, Positive electrode electrons in reaction,1,, -Positive electrode reference exchange-current density [A.m-2(m3.mol)1.5],6E-07,Scott Moura FastDFN,Be careful how we implement BV Reference OCP vs SHE in the positive electrode [V],,, Positive electrode charge transfer coefficient,0.5,Scott Moura FastDFN, Positive electrode double-layer capacity [F.m-2],0.2,, diff --git a/input/parameters/lithium-ion/cathodes/nca_Kim2011/README.md b/input/parameters/lithium-ion/cathodes/nca_Kim2011/README.md new file mode 100644 index 0000000000..f816226d21 --- /dev/null +++ b/input/parameters/lithium-ion/cathodes/nca_Kim2011/README.md @@ -0,0 +1,8 @@ +# Nickel Cobalt Aluminium (NCA) cathode parameters + +Parameters for an NCA cathode, from the paper + +> Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. (2011). Multi-domain modeling of lithium-ion batteries encompassing multi-physics in varied length scales. Journal of The Electrochemical Society, 158(8), A955-A969. + +Note, only an effective cell volumetric heat capacity is provided in the paper. We therefore used the values for the density and specific heat capacity reported in the Marquis2019 parameter set in each region and multiplied each density by the ratio of the volumetric heat capacity provided in smith to the calculated value. This ensures that the values produce the same effective cell volumetric heat capacity. This works fine for x-lumped thermal models but not for x-full thermal models. We do the same for the planar effective thermal conductivity. + diff --git a/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_diffusivity_Kim2011.py b/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_diffusivity_Kim2011.py new file mode 100644 index 0000000000..2cd18b310e --- /dev/null +++ b/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_diffusivity_Kim2011.py @@ -0,0 +1,37 @@ +from pybamm import exp + + +def nca_diffusivity_Kim2011(sto, T, T_inf, E_D_s, R_g): + """ + NCA diffusivity as a function of stochiometry [1]. + + References + ---------- + .. [1] Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. + (2011). Multi-domain modeling of lithium-ion batteries encompassing + multi-physics in varied length scales. Journal of The Electrochemical + Society, 158(8), A955-A969. + + Parameters + ---------- + sto: :class: `numpy.Array` + Electrode stochiometry + T: :class: `numpy.Array` + Dimensional temperature + T_inf: double + Reference temperature + E_D_s: double + Solid diffusion activation energy + R_g: double + The ideal gas constant + + Returns + ------- + : double + Solid diffusivity + """ + + D_ref = 3 * 10 ** (-15) + arrhenius = exp(E_D_s / R_g * (1 / T_inf - 1 / T)) + + return D_ref * arrhenius diff --git a/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_electrolyte_reaction_rate_Kim2011.py b/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_electrolyte_reaction_rate_Kim2011.py new file mode 100644 index 0000000000..9dd468a39f --- /dev/null +++ b/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_electrolyte_reaction_rate_Kim2011.py @@ -0,0 +1,46 @@ +from pybamm import exp + + +def nca_electrolyte_reaction_rate_Kim2011(T, T_inf, E_r, R_g): + """ + Reaction rate for Butler-Volmer reactions between NCA and LiPF6 in EC:DMC + [1]. + + References + ---------- + .. [1] Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. + (2011). Multi-domain modeling of lithium-ion batteries encompassing + multi-physics in varied length scales. Journal of The Electrochemical + Society, 158(8), A955-A969. + + Parameters + ---------- + T: :class: `numpy.Array` + Dimensional temperature + T_inf: double + Reference temperature + E_r: double + Reaction activation energy + R_g: double + The ideal gas constant + + Returns + ------- + : double + Reaction rate + """ + i0_ref = 4 # reference exchange current density at 100% SOC + sto = 0.41 # stochiometry at 100% SOC + c_s_max = 4.9 * 10 ** 4 # max electrode concentration + c_s_ref = sto * c_s_max # reference electrode concentration + c_e_ref = 1.2 * 10 ** 3 # reference electrolyte concentration + alpha = 0.5 # charge transfer coefficient + + m_ref = ( + 2 + * i0_ref + / (c_e_ref ** alpha * (c_s_max - c_s_ref) ** alpha * c_s_ref ** alpha) + ) + arrhenius = exp(E_r / R_g * (1 / T_inf - 1 / T)) + + return m_ref * arrhenius diff --git a/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_ocp_Kim2011_data.csv b/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_ocp_Kim2011_data.csv new file mode 100644 index 0000000000..dd00060753 --- /dev/null +++ b/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_ocp_Kim2011_data.csv @@ -0,0 +1,75 @@ +0.370214428274133, 4.210440859985937 +0.37577436378229034, 4.198214873372019 +0.3836904770360269, 4.182142025684674 +0.3918959828337426, 4.165163132847251 +0.40106922140226364, 4.149604765177982 +0.40686180736573874, 4.138286599370602 +0.4116896199858422, 4.129799619141419 +0.4194137255876832, 4.115653556008545 +0.4266554445178383, 4.10292308566477 +0.4329304171529992, 4.090189327068291 +0.4396907358872798, 4.0802916864290655 +0.44548430832656627, 4.070390757537136 +0.4532103868800297, 4.059079168235163 +0.45852157264763016, 4.050593832132332 +0.4628660121202365, 4.042105207776797 +0.4710764502970082, 4.032212499516627 +0.47638763606460877, 4.023727163413795 +0.4836313279463863, 4.013831166900922 +0.48942490038567266, 4.0039302380089925 +0.4981187117099415, 3.994039173875174 +0.5077763099017708, 3.979899687247709 +0.5164711077018508, 3.971425860029342 +0.5280592390562348, 3.9530412391609326 +0.537716837248064, 3.938901752533467 +0.5493089145056929, 3.9261860793268606 +0.5565516199116592, 3.914872845898536 +0.5671749779226715, 3.8993194106083244 +0.5768345490661232, 3.88801439781176 +0.5869745339296383, 3.872459318395196 +0.5961487589739706, 3.8583181876413786 +0.6087065960507823, 3.844188565772025 +0.6159493014567486, 3.832875332343701 +0.6246431127810175, 3.822984268209883 +0.6352684437436521, 3.8102653067505723 +0.6463781343295951, 3.798965226333064 +0.660386090848898, 3.784840536842767 +0.6763275399581893, 3.7707224238578783 +0.6917856159199836, 3.756602666746637 +0.7038630392767319, 3.7467231114972837 +0.7246372333851825, 3.7312042028604644 +0.7391305360036051, 3.71991563132742 +0.7531414519503417, 3.710042652583475 +0.7676347545687643, 3.698754081050431 +0.7797121779255124, 3.6888745258010776 +0.7917886148064496, 3.677577733636274 +0.8043484248348838, 3.6662825855978216 +0.8144923556016439, 3.65639645384306 +0.8260854193350838, 3.645098017551904 +0.8357449904785356, 3.6337930047553395 +0.8463732808686039, 3.6253257540423807 +0.8560318655362443, 3.612603504330366 +0.8652100364838214, 3.604131321238351 +0.8739028613322789, 3.5928230201890825 +0.8840477785748505, 3.5843541253497717 +0.8927425763749305, 3.5758802981314046 +0.9024031339941933, 3.5659925222502906 +0.9125490377125759, 3.5589408643264306 +0.9222105818076499, 3.5504703253607675 +0.9338056184927125, 3.5420063629005125 +0.9482959616837011, 3.526466080621117 +0.957951586923908, 3.5094921201627503 +0.965192319378252, 3.495344412903525 +0.9709740541078039, 3.4684366410261873 +0.9743448419547373, 3.450024070009794 +0.976744937603432, 3.425939263078894 +0.9805892338397507, 3.393355967034346 +0.9820196237660176, 3.36501616110439 +0.9834510001680955, 3.3380935920898844 +0.9848843495217959, 3.3140054969062804 +0.9858323527763772, 3.287081283765423 +0.987258796799399, 3.2530725301736645 +0.9896421223593032, 3.204894695680104 +0.9905703960976598, 3.1496257442302342 +0.9915055751666949, 3.104277451188519 +0.9933828386354436, 3.023501523513243 \ No newline at end of file diff --git a/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_ocp_Kim2011_function.py b/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_ocp_Kim2011_function.py new file mode 100644 index 0000000000..8366020f0f --- /dev/null +++ b/input/parameters/lithium-ion/cathodes/nca_Kim2011/nca_ocp_Kim2011_function.py @@ -0,0 +1,37 @@ +from pybamm import exp + + +def nca_ocp_Kim2011_function(sto): + """ + NCA open-circuit potential (OCP) [1]. Fit in paper seems wrong to using + nca_ocp_Kim2011_data.csv instead. + References + ---------- + .. [1] Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. + (2011). Multi-domain modeling of lithium-ion batteries encompassing + multi-physics in varied length scales. Journal of The Electrochemical + Society, 158(8), A955-A969. + + Parameters + ---------- + sto: double + Stochiometry of material (li-fraction) + + """ + + u_eq = ( + 1.68 * sto ** 10 + - 2.222 * sto ** 9 + + 15.056 * sto ** 8 + - 23.488 * sto ** 7 + + 81.246 * sto ** 6 + - 344.566 * sto ** 5 + + 621.3475 * sto ** 4 + - 544.774 * sto ** 3 + + 264.427 * sto ** 2 + - 66.3691 * sto + + 11.8058 + - 0.61386 * exp(5.8201 * sto ** 136.4) + ) + + return u_eq diff --git a/input/parameters/lithium-ion/cathodes/nca_Kim2011/parameters.csv b/input/parameters/lithium-ion/cathodes/nca_Kim2011/parameters.csv new file mode 100644 index 0000000000..d152be0362 --- /dev/null +++ b/input/parameters/lithium-ion/cathodes/nca_Kim2011/parameters.csv @@ -0,0 +1,38 @@ +Name [units],Value,Reference,Notes +# Empty rows and rows starting with ‘#’ will be ignored,,, +,,, +# Electrode properties,,, +Positive electrode conductivity [S.m-1],10,, +Maximum concentration in positive electrode [mol.m-3],4.9E4,, +Positive electrode diffusivity [m2.s-1],[function]nca_diffusivity_Kim2011,, +Positive electrode OCP [V],[data]nca_ocp_Kim2011_data, +,,, +# Microstructure,,, +Positive electrode porosity,0.4,, +Positive electrode active material volume fraction,0.41,, +Positive particle radius [m],1.633E-6,, +Positive particle distribution in x,1,, +Positive electrode surface area density [m-1],0.753E6,, +Positive electrode Bruggeman coefficient (electrolyte),2,, +Positive electrode Bruggeman coefficient (electrode),2,, +,,, +# Interfacial reactions,,, +Positive electrode cation signed stoichiometry,-1,, +Positive electrode electrons in reaction,1,, +Reference OCP vs SHE in the positive electrode [V],,, +Positive electrode charge transfer coefficient,0.5,, +Positive electrode double-layer capacity [F.m-2],0.2, Not provided in Kim2011, +,,, +# Density,,, +Positive electrode density [kg.m-3],4205.82708, 3262 * 1.28934, +,,, +# Thermal parameters,,, +Positive electrode specific heat capacity [J.kg-1.K-1],700,, +Positive electrode thermal conductivity [W.m-1.K-1],1.4007, 2.1 * 0.667, +Positive electrode OCP entropic change [V.K-1],0,, +,,, +# Activation energies,,, +Reference temperature [K],298.15,25C, +Positive electrode reaction rate,[function]nca_electrolyte_reaction_rate_Kim2011,, +Positive reaction rate activation energy [J.mol-1],3E4,, +Positive solid diffusion activation energy [J.mol-1],2E4,, diff --git a/input/parameters/lithium-ion/cells/Kim2011/README.md b/input/parameters/lithium-ion/cells/Kim2011/README.md new file mode 100644 index 0000000000..4cc9794415 --- /dev/null +++ b/input/parameters/lithium-ion/cells/Kim2011/README.md @@ -0,0 +1,6 @@ +# Pouch cell parameters + +Parameters for a "Nominal Design" pouch cell, from the paper + +> Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. (2011). Multi-domain modeling of lithium-ion batteries encompassing multi-physics in varied length scales. Journal of The Electrochemical Society, 158(8), A955-A969. + diff --git a/input/parameters/lithium-ion/cells/Kim2011/parameters.csv b/input/parameters/lithium-ion/cells/Kim2011/parameters.csv new file mode 100644 index 0000000000..1091bea8a3 --- /dev/null +++ b/input/parameters/lithium-ion/cells/Kim2011/parameters.csv @@ -0,0 +1,37 @@ +Name [units],Value,Reference,Notes +# Empty rows and rows starting with ‘#’ will be ignored,,, +,,, +# Macroscale geometry,,, +Negative current collector thickness [m],10E-6,, +Negative electrode thickness [m],70E-6,, +Separator thickness [m],25E-6,, +Positive electrode thickness [m],50E-6,, +Positive current collector thickness [m],10E-6,, +Electrode height [m],0.2,, +Electrode width [m],0.14,, +Negative tab width [m],0.044,, +Negative tab centre y-coordinate [m],0.013,, +Negative tab centre z-coordinate [m],0.2, At top, +Positive tab width [m],0.044,, +Positive tab centre y-coordinate [m],0.137,, +Positive tab centre z-coordinate [m],0.2,At top, +,,, +# Current collector properties ,,, +Negative current collector conductivity [S.m-1],59.6E6,, +Positive current collector conductivity [S.m-1],37.8E6,, +,,, +# Density,,, +Negative current collector density [kg.m-3],11544.75, 8954 * 1.28934, +Positive current collector density [kg.m-3],3490.24338, 2707 * 1.28934, +,,, +# Specific heat capacity,,, +Negative current collector specific heat capacity [J.kg-1.K-1],385,, +Positive current collector specific heat capacity [J.kg-1.K-1],897,, +,,, +# Thermal conductivity,,, +Negative current collector thermal conductivity [W.m-1.K-1],267.467, 401 * 0.667, +Positive current collector thermal conductivity [W.m-1.K-1],158.079, 237 * 0.667, +,,, +# Electrical,,, +Cell capacity [A.h],0.43,trial and error, +Typical current [A],0.43,0.2857,1C current diff --git a/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/README.md b/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/README.md new file mode 100644 index 0000000000..d7db16c804 --- /dev/null +++ b/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/README.md @@ -0,0 +1,7 @@ +# LiPF6 electrolyte parameters + +Parameters for a LiPF6 electrolyte, from the paper + +> Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. (2011). Multi-domain modeling of lithium-ion batteries encompassing multi-physics in varied length scales. Journal of The Electrochemical Society, 158(8), A955-A969. + +and references therein. diff --git a/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/electrolyte_conductivity_Kim2011.py b/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/electrolyte_conductivity_Kim2011.py new file mode 100644 index 0000000000..477cd4e3fc --- /dev/null +++ b/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/electrolyte_conductivity_Kim2011.py @@ -0,0 +1,40 @@ +from pybamm import exp + + +def electrolyte_conductivity_Kim2011(c_e, T, T_inf, E_k_e, R_g): + """ + Conductivity of LiPF6 in EC as a function of ion concentration from [1]. + + References + ---------- + .. [1] Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. + (2011). Multi-domain modeling of lithium-ion batteries encompassing + multi-physics in varied length scales. Journal of The Electrochemical + Society, 158(8), A955-A969. + + Parameters + ---------- + c_e: :class: `numpy.Array` + Dimensional electrolyte concentration + T: :class: `numpy.Array` + Dimensional temperature + T_inf: double + Reference temperature + E_k_e: double + Electrolyte conductivity activation energy + R_g: double + The ideal gas constant + + Returns + ------- + :`numpy.Array` + Solid diffusivity + """ + + sigma_e = ( + 3.45 * exp(-798 / T) * (c_e / 1000) ** 3 + - 48.5 * exp(-1080 / T) * (c_e / 1000) ** 2 + + 244 * exp(-1440 / T) * (c_e / 1000) + ) + + return sigma_e diff --git a/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/electrolyte_diffusivity_Kim2011.py b/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/electrolyte_diffusivity_Kim2011.py new file mode 100644 index 0000000000..e852c158b9 --- /dev/null +++ b/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/electrolyte_diffusivity_Kim2011.py @@ -0,0 +1,40 @@ +from pybamm import exp + + +def electrolyte_diffusivity_Kim2011(c_e, T, T_inf, E_D_e, R_g): + """ + Diffusivity of LiPF6 in EC as a function of ion concentration from [1]. + + References + ---------- + .. [1] Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. + (2011). Multi-domain modeling of lithium-ion batteries encompassing + multi-physics in varied length scales. Journal of The Electrochemical + Society, 158(8), A955-A969. + + Parameters + ---------- + c_e: :class: `numpy.Array` + Dimensional electrolyte concentration + T: :class: `numpy.Array` + Dimensional temperature + T_inf: double + Reference temperature + E_D_e: double + Electrolyte diffusion activation energy + R_g: double + The ideal gas constant + + Returns + ------- + :`numpy.Array` + Solid diffusivity + """ + + D_c_e = ( + 5.84 * 10 ** (-7) * exp(-2870 / T) * (c_e / 1000) ** 2 + - 33.9 * 10 ** (-7) * exp(-2920 / T) * (c_e / 1000) + + 129 * 10 ** (-7) * exp(-3200 / T) + ) + + return D_c_e diff --git a/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/parameters.csv b/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/parameters.csv new file mode 100644 index 0000000000..9ea675fe67 --- /dev/null +++ b/input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/parameters.csv @@ -0,0 +1,13 @@ +Name [units],Value,Reference,Notes +# Empty rows and rows starting with ‘#’ will be ignored,,, +,,, +# Electrolyte properties,,, +Typical electrolyte concentration [mol.m-3],1200,, +Cation transference number,0.4,Reported as a function in Kim2011 (Implement later), +Electrolyte diffusivity [m2.s-1],[function]electrolyte_diffusivity_Kim2011,, +Electrolyte conductivity [S.m-1],[function]electrolyte_conductivity_Kim2011,, +,,, +# Activation energies,,, +Reference temperature [K],298.15,25C, +Electrolyte diffusion activation energy [J.mol-1],,Not required, +Electrolyte conductivity activation energy [J.mol-1],,Not requied, diff --git a/input/parameters/lithium-ion/experiments/1C_discharge_from_full_Kim2011/README.md b/input/parameters/lithium-ion/experiments/1C_discharge_from_full_Kim2011/README.md new file mode 100644 index 0000000000..f83025c2ff --- /dev/null +++ b/input/parameters/lithium-ion/experiments/1C_discharge_from_full_Kim2011/README.md @@ -0,0 +1,7 @@ +# 1C discharge from full + +Discharge lithium-ion battery from full charge at 1C, using the initial conditions from the paper + +> Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. (2011). Multi-domain modeling of lithium-ion batteries encompassing multi-physics in varied length scales. Journal of The Electrochemical Society, 158(8), A955-A969. + +and references therein. diff --git a/input/parameters/lithium-ion/experiments/1C_discharge_from_full_Kim2011/parameters.csv b/input/parameters/lithium-ion/experiments/1C_discharge_from_full_Kim2011/parameters.csv new file mode 100644 index 0000000000..1ed5821c2f --- /dev/null +++ b/input/parameters/lithium-ion/experiments/1C_discharge_from_full_Kim2011/parameters.csv @@ -0,0 +1,19 @@ +Name [units],Value,Reference,Notes +# Empty rows and rows starting with ‘#’ will be ignored,,, +,,, +# Temperature +Reference temperature [K],298.15,25C, +Heat transfer coefficient [W.m-2.K-1],25,, +,,, +# Electrical +Number of electrodes connected in parallel to make a cell,1,, +Number of cells connected in series to make a battery,1,, +Lower voltage cut-off [V],2.7,, +Upper voltage cut-off [V],4.5,, +C-rate,1,, +,,, +# Initial conditions +Initial concentration in negative electrode [mol.m-3],18081,0.63*2.84E4, +Initial concentration in positive electrode [mol.m-3],20090,0.41*4.9E4, +Initial concentration in electrolyte [mol.m-3],1200,, +Initial temperature [K],298.15,, diff --git a/input/parameters/lithium-ion/separators/separator_Kim2011/README.md b/input/parameters/lithium-ion/separators/separator_Kim2011/README.md new file mode 100644 index 0000000000..5628b0d80a --- /dev/null +++ b/input/parameters/lithium-ion/separators/separator_Kim2011/README.md @@ -0,0 +1,9 @@ +# Separator parameters + +Parameters for the separator in the paper + +> Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. (2011). Multi-domain modeling of lithium-ion batteries encompassing multi-physics in varied length scales. Journal of The Electrochemical Society, 158(8), A955-A969. + +and references therein. + +Note, only an effective cell volumetric heat capacity is provided in the paper. We therefore used the values for the density and specific heat capacity reported in the Marquis2019 parameter set in each region and multiplied each density by the ratio of the volumetric heat capacity provided in smith to the calculated value. This ensures that the values produce the same effective cell volumetric heat capacity. This works fine for x-lumped thermal models but not for x-full thermal models. We do the same for the planar effective thermal conductivity. \ No newline at end of file diff --git a/input/parameters/lithium-ion/separators/separator_Kim2011/parameters.csv b/input/parameters/lithium-ion/separators/separator_Kim2011/parameters.csv new file mode 100644 index 0000000000..9c8b2ee81d --- /dev/null +++ b/input/parameters/lithium-ion/separators/separator_Kim2011/parameters.csv @@ -0,0 +1,9 @@ +Name [units],Value,Reference,Notes +# Empty rows and rows starting with ‘#’ will be ignored,,, +,,, +Separator porosity,0.4,, +Separator Bruggeman coefficient (electrolyte),2,, +Separator Bruggeman coefficient (electrode),2,, +Separator density [kg.m-3],511.86798,397 * 1.28934, +Separator specific heat capacity [J.kg-1.K-1],700,, +Separator thermal conductivity [W.m-1.K-1],0.10672, 0.16 * 0.667, diff --git a/input/parameters/lithium-ion/separators/separator_Marquis2019/README.md b/input/parameters/lithium-ion/separators/separator_Marquis2019/README.md index 615830690c..8862a317b4 100644 --- a/input/parameters/lithium-ion/separators/separator_Marquis2019/README.md +++ b/input/parameters/lithium-ion/separators/separator_Marquis2019/README.md @@ -1,6 +1,6 @@ # Separator parameters -Parameters for a ??? separator, from the paper +Parameters for the separator in the paper > Scott G. Marquis, Valentin Sulzer, Robert Timms, Colin P. Please, and S. Jon Chapman. "An asymptotic derivation of a single particle model with electrolyte." [arXiv preprint arXiv:1905.12553](https://arxiv.org/abs/1905.12553) (2019). diff --git a/input/parameters/lithium-ion/separators/separator_Marquis2019/parameters.csv b/input/parameters/lithium-ion/separators/separator_Marquis2019/parameters.csv index d1af7d5bda..ca77c0c0c4 100644 --- a/input/parameters/lithium-ion/separators/separator_Marquis2019/parameters.csv +++ b/input/parameters/lithium-ion/separators/separator_Marquis2019/parameters.csv @@ -1,9 +1,9 @@ Name [units],Value,Reference,Notes # Empty rows and rows starting with ‘#’ will be ignored,,, ,,, -Separator porosity,1,Scott Moura FastDFN, -Separator Bruggeman coefficient (electrolyte),1.5,Scott Moura FastDFN, -Separator Bruggeman coefficient (electrode),1.5,Scott Moura FastDFN, +Separator porosity,1,, +Separator Bruggeman coefficient (electrolyte),1.5,, +Separator Bruggeman coefficient (electrode),1.5,, Separator density [kg.m-3],397,, Separator specific heat capacity [J.kg-1.K-1],700,, Separator thermal conductivity [W.m-1.K-1],0.16,, diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 9f560939e1..022ac64370 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -120,6 +120,7 @@ def version(formatted=False): OptionError, ModelError, SolverError, + SolverWarning, ShapeError, ModelWarning, UndefinedOperationError, @@ -175,17 +176,6 @@ def version(formatted=False): tortuosity, ) -# -# Parameters class and methods -# -from .parameters.parameter_values import ParameterValues -from .parameters import geometric_parameters -from .parameters import electrical_parameters -from .parameters import thermal_parameters -from .parameters import standard_parameters_lithium_ion, standard_parameters_lead_acid -from .parameters.print_parameters import print_parameters, print_evaluated_parameters -from .parameters import parameter_sets - # # Geometry # @@ -204,6 +194,18 @@ def version(formatted=False): from .expression_tree.independent_variable import KNOWN_SPATIAL_VARS, KNOWN_COORD_SYS from .geometry import standard_spatial_vars +# +# Parameters class and methods +# +from .parameters.parameter_values import ParameterValues +from .parameters import geometric_parameters +from .parameters import electrical_parameters +from .parameters import thermal_parameters +from .parameters import standard_parameters_lithium_ion, standard_parameters_lead_acid +from .parameters.print_parameters import print_parameters, print_evaluated_parameters +from .parameters import parameter_sets + + # # Mesh and Discretisation classes # @@ -237,7 +239,7 @@ def version(formatted=False): # # Solver classes # -from .solvers.solution import Solution +from .solvers.solution import Solution, _BaseSolution from .solvers.base_solver import BaseSolver from .solvers.algebraic_solver import AlgebraicSolver from .solvers.casadi_solver import CasadiSolver @@ -246,6 +248,12 @@ def version(formatted=False): from .solvers.scipy_solver import ScipySolver from .solvers.idaklu_solver import IDAKLUSolver, have_idaklu +# +# Experiments +# +from .experiments.experiment import Experiment +from . import experiments + # # other # diff --git a/pybamm/experiments/__init__.py b/pybamm/experiments/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pybamm/experiments/experiment.py b/pybamm/experiments/experiment.py new file mode 100644 index 0000000000..fb7bbef648 --- /dev/null +++ b/pybamm/experiments/experiment.py @@ -0,0 +1,251 @@ +# +# Experiment class +# + +examples = """ + + Discharge at 1C for 0.5 hours, + Discharge at C/20 for 0.5 hours, + Charge at 0.5 C for 45 minutes, + Discharge at 1 A for 90 seconds, + Charge at 200mA for 45 minutes (1 minute period), + Discharge at 1 W for 0.5 hours, + Charge at 200 mW for 45 minutes, + Rest for 10 minutes (5 minute period), + Hold at 1 V for 20 seconds, + Charge at 1 C until 4.1V, + Hold at 4.1 V until 50 mA, + Hold at 3V until C/50, + """ + + +class Experiment: + """ + Base class for experimental conditions under which to run the model. In general, a + list of operating conditions should be passed in. Each operating condition should + be of the form "Do this for this long" or "Do this until this happens". For example, + "Charge at 1 C for 1 hour", or "Charge at 1 C until 4.2 V", or "Charge at 1 C for 1 + hour or until 4.2 V". The instructions can be of the form "(Dis)charge at x A/C/W", + "Rest", or "Hold at x V". The running time should be a time in seconds, minutes or + hours, e.g. "10 seconds", "3 minutes" or "1 hour". The stopping conditions should be + a circuit state, e.g. "1 A", "C/50" or "3 V". + + Parameters + ---------- + operating_conditions : list + List of operating conditions + parameters : dict + Dictionary of parameters to use for this experiment, replacing default + parameters as appropriate + period : string, optional + Period (1/frequency) at which to record outputs. Default is 1 minute. Can be + overwritten by individual operating conditions. + + """ + + def __init__(self, operating_conditions, parameters=None, period="1 minute"): + self.period = self.convert_time_to_seconds(period.split()) + self.operating_conditions_strings = operating_conditions + self.operating_conditions, self.events = self.read_operating_conditions( + operating_conditions + ) + parameters = parameters or {} + if isinstance(parameters, dict): + self.parameters = parameters + else: + raise TypeError("experimental parameters should be a dictionary") + + def __str__(self): + return str(self.operating_conditions_strings) + + def __repr__(self): + return "pybamm.Experiment({!s})".format(self) + + def read_operating_conditions(self, operating_conditions): + """ + Convert operating conditions to the appropriate format + + Parameters + ---------- + operating_conditions : list + List of operating conditions + + Returns + ------- + operating_conditions : list + Operating conditions in the tuple format + """ + converted_operating_conditions = [] + events = [] + for cond in operating_conditions: + if isinstance(cond, str): + next_op, next_event = self.read_string(cond) + converted_operating_conditions.append(next_op) + events.append(next_event) + else: + raise TypeError( + """Operating conditions should be strings, not {}. For example: {} + """.format( + type(cond), examples + ) + ) + + return converted_operating_conditions, events + + def read_string(self, cond): + """ + Convert a string to a tuple of the right format + + Parameters + ---------- + cond : str + String of appropriate form for example "Charge at x C for y hours". x and y + must be numbers, 'C' denotes the unit of the external circuit (can be A for + current, C for C-rate, V for voltage or W for power), and 'hours' denotes + the unit of time (can be second(s), minute(s) or hour(s)) + """ + # Read period + if " period)" in cond: + cond, time_period = cond.split("(") + time, _ = time_period.split(" period)") + period = self.convert_time_to_seconds(time.split()) + else: + period = self.period + # Read instructions + if "for" in cond and "or until" in cond: + # e.g. for 3 hours or until 4.2 V + cond_list = cond.split() + idx_for = cond_list.index("for") + idx_until = cond_list.index("or") + electric = self.convert_electric(cond_list[:idx_for]) + time = self.convert_time_to_seconds(cond_list[idx_for + 1 : idx_until]) + events = self.convert_electric(cond_list[idx_until + 2 :]) + elif "for" in cond: + # e.g. for 3 hours + cond_list = cond.split() + idx = cond_list.index("for") + electric = self.convert_electric(cond_list[:idx]) + time = self.convert_time_to_seconds(cond_list[idx + 1 :]) + events = None + elif "until" in cond: + # e.g. until 4.2 V + cond_list = cond.split() + idx = cond_list.index("until") + electric = self.convert_electric(cond_list[:idx]) + time = None + events = self.convert_electric(cond_list[idx + 1 :]) + else: + raise ValueError( + """Operating conditions must contain keyword 'for' or 'until'. + For example: {}""".format( + examples + ) + ) + return electric + (time,) + (period,), events + + def convert_electric(self, electric): + "Convert electrical instructions to consistent output" + # Rest == zero current + if electric[0].lower() == "rest": + return (0, "A") + else: + if len(electric) in [3, 4]: + if len(electric) == 4: + # e.g. Charge at 4 A, Hold at 3 V + instruction, _, value, unit = electric + elif len(electric) == 3: + # e.g. Discharge at C/2, Charge at 1A + instruction, _, value_unit = electric + if value_unit[0] == "C": + # e.g. C/2 + unit = value_unit[0] + value = 1 / float(value_unit[2:]) + else: + # e.g. 1A + if "m" in value_unit: + # e.g. 1mA + unit = value_unit[-2:] + value = float(value_unit[:-2]) + else: + # e.g. 1A + unit = value_unit[-1] + value = float(value_unit[:-1]) + # Read instruction + if instruction.lower() in ["discharge", "hold"]: + sign = 1 + elif instruction.lower() == "charge": + sign = -1 + else: + raise ValueError( + """instruction must be 'discharge', 'charge', 'rest' or 'hold'. + For example: {}""".format( + examples + ) + ) + elif len(electric) == 2: + # e.g. 3 A, 4.1 V + value, unit = electric + sign = 1 + elif len(electric) == 1: + # e.g. C/2, 1A + value_unit = electric[0] + if value_unit[0] == "C": + # e.g. C/2 + unit = value_unit[0] + value = 1 / float(value_unit[2:]) + else: + if "m" in value_unit: + # e.g. 1mA + unit = value_unit[-2:] + value = float(value_unit[:-2]) + else: + # e.g. 1A + unit = value_unit[-1] + value = float(value_unit[:-1]) + sign = 1 + else: + raise ValueError( + """Instruction '{}' not recognized. Some acceptable examples are: {} + """.format( + " ".join(electric), examples + ) + ) + # Read value and units + if unit == "C": + return (sign * float(value), "C") + elif unit == "A": + return (sign * float(value), "A") + elif unit == "mA": + return (sign * float(value) / 1000, "A") + elif unit == "V": + return (float(value), "V") + elif unit == "W": + return (sign * float(value), "W") + elif unit == "mW": + return (sign * float(value) / 1000, "W") + else: + raise ValueError( + """units must be 'C', 'A', 'mA', 'V', 'W' or 'mW', not '{}'. + For example: {} + """.format( + unit, examples + ) + ) + + def convert_time_to_seconds(self, time_and_units): + "Convert a time in seconds, minutes or hours to a time in seconds" + time, units = time_and_units + if units in ["second", "seconds", "s", "sec"]: + time_in_seconds = float(time) + elif units in ["minute", "minutes", "m", "min"]: + time_in_seconds = float(time) * 60 + elif units in ["hour", "hours", "h", "hr"]: + time_in_seconds = float(time) * 3600 + else: + raise ValueError( + """time units must be 'seconds', 'minutes' or 'hours'. For example: {} + """.format( + examples + ) + ) + return time_in_seconds diff --git a/pybamm/expression_tree/concatenations.py b/pybamm/expression_tree/concatenations.py index 6bac3d5d60..e1225bf03a 100644 --- a/pybamm/expression_tree/concatenations.py +++ b/pybamm/expression_tree/concatenations.py @@ -38,6 +38,8 @@ def get_children_domains(self, children): # combine domains from children domain = [] for child in children: + if not isinstance(child, pybamm.Symbol): + raise TypeError("{} is not a pybamm symbol".format(child)) child_domain = child.domain if set(domain).isdisjoint(child_domain): domain += child_domain diff --git a/pybamm/expression_tree/exceptions.py b/pybamm/expression_tree/exceptions.py index cbeca72b5e..a71172cc48 100644 --- a/pybamm/expression_tree/exceptions.py +++ b/pybamm/expression_tree/exceptions.py @@ -37,6 +37,14 @@ class SolverError(Exception): pass +class SolverWarning(UserWarning): + """ + Solver warning: the chosen solver settings may not give the desired output + """ + + pass + + class ShapeError(Exception): """ Shape error: cannot evaluate an object to find its shape diff --git a/pybamm/expression_tree/operations/simplify.py b/pybamm/expression_tree/operations/simplify.py index 6e090db82d..df033cea40 100644 --- a/pybamm/expression_tree/operations/simplify.py +++ b/pybamm/expression_tree/operations/simplify.py @@ -22,8 +22,10 @@ def simplify_if_constant(symbol, keep_domains=False): if symbol.is_constant(): result = symbol.evaluate_ignoring_errors() if result is not None: - if isinstance(result, numbers.Number) or ( - isinstance(result, np.ndarray) and result.ndim == 0 + if ( + isinstance(result, numbers.Number) + or (isinstance(result, np.ndarray) and result.ndim == 0) + or isinstance(result, np.bool_) ): return pybamm.Scalar(result) elif isinstance(result, np.ndarray) or issparse(result): diff --git a/pybamm/expression_tree/parameter.py b/pybamm/expression_tree/parameter.py index 7000bca24b..9c2049ac8c 100644 --- a/pybamm/expression_tree/parameter.py +++ b/pybamm/expression_tree/parameter.py @@ -1,6 +1,7 @@ # # Parameter classes # +import numbers import numpy as np import pybamm @@ -60,10 +61,19 @@ def __init__(self, name, *children, diff_variable=None): # assign diff variable self.diff_variable = diff_variable children_list = list(children) + + # Turn numbers into scalars + for idx, child in enumerate(children_list): + if isinstance(child, numbers.Number): + children_list[idx] = pybamm.Scalar(child) + domain = self.get_children_domains(children_list) - auxiliary_domains = self.get_children_auxiliary_domains(children) + auxiliary_domains = self.get_children_auxiliary_domains(children_list) super().__init__( - name, children=children, domain=domain, auxiliary_domains=auxiliary_domains + name, + children=children_list, + domain=domain, + auxiliary_domains=auxiliary_domains, ) def set_id(self): diff --git a/pybamm/expression_tree/symbol.py b/pybamm/expression_tree/symbol.py index cd3ec77acf..3bc390cc26 100644 --- a/pybamm/expression_tree/symbol.py +++ b/pybamm/expression_tree/symbol.py @@ -285,9 +285,13 @@ def visualise(self, filename): new_node, counter = self.relabel_tree(self, 0) - DotExporter( - new_node, nodeattrfunc=lambda node: 'label="{}"'.format(node.label) - ).to_picture(filename) + try: + DotExporter( + new_node, nodeattrfunc=lambda node: 'label="{}"'.format(node.label) + ).to_picture(filename) + except FileNotFoundError: + # raise error but only through logger so that test passes + pybamm.logger.error("Please install graphviz>=2.42.2 to use dot exporter") def relabel_tree(self, symbol, counter): """ Finds all children of a symbol and assigns them a new id so that they can be diff --git a/pybamm/models/base_model.py b/pybamm/models/base_model.py index 519ea9bee2..f8ae8c5c17 100644 --- a/pybamm/models/base_model.py +++ b/pybamm/models/base_model.py @@ -121,6 +121,9 @@ def __init__(self, name="Unnamed model"): self.use_simplify = True self.convert_to_format = "casadi" + # Default timescale is 1 second + self.timescale = pybamm.Scalar(1) + def _set_dictionary(self, dict, name): """ Convert any scalar equations in dict to 'pybamm.Scalar' @@ -304,6 +307,16 @@ def options(self): def options(self, options): self._options = options + @property + def timescale(self): + "Timescale of model, to be used for non-dimensionalising time when solving" + return self._timescale + + @timescale.setter + def timescale(self, value): + "Set the timescale" + self._timescale = value + def __getitem__(self, key): return self.rhs[key] @@ -315,6 +328,7 @@ def new_copy(self, options=None): new_model.use_jacobian = self.use_jacobian new_model.use_simplify = self.use_simplify new_model.convert_to_format = self.convert_to_format + new_model.timescale = self.timescale return new_model def update(self, *submodels): diff --git a/pybamm/models/full_battery_models/base_battery_model.py b/pybamm/models/full_battery_models/base_battery_model.py index a8e74f2180..035e7cb0df 100644 --- a/pybamm/models/full_battery_models/base_battery_model.py +++ b/pybamm/models/full_battery_models/base_battery_model.py @@ -68,7 +68,6 @@ class BaseBatteryModel(pybamm.BaseModel): def __init__(self, options=None, name="Unnamed battery model"): super().__init__(name) self.options = options - self.set_standard_output_variables() self.submodels = {} self._built = False self._built_fundamental_and_external = False @@ -254,103 +253,13 @@ def options(self, extra_options): self._options = options def set_standard_output_variables(self): - # Standard output variables - - # Interfacial current - self.variables.update( - { - "Negative electrode current density": None, - "Positive electrode current density": None, - "Electrolyte current density": None, - "Interfacial current density": None, - "Exchange current density": None, - } - ) - self.variables.update( - { - "Negative electrode current density [A.m-2]": None, - "Positive electrode current density [A.m-2]": None, - "Electrolyte current density [A.m-2]": None, - "Interfacial current density [A.m-2]": None, - "Exchange current density [A.m-2]": None, - } - ) - - # Voltage - self.variables.update( - { - "Negative electrode open circuit potential": None, - "Positive electrode open circuit potential": None, - "X-averaged negative electrode open circuit potential": None, - "X-averaged positive electrode open circuit potential": None, - "X-averaged open circuit voltage": None, - "Measured open circuit voltage": None, - "Terminal voltage": None, - } - ) - self.variables.update( - { - "Negative electrode open circuit potential [V]": None, - "Positive electrode open circuit potential [V]": None, - "X-averaged negative electrode open circuit potential [V]": None, - "X-averaged positive electrode open circuit potential [V]": None, - "X-averaged open circuit voltage [V]": None, - "Measured open circuit voltage [V]": None, - "Terminal voltage [V]": None, - } - ) - - # Overpotentials - self.variables.update( - { - "Negative reaction overpotential": None, - "Positive reaction overpotential": None, - "X-averaged negative reaction overpotential": None, - "X-averaged positive reaction overpotential": None, - "X-averaged reaction overpotential": None, - "X-averaged electrolyte overpotential": None, - "X-averaged solid phase ohmic losses": None, - } - ) - self.variables.update( - { - "Negative reaction overpotential [V]": None, - "Positive reaction overpotential [V]": None, - "X-averaged negative reaction overpotential [V]": None, - "X-averaged positive reaction overpotential [V]": None, - "X-averaged reaction overpotential [V]": None, - "X-averaged electrolyte overpotential [V]": None, - "X-averaged solid phase ohmic losses [V]": None, - } - ) - - # Concentration - self.variables.update( - { - "Electrolyte concentration": None, - "Electrolyte concentration [mol.m-3]": None, - } - ) - - # Potential - self.variables.update( - { - "Negative electrode potential": None, - "Positive electrode potential": None, - "Electrolyte potential": None, - } - ) - - self.variables = {} - # Time - time_scale = pybamm.electrical_parameters.timescale self.variables.update( { "Time": pybamm.t, - "Time [s]": pybamm.t * time_scale, - "Time [min]": pybamm.t * time_scale / 60, - "Time [h]": pybamm.t * time_scale / 3600, + "Time [s]": pybamm.t * self.timescale, + "Time [min]": pybamm.t * self.timescale / 60, + "Time [h]": pybamm.t * self.timescale / 3600, } ) @@ -767,16 +676,20 @@ def set_voltage_variables(self): # Cut-off voltage voltage = self.variables["Terminal voltage"] - self.events.append(pybamm.Event( - "Minimum voltage", - voltage - self.param.voltage_low_cut, - pybamm.EventType.TERMINATION - )) - self.events.append(pybamm.Event( - "Maximum voltage", - voltage - self.param.voltage_high_cut, - pybamm.EventType.TERMINATION - )) + self.events.append( + pybamm.Event( + "Minimum voltage", + voltage - self.param.voltage_low_cut, + pybamm.EventType.TERMINATION, + ) + ) + self.events.append( + pybamm.Event( + "Maximum voltage", + voltage - self.param.voltage_high_cut, + pybamm.EventType.TERMINATION, + ) + ) # Power I_dim = self.variables["Current [A]"] @@ -816,8 +729,11 @@ def process_parameters_and_discretise(self, symbol, parameter_values, disc): variables = list(self.rhs.keys()) + list(self.algebraic.keys()) disc.set_variable_slices(variables) - # Set boundary condtions + # Set boundary condtions (also requires setting parameter values) if disc.bcs == {}: + self.boundary_conditions = parameter_values.process_boundary_conditions( + self + ) disc.bcs = disc.process_boundary_conditions(self) # Process diff --git a/pybamm/models/full_battery_models/lead_acid/base_lead_acid_model.py b/pybamm/models/full_battery_models/lead_acid/base_lead_acid_model.py index b2e10213e9..97fb53115a 100644 --- a/pybamm/models/full_battery_models/lead_acid/base_lead_acid_model.py +++ b/pybamm/models/full_battery_models/lead_acid/base_lead_acid_model.py @@ -19,6 +19,10 @@ def __init__(self, options=None, name="Unnamed lead-acid model"): super().__init__(options, name) self.param = pybamm.standard_parameters_lead_acid + # Default timescale is discharge timescale + self.timescale = self.param.tau_discharge + self.set_standard_output_variables() + @property def default_parameter_values(self): return pybamm.ParameterValues(chemistry=pybamm.parameter_sets.Sulzer2019) @@ -51,19 +55,6 @@ def default_solver(self): else: # pragma: no cover return pybamm.CasadiSolver(mode="safe") - def set_standard_output_variables(self): - super().set_standard_output_variables() - - # Time - time_scale = pybamm.standard_parameters_lead_acid.tau_discharge - self.variables.update( - { - "Time [s]": pybamm.t * time_scale, - "Time [min]": pybamm.t * time_scale / 60, - "Time [h]": pybamm.t * time_scale / 3600, - } - ) - def set_reactions(self): # Should probably refactor as this is a bit clunky at the moment diff --git a/pybamm/models/full_battery_models/lithium_ion/base_lithium_ion_model.py b/pybamm/models/full_battery_models/lithium_ion/base_lithium_ion_model.py index 908e131b12..0901269bb5 100644 --- a/pybamm/models/full_battery_models/lithium_ion/base_lithium_ion_model.py +++ b/pybamm/models/full_battery_models/lithium_ion/base_lithium_ion_model.py @@ -17,32 +17,14 @@ def __init__(self, options=None, name="Unnamed lithium-ion model"): super().__init__(options, name) self.param = pybamm.standard_parameters_lithium_ion + # Default timescale is discharge timescale + self.timescale = self.param.tau_discharge + self.set_standard_output_variables() + def set_standard_output_variables(self): super().set_standard_output_variables() - # Time - time_scale = pybamm.standard_parameters_lithium_ion.tau_discharge - self.variables.update( - { - "Time [s]": pybamm.t * time_scale, - "Time [min]": pybamm.t * time_scale / 60, - "Time [h]": pybamm.t * time_scale / 3600, - } - ) - - # Particle concentration and position - self.variables.update( - { - "Negative particle concentration": None, - "Positive particle concentration": None, - "Negative particle surface concentration": None, - "Positive particle surface concentration": None, - "Negative particle concentration [mol.m-3]": None, - "Positive particle concentration [mol.m-3]": None, - "Negative particle surface concentration [mol.m-3]": None, - "Positive particle surface concentration [mol.m-3]": None, - } - ) + # Particle concentration position var = pybamm.standard_spatial_vars param = pybamm.geometric_parameters self.variables.update( diff --git a/pybamm/models/full_battery_models/lithium_ion/basic_dfn.py b/pybamm/models/full_battery_models/lithium_ion/basic_dfn.py index 8a030bbe6d..16d17eef28 100644 --- a/pybamm/models/full_battery_models/lithium_ion/basic_dfn.py +++ b/pybamm/models/full_battery_models/lithium_ion/basic_dfn.py @@ -100,9 +100,15 @@ def __init__(self, name="Doyle-Fuller-Newman model"): # Porosity # Primary broadcasts are used to broadcast scalar quantities across a domain # into a vector of the right shape, for multiplying with other vectors - eps_n = pybamm.PrimaryBroadcast(param.epsilon_n, "negative electrode") - eps_s = pybamm.PrimaryBroadcast(param.epsilon_s, "separator") - eps_p = pybamm.PrimaryBroadcast(param.epsilon_p, "positive electrode") + eps_n = pybamm.PrimaryBroadcast( + pybamm.Parameter("Negative electrode porosity"), "negative electrode" + ) + eps_s = pybamm.PrimaryBroadcast( + pybamm.Parameter("Separator porosity"), "separator" + ) + eps_p = pybamm.PrimaryBroadcast( + pybamm.Parameter("Positive electrode porosity"), "positive electrode" + ) eps = pybamm.Concatenation(eps_n, eps_s, eps_p) # Tortuosity @@ -177,8 +183,16 @@ def __init__(self, name="Doyle-Fuller-Newman model"): "left": (pybamm.Scalar(0), "Neumann"), "right": (-param.C_p * j_p / param.a_p / param.gamma_p, "Neumann"), } - self.initial_conditions[c_s_n] = param.c_n_init - self.initial_conditions[c_s_p] = param.c_p_init + # c_n_init and c_p_init can in general be functions of x + # Note the broadcasting, for domains + x_n = pybamm.PrimaryBroadcast( + pybamm.standard_spatial_vars.x_n, "negative particle" + ) + self.initial_conditions[c_s_n] = param.c_n_init(x_n) + x_p = pybamm.PrimaryBroadcast( + pybamm.standard_spatial_vars.x_p, "positive particle" + ) + self.initial_conditions[c_s_p] = param.c_p_init(x_p) # Events specify points at which a solution should terminate self.events += [ pybamm.Event("Minimum negative particle surface concentration", @@ -211,10 +225,12 @@ def __init__(self, name="Doyle-Fuller-Newman model"): # Initial conditions must also be provided for algebraic equations, as an # initial guess for a root-finding algorithm which calculates consistent initial # conditions + # We evaluate c_n_init at x=0 and c_p_init at x=1 (this is just an initial + # guess so actual value is not too important) self.initial_conditions[phi_s_n] = pybamm.Scalar(0) self.initial_conditions[phi_s_p] = param.U_p( - param.c_p_init, param.T_init - ) - param.U_n(param.c_n_init, param.T_init) + param.c_p_init(1), param.T_init + ) - param.U_n(param.c_n_init(0), param.T_init) ###################### # Current in the electrolyte @@ -227,7 +243,7 @@ def __init__(self, name="Doyle-Fuller-Newman model"): "left": (pybamm.Scalar(0), "Neumann"), "right": (pybamm.Scalar(0), "Neumann"), } - self.initial_conditions[phi_e] = -param.U_n(param.c_n_init, param.T_init) + self.initial_conditions[phi_e] = -param.U_n(param.c_n_init(0), param.T_init) ###################### # Electrolyte concentration diff --git a/pybamm/models/full_battery_models/lithium_ion/basic_spm.py b/pybamm/models/full_battery_models/lithium_ion/basic_spm.py index 228ce51896..15d8e2ab92 100644 --- a/pybamm/models/full_battery_models/lithium_ion/basic_spm.py +++ b/pybamm/models/full_battery_models/lithium_ion/basic_spm.py @@ -89,8 +89,10 @@ def __init__(self, name="Single Particle Model"): "left": (pybamm.Scalar(0), "Neumann"), "right": (-param.C_p * j_p / param.a_p / param.gamma_p, "Neumann"), } - self.initial_conditions[c_s_n] = param.c_n_init - self.initial_conditions[c_s_p] = param.c_p_init + # c_n_init and c_p_init are functions, but for the SPM we evaluate them at x=0 + # and x=1 since there is no x-dependence in the particles + self.initial_conditions[c_s_n] = param.c_n_init(0) + self.initial_conditions[c_s_p] = param.c_p_init(1) # Surf takes the surface value of a variable, i.e. its boundary value on the # right side. This is also accessible via `boundary_value(x, "right")`, with # "left" providing the boundary value of the left side diff --git a/pybamm/models/submodels/electrode/ohm/full_ohm.py b/pybamm/models/submodels/electrode/ohm/full_ohm.py index 7ed04dc09b..6ba51ab766 100644 --- a/pybamm/models/submodels/electrode/ohm/full_ohm.py +++ b/pybamm/models/submodels/electrode/ohm/full_ohm.py @@ -95,8 +95,8 @@ def set_initial_conditions(self, variables): if self.domain == "Negative": phi_s_init = pybamm.Scalar(0) elif self.domain == "Positive": - phi_s_init = self.param.U_p(self.param.c_p_init, T_init) - self.param.U_n( - self.param.c_n_init, T_init - ) + phi_s_init = self.param.U_p( + self.param.c_p_init(1), T_init + ) - self.param.U_n(self.param.c_n_init(0), T_init) self.initial_conditions[phi_s] = phi_s_init diff --git a/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/full_stefan_maxwell_conductivity.py b/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/full_stefan_maxwell_conductivity.py index e381f0daad..e15320b273 100644 --- a/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/full_stefan_maxwell_conductivity.py +++ b/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/full_stefan_maxwell_conductivity.py @@ -64,4 +64,6 @@ def set_algebraic(self, variables): def set_initial_conditions(self, variables): phi_e = variables["Electrolyte potential"] T_init = self.param.T_init - self.initial_conditions = {phi_e: -self.param.U_n(self.param.c_n_init, T_init)} + self.initial_conditions = { + phi_e: -self.param.U_n(self.param.c_n_init(0), T_init) + } diff --git a/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/surface_potential_form/full_surface_form_stefan_maxwell_conductivity.py b/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/surface_potential_form/full_surface_form_stefan_maxwell_conductivity.py index 75916253f7..945437ac41 100644 --- a/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/surface_potential_form/full_surface_form_stefan_maxwell_conductivity.py +++ b/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/surface_potential_form/full_surface_form_stefan_maxwell_conductivity.py @@ -45,9 +45,9 @@ def set_initial_conditions(self, variables): delta_phi_e = variables[self.domain + " electrode surface potential difference"] if self.domain == "Negative": - delta_phi_e_init = self.param.U_n(self.param.c_n_init, self.param.T_init) + delta_phi_e_init = self.param.U_n(self.param.c_n_init(0), self.param.T_init) elif self.domain == "Positive": - delta_phi_e_init = self.param.U_p(self.param.c_p_init, self.param.T_init) + delta_phi_e_init = self.param.U_p(self.param.c_p_init(1), self.param.T_init) self.initial_conditions = {delta_phi_e: delta_phi_e_init} diff --git a/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/surface_potential_form/leading_surface_form_stefan_maxwell_conductivity.py b/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/surface_potential_form/leading_surface_form_stefan_maxwell_conductivity.py index a264497520..8d46bdb670 100644 --- a/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/surface_potential_form/leading_surface_form_stefan_maxwell_conductivity.py +++ b/pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/surface_potential_form/leading_surface_form_stefan_maxwell_conductivity.py @@ -49,9 +49,9 @@ def set_initial_conditions(self, variables): + " electrode surface potential difference" ] if self.domain == "Negative": - delta_phi_init = self.param.U_n(self.param.c_n_init, self.param.T_init) + delta_phi_init = self.param.U_n(self.param.c_n_init(0), self.param.T_init) elif self.domain == "Positive": - delta_phi_init = self.param.U_p(self.param.c_p_init, self.param.T_init) + delta_phi_init = self.param.U_p(self.param.c_p_init(1), self.param.T_init) self.initial_conditions = {delta_phi: delta_phi_init} diff --git a/pybamm/models/submodels/external_circuit/function_control_external_circuit.py b/pybamm/models/submodels/external_circuit/function_control_external_circuit.py index fb1dd39f6b..6e3812f99a 100644 --- a/pybamm/models/submodels/external_circuit/function_control_external_circuit.py +++ b/pybamm/models/submodels/external_circuit/function_control_external_circuit.py @@ -8,9 +8,9 @@ class FunctionControl(BaseModel): """External circuit with an arbitrary function. """ - def __init__(self, param, external_circuit_class): + def __init__(self, param, external_circuit_function): super().__init__(param) - self.external_circuit_class = external_circuit_class + self.external_circuit_function = external_circuit_function def _get_current_variable(self): return pybamm.Variable("Total current density") @@ -23,14 +23,6 @@ def get_fundamental_variables(self): # Add discharge capacity variable variables.update(super().get_fundamental_variables()) - # Add switches - # These are not implemented yet but can be used later with the Experiment class - # to simulate different external circuit conditions sequentially within a - # single model (for example Constant Current - Constant Voltage) - # for i in range(self.external_circuit_class.num_switches): - # s = pybamm.Parameter("Switch {}".format(i + 1)) - # variables["Switch {}".format(i + 1)] = s - return variables def set_initial_conditions(self, variables): @@ -44,7 +36,7 @@ def set_algebraic(self, variables): # The external circuit function should fix either the current, or the voltage, # or a combination (e.g. I*V for power control) i_cell = variables["Total current density"] - self.algebraic[i_cell] = self.external_circuit_class(variables) + self.algebraic[i_cell] = self.external_circuit_function(variables) class VoltageFunctionControl(FunctionControl): @@ -53,31 +45,25 @@ class VoltageFunctionControl(FunctionControl): """ def __init__(self, param): - super().__init__(param, ConstantVoltage()) + super().__init__(param, constant_voltage) -class ConstantVoltage: - num_switches = 0 - - def __call__(self, variables): - V = variables["Terminal voltage [V]"] - return V - pybamm.FunctionParameter("Voltage function [V]", pybamm.t) +def constant_voltage(variables): + V = variables["Terminal voltage [V]"] + return V - pybamm.FunctionParameter("Voltage function [V]", pybamm.t) class PowerFunctionControl(FunctionControl): """External circuit with power control. """ def __init__(self, param): - super().__init__(param, ConstantPower()) - + super().__init__(param, constant_power) -class ConstantPower: - num_switches = 0 - def __call__(self, variables): - I = variables["Current [A]"] - V = variables["Terminal voltage [V]"] - return I * V - pybamm.FunctionParameter("Power function [W]", pybamm.t) +def constant_power(variables): + I = variables["Current [A]"] + V = variables["Terminal voltage [V]"] + return I * V - pybamm.FunctionParameter("Power function [W]", pybamm.t) class LeadingOrderFunctionControl(FunctionControl, LeadingOrderBaseModel): @@ -97,12 +83,12 @@ class LeadingOrderVoltageFunctionControl(LeadingOrderFunctionControl): """ def __init__(self, param): - super().__init__(param, ConstantVoltage()) + super().__init__(param, constant_voltage) class LeadingOrderPowerFunctionControl(LeadingOrderFunctionControl): """External circuit with power control, at leading order. """ def __init__(self, param): - super().__init__(param, ConstantPower()) + super().__init__(param, constant_power) diff --git a/pybamm/models/submodels/particle/base_particle.py b/pybamm/models/submodels/particle/base_particle.py index 1e1adae470..f4234d6458 100644 --- a/pybamm/models/submodels/particle/base_particle.py +++ b/pybamm/models/submodels/particle/base_particle.py @@ -70,36 +70,23 @@ def _get_standard_flux_variables(self, N_s, N_s_xav): return variables - def _flux_law(self, c, T): - raise NotImplementedError - - def _unpack(self, variables): - raise NotImplementedError - - def set_initial_conditions(self, variables): - c, _, _ = self._unpack(variables) - - if self.domain == "Negative": - c_init = self.param.c_n_init - - elif self.domain == "Positive": - c_init = self.param.c_p_init - - self.initial_conditions = {c: c_init} - def set_events(self, variables): c_s_surf = variables[self.domain + " particle surface concentration"] tol = 0.01 - self.events.append(pybamm.Event( - "Minumum " + self.domain.lower() + " particle surface concentration", - pybamm.min(c_s_surf) - tol, - pybamm.EventType.TERMINATION - )) - - self.events.append(pybamm.Event( - "Maximum " + self.domain.lower() + " particle surface concentration", - (1 - tol) - pybamm.max(c_s_surf), - pybamm.EventType.TERMINATION - )) + self.events.append( + pybamm.Event( + "Minumum " + self.domain.lower() + " particle surface concentration", + pybamm.min(c_s_surf) - tol, + pybamm.EventType.TERMINATION, + ) + ) + + self.events.append( + pybamm.Event( + "Maximum " + self.domain.lower() + " particle surface concentration", + (1 - tol) - pybamm.max(c_s_surf), + pybamm.EventType.TERMINATION, + ) + ) diff --git a/pybamm/models/submodels/particle/fast/base_fast_particle.py b/pybamm/models/submodels/particle/fast/base_fast_particle.py index 9c7a8870c6..a39e00b519 100644 --- a/pybamm/models/submodels/particle/fast/base_fast_particle.py +++ b/pybamm/models/submodels/particle/fast/base_fast_particle.py @@ -2,7 +2,6 @@ # Base class for particles each with uniform concentration (i.e. infinitely fast # diffusion in r) # - from ..base_particle import BaseParticle diff --git a/pybamm/models/submodels/particle/fast/fast_many_particles.py b/pybamm/models/submodels/particle/fast/fast_many_particles.py index fe23a4af8e..b1ca21a7f1 100644 --- a/pybamm/models/submodels/particle/fast/fast_many_particles.py +++ b/pybamm/models/submodels/particle/fast/fast_many_particles.py @@ -69,3 +69,16 @@ def _unpack(self, variables): j = variables[self.domain + " electrode interfacial current density"] return c_s_surf, N_s, j + + def set_initial_conditions(self, variables): + c, _, _ = self._unpack(variables) + + if self.domain == "Negative": + x_n = pybamm.standard_spatial_vars.x_n + c_init = self.param.c_n_init(x_n) + + elif self.domain == "Positive": + x_p = pybamm.standard_spatial_vars.x_p + c_init = self.param.c_p_init(x_p) + + self.initial_conditions = {c: c_init} diff --git a/pybamm/models/submodels/particle/fast/fast_single_particle.py b/pybamm/models/submodels/particle/fast/fast_single_particle.py index 925229086b..3cfc6c9d6a 100644 --- a/pybamm/models/submodels/particle/fast/fast_single_particle.py +++ b/pybamm/models/submodels/particle/fast/fast_single_particle.py @@ -77,3 +77,19 @@ def _unpack(self, variables): ] return c_s_surf_xav, N_s_xav, j_av + + def set_initial_conditions(self, variables): + """ + For single particle models, initial conditions can't depend on x so we + arbitrarily evaluate them at x=0 in the negative electrode and x=1 in the + positive electrode (they will usually be constant) + """ + c, _, _ = self._unpack(variables) + + if self.domain == "Negative": + c_init = self.param.c_n_init(0) + + elif self.domain == "Positive": + c_init = self.param.c_p_init(1) + + self.initial_conditions = {c: c_init} diff --git a/pybamm/models/submodels/particle/fickian/__init__.py b/pybamm/models/submodels/particle/fickian/__init__.py index f45a889c89..86a9ba03be 100644 --- a/pybamm/models/submodels/particle/fickian/__init__.py +++ b/pybamm/models/submodels/particle/fickian/__init__.py @@ -1,3 +1,2 @@ -from .base_fickian_particle import BaseModel from .fickian_many_particles import ManyParticles from .fickian_single_particle import SingleParticle diff --git a/pybamm/models/submodels/particle/fickian/base_fickian_particle.py b/pybamm/models/submodels/particle/fickian/base_fickian_particle.py deleted file mode 100644 index 368927c5c1..0000000000 --- a/pybamm/models/submodels/particle/fickian/base_fickian_particle.py +++ /dev/null @@ -1,50 +0,0 @@ -# -# Base class for particles with Fickian diffusion -# -import pybamm - -from ..base_particle import BaseParticle - - -class BaseModel(BaseParticle): - """Base class for molar conservation in particles which employ Fick's law. - - Parameters - ---------- - param : parameter class - The parameters to use for this submodel - domain : str - The domain of the model either 'Negative' or 'Positive' - - - **Extends:** :class:`pybamm.particle.BaseParticle` - """ - - def __init__(self, param, domain): - super().__init__(param, domain) - - def _flux_law(self, c, T): - - if self.domain == "Negative": - D = self.param.D_n(c, T) - elif self.domain == "Positive": - D = self.param.D_p(c, T) - - return -D * pybamm.grad(c) - - def _unpack(self, variables): - raise NotImplementedError - - def set_boundary_conditions(self, variables): - - c, _, j = self._unpack(variables) - - if self.domain == "Negative": - rbc = -self.param.C_n * j / self.param.a_n - - elif self.domain == "Positive": - rbc = -self.param.C_p * j / self.param.a_p / self.param.gamma_p - - self.boundary_conditions = { - c: {"left": (pybamm.Scalar(0), "Neumann"), "right": (rbc, "Neumann")} - } diff --git a/pybamm/models/submodels/particle/fickian/fickian_many_particles.py b/pybamm/models/submodels/particle/fickian/fickian_many_particles.py index 8b0d9d40cd..87677fde30 100644 --- a/pybamm/models/submodels/particle/fickian/fickian_many_particles.py +++ b/pybamm/models/submodels/particle/fickian/fickian_many_particles.py @@ -2,10 +2,10 @@ # Class for many particles with Fickian diffusion # import pybamm -from .base_fickian_particle import BaseModel +from ..base_particle import BaseParticle -class ManyParticles(BaseModel): +class ManyParticles(BaseParticle): """Base class for molar conservation in many particles which employs Fick's law. @@ -17,7 +17,7 @@ class ManyParticles(BaseModel): The domain of the model either 'Negative' or 'Positive' - **Extends:** :class:`pybamm.particle.fickian.BaseModel` + **Extends:** :class:`pybamm.particle.BaseParticle` """ def __init__(self, param, domain): @@ -43,7 +43,10 @@ def get_coupled_variables(self, variables): [self.domain.lower() + " particle"], ) - N_s = self._flux_law(c_s, T_k) + if self.domain == "Negative": + N_s = -self.param.D_n(c_s, T_k) * pybamm.grad(c_s) + elif self.domain == "Positive": + N_s = -self.param.D_p(c_s, T_k) * pybamm.grad(c_s) variables.update(self._get_standard_flux_variables(N_s, N_s)) @@ -56,23 +59,57 @@ def get_coupled_variables(self, variables): x = pybamm.standard_spatial_vars.x_p R = pybamm.FunctionParameter("Positive particle distribution in x", x) variables.update({"Positive particle distribution in x": R}) + return variables def set_rhs(self, variables): - - c, N, _ = self._unpack(variables) + c_s = variables[self.domain + " particle concentration"] + N_s = variables[self.domain + " particle flux"] if self.domain == "Negative": R = variables["Negative particle distribution in x"] - self.rhs = {c: -(1 / (R ** 2 * self.param.C_n)) * pybamm.div(N)} + self.rhs = {c_s: -(1 / (R ** 2 * self.param.C_n)) * pybamm.div(N_s)} elif self.domain == "Positive": R = variables["Positive particle distribution in x"] - self.rhs = {c: -(1 / (R ** 2 * self.param.C_p)) * pybamm.div(N)} + self.rhs = {c_s: -(1 / (R ** 2 * self.param.C_p)) * pybamm.div(N_s)} + + def set_boundary_conditions(self, variables): - def _unpack(self, variables): c_s = variables[self.domain + " particle concentration"] - N_s = variables[self.domain + " particle flux"] + c_s_surf = variables[self.domain + " particle surface concentration"] + T_k = variables[self.domain + " electrode temperature"] j = variables[self.domain + " electrode interfacial current density"] - return c_s, N_s, j + if self.domain == "Negative": + rbc = -self.param.C_n * j / self.param.a_n / self.param.D_n(c_s_surf, T_k) + + elif self.domain == "Positive": + rbc = ( + -self.param.C_p + * j + / self.param.a_p + / self.param.gamma_p + / self.param.D_p(c_s_surf, T_k) + ) + + self.boundary_conditions = { + c_s: {"left": (pybamm.Scalar(0), "Neumann"), "right": (rbc, "Neumann")} + } + + def set_initial_conditions(self, variables): + c_s = variables[self.domain + " particle concentration"] + + if self.domain == "Negative": + x_n = pybamm.PrimaryBroadcast( + pybamm.standard_spatial_vars.x_n, "negative particle" + ) + c_init = self.param.c_n_init(x_n) + + elif self.domain == "Positive": + x_p = pybamm.PrimaryBroadcast( + pybamm.standard_spatial_vars.x_p, "positive particle" + ) + c_init = self.param.c_p_init(x_p) + + self.initial_conditions = {c_s: c_init} diff --git a/pybamm/models/submodels/particle/fickian/fickian_single_particle.py b/pybamm/models/submodels/particle/fickian/fickian_single_particle.py index 9715e2e1c4..84579de66c 100644 --- a/pybamm/models/submodels/particle/fickian/fickian_single_particle.py +++ b/pybamm/models/submodels/particle/fickian/fickian_single_particle.py @@ -3,10 +3,10 @@ # import pybamm -from .base_fickian_particle import BaseModel +from ..base_particle import BaseParticle -class SingleParticle(BaseModel): +class SingleParticle(BaseParticle): """Base class for molar conservation in a single x-averaged particle which employs Fick's law. @@ -18,7 +18,7 @@ class SingleParticle(BaseModel): The domain of the model either 'Negative' or 'Positive' - **Extends:** :class:`pybamm.particle.fickian.BaseModel` + **Extends:** :class:`pybamm.particle.BaseParticle` """ def __init__(self, param, domain): @@ -41,11 +41,17 @@ def get_coupled_variables(self, variables): c_s_xav = variables[ "X-averaged " + self.domain.lower() + " particle concentration" ] + T_k_xav = pybamm.PrimaryBroadcast( variables["X-averaged " + self.domain.lower() + " electrode temperature"], [self.domain.lower() + " particle"], ) - N_s_xav = self._flux_law(c_s_xav, T_k_xav) + + if self.domain == "Negative": + N_s_xav = -self.param.D_n(c_s_xav, T_k_xav) * pybamm.grad(c_s_xav) + elif self.domain == "Positive": + N_s_xav = -self.param.D_p(c_s_xav, T_k_xav) * pybamm.grad(c_s_xav) + N_s = pybamm.SecondaryBroadcast(N_s_xav, [self._domain.lower() + " electrode"]) variables.update(self._get_standard_flux_variables(N_s, N_s_xav)) @@ -53,24 +59,73 @@ def get_coupled_variables(self, variables): return variables def set_rhs(self, variables): + c_s_xav = variables[ + "X-averaged " + self.domain.lower() + " particle concentration" + ] - c, N, _ = self._unpack(variables) + N_s_xav = variables["X-averaged " + self.domain.lower() + " particle flux"] if self.domain == "Negative": - self.rhs = {c: -(1 / self.param.C_n) * pybamm.div(N)} - + self.rhs = {c_s_xav: -(1 / self.param.C_n) * pybamm.div(N_s_xav)} elif self.domain == "Positive": - self.rhs = {c: -(1 / self.param.C_p) * pybamm.div(N)} + self.rhs = {c_s_xav: -(1 / self.param.C_p) * pybamm.div(N_s_xav)} - def _unpack(self, variables): + def set_boundary_conditions(self, variables): c_s_xav = variables[ "X-averaged " + self.domain.lower() + " particle concentration" ] - N_s_xav = variables["X-averaged " + self.domain.lower() + " particle flux"] - j_av = variables[ + + c_s_surf_xav = variables[ + "X-averaged " + self.domain.lower() + " particle surface concentration" + ] + + T_k_xav = variables[ + "X-averaged " + self.domain.lower() + " electrode temperature" + ] + + j_xav = variables[ "X-averaged " + self.domain.lower() + " electrode interfacial current density" ] - return c_s_xav, N_s_xav, j_av + if self.domain == "Negative": + rbc = ( + -self.param.C_n + * j_xav + / self.param.a_n + / self.param.D_n(c_s_surf_xav, T_k_xav) + ) + + elif self.domain == "Positive": + rbc = ( + -self.param.C_p + * j_xav + / self.param.a_p + / self.param.gamma_p + / self.param.D_p(c_s_surf_xav, T_k_xav) + ) + + self.boundary_conditions = { + c_s_xav: {"left": (pybamm.Scalar(0), "Neumann"), "right": (rbc, "Neumann")} + } + + def set_initial_conditions(self, variables): + """ + For single particle models, initial conditions can't depend on x so we + arbitrarily set the initial values of the single particles to be given + by the values at x=0 in the negative electrode and x=1 in the + positive electrode. Typically, supplied initial conditions are uniform + x. + """ + c_s_xav = variables[ + "X-averaged " + self.domain.lower() + " particle concentration" + ] + + if self.domain == "Negative": + c_init = self.param.c_n_init(0) + + elif self.domain == "Positive": + c_init = self.param.c_p_init(1) + + self.initial_conditions = {c_s_xav: c_init} diff --git a/pybamm/models/submodels/porosity/constant_porosity.py b/pybamm/models/submodels/porosity/constant_porosity.py index c487957f2b..da07259ac5 100644 --- a/pybamm/models/submodels/porosity/constant_porosity.py +++ b/pybamm/models/submodels/porosity/constant_porosity.py @@ -20,17 +20,10 @@ class Constant(BaseModel): def get_fundamental_variables(self): - eps_n_av = self.param.epsilon_n - eps_s_av = self.param.epsilon_s - eps_p_av = self.param.epsilon_p + eps_n = self.param.epsilon_n + eps_s = self.param.epsilon_s + eps_p = self.param.epsilon_p - eps_n = pybamm.FullBroadcast( - eps_n_av, "negative electrode", "current collector" - ) - eps_s = pybamm.FullBroadcast(eps_s_av, "separator", "current collector") - eps_p = pybamm.FullBroadcast( - eps_p_av, "positive electrode", "current collector" - ) eps = pybamm.Concatenation(eps_n, eps_s, eps_p) deps_n_dt = pybamm.FullBroadcast(0, "negative electrode", "current collector") diff --git a/pybamm/parameters/electrical_parameters.py b/pybamm/parameters/electrical_parameters.py index 7e9d1ecfac..c83405ca5a 100644 --- a/pybamm/parameters/electrical_parameters.py +++ b/pybamm/parameters/electrical_parameters.py @@ -13,6 +13,7 @@ n_electrodes_parallel = pybamm.Parameter( "Number of electrodes connected in parallel to make a cell" ) +n_cells = pybamm.Parameter("Number of cells connected in series to make a battery") i_typ = pybamm.Function( np.abs, I_typ / (n_electrodes_parallel * pybamm.geometric_parameters.A_cc) ) diff --git a/pybamm/parameters/parameter_sets.py b/pybamm/parameters/parameter_sets.py index c79d5474b1..8e229fbf6b 100644 --- a/pybamm/parameters/parameter_sets.py +++ b/pybamm/parameters/parameter_sets.py @@ -15,6 +15,12 @@ Ecker, Madeleine, et al. "Parameterization of a physico-chemical model of a lithium-ion battery i. determination of parameters." Journal of the Electrochemical Society 162.9 (2015): A1836-A1848. Ecker, Madeleine, et al. "Parameterization of a physico-chemical model of a lithium-ion battery II. Model validation." Journal of The Electrochemical Society 162.9 (2015): A1849-A1857. +NCA_Kim2011 + Kim, G. H., Smith, K., Lee, K. J., Santhanagopalan, S., & Pesaran, A. + (2011). Multi-domain modeling of lithium-ion batteries encompassing + multi-physics in varied length scales. Journal of The Electrochemical + Society, 158(8), A955-A969. + Lead-acid --------- Sulzer2019 @@ -47,6 +53,16 @@ "experiment": "1C_discharge_from_full_Ecker2015", } +NCA_Kim2011 = { + "chemistry": "lithium-ion", + "cell": "Kim2011", + "anode": "graphite_Kim2011", + "separator": "separator_Kim2011", + "cathode": "nca_Kim2011", + "electrolyte": "lipf6_Kim2011", + "experiment": "1C_discharge_from_full_Kim2011", +} + # # Lead-acid # diff --git a/pybamm/parameters/parameter_values.py b/pybamm/parameters/parameter_values.py index 234564dc66..3bb3c55d47 100644 --- a/pybamm/parameters/parameter_values.py +++ b/pybamm/parameters/parameter_values.py @@ -228,7 +228,7 @@ def update(self, values, check_conflict=False, check_already_exists=True, path=" filename = os.path.join(path, value[6:] + ".csv") function_name = value[6:] data = pd.read_csv( - filename, comment="#", skip_blank_lines=True + filename, comment="#", skip_blank_lines=True, header=None ).to_numpy() # Save name and data self._dict_items[name] = (function_name, data) @@ -351,10 +351,35 @@ def process_model(self, unprocessed_model, inplace=True): ) model.initial_conditions[variable] = self.process_symbol(equation) - # Boundary conditions are dictionaries {"left": left bc, "right": right bc} - # in general, but may be imposed on the tabs (or *not* on the tab) for a - # small number of variables, e.g. {"negative tab": neg. tab bc, - # "positive tab": pos. tab bc "no tab": no tab bc}. + model.boundary_conditions = self.process_boundary_conditions(model) + + for variable, equation in model.variables.items(): + pybamm.logger.debug( + "Processing parameters for {!r} (variables)".format(variable) + ) + model.variables[variable] = self.process_symbol(equation) + + for event in model.events: + pybamm.logger.debug( + "Processing parameters for event'{}''".format(event.name) + ) + event.expression = self.process_symbol(event.expression) + + # Process timescale + model.timescale = self.process_symbol(model.timescale) + + pybamm.logger.info("Finish setting parameters for {}".format(model.name)) + + return model + + def process_boundary_conditions(self, model): + """ + Process boundary conditions for a model + Boundary conditions are dictionaries {"left": left bc, "right": right bc} + in general, but may be imposed on the tabs (or *not* on the tab) for a + small number of variables, e.g. {"negative tab": neg. tab bc, + "positive tab": pos. tab bc "no tab": no tab bc}. + """ new_boundary_conditions = {} sides = ["left", "right", "negative tab", "positive tab", "no tab"] for variable, bcs in model.boundary_conditions.items(): @@ -377,22 +402,7 @@ def process_model(self, unprocessed_model, inplace=True): else: raise KeyError(err) - model.boundary_conditions = new_boundary_conditions - - for variable, equation in model.variables.items(): - pybamm.logger.debug( - "Processing parameters for {!r} (variables)".format(variable) - ) - model.variables[variable] = self.process_symbol(equation) - - for event in model.events: - pybamm.logger.debug("Processing parameters for event'{}''" - .format(event.name)) - event.expression = self.process_symbol(event.expression) - - pybamm.logger.info("Finish setting parameters for {}".format(model.name)) - - return model + return new_boundary_conditions def update_model(self, model, disc): raise NotImplementedError( diff --git a/pybamm/parameters/standard_parameters_lead_acid.py b/pybamm/parameters/standard_parameters_lead_acid.py index d0d7bab989..e48faefcb1 100644 --- a/pybamm/parameters/standard_parameters_lead_acid.py +++ b/pybamm/parameters/standard_parameters_lead_acid.py @@ -420,9 +420,13 @@ def U_p_dimensional(c_e, T): # hack to make consistent ic with lithium-ion -# find a way to not have to do this -c_n_init = c_e_init -c_p_init = c_e_init +def c_n_init(x): + return c_e_init + + +def c_p_init(x): + return c_e_init + # Thermal effects not implemented for lead-acid, but parameters needed for consistency T_init = pybamm.Scalar(0) diff --git a/pybamm/parameters/standard_parameters_lithium_ion.py b/pybamm/parameters/standard_parameters_lithium_ion.py index 3c6492f9f9..99e983bf27 100644 --- a/pybamm/parameters/standard_parameters_lithium_ion.py +++ b/pybamm/parameters/standard_parameters_lithium_ion.py @@ -99,12 +99,21 @@ c_e_init_dimensional = pybamm.Parameter( "Initial concentration in electrolyte [mol.m-3]" ) -c_n_init_dimensional = pybamm.Parameter( - "Initial concentration in negative electrode [mol.m-3]" -) -c_p_init_dimensional = pybamm.Parameter( - "Initial concentration in positive electrode [mol.m-3]" -) + + +def c_n_init_dimensional(x): + "Initial concentration as a function of dimensionless position x" + return pybamm.FunctionParameter( + "Initial concentration in negative electrode [mol.m-3]", x + ) + + +def c_p_init_dimensional(x): + "Initial concentration as a function of dimensionless position x" + return pybamm.FunctionParameter( + "Initial concentration in positive electrode [mol.m-3]", x + ) + # thermal Delta_T = pybamm.thermal_parameters.Delta_T @@ -268,14 +277,11 @@ def U_p_dimensional(sto, T): centre_z_tab_p = pybamm.geometric_parameters.centre_z_tab_p # Microscale geometry -epsilon_n = pybamm.Parameter("Negative electrode porosity") -epsilon_s = pybamm.Parameter("Separator porosity") -epsilon_p = pybamm.Parameter("Positive electrode porosity") -epsilon = pybamm.Concatenation( - pybamm.FullBroadcast(epsilon_n, ["negative electrode"], "current collector"), - pybamm.FullBroadcast(epsilon_s, ["separator"], "current collector"), - pybamm.FullBroadcast(epsilon_p, ["positive electrode"], "current collector"), -) +var = pybamm.standard_spatial_vars +epsilon_n = pybamm.FunctionParameter("Negative electrode porosity", var.x_n) +epsilon_s = pybamm.FunctionParameter("Separator porosity", var.x_s) +epsilon_p = pybamm.FunctionParameter("Positive electrode porosity", var.x_p) +epsilon = pybamm.Concatenation(epsilon_n, epsilon_s, epsilon_p) epsilon_s_n = pybamm.Parameter("Negative electrode active material volume fraction") epsilon_s_p = pybamm.Parameter("Positive electrode active material volume fraction") epsilon_inactive_n = 1 - epsilon_n - epsilon_s_n @@ -364,6 +370,20 @@ def chi(c_e): / (pybamm.thermal_parameters.rho_eff_dim * F * Delta_T * L_x) ) +# Initial conditions +T_init = pybamm.thermal_parameters.T_init +c_e_init = c_e_init_dimensional / c_e_typ + + +def c_n_init(x): + "Dimensionless initial concentration as a function of dimensionless position x" + return c_n_init_dimensional(x) / c_n_max + + +def c_p_init(x): + "Dimensionless initial concentration as a function of dimensionless position x" + return c_p_init_dimensional(x) / c_p_max + # -------------------------------------------------------------------------------------- "5. Dimensionless Functions" diff --git a/pybamm/quick_plot.py b/pybamm/quick_plot.py index e320adffd3..4d44fb8d77 100644 --- a/pybamm/quick_plot.py +++ b/pybamm/quick_plot.py @@ -3,6 +3,7 @@ # import numpy as np import pybamm +import warnings from collections import defaultdict @@ -85,10 +86,11 @@ def __init__( self.colors = colors self.linestyles = linestyles - # Scales (default to 1 if information not in model) + # Time scale in hours + self.time_scale = models[0].timescale_eval / 3600 + # Spatial scales (default to 1 if information not in model) variables = models[0].variables - self.spatial_scales = {"x": 1, "y": 1, "z": 1} - self.time_scale = 1 + self.spatial_scales = {"x": 1, "y": 1, "z": 1, "r_n": 1, "r_p": 1} if "x [m]" and "x" in variables: self.spatial_scales["x"] = (variables["x [m]"] / variables["x"]).evaluate()[ -1 @@ -109,8 +111,6 @@ def __init__( self.spatial_scales["r_p"] = ( variables["r_p [m]"] / variables["r_p"] ).evaluate()[-1] - if "Time [h]" and "Time" in variables: - self.time_scale = (variables["Time [h]"] / variables["Time"]).evaluate(t=1) # Time parameters self.ts = [solution.t for solution in solutions] @@ -373,10 +373,10 @@ def dynamic_plot(self, testing=False): self.sfreq = Slider(axfreq, "Time", 0, self.max_t, valinit=0) self.sfreq.on_changed(self.update) - # plt.subplots_adjust( - # top=0.92, bottom=0.15, left=0.10, right=0.9, hspace=0.5, wspace=0.5 - # ) + # ignore the warning about tight layout + warnings.simplefilter("ignore") self.fig.tight_layout() + warnings.simplefilter("always") if not testing: # pragma: no cover plt.show() diff --git a/pybamm/simulation.py b/pybamm/simulation.py index d94e47e7c7..75d7f14274 100644 --- a/pybamm/simulation.py +++ b/pybamm/simulation.py @@ -5,6 +5,8 @@ import pybamm import numpy as np import copy +import warnings +import sys def isnotebook(): @@ -20,6 +22,26 @@ def isnotebook(): return False # Probably standard Python interpreter +def constant_current_constant_voltage_constant_power(variables): + I = variables["Current [A]"] + V = variables["Terminal voltage [V]"] + s_I = pybamm.InputParameter("Current switch") + s_V = pybamm.InputParameter("Voltage switch") + s_P = pybamm.InputParameter("Power switch") + n_electrodes_parallel = pybamm.electrical_parameters.n_electrodes_parallel + n_cells = pybamm.electrical_parameters.n_cells + return ( + s_I * (I - pybamm.InputParameter("Current input [A]") / n_electrodes_parallel) + + s_V * (V - pybamm.InputParameter("Voltage input [V]") / n_cells) + + s_P + * ( + V * I + - pybamm.InputParameter("Power input [W]") + / (n_cells * n_electrodes_parallel) + ) + ) + + class Simulation: """A Simulation class for easy building and running of PyBaMM simulations. @@ -27,6 +49,8 @@ class Simulation: ---------- model : :class:`pybamm.BaseModel` The model to be simulated + experiment : : class:`pybamm.Experiment` (optional) + The experimental conditions under which to solve the model geometry: :class:`pybamm.Geometry` (optional) The geometry upon which to solve the model parameter_values: dict (optional) @@ -52,6 +76,7 @@ class Simulation: def __init__( self, model, + experiment=None, geometry=None, parameter_values=None, submesh_types=None, @@ -61,19 +86,23 @@ def __init__( quick_plot_vars=None, C_rate=None, ): - self.model = model - - self.geometry = geometry or model.default_geometry self._parameter_values = parameter_values or model.default_parameter_values - self._submesh_types = submesh_types or model.default_submesh_types - self._var_pts = var_pts or model.default_var_pts - self._spatial_methods = spatial_methods or model.default_spatial_methods - self._solver = solver or self._model.default_solver - self._quick_plot_vars = quick_plot_vars - self.C_rate = C_rate - if self.C_rate: - self._parameter_values.update({"C-rate": self.C_rate}) + if experiment is None: + self.operating_mode = "without experiment" + self.C_rate = C_rate + if self.C_rate: + self._parameter_values.update({"C-rate": self.C_rate}) + self.model = model + else: + self.set_up_experiment(model, experiment) + + self.geometry = geometry or self.model.default_geometry + self._submesh_types = submesh_types or self.model.default_submesh_types + self._var_pts = var_pts or self.model.default_var_pts + self._spatial_methods = spatial_methods or self.model.default_spatial_methods + self._solver = solver or self.model.default_solver + self._quick_plot_vars = quick_plot_vars self.reset(update_model=False) @@ -83,6 +112,130 @@ def __init__( warnings.filterwarnings("ignore") + def set_up_experiment(self, model, experiment): + """ + Set up a simulation to run with an experiment. This creates a dictionary of + inputs (current/voltage/power, running time, stopping condition) for each + operating condition in the experiment. The model will then be solved by + integrating the model successively with each group of inputs, one group at a + time. + """ + self.operating_mode = "with experiment" + self.model = model.new_copy( + options={ + **model.options, + "operating mode": constant_current_constant_voltage_constant_power, + } + ) + if not isinstance(experiment, pybamm.Experiment): + raise TypeError("experiment must be a pybamm `Experiment` instance") + # Save the experiment + self.experiment = experiment + # Update parameter values with experiment parameters + self._parameter_values.update(experiment.parameters) + # Create a new submodel for each set of operating conditions and update + # parameters and events accordingly + self._experiment_inputs = [] + self._experiment_times = [] + for op, events in zip(experiment.operating_conditions, experiment.events): + if op[1] in ["A", "C"]: + # Update inputs for constant current + if op[1] == "A": + I = op[0] + else: + # Scale C-rate with capacity to obtain current + capacity = self._parameter_values["Cell capacity [A.h]"] + I = op[0] * capacity + operating_inputs = { + "Current switch": 1, + "Voltage switch": 0, + "Power switch": 0, + "Current input [A]": I, + "Voltage input [V]": 0, # doesn't matter + "Power input [W]": 0, # doesn't matter + } + elif op[1] == "V": + # Update inputs for constant voltage + V = op[0] + operating_inputs = { + "Current switch": 0, + "Voltage switch": 1, + "Power switch": 0, + "Current input [A]": 0, # doesn't matter + "Voltage input [V]": V, + "Power input [W]": 0, # doesn't matter + } + elif op[1] == "W": + # Update inputs for constant power + P = op[0] + operating_inputs = { + "Current switch": 0, + "Voltage switch": 0, + "Power switch": 1, + "Current input [A]": 0, # doesn't matter + "Voltage input [V]": 0, # doesn't matter + "Power input [W]": P, + } + # Update period + operating_inputs["period"] = op[3] + # Update events + if events is None: + # make current and voltage values that won't be hit + operating_inputs.update( + {"Current cut-off [A]": -1e10, "Voltage cut-off [V]": -1e10} + ) + elif events[1] in ["A", "C"]: + # update current cut-off, make voltage a value that won't be hit + if events[1] == "A": + I = events[0] + else: + # Scale C-rate with capacity to obtain current + capacity = self._parameter_values["Cell capacity [A.h]"] + I = events[0] * capacity + operating_inputs.update( + {"Current cut-off [A]": I, "Voltage cut-off [V]": -1e10} + ) + elif events[1] == "V": + # update voltage cut-off, make current a value that won't be hit + V = events[0] + operating_inputs.update( + {"Current cut-off [A]": -1e10, "Voltage cut-off [V]": V} + ) + + self._experiment_inputs.append(operating_inputs) + # Add time to the experiment times + dt = op[2] + if dt is None: + # max simulation time: 1 week + dt = 7 * 24 * 3600 + self._experiment_times.append(dt) + + # add current and voltage events to the model + # current events both negative and positive to catch specification + n_electrodes_parallel = pybamm.electrical_parameters.n_electrodes_parallel + n_cells = pybamm.electrical_parameters.n_cells + self.model.events.extend( + [ + pybamm.Event( + "Current cut-off (positive) [A] [experiment]", + self.model.variables["Current [A]"] + - abs(pybamm.InputParameter("Current cut-off [A]")) + / n_electrodes_parallel, + ), + pybamm.Event( + "Current cut-off (negative) [A] [experiment]", + self.model.variables["Current [A]"] + + abs(pybamm.InputParameter("Current cut-off [A]")) + / n_electrodes_parallel, + ), + pybamm.Event( + "Voltage cut-off [V] [experiment]", + self.model.variables["Terminal voltage [V]"] + - pybamm.InputParameter("Voltage cut-off [V]") / n_cells, + ), + ] + ) + def set_defaults(self): """ A method to set all the simulation specs to default values for the @@ -146,7 +299,7 @@ def build(self, check_model=True): self._mesh = pybamm.Mesh(self._geometry, self._submesh_types, self._var_pts) self._disc = pybamm.Discretisation(self._mesh, self._spatial_methods) self._built_model = self._disc.process_model( - self._model, inplace=False, check_model=check_model + self._model_with_set_params, inplace=False, check_model=check_model ) def solve( @@ -164,10 +317,11 @@ def solve( Parameters ---------- t_eval : numeric type, optional - The times at which to compute the solution. If None the model will - be solved for a full discharge (1 hour / C_rate) if the discharge - timescale is provided. Otherwise the model will be solved up to a - non-dimensional time of 1. + The times at which to compute the solution. If None and the parameter + "Current function [A]" is not read from data the model will + be solved for a full discharge (1 hour / C_rate). If None and the + parameter "Current function [A]" is read from data the model will be + solved at the times provided in the data. solver : :class:`pybamm.BaseSolver` The solver to use to solve the model. external_variables : dict @@ -181,28 +335,110 @@ def solve( If True, model checks are performed after discretisation (see :meth:`pybamm.Discretisation.process_model`). Default is True. """ + # Setup self.build(check_model=check_model) + if solver is None: + solver = self.solver - if t_eval is None: - try: - # Try to compute discharge time - tau = self._parameter_values.evaluate(self.model.param.tau_discharge) + if self.operating_mode == "without experiment": + # For drive cycles (current provided as data) we perform additional tests + # on t_eval (if provided) to ensure the returned solution captures the + # input. If the current is provided as data then the "Current function [A]" + # is the tuple (filename, data). + if isinstance(self._parameter_values["Current function [A]"], tuple): + filename = self._parameter_values["Current function [A]"][0] + time_data = self._parameter_values["Current function [A]"][1][:, 0] + # If no t_eval is provided, we use the times provided in the data. + if t_eval is None: + pybamm.logger.info( + "Setting t_eval as specified by the data '{}'".format(filename) + ) + t_eval = time_data + # If t_eval is provided we first check if it contains all of the times + # in the data to within 10-12. If it doesn't, we then check + # that the largest gap in t_eval is smaller than the smallest gap in the + # time data (to ensure the resolution of t_eval is fine enough). + # We only raise a warning here as users may genuinely only want + # the solution returned at some specified points. + elif ( + set(np.round(time_data, 12)).issubset(set(np.round(t_eval, 12))) + ) is False: + warnings.warn( + """ + t_eval does not contain all of the time points in the data + '{}'. Note: passing t_eval = None automatically sets t_eval + to be the points in the data. + """.format( + filename + ), + pybamm.SolverWarning, + ) + dt_data_min = np.min(np.diff(time_data)) + dt_eval_max = np.max(np.diff(t_eval)) + if dt_eval_max > dt_data_min + sys.float_info.epsilon: + warnings.warn( + """ + The largest timestep in t_eval ({}) is larger than + the smallest timestep in the data ({}). The returned + solution may not have the correct resolution to accurately + capture the input. Try refining t_eval. Alternatively, + passing t_eval = None automatically sets t_eval to be the + points in the data. + """.format( + dt_eval_max, dt_data_min + ), + pybamm.SolverWarning, + ) + # If not using a drive cycle and t_eval is not provided, set t_eval + # to correspond to a single discharge + elif t_eval is None: C_rate = self._parameter_values["C-rate"] - t_end = 3600 / tau / C_rate + t_end = 3600 / C_rate t_eval = np.linspace(0, t_end, 100) - except AttributeError: - t_eval = np.linspace(0, 1, 100) - if solver is None: - solver = self.solver - - self.t_eval = t_eval - self._solution = solver.solve( - self.built_model, - t_eval, - external_variables=external_variables, - inputs=inputs, - ) + self.t_eval = t_eval + self._solution = solver.solve(self.built_model, t_eval, inputs=inputs) + + elif self.operating_mode == "with experiment": + if t_eval is not None: + pybamm.logger.warning( + "Ignoring t_eval as solution times are specified by the experiment" + ) + # Step through all experimental conditions + inputs = inputs or {} + pybamm.logger.info("Start running experiment") + timer = pybamm.Timer() + for idx, (exp_inputs, dt) in enumerate( + zip(self._experiment_inputs, self._experiment_times) + ): + pybamm.logger.info(self.experiment.operating_conditions_strings[idx]) + inputs.update(exp_inputs) + # Make sure we take at least 2 timesteps + npts = max(int(round(dt / exp_inputs["period"])) + 1, 2) + self.step( + dt, npts=npts, external_variables=external_variables, inputs=inputs + ) + # Only allow events specified by experiment + if not ( + self._solution.termination == "final time" + or "[experiment]" in self._solution.termination + ): + pybamm.logger.warning( + """ + Experiment is infeasible: '{}' was triggered during '{}'. Try + reducing current, shortening the time interval, or reducing + the period. + """.format( + self._solution.termination, + self.experiment.operating_conditions_strings[idx], + ) + ) + break + pybamm.logger.info( + "Finish experiment simulation, took {}".format( + timer.format(timer.time()) + ) + ) def step( self, dt, solver=None, npts=2, external_variables=None, inputs=None, save=True @@ -469,7 +705,7 @@ def specs( def save(self, filename): """Save simulation using pickle""" if self.model.convert_to_format == "python": - # We currently cannot save models in the 'python' + # We currently cannot save models in the 'python' format raise NotImplementedError( """ Cannot save simulation if model format is python. diff --git a/pybamm/solvers/base_solver.py b/pybamm/solvers/base_solver.py index 36672d6070..f17b85a1fa 100644 --- a/pybamm/solvers/base_solver.py +++ b/pybamm/solvers/base_solver.py @@ -47,6 +47,7 @@ def __init__( self.root_tol = root_tol self.max_steps = max_steps + self.models_set_up = set() self.model_step_times = {} # Defaults, can be overwritten by specific solver @@ -116,6 +117,9 @@ def set_up(self, model, inputs=None): inputs = inputs or {} y0 = model.concatenated_initial_conditions + # Set model timescale + model.timescale_eval = model.timescale.evaluate(u=inputs) + # Check model.algebraic for ode solvers if self.ode_solver is True and len(model.algebraic) > 0: raise pybamm.SolverError( @@ -429,6 +433,8 @@ def solve(self, model, t_eval, external_variables=None, inputs=None): if (np.diff(t_eval) < 0).any(): raise pybamm.SolverError("t_eval must increase monotonically") + # Non-dimensionalise t_eval + # Set up timer = pybamm.Timer() @@ -437,9 +443,23 @@ def solve(self, model, t_eval, external_variables=None, inputs=None): inputs = inputs or {} ext_and_inputs = {**external_variables, **inputs} - self.set_up(model, ext_and_inputs) - set_up_time = timer.time() + # Raise warning if t_eval looks like it was supposed to be dimensionless + # already + if t_eval[-1] < 0.5: + raise pybamm.SolverError( + """It looks like t_eval might be dimensionless. + t_eval should now be provided in seconds""" + ) + # Set up (if not done already) + if model not in self.models_set_up: + self.set_up(model, ext_and_inputs) + set_up_time = timer.time() + self.models_set_up.add(model) + else: + set_up_time = 0 + # Non-dimensionalise time + t_eval_dimensionless = t_eval / model.timescale_eval # Solve # Set inputs and external self.set_inputs(model, ext_and_inputs) @@ -452,9 +472,14 @@ def solve(self, model, t_eval, external_variables=None, inputs=None): # make sure they are increasing in time discontinuities = sorted(discontinuities) - pybamm.logger.info( - "Discontinuity events found at t = {}".format(discontinuities) - ) + + if len(discontinuities) > 0: + pybamm.logger.info( + "Discontinuity events found at t = {}".format(discontinuities) + ) + else: + pybamm.logger.info("No discontinuity events found") + # remove any identical discontinuities discontinuities = [ v @@ -468,19 +493,21 @@ def solve(self, model, t_eval, external_variables=None, inputs=None): start_indices = [0] end_indices = [] for dtime in discontinuities: - dindex = np.searchsorted(t_eval, dtime, side="left") + dindex = np.searchsorted(t_eval_dimensionless, dtime, side="left") end_indices.append(dindex + 1) start_indices.append(dindex + 1) - if t_eval[dindex] == dtime: - t_eval[dindex] += sys.float_info.epsilon - t_eval = np.insert(t_eval, dindex, dtime - sys.float_info.epsilon) + if t_eval_dimensionless[dindex] == dtime: + t_eval_dimensionless[dindex] += sys.float_info.epsilon + t_eval_dimensionless = np.insert( + t_eval_dimensionless, dindex, dtime - sys.float_info.epsilon + ) else: - t_eval = np.insert( - t_eval, + t_eval_dimensionless = np.insert( + t_eval_dimensionless, dindex, [dtime - sys.float_info.epsilon, dtime + sys.float_info.epsilon], ) - end_indices.append(len(t_eval)) + end_indices.append(len(t_eval_dimensionless)) # integrate separatly over each time segment and accumulate into the solution # object, restarting the solver at each discontinuity (and recalculating a @@ -490,18 +517,19 @@ def solve(self, model, t_eval, external_variables=None, inputs=None): for start_index, end_index in zip(start_indices, end_indices): pybamm.logger.info( "Calling solver for {} < t < {}".format( - t_eval[start_index], t_eval[end_index - 1] + t_eval_dimensionless[start_index] * model.timescale_eval, + t_eval_dimensionless[end_index - 1] * model.timescale_eval, ) ) timer.reset() if solution is None: solution = self._integrate( - model, t_eval[start_index:end_index], ext_and_inputs + model, t_eval_dimensionless[start_index:end_index], ext_and_inputs ) solution.solve_time = timer.time() else: new_solution = self._integrate( - model, t_eval[start_index:end_index], ext_and_inputs + model, t_eval_dimensionless[start_index:end_index], ext_and_inputs ) new_solution.solve_time = timer.time() solution.append(new_solution, start_index=0) @@ -509,12 +537,12 @@ def solve(self, model, t_eval, external_variables=None, inputs=None): if solution.termination != "final time": break - if end_index != len(t_eval): + if end_index != len(t_eval_dimensionless): # setup for next integration subsection y0_guess = solution.y[:, -1] if model.algebraic: model.y0 = self.calculate_consistent_state( - model, t_eval[end_index], y0_guess + model, t_eval_dimensionless[end_index], y0_guess ) else: model.y0 = y0_guess @@ -522,7 +550,7 @@ def solve(self, model, t_eval, external_variables=None, inputs=None): last_state = solution.y[:, -1] if len(model.algebraic) > 0: model.y0 = self.calculate_consistent_state( - model, t_eval[end_index], last_state + model, t_eval_dimensionless[end_index], last_state ) else: model.y0 = last_state @@ -583,8 +611,13 @@ def step( If an empty model is passed (`model.rhs = {}` and `model.algebraic={}`) """ - if old_solution is not None and old_solution.termination != "final time": + + if old_solution is not None and not ( + old_solution.termination == "final time" + or "[experiment]" in old_solution.termination + ): # Return same solution as an event has already been triggered + # With hack to allow stepping past experiment current / voltage cut-off return old_solution # Make sure model isn't empty @@ -610,9 +643,11 @@ def step( else: set_up_time = 0 + # Non-dimensionalise dt + dt_dimensionless = dt / model.timescale_eval # Step t = self.model_step_times[model] - t_eval = np.linspace(t, t + dt, npts) + t_eval = np.linspace(t, t + dt_dimensionless, npts) # Set inputs and external self.set_inputs(model, ext_and_inputs) @@ -709,10 +744,16 @@ def set_inputs(self, inputs): self.inputs = inputs elif self.form == "casadi": self.inputs = casadi.vertcat(*[x for x in inputs.values()]) + self.timescale = self.model.timescale_eval def __call__(self, t, y): y = y[:, np.newaxis] if self.name in ["RHS", "algebraic", "residuals", "event"]: + pybamm.logger.debug( + "Evaluating {} for {} at t={}".format( + self.name, self.model.name, t * self.timescale + ) + ) return self.function(t, y).flatten() else: return self.function(t, y) @@ -736,8 +777,5 @@ def __init__(self, function, name, model): self.mass_matrix = model.mass_matrix.entries def __call__(self, t, y, ydot): - pybamm.logger.debug( - "Evaluating residuals for {} at t={}".format(self.model.name, t) - ) states_eval = super().__call__(t, y) return states_eval - self.mass_matrix @ ydot diff --git a/pybamm/solvers/casadi_solver.py b/pybamm/solvers/casadi_solver.py index 01e031c1cf..141364ac24 100644 --- a/pybamm/solvers/casadi_solver.py +++ b/pybamm/solvers/casadi_solver.py @@ -87,29 +87,25 @@ def _integrate(self, model, t_eval, inputs=None): """ inputs = inputs or {} - rhs_size = model.rhs_eval(0, model.y0).shape[0] if self.mode == "fast": integrator = self.get_integrator(model, t_eval, inputs) - y0_diff, y0_alg = np.split(model.y0, [rhs_size]) - solution = self._run_integrator(integrator, y0_diff, y0_alg, inputs, t_eval) + solution = self._run_integrator(integrator, model, model.y0, inputs, t_eval) solution.termination = "final time" return solution elif not model.events: pybamm.logger.info("No events found, running fast mode") integrator = self.get_integrator(model, t_eval, inputs) - y0_diff, y0_alg = np.split(model.y0, [rhs_size]) - solution = self._run_integrator(integrator, y0_diff, y0_alg, inputs, t_eval) + solution = self._run_integrator(integrator, model, model.y0, inputs, t_eval) solution.termination = "final time" return solution elif self.mode == "safe": # Step-and-check init_event_signs = np.sign( - np.concatenate([event(0, model.y0) - for event in model.terminate_events_eval]) - ) - pybamm.logger.info( - "Start solving {} with {} in 'safe' mode".format(model.name, self.name) + np.concatenate( + [event(0, model.y0) for event in model.terminate_events_eval] + ) ) + pybamm.logger.info("Start solving {} with {}".format(model.name, self.name)) t = t_eval[0] y0 = model.y0 # Initialize solution @@ -128,9 +124,8 @@ def _integrate(self, model, t_eval, inputs=None): # different to t_eval, but shouldn't matter too much as it should # only happen near events. try: - y0_diff, y0_alg = np.split(y0, [rhs_size]) current_step_sol = self._run_integrator( - integrator, y0_diff, y0_alg, inputs, np.array([t, t + dt]) + integrator, model, y0, inputs, np.array([t, t + dt]) ) solved = True except pybamm.SolverError: @@ -165,7 +160,9 @@ def _integrate(self, model, t_eval, inputs=None): current_step_sol.solve_time = np.nan # append solution from the current step to solution solution.append(current_step_sol) - t = solution.t[-1] + # update time + t += dt + # update y0 y0 = solution.y[:, -1] return solution @@ -217,7 +214,9 @@ def get_integrator(self, model, t_eval, inputs): "F", self.methods[model], self.problems[model], self.options[model] ) - def _run_integrator(self, integrator, y0_diff, y0_alg, inputs, t_eval): + def _run_integrator(self, integrator, model, y0, inputs, t_eval): + rhs_size = model.rhs_eval(0, y0).shape[0] + y0_diff, y0_alg = np.split(y0, [rhs_size]) try: # Try solving u_stacked = casadi.vertcat(*[x for x in inputs.values()]) diff --git a/pybamm/solvers/scikits_dae_solver.py b/pybamm/solvers/scikits_dae_solver.py index c7c534566e..5f9999cbb7 100644 --- a/pybamm/solvers/scikits_dae_solver.py +++ b/pybamm/solvers/scikits_dae_solver.py @@ -117,10 +117,14 @@ def jacfn(t, y, ydot, residuals, cj, J): # 2 = found root(s) elif sol.flag == 2: termination = "event" + if sol.roots.t is None: + t_root = None + else: + t_root = sol.roots.t return pybamm.Solution( sol.values.t, np.transpose(sol.values.y), - sol.roots.t, + t_root, np.transpose(sol.roots.y), termination, ) diff --git a/pybamm/solvers/scikits_ode_solver.py b/pybamm/solvers/scikits_ode_solver.py index 57ea369f80..196c05e97a 100644 --- a/pybamm/solvers/scikits_ode_solver.py +++ b/pybamm/solvers/scikits_ode_solver.py @@ -125,10 +125,14 @@ def jac_times_setupfn(t, y, fy, userdata): # 2 = found root(s) elif sol.flag == 2: termination = "event" + if sol.roots.t is None: + t_root = None + else: + t_root = sol.roots.t return pybamm.Solution( sol.values.t, np.transpose(sol.values.y), - sol.roots.t, + t_root, np.transpose(sol.roots.y), termination, ) diff --git a/pybamm/solvers/solution.py b/pybamm/solvers/solution.py index 31f9ef387c..2c36ecc73d 100644 --- a/pybamm/solvers/solution.py +++ b/pybamm/solvers/solution.py @@ -1,17 +1,21 @@ # # Solution class # +import copy import numbers import numpy as np import pickle import pybamm +import pandas as pd from collections import defaultdict +from scipy.io import savemat -class Solution(object): +class _BaseSolution(object): """ - Class containing the solution of, and various attributes associated with, a PyBaMM - model. + (Semi-private) class containing the solution of, and various attributes associated + with, a PyBaMM model. This class is automatically created by the `Solution` class, + and should never be called from outside the `Solution` class. Parameters ---------- @@ -27,48 +31,56 @@ class Solution(object): the event happens. termination : str String to indicate why the solution terminated + copy_this : :class:`pybamm.Solution`, optional + A solution to copy, if provided. Default is None. """ - def __init__(self, t, y, t_event=None, y_event=None, termination="final time"): - self.t = t - self.y = y - self.t_event = t_event - self.y_event = y_event - self.termination = termination - # initialize empty inputs and model, to be populated later - self.inputs = {} - self._model = None + def __init__( + self, + t, + y, + t_event=None, + y_event=None, + termination="final time", + copy_this=None, + ): + self._t = t + self._y = y + self._t_event = t_event + self._y_event = y_event + self._termination = termination + if copy_this is None: + # initialize empty inputs and model, to be populated later + self._inputs = pybamm.FuzzyDict() + self._model = None + self.set_up_time = None + self.solve_time = None + else: + self._inputs = copy.copy(copy_this.inputs) + self._model = copy_this.model + self.set_up_time = copy_this.set_up_time + self.solve_time = copy_this.solve_time # initiaize empty variables and data - self._variables = {} - self.data = {} + self._variables = pybamm.FuzzyDict() + self.data = pybamm.FuzzyDict() # initialize empty known evals - self.known_evals = defaultdict(dict) + self._known_evals = defaultdict(dict) for time in t: - self.known_evals[time] = {} + self._known_evals[time] = {} @property def t(self): "Times at which the solution is evaluated" return self._t - @t.setter - def t(self, value): - "Updates the solution times" - self._t = value - @property def y(self): "Values of the solution" return self._y - @y.setter - def y(self, value): - "Updates the solution values" - self._y = value - @property def inputs(self): "Values of the inputs" @@ -124,44 +136,6 @@ def termination(self, value): "Updates the reason for termination" self._termination = value - def __add__(self, other): - "See :meth:`Solution.append`" - self.append(other) - return self - - def append(self, solution, start_index=1): - """ - - Appends solution.t and solution.y onto self.t and self.y. - - Note: by default this process removes the initial time and state of solution to - avoid duplicate times and states being stored (self.t[-1] is equal to - solution.t[0], and self.y[:, -1] is equal to solution.y[:, 0]). Set the optional - argument ``start_index`` to override this behavior - - """ - # Update t, y and inputs - self.t = np.concatenate((self.t, solution.t[start_index:])) - self.y = np.concatenate((self.y, solution.y[:, start_index:]), axis=1) - for name, inp in self.inputs.items(): - solution_inp = solution.inputs[name] - if isinstance(solution_inp, numbers.Number): - solution_inp = solution_inp * np.ones_like(solution.t) - self.inputs[name] = np.concatenate((inp, solution_inp[start_index:])) - # Update solution time - self.solve_time += solution.solve_time - # Update termination - self.termination = solution.termination - self.t_event = solution.t_event - self.y_event = solution.y_event - - # Update known_evals - for t, evals in solution.known_evals.items(): - self.known_evals[t].update(evals) - # Recompute existing variables - for var in self._variables.keys(): - self.update(var) - @property def total_time(self): return self.set_up_time + self.solve_time @@ -175,12 +149,12 @@ def update(self, variables): for key in variables: pybamm.logger.debug("Post-processing {}".format(key)) var = pybamm.ProcessedVariable( - self.model.variables[key], self, self.known_evals + self.model.variables[key], self, self._known_evals ) # Update known_evals in order to process any other variables faster for t in var.known_evals: - self.known_evals[t].update(var.known_evals[t]) + self._known_evals[t].update(var.known_evals[t]) # Save variable and data self._variables[key] = var @@ -218,15 +192,144 @@ def save(self, filename): with open(filename, "wb") as f: pickle.dump(self, f, pickle.HIGHEST_PROTOCOL) - def save_data(self, filename): - """Save solution data only (raw arrays) using pickle""" - if len(self.data) == 0: + def save_data(self, filename, variables=None, to_format="pickle"): + """ + Save solution data only (raw arrays) + + Parameters + ---------- + filename : str + The name of the file to save data to + variables : list, optional + List of variables to save. If None, saves all of the variables that have + been created so far + to_format : str, optional + The format to save to. Options are: + + - 'pickle' (default): creates a pickle file with the data dictionary + - 'matlab': creates a .mat file, for loading in matlab + - 'csv': creates a csv file (1D variables only) + + """ + if variables is None: + # variables not explicitly provided -> save all variables that have been + # computed + data = self.data + else: + # otherwise, save only the variables specified + data = {} + for name in variables: + data[name] = self[name].data + if len(data) == 0: raise ValueError( - """Solution does not have any data. Add variables by calling - 'solution.update', e.g. - 'solution.update(["Terminal voltage [V]", "Current [A]"])' - and then save""" + """ + Solution does not have any data. Please provide a list of variables + to save. + """ + ) + if to_format == "pickle": + with open(filename, "wb") as f: + pickle.dump(data, f, pickle.HIGHEST_PROTOCOL) + elif to_format == "matlab": + savemat(filename, data) + elif to_format == "csv": + for name, var in data.items(): + if var.ndim == 2: + raise ValueError( + "only 1D variables can be saved to csv, but '{}' is 2D".format( + name + ) + ) + df = pd.DataFrame(data) + df.to_csv(filename, index=False) + + +class Solution(_BaseSolution): + """ + Class extending the base solution, with additional functionality for concatenating + different solutions together + + **Extends**: :class:`_BaseSolution` + + """ + + def __init__( + self, t, y, t_event=None, y_event=None, termination="final time", + ): + super().__init__(t, y, t_event, y_event, termination) + + @property + def sub_solutions(self): + "List of sub solutions that have been concatenated to form the full solution" + try: + return self._sub_solutions + except AttributeError: + raise AttributeError( + "sub solutions are only created once other solutions have been appended" + ) + + def __add__(self, other): + "See :meth:`Solution.append`" + self.append(other, create_sub_solutions=True) + return self + + def append(self, solution, start_index=1, create_sub_solutions=False): + """ + Appends solution.t and solution.y onto self.t and self.y. + + Note: by default this process removes the initial time and state of solution to + avoid duplicate times and states being stored (self.t[-1] is equal to + solution.t[0], and self.y[:, -1] is equal to solution.y[:, 0]). Set the optional + argument ``start_index`` to override this behavior + """ + # Create sub-solutions if necessary + # sub-solutions are 'BaseSolution' objects, which have slightly reduced + # functionality compared to normal solutions (can't append other solutions) + if create_sub_solutions and not hasattr(self, "_sub_solutions"): + self._sub_solutions = [ + _BaseSolution( + self.t, + self.y, + self.t_event, + self.y_event, + self.termination, + copy_this=self, + ) + ] + + # (Create and) update sub-solutions + # Create a list of sub-solutions, which are simpler BaseSolution classes + + # Update t, y and inputs + self._t = np.concatenate((self._t, solution.t[start_index:])) + self._y = np.concatenate((self._y, solution.y[:, start_index:]), axis=1) + for name, inp in self.inputs.items(): + solution_inp = solution.inputs[name] + self.inputs[name] = np.concatenate((inp, solution_inp[start_index:])) + # Update solution time + self.solve_time += solution.solve_time + # Update termination + self._termination = solution.termination + self._t_event = solution._t_event + self._y_event = solution._y_event + + # Update known_evals + for t, evals in solution._known_evals.items(): + self._known_evals[t].update(evals) + # Recompute existing variables + for var in self._variables.keys(): + self.update(var) + + # Append sub_solutions + if create_sub_solutions: + self._sub_solutions.append( + _BaseSolution( + solution.t, + solution.y, + solution.t_event, + solution.y_event, + solution.termination, + copy_this=solution, + ) ) - with open(filename, "wb") as f: - pickle.dump(self.data, f, pickle.HIGHEST_PROTOCOL) diff --git a/scripts/install_scikits_odes.sh b/scripts/install_scikits_odes.sh index 997d67c4e1..ef943db8a9 100755 --- a/scripts/install_scikits_odes.sh +++ b/scripts/install_scikits_odes.sh @@ -16,7 +16,8 @@ cmake -DLAPACK_ENABLE=ON -DSUNDIALS_INDEX_TYPE=int32_t -DBUILD_ARKODE:BOOL=OFF - make install cd $CURRENT_DIR rm -rf $TMP_DIR -export LD_LIBRARY_PATH=$INSTALL_DIR/lib:$LD_LIBRARY_PATH +export LD_LIBRARY_PATH=$INSTALL_DIR/lib:$LD_LIBRARY_PATH # For Linux +export DYLD_LIBRARY_PATH=$INSTALL_DIR/lib:$DYLD_LIBRARY_PATH # For Mac export SUNDIALS_INST=$INSTALL_DIR pip install scikits.odes diff --git a/scripts/install_sundials_4.1.0.sh b/scripts/install_sundials_4.1.0.sh index 725ce5457c..6da6751e70 100755 --- a/scripts/install_sundials_4.1.0.sh +++ b/scripts/install_sundials_4.1.0.sh @@ -32,14 +32,20 @@ cmake -DBLAS_ENABLE=ON\ -DKLU_ENABLE=ON\ ../sundials-4.1.0 - -NUM_OF_CORES=$(cat /proc/cpuinfo | grep processor | wc -l) +if [ "$(uname)" == "Darwin" ]; then + # Mac OS X platform + NUM_OF_CORES=$(sysctl -n hw.cpu) +elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then + # GNU/Linux platform + NUM_OF_CORES=$(cat /proc/cpuinfo | grep processor | wc -l) +fi make clean make -j$NUM_OF_CORES install cd $CURRENT_DIR rm -rf build-sundials-4.1.0 rm -rf sundials-4.1.0 -export LD_LIBRARY_PATH=$INSTALL_DIR/lib:$LD_LIBRARY_PATH +export LD_LIBRARY_PATH=$INSTALL_DIR/lib:$LD_LIBRARY_PATH # For Linux +export DYLD_LIBRARY_PATH=$INSTALL_DIR/lib:$DYLD_LIBRARY_PATH # For Mac export SUNDIALS_INST=$INSTALL_DIR # get pybind11 diff --git a/tests/integration/test_experiments.py b/tests/integration/test_experiments.py new file mode 100644 index 0000000000..8f3a3b6880 --- /dev/null +++ b/tests/integration/test_experiments.py @@ -0,0 +1,60 @@ +# +# Test some experiments +# +import pybamm +import numpy as np +import unittest + + +class TestExperiments(unittest.TestCase): + def test_discharge_rest_charge(self): + experiment = pybamm.Experiment( + [ + "Discharge at C/2 for 1 hour", + "Rest for 1 hour", + "Charge at C/2 for 1 hour", + ], + period="0.25 hours", + ) + model = pybamm.lithium_ion.SPM() + sim = pybamm.Simulation( + model, experiment=experiment, solver=pybamm.CasadiSolver() + ) + sim.solve() + np.testing.assert_array_almost_equal( + sim._solution["Time [h]"].entries, np.linspace(0, 3, 13) + ) + cap = model.default_parameter_values["Cell capacity [A.h]"] + np.testing.assert_array_almost_equal( + sim._solution["Current [A]"].entries, + [cap / 2] * 5 + [0] * 4 + [-cap / 2] * 4, + ) + + def test_gitt(self): + experiment = pybamm.Experiment( + ["Discharge at C/20 for 1 hour", "Rest for 1 hour"] * 10, + period="6 minutes", + ) + model = pybamm.lithium_ion.SPM() + sim = pybamm.Simulation( + model, experiment=experiment, solver=pybamm.CasadiSolver() + ) + sim.solve() + np.testing.assert_array_almost_equal( + sim._solution["Time [h]"].entries, np.arange(0, 20.01, 0.1) + ) + cap = model.default_parameter_values["Cell capacity [A.h]"] + np.testing.assert_array_almost_equal( + sim._solution["Current [A]"].entries, + [cap / 20] * 11 + [0] * 10 + ([cap / 20] * 10 + [0] * 10) * 9, + ) + + +if __name__ == "__main__": + print("Add -v for more debug output") + import sys + + if "-v" in sys.argv: + debug = True + pybamm.settings.debug_mode = True + unittest.main() diff --git a/tests/integration/test_models/standard_model_tests.py b/tests/integration/test_models/standard_model_tests.py index 1f1340730d..821428c2ec 100644 --- a/tests/integration/test_models/standard_model_tests.py +++ b/tests/integration/test_models/standard_model_tests.py @@ -75,8 +75,12 @@ def test_solving(self, solver=None, t_eval=None): self.solver.rtol = 1e-8 self.solver.atol = 1e-8 + Crate = abs(self.parameter_values["C-rate"]) + # don't allow zero C-rate + if Crate == 0: + Crate = 1 if t_eval is None: - t_eval = np.linspace(0, 1, 100) + t_eval = np.linspace(0, 3600 / Crate, 100) self.solution = self.solver.solve(self.model, t_eval) diff --git a/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_asymptotics_convergence.py b/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_asymptotics_convergence.py index ddc43724b1..9ca3c3f5a5 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_asymptotics_convergence.py +++ b/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_asymptotics_convergence.py @@ -47,7 +47,7 @@ def test_leading_order_convergence(self): def get_max_error(current): pybamm.logger.info("current = {}".format(current)) # Solve, make sure times are the same and use tight tolerances - t_eval = np.linspace(0, 0.6) + t_eval = np.linspace(0, 3600 * 17 / current) solver = pybamm.CasadiSolver() solver.rtol = 1e-8 solver.atol = 1e-8 diff --git a/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_compare_outputs.py b/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_compare_outputs.py index 28e6dff854..a3700d62d1 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_compare_outputs.py +++ b/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_compare_outputs.py @@ -39,9 +39,9 @@ def test_compare_averages_asymptotics(self): # solve model solutions = [] - t_eval = np.linspace(0, 1, 100) + t_eval = np.linspace(0, 3600 * 17, 100) for model in models: - solution = model.default_solver.solve(model, t_eval) + solution = pybamm.CasadiSolver().solve(model, t_eval) solutions.append(solution) # test averages @@ -85,9 +85,9 @@ def test_compare_outputs_capacitance(self): # solve model solutions = [] - t_eval = np.linspace(0, 1, 100) + t_eval = np.linspace(0, 3600 * 20, 100) for model in models: - solution = model.default_solver.solve(model, t_eval) + solution = pybamm.CasadiSolver().solve(model, t_eval) solutions.append(solution) # compare outputs diff --git a/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_full.py b/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_full.py index 22103c86b6..54529ed5fc 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_full.py +++ b/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_full.py @@ -13,7 +13,9 @@ def test_basic_processing(self): options = {"thermal": "isothermal"} model = pybamm.lead_acid.Full(options) modeltest = tests.StandardModelTest(model) - modeltest.test_all(t_eval=np.linspace(0, 0.6), solver=pybamm.CasadiSolver()) + modeltest.test_all( + t_eval=np.linspace(0, 3600 * 17), solver=pybamm.CasadiSolver() + ) def test_basic_processing_with_convection(self): options = {"thermal": "isothermal", "convection": True} @@ -21,7 +23,7 @@ def test_basic_processing_with_convection(self): var = pybamm.standard_spatial_vars var_pts = {var.x_n: 10, var.x_s: 10, var.x_p: 10} modeltest = tests.StandardModelTest(model, var_pts=var_pts) - modeltest.test_all(t_eval=np.linspace(0, 0.6)) + modeltest.test_all(t_eval=np.linspace(0, 3600 * 10)) def test_optimisations(self): options = {"thermal": "isothermal"} diff --git a/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_side_reactions/test_full_side_reactions.py b/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_side_reactions/test_full_side_reactions.py index bb86413b5c..b712f40910 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_side_reactions/test_full_side_reactions.py +++ b/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_side_reactions/test_full_side_reactions.py @@ -13,7 +13,7 @@ def test_basic_processing(self): options = {"side reactions": ["oxygen"]} model = pybamm.lead_acid.Full(options) modeltest = tests.StandardModelTest(model) - modeltest.test_all(skip_output_tests=True, t_eval=np.linspace(0, 0.6)) + modeltest.test_all(skip_output_tests=True, t_eval=np.linspace(0, 3600 * 17)) def test_basic_processing_differential(self): options = {"side reactions": ["oxygen"], "surface form": "differential"} diff --git a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_compare_basic_models.py b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_compare_basic_models.py index dfb2f3c893..41a4100545 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_compare_basic_models.py +++ b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_compare_basic_models.py @@ -14,13 +14,13 @@ def test_compare_dfns(self): # Solve basic DFN basic_sim = pybamm.Simulation(basic_dfn) - t_eval = np.linspace(0, 1) + t_eval = np.linspace(0, 3600) basic_sim.solve(t_eval) basic_sol = basic_sim.solution # Solve main DFN sim = pybamm.Simulation(dfn) - t_eval = np.linspace(0, 1) + t_eval = np.linspace(0, 3600) sim.solve(t_eval) sol = sim.solution @@ -39,13 +39,13 @@ def test_compare_spms(self): # Solve basic SPM basic_sim = pybamm.Simulation(basic_spm) - t_eval = np.linspace(0, 1) + t_eval = np.linspace(0, 3600) basic_sim.solve(t_eval) basic_sol = basic_sim.solution # Solve main SPM sim = pybamm.Simulation(spm) - t_eval = np.linspace(0, 1) + t_eval = np.linspace(0, 3600) sim.solve(t_eval) sol = sim.solution diff --git a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_current_collector.py b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_current_collector.py index 7f0a661fda..08798ca215 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_current_collector.py +++ b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_current_collector.py @@ -28,7 +28,8 @@ def test_2p1d(self): solver = pybamm.IDAKLUSolver() sim = pybamm.Simulation(model, var_pts=var_pts, solver=solver) - t_eval = np.linspace(0, 0.08, 3) + # Simulate 100 seconds + t_eval = np.linspace(0, 100, 3) for i in np.arange(1, len(t_eval) - 1): dt = t_eval[i + 1] - t_eval[i] diff --git a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_temperature.py b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_temperature.py index fad8f88793..27b06e1796 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_temperature.py +++ b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_external/test_external_temperature.py @@ -15,7 +15,7 @@ def test_external_lumped_temperature(self): model = pybamm.lithium_ion.SPMe(model_options) sim = pybamm.Simulation(model) - t_eval = np.linspace(0, 0.01, 3) + t_eval = np.linspace(0, 100, 3) T_av = 0 @@ -49,7 +49,7 @@ def test_external_temperature(self): sim = pybamm.Simulation(model, var_pts=var_pts) - t_eval = np.linspace(0, 0.01, 3) + t_eval = np.linspace(0, 100, 3) x = np.linspace(0, 1, tot_pts) for i in np.arange(1, len(t_eval) - 1): @@ -87,7 +87,7 @@ def test_dae_external_temperature(self): sim = pybamm.Simulation(model, var_pts=var_pts, solver=solver) sim.build() - t_eval = np.linspace(0, 0.01, 3) + t_eval = np.linspace(0, 100, 3) x = np.linspace(0, 1, tot_pts) for i in np.arange(1, len(t_eval) - 1): diff --git a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_spme.py b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_spme.py index 0dc59f881c..bf48669845 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_spme.py +++ b/tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_spme.py @@ -15,6 +15,13 @@ def test_basic_processing(self): modeltest = tests.StandardModelTest(model) modeltest.test_all() + def test_basic_processing_python(self): + options = {"thermal": "isothermal"} + model = pybamm.lithium_ion.SPMe(options) + model.convert_to_format = "python" + modeltest = tests.StandardModelTest(model, solver=pybamm.ScipySolver()) + modeltest.test_all() + def test_basic_processing_1plus1D(self): options = {"current collector": "potential pair", "dimensionality": 1} model = pybamm.lithium_ion.SPMe(options) diff --git a/tests/integration/test_models/test_submodels/test_external_circuit/test_function_control.py b/tests/integration/test_models/test_submodels/test_external_circuit/test_function_control.py index 538846c377..e424b0f763 100644 --- a/tests/integration/test_models/test_submodels/test_external_circuit/test_function_control.py +++ b/tests/integration/test_models/test_submodels/test_external_circuit/test_function_control.py @@ -8,17 +8,14 @@ class TestFunctionControl(unittest.TestCase): def test_constant_current(self): - class ConstantCurrent: - num_switches = 0 - - def __call__(self, variables): - I = variables["Current [A]"] - return I + 1 + def constant_current(variables): + I = variables["Current [A]"] + return I + 1 # load models models = [ pybamm.lithium_ion.SPM(), - pybamm.lithium_ion.SPM({"operating mode": ConstantCurrent()}), + pybamm.lithium_ion.SPM({"operating mode": constant_current}), ] # load parameter values and process models and geometry @@ -42,7 +39,7 @@ def __call__(self, variables): # solve model solutions = [None] * len(models) - t_eval = np.linspace(0, 1, 100) + t_eval = np.linspace(0, 3600, 100) for i, model in enumerate(models): solutions[i] = model.default_solver.solve(model, t_eval) @@ -56,17 +53,14 @@ def __call__(self, variables): ) def test_constant_voltage(self): - class ConstantVoltage: - num_switches = 0 - - def __call__(self, variables): - V = variables["Terminal voltage [V]"] - return V - 4.1 + def constant_voltage(variables): + V = variables["Terminal voltage [V]"] + return V - 4.1 # load models models = [ pybamm.lithium_ion.SPM({"operating mode": "voltage"}), - pybamm.lithium_ion.SPM({"operating mode": ConstantVoltage()}), + pybamm.lithium_ion.SPM({"operating mode": constant_voltage}), ] # load parameter values and process models and geometry @@ -89,7 +83,7 @@ def __call__(self, variables): # solve model solutions = [None] * len(models) - t_eval = np.linspace(0, 1, 100) + t_eval = np.linspace(0, 3600, 100) for i, model in enumerate(models): solutions[i] = model.default_solver.solve(model, t_eval) @@ -102,18 +96,15 @@ def __call__(self, variables): np.testing.assert_array_almost_equal(abs((I1 - I0) / I0), 0, decimal=1) def test_constant_power(self): - class ConstantPower: - num_switches = 0 - - def __call__(self, variables): - I = variables["Current [A]"] - V = variables["Terminal voltage [V]"] - return I * V - 4 + def constant_power(variables): + I = variables["Current [A]"] + V = variables["Terminal voltage [V]"] + return I * V - 4 # load models models = [ pybamm.lithium_ion.SPM({"operating mode": "power"}), - pybamm.lithium_ion.SPM({"operating mode": ConstantPower()}), + pybamm.lithium_ion.SPM({"operating mode": constant_power}), ] # load parameter values and process models and geometry @@ -136,7 +127,7 @@ def __call__(self, variables): # solve model solutions = [None] * len(models) - t_eval = np.linspace(0, 1, 100) + t_eval = np.linspace(0, 3600, 100) for i, model in enumerate(models): solutions[i] = model.default_solver.solve(model, t_eval) diff --git a/tests/integration/test_quick_plot.py b/tests/integration/test_quick_plot.py index c18e0b3d67..9be762f7b0 100644 --- a/tests/integration/test_quick_plot.py +++ b/tests/integration/test_quick_plot.py @@ -21,7 +21,7 @@ def test_plot_lithium_ion(self): disc_spme = pybamm.Discretisation(mesh, spme.default_spatial_methods) disc_spm.process_model(spm) disc_spme.process_model(spme) - t_eval = np.linspace(0, 2, 100) + t_eval = np.linspace(0, 3600, 100) solution_spm = spm.default_solver.solve(spm, t_eval) solution_spme = spme.default_solver.solve(spme, t_eval) quick_plot = pybamm.QuickPlot([solution_spm, solution_spme]) @@ -74,7 +74,7 @@ def test_plot_lead_acid(self): mesh = pybamm.Mesh(geometry, loqs.default_submesh_types, loqs.default_var_pts) disc_loqs = pybamm.Discretisation(mesh, loqs.default_spatial_methods) disc_loqs.process_model(loqs) - t_eval = np.linspace(0, 1, 100) + t_eval = np.linspace(0, 3600, 100) solution_loqs = loqs.default_solver.solve(loqs, t_eval) pybamm.QuickPlot(solution_loqs) diff --git a/tests/integration/test_solvers/test_idaklu.py b/tests/integration/test_solvers/test_idaklu.py index 392854890f..69aabb5861 100644 --- a/tests/integration/test_solvers/test_idaklu.py +++ b/tests/integration/test_solvers/test_idaklu.py @@ -15,7 +15,7 @@ def test_on_spme(self): mesh = pybamm.Mesh(geometry, model.default_submesh_types, model.default_var_pts) disc = pybamm.Discretisation(mesh, model.default_spatial_methods) disc.process_model(model) - t_eval = np.linspace(0, 0.2, 100) + t_eval = np.linspace(0, 3600, 100) solution = pybamm.IDAKLUSolver().solve(model, t_eval) np.testing.assert_array_less(1, solution.t.size) @@ -28,7 +28,7 @@ def test_set_tol_by_variable(self): mesh = pybamm.Mesh(geometry, model.default_submesh_types, model.default_var_pts) disc = pybamm.Discretisation(mesh, model.default_spatial_methods) disc.process_model(model) - t_eval = np.linspace(0, 0.2, 100) + t_eval = np.linspace(0, 3600, 100) solver = pybamm.IDAKLUSolver() variable_tols = {"Electrolyte concentration": 1e-3} @@ -50,7 +50,7 @@ def test_changing_grid(self): # Calculate time for each solver and each number of grid points var = pybamm.standard_spatial_vars - t_eval = np.linspace(0, 0.25, 100) + t_eval = np.linspace(0, 3600, 100) for npts in [100, 200]: # discretise var_pts = { diff --git a/tests/integration/test_solvers/test_solution.py b/tests/integration/test_solvers/test_solution.py index 23adfe0583..13f6d0292f 100644 --- a/tests/integration/test_solvers/test_solution.py +++ b/tests/integration/test_solvers/test_solution.py @@ -25,7 +25,7 @@ def test_append(self): disc.process_model(model) # solve model - t_eval = np.linspace(0, 0.2, 100) + t_eval = np.linspace(0, 3600, 100) solver = model.default_solver solution = solver.solve(model, t_eval) @@ -33,10 +33,12 @@ def test_append(self): old_t = 0 step_solver = model.default_solver step_solution = None - for t in solution.t[1:]: + # dt should be dimensional + solution_times_dimensional = solution.t * model.timescale_eval + for t in solution_times_dimensional[1:]: dt = t - old_t step_solution = step_solver.step(step_solution, model, dt=dt, npts=10) - if t == solution.t[1]: + if t == solution_times_dimensional[1]: # Create voltage variable step_solution.update("Terminal voltage") old_t = t @@ -52,8 +54,8 @@ def test_append(self): self.assertLess(step_sol_time, sol_time) # Check both give the same answer np.testing.assert_array_almost_equal( - solution["Terminal voltage"](solution.t), - step_solution["Terminal voltage"](solution.t), + solution["Terminal voltage"](solution.t[:-1]), + step_solution["Terminal voltage"](solution.t[:-1]), decimal=4, ) diff --git a/tests/unit/test_experiments/__init__.py b/tests/unit/test_experiments/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/tests/unit/test_experiments/test_experiment.py b/tests/unit/test_experiments/test_experiment.py new file mode 100644 index 0000000000..dbde2faa6d --- /dev/null +++ b/tests/unit/test_experiments/test_experiment.py @@ -0,0 +1,125 @@ +# +# Test the base experiment class +# +import pybamm +import unittest + + +class TestExperiment(unittest.TestCase): + def test_read_strings(self): + experiment = pybamm.Experiment( + [ + "Discharge at 1C for 0.5 hours", + "Discharge at C/20 for 0.5 hours", + "Charge at 0.5 C for 45 minutes", + "Discharge at 1 A for 0.5 hours", + "Charge at 200 mA for 45 minutes (1 minute period)", + "Discharge at 1W for 0.5 hours", + "Charge at 200 mW for 45 minutes", + "Rest for 10 minutes (5 minute period)", + "Hold at 1V for 20 seconds", + "Charge at 1 C until 4.1V", + "Hold at 4.1 V until 50mA", + "Hold at 3V until C/50", + "Discharge at C/3 for 2 hours or until 2.5 V", + ], + {"test": "test"}, + period="20 seconds", + ) + self.assertEqual( + experiment.operating_conditions, + [ + (1, "C", 1800.0, 20.0), + (0.05, "C", 1800.0, 20.0), + (-0.5, "C", 2700.0, 20.0), + (1, "A", 1800.0, 20.0), + (-0.2, "A", 2700.0, 60.0), + (1, "W", 1800.0, 20.0), + (-0.2, "W", 2700.0, 20.0), + (0, "A", 600.0, 300.0), + (1, "V", 20.0, 20.0), + (-1, "C", None, 20.0), + (4.1, "V", None, 20.0), + (3, "V", None, 20.0), + (1 / 3, "C", 7200.0, 20.0), + ], + ) + self.assertEqual( + experiment.events, + [ + None, + None, + None, + None, + None, + None, + None, + None, + None, + (4.1, "V"), + (0.05, "A"), + (0.02, "C"), + (2.5, "V"), + ], + ) + self.assertEqual(experiment.parameters, {"test": "test"}) + self.assertEqual(experiment.period, 20) + + def test_read_strings_repeat(self): + experiment = pybamm.Experiment( + ["Discharge at 10 mA for 0.5 hours"] + + ["Charge at 0.5 C for 45 minutes", "Hold at 1 V for 20 seconds"] * 2, + ) + self.assertEqual( + experiment.operating_conditions, + [ + (0.01, "A", 1800.0, 60), + (-0.5, "C", 2700.0, 60), + (1, "V", 20.0, 60), + (-0.5, "C", 2700.0, 60), + (1, "V", 20.0, 60), + ], + ) + self.assertEqual(experiment.period, 60) + + def test_str_repr(self): + conds = ["Discharge at 1 C for 20 seconds", "Charge at 0.5 W for 10 minutes"] + experiment = pybamm.Experiment(conds) + self.assertEqual(str(experiment), str(conds)) + self.assertEqual( + repr(experiment), + "pybamm.Experiment(['Discharge at 1 C for 20 seconds'" + + ", 'Charge at 0.5 W for 10 minutes'])", + ) + + def test_bad_strings(self): + with self.assertRaisesRegex( + TypeError, "Operating conditions should be strings" + ): + pybamm.Experiment([1, 2, 3]) + with self.assertRaisesRegex(ValueError, "Operating conditions must contain"): + pybamm.Experiment(["Discharge at 1 A at 2 hours"]) + with self.assertRaisesRegex(ValueError, "instruction must be"): + pybamm.Experiment(["Run at 1 A for 2 hours"]) + with self.assertRaisesRegex( + ValueError, "Instruction 'Run at at 1 A' not recognized" + ): + pybamm.Experiment(["Run at at 1 A for 2 hours"]) + with self.assertRaisesRegex(ValueError, "units must be"): + pybamm.Experiment(["Discharge at 1 B for 2 hours"]) + with self.assertRaisesRegex(ValueError, "time units must be"): + pybamm.Experiment(["Discharge at 1 A for 2 years"]) + with self.assertRaisesRegex( + TypeError, "experimental parameters should be a dictionary" + ): + pybamm.Experiment([], "not a dictionary") + + +if __name__ == "__main__": + print("Add -v for more debug output") + import sys + + if "-v" in sys.argv: + debug = True + pybamm.settings.debug_mode = True + unittest.main() diff --git a/tests/unit/test_experiments/test_simulation_with_experiment.py b/tests/unit/test_experiments/test_simulation_with_experiment.py new file mode 100644 index 0000000000..901f43f1c0 --- /dev/null +++ b/tests/unit/test_experiments/test_simulation_with_experiment.py @@ -0,0 +1,104 @@ +# +# Test setting up a simulation with an experiment +# +import pybamm +import unittest + + +class TestSimulationExperiment(unittest.TestCase): + def test_set_up(self): + experiment = pybamm.Experiment( + [ + "Discharge at C/20 for 1 hour", + "Charge at 1 A until 4.1 V", + "Hold at 4.1 V until 50 mA", + "Discharge at 2 W for 1 hour", + ], + ) + model = pybamm.lithium_ion.DFN() + sim = pybamm.Simulation(model, experiment=experiment) + + self.assertEqual(sim.experiment, experiment) + self.assertEqual( + sim._experiment_inputs[0]["Current input [A]"], + 1 / 20 * model.default_parameter_values["Cell capacity [A.h]"], + ) + self.assertEqual(sim._experiment_inputs[0]["Current switch"], 1) + self.assertEqual(sim._experiment_inputs[0]["Voltage switch"], 0) + self.assertEqual(sim._experiment_inputs[0]["Power switch"], 0) + self.assertEqual(sim._experiment_inputs[0]["Current cut-off [A]"], -1e10) + self.assertEqual(sim._experiment_inputs[0]["Voltage cut-off [V]"], -1e10) + self.assertEqual(sim._experiment_inputs[1]["Current input [A]"], -1) + self.assertEqual(sim._experiment_inputs[1]["Current switch"], 1) + self.assertEqual(sim._experiment_inputs[1]["Voltage switch"], 0) + self.assertEqual(sim._experiment_inputs[1]["Power switch"], 0) + self.assertEqual(sim._experiment_inputs[1]["Current cut-off [A]"], -1e10) + self.assertEqual(sim._experiment_inputs[1]["Voltage cut-off [V]"], 4.1) + self.assertEqual(sim._experiment_inputs[2]["Current switch"], 0) + self.assertEqual(sim._experiment_inputs[2]["Voltage switch"], 1) + self.assertEqual(sim._experiment_inputs[2]["Power switch"], 0) + self.assertEqual(sim._experiment_inputs[2]["Voltage input [V]"], 4.1) + self.assertEqual(sim._experiment_inputs[2]["Current cut-off [A]"], 0.05) + self.assertEqual(sim._experiment_inputs[2]["Voltage cut-off [V]"], -1e10) + self.assertEqual(sim._experiment_inputs[3]["Current switch"], 0) + self.assertEqual(sim._experiment_inputs[3]["Voltage switch"], 0) + self.assertEqual(sim._experiment_inputs[3]["Power switch"], 1) + self.assertEqual(sim._experiment_inputs[3]["Power input [W]"], 2) + self.assertEqual(sim._experiment_inputs[3]["Current cut-off [A]"], -1e10) + self.assertEqual(sim._experiment_inputs[3]["Voltage cut-off [V]"], -1e10) + + self.assertEqual( + sim._experiment_times, [3600, 7 * 24 * 3600, 7 * 24 * 3600, 3600], + ) + + self.assertIn( + "Current cut-off (positive) [A] [experiment]", + [event.name for event in sim.model.events], + ) + self.assertIn( + "Current cut-off (negative) [A] [experiment]", + [event.name for event in sim.model.events], + ) + self.assertIn( + "Voltage cut-off [V] [experiment]", + [event.name for event in sim.model.events], + ) + + # fails if trying to set up with something that isn't an experiment + with self.assertRaisesRegex(TypeError, "experiment must be"): + pybamm.Simulation(model, experiment=0) + + def test_run_experiment(self): + experiment = pybamm.Experiment( + [ + "Discharge at C/20 for 1 hour", + "Charge at 1 A until 4.1 V", + "Hold at 4.1 V until C/2", + "Discharge at 2 W for 1 hour", + ], + ) + model = pybamm.lithium_ion.SPM() + sim = pybamm.Simulation(model, experiment=experiment) + sim.solve() + self.assertEqual(sim._solution.termination, "final time") + + def test_run_experiment_breaks_early(self): + experiment = pybamm.Experiment(["Discharge at 2 C for 1 hour"]) + model = pybamm.lithium_ion.SPM() + sim = pybamm.Simulation(model, experiment=experiment) + pybamm.set_logging_level("ERROR") + # giving the time, should get ignored + t_eval = [0, 1] + sim.solve(t_eval) + pybamm.set_logging_level("WARNING") + self.assertIn("event", sim._solution.termination) + + +if __name__ == "__main__": + print("Add -v for more debug output") + import sys + + if "-v" in sys.argv: + debug = True + pybamm.settings.debug_mode = True + unittest.main() diff --git a/tests/unit/test_expression_tree/test_concatenations.py b/tests/unit/test_expression_tree/test_concatenations.py index 2a5a161148..eb18381ddf 100644 --- a/tests/unit/test_expression_tree/test_concatenations.py +++ b/tests/unit/test_expression_tree/test_concatenations.py @@ -25,6 +25,10 @@ def test_base_concatenation(self): with self.assertRaises(TypeError): conc2.evaluate() + # trying to concatenate non-pybamm symbols + with self.assertRaises(TypeError): + pybamm.Concatenation(1, 2) + def test_concatenation_domains(self): a = pybamm.Symbol("a", domain=["negative electrode"]) b = pybamm.Symbol("b", domain=["separator", "positive electrode"]) diff --git a/tests/unit/test_models/test_base_model.py b/tests/unit/test_models/test_base_model.py index 7feb273503..b9c5e6c703 100644 --- a/tests/unit/test_models/test_base_model.py +++ b/tests/unit/test_models/test_base_model.py @@ -401,6 +401,10 @@ def test_default_parameters(self): ) os.chdir(cwd) + def test_timescale(self): + model = pybamm.BaseModel() + self.assertEqual(model.timescale.evaluate(), 1) + if __name__ == "__main__": print("Add -v for more debug output") diff --git a/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_loqs.py b/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_loqs.py index 59697e2b3a..0c7757d17f 100644 --- a/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_loqs.py +++ b/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_loqs.py @@ -167,15 +167,12 @@ def test_well_posed_power(self): model.check_well_posedness() def test_well_posed_function(self): - class ExternalCircuitFunction: - num_switches = 0 + def external_circuit_function(variables): + I = variables["Current [A]"] + V = variables["Terminal voltage [V]"] + return V + I - pybamm.FunctionParameter("Function", pybamm.t) - def __call__(self, variables): - I = variables["Current [A]"] - V = variables["Terminal voltage [V]"] - return V + I - pybamm.FunctionParameter("Function", pybamm.t) - - options = {"operating mode": ExternalCircuitFunction()} + options = {"operating mode": external_circuit_function} model = pybamm.lead_acid.LOQS(options) model.check_well_posedness() diff --git a/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_spm.py b/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_spm.py index 3df0760bbd..87da7b98b2 100644 --- a/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_spm.py +++ b/tests/unit/test_models/test_full_battery_models/test_lithium_ion/test_spm.py @@ -190,15 +190,12 @@ def test_well_posed_power(self): model.check_well_posedness() def test_well_posed_function(self): - class ExternalCircuitFunction: - num_switches = 0 + def external_circuit_function(variables): + I = variables["Current [A]"] + V = variables["Terminal voltage [V]"] + return V + I - pybamm.FunctionParameter("Function", pybamm.t) - def __call__(self, variables): - I = variables["Current [A]"] - V = variables["Terminal voltage [V]"] - return V + I - pybamm.FunctionParameter("Function", pybamm.t) - - options = {"operating mode": ExternalCircuitFunction()} + options = {"operating mode": external_circuit_function} model = pybamm.lithium_ion.SPM(options) model.check_well_posedness() diff --git a/tests/unit/test_models/test_submodels/test_current_collector/test_effective_current_collector.py b/tests/unit/test_models/test_submodels/test_current_collector/test_effective_current_collector.py index 28ea508205..352d6a726b 100644 --- a/tests/unit/test_models/test_submodels/test_current_collector/test_effective_current_collector.py +++ b/tests/unit/test_models/test_submodels/test_current_collector/test_effective_current_collector.py @@ -47,7 +47,7 @@ def test_get_processed_potentials(self): disc = pybamm.Discretisation(meshes[i], model.default_spatial_methods) disc.process_model(model) solutions = [None] * len(models) - t_eval = np.linspace(0, 0.1, 10) + t_eval = np.linspace(0, 100, 10) solutions[0] = models[0].default_solver.solve(models[0]) solutions[1] = models[1].default_solver.solve(models[1], t_eval) diff --git a/tests/unit/test_models/test_submodels/test_external_circuit/test_function_control.py b/tests/unit/test_models/test_submodels/test_external_circuit/test_function_control.py index ec961b4316..4a06002baa 100644 --- a/tests/unit/test_models/test_submodels/test_external_circuit/test_function_control.py +++ b/tests/unit/test_models/test_submodels/test_external_circuit/test_function_control.py @@ -6,22 +6,17 @@ import unittest -class ExternalCircuitFunction: - num_switches = 0 - - def __call__(self, variables): - I = variables["Current [A]"] - V = variables["Terminal voltage [V]"] - return ( - V + I - pybamm.FunctionParameter("Current plus voltage function", pybamm.t) - ) +def external_circuit_function(variables): + I = variables["Current [A]"] + V = variables["Terminal voltage [V]"] + return V + I - pybamm.FunctionParameter("Current plus voltage function", pybamm.t) class TestFunctionControl(unittest.TestCase): def test_public_functions(self): param = pybamm.standard_parameters_lithium_ion submodel = pybamm.external_circuit.FunctionControl( - param, ExternalCircuitFunction() + param, external_circuit_function ) variables = {"Terminal voltage [V]": pybamm.Scalar(0)} std_tests = tests.StandardSubModelTests(submodel, variables) diff --git a/tests/unit/test_models/test_submodels/test_particle/test_base_particle.py b/tests/unit/test_models/test_submodels/test_particle/test_base_particle.py index 8cc958d1d2..084bc3b621 100644 --- a/tests/unit/test_models/test_submodels/test_particle/test_base_particle.py +++ b/tests/unit/test_models/test_submodels/test_particle/test_base_particle.py @@ -9,15 +9,17 @@ class TestBaseParticle(unittest.TestCase): def test_public_functions(self): + variables = { + "Negative particle surface concentration": 0, + "Positive particle surface concentration": 0, + } submodel = pybamm.particle.BaseParticle(None, "Negative") - std_tests = tests.StandardSubModelTests(submodel) - with self.assertRaises(NotImplementedError): - std_tests.test_all() + std_tests = tests.StandardSubModelTests(submodel, variables) + std_tests.test_all() submodel = pybamm.particle.BaseParticle(None, "Positive") - std_tests = tests.StandardSubModelTests(submodel) - with self.assertRaises(NotImplementedError): - std_tests.test_all() + std_tests = tests.StandardSubModelTests(submodel, variables) + std_tests.test_all() if __name__ == "__main__": diff --git a/tests/unit/test_models/test_submodels/test_particle/test_fickian/test_base_fickian_particle.py b/tests/unit/test_models/test_submodels/test_particle/test_fickian/test_base_fickian_particle.py deleted file mode 100644 index be03973287..0000000000 --- a/tests/unit/test_models/test_submodels/test_particle/test_fickian/test_base_fickian_particle.py +++ /dev/null @@ -1,30 +0,0 @@ -# -# Test base fickian submodel -# - -import pybamm -import tests -import unittest - - -class TestBaseModel(unittest.TestCase): - def test_public_functions(self): - submodel = pybamm.particle.fickian.BaseModel(None, "Negative") - std_tests = tests.StandardSubModelTests(submodel) - with self.assertRaises(NotImplementedError): - std_tests.test_all() - - submodel = pybamm.particle.fickian.BaseModel(None, "Positive") - std_tests = tests.StandardSubModelTests(submodel) - with self.assertRaises(NotImplementedError): - std_tests.test_all() - - -if __name__ == "__main__": - print("Add -v for more debug output") - import sys - - if "-v" in sys.argv: - debug = True - pybamm.settings.debug_mode = True - unittest.main() diff --git a/tests/unit/test_parameters/test_dimensionless_parameter_values_lithium_ion.py b/tests/unit/test_parameters/test_dimensionless_parameter_values_lithium_ion.py index 73ad08911d..7c7dd3000c 100644 --- a/tests/unit/test_parameters/test_dimensionless_parameter_values_lithium_ion.py +++ b/tests/unit/test_parameters/test_dimensionless_parameter_values_lithium_ion.py @@ -63,7 +63,7 @@ def test_lithium_ion(self): "particle dynamics" # neg diffusion coefficient np.testing.assert_almost_equal( - values.evaluate(param.D_n_dimensional(param.c_n_init, param.T_ref)), + values.evaluate(param.D_n_dimensional(param.c_n_init(0), param.T_ref)), 3.9 * 10 ** (-14), 2, ) @@ -78,7 +78,7 @@ def test_lithium_ion(self): # pos diffusion coefficient np.testing.assert_almost_equal( - values.evaluate(param.D_p_dimensional(param.c_p_init, param.T_ref)), + values.evaluate(param.D_p_dimensional(param.c_p_init(1), param.T_ref)), 1 * 10 ** (-13), 2, ) diff --git a/tests/unit/test_parameters/test_parameter_sets/test_NCA_Kim2011.py b/tests/unit/test_parameters/test_parameter_sets/test_NCA_Kim2011.py new file mode 100644 index 0000000000..3225b3b45f --- /dev/null +++ b/tests/unit/test_parameters/test_parameter_sets/test_NCA_Kim2011.py @@ -0,0 +1,50 @@ +# +# Tests for NCA parameter set loads +# +import pybamm +import unittest + + +class TestKim(unittest.TestCase): + def test_load_params(self): + anode = pybamm.ParameterValues({}).read_parameters_csv( + "input/parameters/lithium-ion/anodes/graphite_Kim2011/parameters.csv" + ) + self.assertEqual(anode["Reference temperature [K]"], "298.15") + + cathode = pybamm.ParameterValues({}).read_parameters_csv( + "input/parameters/lithium-ion/cathodes/nca_Kim2011/parameters.csv" + ) + self.assertEqual(cathode["Reference temperature [K]"], "298.15") + + electrolyte = pybamm.ParameterValues({}).read_parameters_csv( + "input/parameters/lithium-ion/electrolytes/lipf6_Kim2011/parameters.csv" + ) + self.assertEqual(electrolyte["Reference temperature [K]"], "298.15") + + cell = pybamm.ParameterValues({}).read_parameters_csv( + "input/parameters/lithium-ion/cells/Kim2011/parameters.csv" + ) + self.assertAlmostEqual( + cell["Negative current collector thickness [m]"], 10 ** (-5) + ) + + def test_standard_lithium_parameters(self): + + chemistry = pybamm.parameter_sets.NCA_Kim2011 + parameter_values = pybamm.ParameterValues(chemistry=chemistry) + + model = pybamm.lithium_ion.DFN() + sim = pybamm.Simulation(model, parameter_values=parameter_values) + sim.set_parameters() + sim.build() + + +if __name__ == "__main__": + print("Add -v for more debug output") + import sys + + if "-v" in sys.argv: + debug = True + pybamm.settings.debug_mode = True + unittest.main() diff --git a/tests/unit/test_quick_plot.py b/tests/unit/test_quick_plot.py index df41b16a50..2abe645568 100644 --- a/tests/unit/test_quick_plot.py +++ b/tests/unit/test_quick_plot.py @@ -31,6 +31,12 @@ def test_simple_ode_model(self): "c broadcasted": pybamm.FullBroadcast( c, ["negative electrode", "separator"], "current collector" ), + "b broadcasted negative electrode": pybamm.PrimaryBroadcast( + b, "negative particle" + ), + "c broadcasted positive electrode": pybamm.PrimaryBroadcast( + c, "positive particle" + ), } # ODEs only (don't use jacobian) @@ -70,9 +76,16 @@ def test_simple_ode_model(self): quick_plot.plot(0) quick_plot = pybamm.QuickPlot( - solution, [["a", "a"], ["b broadcasted", "b broadcasted"], "c broadcasted"] + solution, + [ + ["a", "a"], + ["b broadcasted", "b broadcasted"], + "c broadcasted", + "b broadcasted negative electrode", + "c broadcasted positive electrode", + ], ) - self.assertEqual(len(quick_plot.axis), 3) + self.assertEqual(len(quick_plot.axis), 5) quick_plot.plot(0) # update the axis @@ -107,7 +120,7 @@ def test_simple_ode_model(self): pybamm.QuickPlot(solution, ["3D variable"]) def test_loqs_spm_base(self): - t_eval = np.linspace(0, 0.01, 2) + t_eval = np.linspace(0, 10, 2) # SPM for model in [pybamm.lithium_ion.SPM(), pybamm.lead_acid.LOQS()]: diff --git a/tests/unit/test_simulation.py b/tests/unit/test_simulation.py index 5e3a090a40..af9c6a1796 100644 --- a/tests/unit/test_simulation.py +++ b/tests/unit/test_simulation.py @@ -1,5 +1,7 @@ import pybamm import numpy as np +import pandas as pd +import os import unittest @@ -205,23 +207,25 @@ def test_set_external_variable(self): def test_step(self): dt = 0.001 - sim = pybamm.Simulation(pybamm.lithium_ion.SPM()) + model = pybamm.lithium_ion.SPM() + sim = pybamm.Simulation(model) sim.step(dt) # 1 step stores first two points + tau = model.timescale.evaluate() self.assertEqual(sim.solution.t.size, 2) self.assertEqual(sim.solution.y[0, :].size, 2) self.assertEqual(sim.solution.t[0], 0) - self.assertEqual(sim.solution.t[1], dt) + self.assertEqual(sim.solution.t[1], dt / tau) sim.step(dt) # automatically append the next step self.assertEqual(sim.solution.t.size, 3) self.assertEqual(sim.solution.y[0, :].size, 3) self.assertEqual(sim.solution.t[0], 0) - self.assertEqual(sim.solution.t[1], dt) - self.assertEqual(sim.solution.t[2], 2 * dt) + self.assertEqual(sim.solution.t[1], dt / tau) + self.assertEqual(sim.solution.t[2], 2 * dt / tau) sim.step(dt, save=False) # now only store the two end step points self.assertEqual(sim.solution.t.size, 2) self.assertEqual(sim.solution.y[0, :].size, 2) - self.assertEqual(sim.solution.t[0], 2 * dt) - self.assertEqual(sim.solution.t[1], 3 * dt) + self.assertEqual(sim.solution.t[0], 2 * dt / tau) + self.assertEqual(sim.solution.t[1], 3 * dt / tau) def test_step_with_inputs(self): dt = 0.001 @@ -232,10 +236,11 @@ def test_step_with_inputs(self): sim.step( dt, inputs={"Current function [A]": 1} ) # 1 step stores first two points + tau = model.timescale.evaluate() self.assertEqual(sim.solution.t.size, 2) self.assertEqual(sim.solution.y[0, :].size, 2) self.assertEqual(sim.solution.t[0], 0) - self.assertEqual(sim.solution.t[1], dt) + self.assertEqual(sim.solution.t[1], dt / tau) np.testing.assert_array_equal(sim.solution.inputs["Current function [A]"], 1) sim.step( dt, inputs={"Current function [A]": 2} @@ -243,8 +248,8 @@ def test_step_with_inputs(self): self.assertEqual(sim.solution.t.size, 3) self.assertEqual(sim.solution.y[0, :].size, 3) self.assertEqual(sim.solution.t[0], 0) - self.assertEqual(sim.solution.t[1], dt) - self.assertEqual(sim.solution.t[2], 2 * dt) + self.assertEqual(sim.solution.t[1], dt / tau) + self.assertEqual(sim.solution.t[2], 2 * dt / tau) np.testing.assert_array_equal( sim.solution.inputs["Current function [A]"], np.array([1, 1, 2]) ) @@ -343,10 +348,43 @@ def test_plot(self): sim.plot() # now solve and plot - t_eval = np.linspace(0, 0.01, 5) + t_eval = np.linspace(0, 100, 5) sim.solve(t_eval=t_eval) sim.plot(testing=True) + def test_drive_cycle_data(self): + model = pybamm.lithium_ion.SPM() + param = model.default_parameter_values + param["Current function [A]"] = "[current data]US06" + + drive_cycle = pd.read_csv( + os.path.join(pybamm.root_dir(), "input", "drive_cycles", "US06.csv"), + comment="#", + skip_blank_lines=True, + header=None, + ) + time_data = drive_cycle.values[:, 0] + + sim = pybamm.Simulation(model, parameter_values=param) + + # check solution is returned at the times in the data + sim.solve() + tau = model.timescale.evaluate() + np.testing.assert_array_almost_equal(sim.solution.t, time_data / tau) + + # check warning raised if the largest gap in t_eval is bigger than the + # smallest gap in the data + sim.reset() + with self.assertWarns(pybamm.SolverWarning): + sim.solve(t_eval=np.linspace(0, 1, 100)) + + # check warning raised if t_eval doesnt contain time_data , but has a finer + # resolution (can still solve, but good for users to know they dont have + # the solution returned at the data points) + sim.reset() + with self.assertWarns(pybamm.SolverWarning): + sim.solve(t_eval=np.linspace(0, time_data[-1], 800)) + if __name__ == "__main__": print("Add -v for more debug output") diff --git a/tests/unit/test_solvers/test_casadi_solver.py b/tests/unit/test_solvers/test_casadi_solver.py index a109f5bc6e..7319768462 100644 --- a/tests/unit/test_solvers/test_casadi_solver.py +++ b/tests/unit/test_solvers/test_casadi_solver.py @@ -141,22 +141,24 @@ def test_model_step(self): solver = pybamm.CasadiSolver(rtol=1e-8, atol=1e-8) # Step once - dt = 0.1 + dt = 1 step_sol = solver.step(None, model, dt) np.testing.assert_array_equal(step_sol.t, [0, dt]) - np.testing.assert_allclose(step_sol.y[0], np.exp(0.1 * step_sol.t)) + np.testing.assert_array_almost_equal(step_sol.y[0], np.exp(0.1 * step_sol.t)) # Step again (return 5 points) step_sol_2 = solver.step(step_sol, model, dt, npts=5) np.testing.assert_array_equal( step_sol_2.t, np.concatenate([np.array([0]), np.linspace(dt, 2 * dt, 5)]) ) - np.testing.assert_allclose(step_sol_2.y[0], np.exp(0.1 * step_sol_2.t)) + np.testing.assert_array_almost_equal( + step_sol_2.y[0], np.exp(0.1 * step_sol_2.t) + ) # Check steps give same solution as solve t_eval = step_sol.t solution = solver.solve(model, t_eval) - np.testing.assert_allclose(solution.y[0], step_sol.y[0]) + np.testing.assert_array_almost_equal(solution.y[0], step_sol.y[0]) def test_model_step_with_input(self): # Create model diff --git a/tests/unit/test_solvers/test_scikits_solvers.py b/tests/unit/test_solvers/test_scikits_solvers.py index 3a7067e8f8..7e6974c57e 100644 --- a/tests/unit/test_solvers/test_scikits_solvers.py +++ b/tests/unit/test_solvers/test_scikits_solvers.py @@ -40,6 +40,7 @@ class Model: mass_matrix = pybamm.Matrix(np.array([[1.0, 0.0], [0.0, 0.0]])) y0 = np.array([0.0, 1.0]) terminate_events_eval = [] + timescale_eval = 1 def residuals_eval(self, t, y, ydot): return np.array([0.5 * np.ones_like(y[0]) - ydot[0], 2 * y[0] - y[1]]) @@ -59,6 +60,7 @@ def test_dae_integrate_bad_ics(self): solver = pybamm.ScikitsDaeSolver(rtol=1e-8, atol=1e-8) model = pybamm.BaseModel() + model.timescale_eval = 1 var = pybamm.Variable("var") var2 = pybamm.Variable("var2") model.rhs = {var: 0.5} @@ -86,6 +88,7 @@ class Model: mass_matrix = pybamm.Matrix(np.array([[4.0, 0.0], [0.0, 0.0]])) y0 = np.array([0.0, 0.0]) terminate_events_eval = [] + timescale_eval = 1 def residuals_eval(self, t, y, ydot): return np.array( @@ -385,7 +388,7 @@ def test_model_step_ode_python(self): solver = pybamm.ScikitsOdeSolver(rtol=1e-9, atol=1e-9) # Step once - dt = 0.1 + dt = 1 step_sol = solver.step(None, model, dt) np.testing.assert_array_equal(step_sol.t, [0, dt]) np.testing.assert_allclose(step_sol.y[0], np.exp(-0.1 * step_sol.t)) @@ -418,7 +421,7 @@ def test_model_step_dae_python(self): solver = pybamm.ScikitsDaeSolver(rtol=1e-8, atol=1e-8) # Step once - dt = 0.1 + dt = 1 step_sol = solver.step(None, model, dt) np.testing.assert_array_equal(step_sol.t, [0, dt]) np.testing.assert_allclose(step_sol.y[0], np.exp(0.1 * step_sol.t)) diff --git a/tests/unit/test_solvers/test_scipy_solver.py b/tests/unit/test_solvers/test_scipy_solver.py index 0068835b15..dbd2aabc00 100644 --- a/tests/unit/test_solvers/test_scipy_solver.py +++ b/tests/unit/test_solvers/test_scipy_solver.py @@ -156,10 +156,11 @@ def nonsmooth_rate(t): model1.initial_conditions = {var1: 1} model1.events = [ pybamm.Event("var1 = 1.5", pybamm.min(var1 - 1.5)), - pybamm.Event("nonsmooth rate", - pybamm.Scalar(discontinuity), - pybamm.EventType.DISCONTINUITY - ), + pybamm.Event( + "nonsmooth rate", + pybamm.Scalar(discontinuity), + pybamm.EventType.DISCONTINUITY, + ), ] # second model implicitly adds a discontinuity event via a heaviside function @@ -190,9 +191,9 @@ def nonsmooth_rate(t): # create two time series, one without a time point on the discontinuity, # and one with t_eval1 = np.linspace(0, 5, 10) - t_eval2 = np.insert(t_eval1, - np.searchsorted(t_eval1, discontinuity), - discontinuity) + t_eval2 = np.insert( + t_eval1, np.searchsorted(t_eval1, discontinuity), discontinuity + ) solution1 = solver.solve(model, t_eval1) solution2 = solver.solve(model, t_eval2) @@ -217,8 +218,7 @@ def nonsmooth_rate(t): np.testing.assert_array_less(solution.y[-1], 2.5) var1_soln = np.exp(0.2 * solution.t) y0 = np.exp(0.2 * discontinuity) - var1_soln[solution.t > discontinuity] = \ - y0 * np.exp( + var1_soln[solution.t > discontinuity] = y0 * np.exp( 0.1 * (solution.t[solution.t > discontinuity] - discontinuity) ) np.testing.assert_allclose(solution.y[0], var1_soln, rtol=1e-06) @@ -242,22 +242,24 @@ def test_model_step_python(self): solver = pybamm.ScipySolver(rtol=1e-8, atol=1e-8, method="RK45") # Step once - dt = 0.1 + dt = 1 step_sol = solver.step(None, model, dt) np.testing.assert_array_equal(step_sol.t, [0, dt]) - np.testing.assert_allclose(step_sol.y[0], np.exp(0.1 * step_sol.t)) + np.testing.assert_array_almost_equal(step_sol.y[0], np.exp(0.1 * step_sol.t)) # Step again (return 5 points) step_sol_2 = solver.step(step_sol, model, dt, npts=5) np.testing.assert_array_equal( step_sol_2.t, np.concatenate([np.array([0]), np.linspace(dt, 2 * dt, 5)]) ) - np.testing.assert_allclose(step_sol_2.y[0], np.exp(0.1 * step_sol_2.t)) + np.testing.assert_array_almost_equal( + step_sol_2.y[0], np.exp(0.1 * step_sol_2.t) + ) # Check steps give same solution as solve t_eval = step_sol.t solution = solver.solve(model, t_eval) - np.testing.assert_allclose(solution.y[0], step_sol.y[0]) + np.testing.assert_array_almost_equal(solution.y[0], step_sol.y[0]) def test_model_solver_with_inputs(self): # Create model diff --git a/tests/unit/test_solvers/test_solution.py b/tests/unit/test_solvers/test_solution.py index 7aa4db34fe..0fa8a33013 100644 --- a/tests/unit/test_solvers/test_solution.py +++ b/tests/unit/test_solvers/test_solution.py @@ -4,6 +4,9 @@ import pybamm import unittest import numpy as np +import pandas as pd +from scipy.io import loadmat +from tests import get_discretisation_for_testing class TestSolution(unittest.TestCase): @@ -19,25 +22,47 @@ def test_init(self): self.assertEqual(sol.inputs, {}) self.assertEqual(sol.model, None) + with self.assertRaisesRegex(AttributeError, "sub solutions"): + print(sol.sub_solutions) + def test_append(self): # Set up first solution t1 = np.linspace(0, 1) y1 = np.tile(t1, (20, 1)) sol1 = pybamm.Solution(t1, y1) sol1.solve_time = 1.5 - sol1.inputs = {} + sol1.model = pybamm.BaseModel() + sol1.inputs = {"a": 1} # Set up second solution t2 = np.linspace(1, 2) y2 = np.tile(t2, (20, 1)) sol2 = pybamm.Solution(t2, y2) sol2.solve_time = 1 - sol1.append(sol2) + sol2.inputs = {"a": 2} + sol1.append(sol2, create_sub_solutions=True) # Test self.assertEqual(sol1.solve_time, 2.5) np.testing.assert_array_equal(sol1.t, np.concatenate([t1, t2[1:]])) np.testing.assert_array_equal(sol1.y, np.concatenate([y1, y2[:, 1:]], axis=1)) + np.testing.assert_array_equal( + sol1.inputs["a"], + np.concatenate([1 * np.ones_like(t1), 2 * np.ones_like(t2[1:])]), + ) + + # Test sub-solutions + self.assertEqual(len(sol1.sub_solutions), 2) + np.testing.assert_array_equal(sol1.sub_solutions[0].t, t1) + np.testing.assert_array_equal(sol1.sub_solutions[1].t, t2) + self.assertEqual(sol1.sub_solutions[0].model, sol1.model) + np.testing.assert_array_equal( + sol1.sub_solutions[0].inputs["a"], 1 * np.ones_like(t1) + ) + self.assertEqual(sol1.sub_solutions[1].model, sol2.model) + np.testing.assert_array_equal( + sol1.sub_solutions[1].inputs["a"], 2 * np.ones_like(t2) + ) def test_total_time(self): sol = pybamm.Solution([], None) @@ -71,12 +96,14 @@ def test_getitem(self): def test_save(self): model = pybamm.BaseModel() + # create both 1D and 2D variables c = pybamm.Variable("c") - model.rhs = {c: -c} - model.initial_conditions = {c: 1} - model.variables["c"] = c + d = pybamm.Variable("d", domain="negative electrode") + model.rhs = {c: -c, d: 1} + model.initial_conditions = {c: 1, d: 2} + model.variables = {"c": c, "d": d, "2c": 2 * c} - disc = pybamm.Discretisation() + disc = get_discretisation_for_testing() disc.process_model(model) solution = pybamm.ScipySolver().solve(model, np.linspace(0, 1)) @@ -84,16 +111,36 @@ def test_save(self): with self.assertRaises(ValueError): solution.save_data("test.pickle") # set variables first then save - solution.update(["c"]) + solution.update(["c", "d"]) solution.save_data("test.pickle") data_load = pybamm.load("test.pickle") np.testing.assert_array_equal(solution.data["c"], data_load["c"]) - - # test save + np.testing.assert_array_equal(solution.data["d"], data_load["d"]) + + # to matlab + solution.save_data("test.mat", to_format="matlab") + data_load = loadmat("test.mat") + np.testing.assert_array_equal(solution.data["c"], data_load["c"].flatten()) + np.testing.assert_array_equal(solution.data["d"], data_load["d"]) + + # to csv + with self.assertRaisesRegex( + ValueError, "only 1D variables can be saved to csv" + ): + solution.save_data("test.csv", to_format="csv") + # only save "c" and "2c" + solution.save_data("test.csv", ["c", "2c"], to_format="csv") + # read csv + df = pd.read_csv("test.csv") + np.testing.assert_array_almost_equal(df["c"], solution.data["c"]) + np.testing.assert_array_almost_equal(df["2c"], solution.data["2c"]) + + # test save whole solution solution.save("test.pickle") solution_load = pybamm.load("test.pickle") self.assertEqual(solution.model.name, solution_load.model.name) np.testing.assert_array_equal(solution["c"].entries, solution_load["c"].entries) + np.testing.assert_array_equal(solution["d"].entries, solution_load["d"].entries) def test_solution_evals_with_inputs(self): model = pybamm.lithium_ion.SPM() @@ -115,7 +162,7 @@ def test_solution_evals_with_inputs(self): solver=solver, ) inputs = {"Electrode height [m]": 0.1} - sim.solve(t_eval=np.linspace(0, 0.01, 10), inputs=inputs) + sim.solve(t_eval=np.linspace(0, 10, 10), inputs=inputs) time = sim.solution["Time [h]"](sim.solution.t) self.assertEqual(len(time), 10)