From de2d5b2091f970ec5bbb50a70a8eb2c27ef27fc2 Mon Sep 17 00:00:00 2001 From: pauljgasper Date: Fri, 7 Apr 2023 15:05:55 -0600 Subject: [PATCH] Initial commit from internal repo. --- NOTICE.txt | 5 + README.md | 6 + SWR-22-69.docx | Bin 0 -> 24378 bytes example.ipynb | 731 ++++++++++++++++++++++++++ functions/extract_stressors.py | 32 ++ functions/rainflow.py | 176 +++++++ functions/state_functions.py | 48 ++ lfp_gr_SonyMurata3Ah_2018.py | 271 ++++++++++ lmo_gr_NissanLeaf66Ah_2ndLife_2020.py | 159 ++++++ nca_gr_Panasonic3Ah_2018.py | 169 ++++++ nmc111_gr_Kokam75Ah_2017.py | 217 ++++++++ nmc111_gr_Sanyo2Ah_2014.py | 225 ++++++++ nmc811_grSi_LGMJ1_4Ah_2020.py | 166 ++++++ nmc_lto_10Ah_2020.py | 177 +++++++ 14 files changed, 2382 insertions(+) create mode 100644 NOTICE.txt create mode 100644 README.md create mode 100644 SWR-22-69.docx create mode 100644 example.ipynb create mode 100644 functions/extract_stressors.py create mode 100644 functions/rainflow.py create mode 100644 functions/state_functions.py create mode 100644 lfp_gr_SonyMurata3Ah_2018.py create mode 100644 lmo_gr_NissanLeaf66Ah_2ndLife_2020.py create mode 100644 nca_gr_Panasonic3Ah_2018.py create mode 100644 nmc111_gr_Kokam75Ah_2017.py create mode 100644 nmc111_gr_Sanyo2Ah_2014.py create mode 100644 nmc811_grSi_LGMJ1_4Ah_2020.py create mode 100644 nmc_lto_10Ah_2020.py diff --git a/NOTICE.txt b/NOTICE.txt new file mode 100644 index 0000000..aa5c9b4 --- /dev/null +++ b/NOTICE.txt @@ -0,0 +1,5 @@ +NOTICE + +BLAST-Python Copyright ©2022 Alliance for Sustainable Energy, LLC + +These data were produced by the Alliance for Sustainable Energy, LLC (Contractor) under Contract No. DE-AC36-08GO28308 with the U.S. Department of Energy (DOE). During the period of commercialization or such other time period specified by the DOE, the Government is granted for itself and others acting on its behalf a nonexclusive, paid-up, irrevocable worldwide license in this data to reproduce, prepare derivative works, and perform publicly and display publicly, by or on behalf of the Government. Subsequent to that period the Government is granted for itself and others acting on its behalf a nonexclusive, paid-up, irrevocable worldwide license in this data to reproduce, prepare derivative works, distribute copies to the public, perform publicly and display publicly, and to permit others to do so. The specific term of the license can be identified by inquiry made to the Contractor or DOE. NEITHER CONTRACTOR, THE UNITED STATES, NOR THE UNITED STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL LIABILITY OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR USEFULNESS OF ANY DATA, APPARATUS, PRODUCT, OR PROCESS DISCLOSED, OR REPRESENTS THAT ITS USE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS. diff --git a/README.md b/README.md new file mode 100644 index 0000000..7381129 --- /dev/null +++ b/README.md @@ -0,0 +1,6 @@ +### BLAST-Lite + +Battery Lifetime Analysis and Simulation Toolsuite in the python programming language. +Provides a library of battery lifetime and degradation models for various commercial lithium-ion batteries. + +SWR-22-69 \ No newline at end of file diff --git a/SWR-22-69.docx b/SWR-22-69.docx new file mode 100644 index 0000000000000000000000000000000000000000..0488f1b06b182715fb1f504b5af70457c24179eb GIT binary patch literal 24378 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 literal 0 HcmV?d00001 diff --git a/example.ipynb b/example.ipynb new file mode 100644 index 0000000..89fae05 --- /dev/null +++ b/example.ipynb @@ -0,0 +1,731 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Battery life model library\n", + "Example notebook demonstrating how to use the battery life models in Python.\n", + "\n", + "First examples use the Kokam NMC111|Gr 75Ah battery life model. The battery modeled here is a high-power cell with long cycle life. Because nominal cell resistance is low, the relative change of resistance at end-of-life is quite high compared to other cell designs (~300% increase in cell resistance at 80% capacity if not more). Fade rates can be changed in the code to accomodate other cell models. Documentation is provided in the life model class. See https://ieeexplore.ieee.org/abstract/document/7963578 for the aging test details and results used to parameterize this model." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from nmc111_gr_Kokam75Ah_2017 import Nmc111_Gr_Kokam75Ah_Battery" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To run, the life model needs timeseries data: the time in seconds since beginning-of-life of the battery, the state-of-charge of the battery (0 to 1), and the ambient temperature (or battery temperature, if you have a thermal model)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaMAAAEGCAYAAADIRPqpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAABSQUlEQVR4nO2dd3iUVfbHPycJoUsPIiBNQIooSlMQAXftrmtbu+hPQRQVO4gGSAKKXRQVUextWV3r2nadAZRepEVEIgEBkS49kHJ+f9wJBEh5M5l33in38zz3mZl3bjmTycyZe++55yuqisVisVgsXpLgtQEWi8VisVhnZLFYLBbPsc7IYrFYLJ5jnZHFYrFYPMc6I4vFYrF4TpLXBpSXhIQErVq1qtdmWCwWS1SxZ88eVdWInYBEnTOqWrUqu3fv9toMi8ViiSpEZK/XNpRGxHpJi8ViscQP1hlZLBaLxXOsM7JYLBaL51hnZLFYLBbPsc7IYrFYLJ7jmjMSkddEZKOILC3heRGR50QkS0QWi8jJbtlisVgslsjGzZnRG8A5pTx/LtA6UAYCL7loi8VisVhKQ6QKInMQWYRIJiJpget1EfkvIisCt3XcGN61c0aqOk1EmpdS5SLgLTUaFrNEpLaINFLV9W7Ys3TpUiZPnuxG11GBiHD11VfTtm1br00JO6tWreKNN96goKDAcZtjf/uNs2vUoGmTJqDqrFSrBrfcAnVc+axa4pz09HR69epFv3793BpiH9AP1V2IVAJ+QOQr4BLgO1THIjIMGAYMDfXgXh56bQysKfJ4beDaEc5IRAZiZk8kJycHNdiyZcsYPXp0UG1jAVVlw4YNTJgwwWtTws7zzz/P008/jYg4qt9JldlA5WAGmz4dPvsMHI5lsThh69atjBo1irS0NPeckZkY7Ao8qhQoipk49AlcfxOYggvOyMsAhuI+rcUq/anqRFXtoqpdkpKC85+XX345BQUFcVs6derEhg0bgvrbRTsrV66kQ4cOzv5Wu3ezsEMHtE4dGgOvjBsHe/dCTg7s2wf790NuLuTlQX4+FBSYogrjxsEXX0AcOnyLu0ydOhVVpW/fvhXpJklE5hUpA4+oIZKIyEJgI/BfVGcDDSlcsTK3KRUxoiS8dEZrgaZFHjcBfvfIlpinQYMGbNy40WszPCE7O5sWLVo4qzxsGGRmUvndd2l+2mmkPf44OQCVK0NyMlSqBElJkJgICQlmBlQ4C7rjDjj7bLjnHli2zK2XY4lDfD4f1apVo1u3bhXpJq/wR32gTDyihmo+qidhvo+7IdKxIgOWBy+d0WfA9YGouh7Adrf2iyyQkpISl85IVcnOzqZ58+ZlV/7mG3juObjjDuTccxk9ejTr1q1j4sQjP7PFIgKvvw41asDVV5uZlMUSAvx+P6effnrQ2xTlRvVPzHLcOcAGRBoBBG5d+SJxM7T7fWAm0FZE1orITSIySEQGBap8CawEsoBXgNvcssUSv85o27Zt7Nixo+yZ0ebNcMMN0L49PPYYAH379qVv37488sgj7Nmzx9mAjRrBpEmwcCGkplbIdosFYMOGDWRmZlZ0ia5sRBogUjtwvyrwF+BnzMShf6BWf+BTN4Z3M5ruqjKeV2CwW+NbDiUlJYUdO3aQk5NDlSpVvDYnbGRnZwOU7oxUYcAA2LIFvvoKikiUZGRk0KtXL1544QXuv/9+Z4P+7W8mqu7JJ+Gcc8C96CdLHOD3+wHcjKIrpBHwJiKJmInKZFS/QGQmMBmRm4DfgMvdGNxmYIgTUlLMnuOmTZs8tiS8OHJGr70Gn3wCjzwCJ510yFM9e/bknHPO4bHHHmPnzp3OB37qKWjTBq6/HrZuLb/hFksAn89HrVq16Ny5s7sDqS5GtTOqnVDtiGp64PoWVM9EtXXg1pV/aOuM4oRCZxRvS3WrVq0CSnFGK1bAkCFm9nLPPcVWSU9PZ8uWLYwbN875wNWrw3vvwcaNZpakxQaKWixl4vf7OeOMMwg2kjhasM4oTohXZ5SdnU2dOnWoVavWkU/m5sK115oIuTffNNFxxdC1a1cuuuginnzySbZt2+Z88JNPhowM+PBD07/FUk5+++03srKy3N8vigCsM4oT4tkZlTgrGj0a5syBl1+GJk1K7Sc9PZ3t27fz9NNPl8+A++6DPn1M2HdWVvnaWuKeMO4XeY51RnFCPDujYsO6Z8wwzuj66+Ef/yizn06dOnH55Zfz7LPPsnnzZucGJCbCW2+Zs0nXXmtmYxaLQ/x+P/Xr16djx7Ad9/EM64zihOrVq1O1atW4CmBQVVatWnXkzGjnTuMYmjWD55933F9aWhp79uzh8ccfL58hTZua2dfs2cYBWiwOUFV8Ph99+vQhoYQl5Fgi9l+hBTCJUuMtC8Mff/xBTk7Okc7ozjth9Wp4+2046ijH/bVr146rr76a8ePH88cff5TPmH/8A/r3N85o+vTytbXEJb/++itr1qyJiyU6sM4oroi3g6/FRtJ9+CG88QYMHw49e5a7z5EjR7J//37Gjh1bfoOee87Mxq69FrZvL397S1wRT/tFYJ1RXBFvzuiIM0br1sHAgdCtG4wYEVSfxx13HDfccAMvvfQSa9euLV/jo46Cd9+FNWtMQIPFUgo+n49GjRrRpk0br00JC9YZxRHx6oyaN29uMmv372+ybr/zjgnnDpLU1FRUlTFjxpS/8amnmjRBb78N778ftA2W2EZV8fv99OvXz7H0SbRjnVEcUeiMNE4OYGZnZ9OwYUOqVq0Kzz4L331nblu3rlC/zZo1Y8CAAUyaNOmAwysXDz1knNKtt5q9K4vlMJYtW8aGDRviZokOrDOKK1JSUti3b1/50tpEMQfOGC1eDA8+CBddBDfdFJK+hw8fTkJCAhkZGeVvnJRkZmf5+Sa0PD8/JDZZYgefzwcQF4ddC7HOKI6It7NG2dnZtDn2WLjmGqhbF159NWQKrI0bN+bWW2/lrbfe4pdffil/By1bwvjxMG0alDdU3BLz+Hw+mjdv7lyHKwawziiOiCdnlJeXx2+//cbA7GxYutRE0NWvH9Ixhg0bRuXKlUlLSwuug8IDtyNGwLx5IbXNEr0UFBQwZcqUuFqiA+uM4op4ckbr1q2jX34+PefONeeKzj475GM0bNiQO+64g/fff5/MzMzydyBiJMqPPtqI8e3eHXIbLdHHokWL2LZtW1wt0YF1RnFFgwYNgPiQkVi7cCFvALuaN4dgzgQ55P7776dGjRqMGjUquA7q1DGRdVlZcPfdIbXNEp3E434RuOyMROQcEVkuIlkiMqyY5+uIyMcislhE5kgY9dbjkUJnFPMzI1WapKdTD/hz/PhDxPJCTb169bj77rv58MMPWbhwYXCd9OkDDzwAr7xidJUscY3P56Nt27Y0btzYa1PCipuy44nAC8C5QHvgKhFpf1i14cBCVe0EXA+UQzDGUl4qV65MrVq1Yt8ZvfYazRYs4CERGp51luvD3X333dSuXZsRQR6kBSA93UhO3Hwz/P576IyzRBW5ublMmzYt7vaLwN2ZUTcgS1VXqup+4APgosPqtAe+A1DVn4HmItLQRZvinpg/+JqVBUOGkHn00XzYpAmVKnC41Sm1a9fmvvvu4/PPP2fOnDnBdZKcbLIz7NkDN95oDula4o758+eza9euuFuiA3edUWNgTZHHawPXirIIuARARLoBzYAjhGVEZKCIzBOReXl5eS6ZGx/EtDMqFMtLTubhJk1o3rJl2Ia+8847qV+/PqmpqcF3cvzx8Mwz8O23Jo+dJe4o3C/q06ePt4Z4gJvOqLgDHYcf/R8L1BGRhcAdwI/AEd5GVSeqahdV7RLr0rtuE9POaPRoI9Pw8svM+f33sJ7RqFmzJkOHDuXbb7/l+++/D76jgQPhb3+DoUPNYV1LXOH3++nUqdOB/d14wk1ntBZoWuRxE+CQxXBV3aGqN6rqSZg9owZAEPlVLE6JWWdURCxv39/+xu9hdkYAt912G0cfffSB3HVBIWIO59apYw7r5uSE1khLxLJv3z5++OGHuFyiA3ed0VygtYi0EJFk4Ergs6IVRKR24DmAm4FpqrrDRZvinpSUFDZv3kx+LKWgOUwsb3Ug31u4nVG1atUYPnw4U6dOPbDcEhQNGphDukuXwrAjglAtMcqsWbPIycmJy+AFcNEZqWoecDvwDbAMmKyqmSIySEQGBaq1AzJF5GdM1N0Qt+yxGFJSUigoKGDr1q1emxI6DhPLOyRbd5gZMGAATZo0qdjsCOCcc8zrGjcOvv46dAZaIha/309CQgK9e/f22hRPcPWckap+qaptVLWVqo4JXJugqhMC92eqamtVPV5VL1HVbW7aY4nBLAyFYnkPPXRALO8IHaMwUqVKFVJTU5k5cyZfffVVxTobOxY6dIAbboA4OKgc7/h8Pk4++WRq167ttSmeYDMwxBkxdfB17dqDYnlFotiys7NJTk7mmGOO8cSsG2+8kRYtWlR8dlS1Krz3HmzbZs4fxYn0RzyyZ88eZs2aFbdLdGCdUdxRODOK+pRABQVmxlCMWF52djbNmjUjIcGbf+9KlSoxcuRIFixYwCcVzajQqRM89hh89hlMnBgS+yyRx/Tp08nNzbXOyBI/xMwyXSlieatWrfI89f4111xDmzZtGDFiBAUVPcB6553w17+a3HU//xwaAy0Rhc/nIykpiZ6BpeZ4xDqjOKNu3bokJCREtzNatKhUsbwDonoekpSUxKhRo1i6dCn/+te/KtZZQoLZF6tWzYR7798fEhstkYPP56N79+7UqFHDa1M8wzqjOCMxMZH69etHrzPKySlVLG/Xrl1s3rzZc2cEcMUVV9CxY0dGjhxJhTOHHHOMeb0LFhj9I0vMsH37dubNmxfXS3RgnVFcEtUHX4cNg8xMeP31YsXyvAzrPpyEhATS0tJYvnw57733XsU7/PvfYcAAoww7ZUrF+7NEBN9//z0FBQXWGXltgCX8RK0z+vZbc+7mjjvMOZxi8DKsuzguvvhiOnfuTFpaGrm5uRXv8JlnzB7ZddeZKDtL1OPz+ahcuTI9evTw1hCRpoj4EVmGSCYiQwLXT0JkFiILEZmHySMacqwzikOi0hlt3gz9+5tzN489VmK1SHNGIkJGRgYrV67kjTfeqHiH1aub7N5//AGDBtlw7xjA5/PRs2dPqlSp4rUpecC9qLYDegCDMbI/jwNpmLRtIwKPQ451RnFI1DkjVbM8tXWr+SIuRSwvOzub6tWrU7+YJTyvOO+88+jevTsZGRns27ev4h126WL0jyZPNlknLFHLli1bWLRoUWQs0amuR3VB4P5OTOacxpgE10cFatXisByjocI6ozikQYMGbN++PTRfjOHgtdeMAuqYMXDiiaVWLQzrFikuabw3iAijR49mzZo1vPLKK6Hp9IEHoHdvGDwYVq4MTZ+WsDMlsPcXpuSoSYVSPIEysMSaIs2BzsBs4C7gCUTWAE8CD7phnHVGcUhUHXxdsQKGDIF+/eCee8qsHglh3cVx5pln0rt3b8aMGcOePXsq3mFiopkVJSaaJLFW5ysq8fl8VK9ena5du4ZjuLxCKZ5AKf4UtUgN4CPgLkzi6luBu1FtCtwNTHLDOOuM4pCocUaFYnmVKsGbb5rzNqWgqmRnZ0dEJN3hFO4d/fHHH7z00kuh6fTYY2HCBJg508waLVGH3++nd+/eYVEkdoRIJYwjehfVfweu9gcK7/8Lo+IdcqwzikOiJgvD6NEwZw68/DI0OUIA+Ai2bt3Kzp07I3JmBNC7d2/++te/MnbsWHbt2hWaTq+80kTWpacbp2SJGtavX8+yZcsiR7/IrG1PApah+nSRZ34Hzgjc7wescGN464zikKhwRkXE8vjHPxw1ibRIuuLIyMhg8+bNPP/886HrdPx4M0u65hrYYeXAogW/3w8QGcELhp7AdUC/QBj3QkTOAwYATyGyCHgEKHmvqQJYZxSHRLwz2rHDLM8deyyU40s7GpxR9+7dOf/883niiSfYvn17aDo96iiTLHb1apPHzhIV+P1+ateuzUknneS1KQbVH1AVVDuhelKgfBm4fgqqJ6LaHdX5bgxvnVEcUrNmTSpXrhy5zqhQLO+dd8wXrUNWrVoFRLYzAkhPT2fbtm0888wzoeu0Z094+GGztzZ5cuj6tbiGz+fjjDPOIDEx0WtTIgJXnZGInCMiy0UkS0SO0E8WkVoi8rmILBKRTBG50U17LAYRidyzRv/6l/lCHT78gFieU7Kzs6lbty5HlcOBecHJJ5/MJZdcwtNPP82WLVtC13FqKnTvDrfcAmvWhK5fS8hZtWoVK1eujKQlutAg0gWRuxF5ApF0RP6BSF0nTV1zRiKSCLyAkRNvD1wl5jRvUQYDP6nqiUAf4CkRSXbLJstBItIZrV1rvki7dg0qGWikhnUXR1paGrt27eLJJ58MXadJSeZQcF6e2WvLzw9d35aQEoH7RRVD5AZEFmDOIFUFlgMbgV7AfxF5E5FjS+vCzZlRNyBLVVeq6n7gA+Ciw+ooUFNMFEcNYCsmJYXFZSLOGRWK5e3bd4RYnlMiNay7ODp27MiVV17Jc889x4YNG0LXcatWZp9tyhR46qnQ9WsJKX6/nwYNGtChQwevTQkV1YGeqF6K6iOovorqeFTvRPUU4BmgdWkduOmMGgNF1wrWBq4VZTzQDhM6uAQYoqpHKJGJyMDCU8MVTsVvAUwWhohyRs88c1Asr02bcjcvKCiICFG98jBq1ChycnJ4rJRce0HRvz9cdpnZQ5rvyl6zpQKoKj6fj759+0ZUppAKofoCqntLeX4hqt+V1oWbzqi4v/LhWR3PBhYCxwAnAeNF5IgFf1WdWHhqOCkpKdR2xiWFMyONhESbixaZPaKLLoKbbw6qiz/++IN9+/ZFlTNq06YN119/PS+99BLr1q0LXcci5mxWSooJ9w5FxgdLyFixYgXr1q2LnSW6oog8jshRiFRC5DtENiNyrZOmbjqjtUDTIo+bcGSCvRuBf6shC8gGjnfRJkuAlJQUcnJy2L17t7eG7N17UCzvlVeOEMtzSjSEdRfHiBEjyMvL45FHHgltx3XrmnRBv/wC994b2r4tFSLm9osO5axACqELMD6gDXC/k4ZuOqO5QGsRaREISrgS+OywOr8BZwKISEOgLWCzPoaBiDlrVFQsr0GDoLuJlrDuw2nRogU33XQTr7zyCqtXrw5t5337wn33mZRBnx3+0bN4hc/no3Hjxhx33HFem+IGhZu95wHvo7rVaUPXnJGq5gG3A99gUpFPVtVMERkkIoMC1TKA00RkCfAdMFRVN7tlk+UgEeGMvvkGnnuuVLE8pxTOjJo1axYKy8LKQw89dCB3XcgZPRo6d4abbjIaSBZPUVX8fj/9+vWLnf2iQ/kckZ+BLsB3iDQAcpw0dPWckap+qaptVLWVqo4JXJugqhMC939X1bNU9QRV7aiq77hpj+UgnjujzZtN9Fz79qWK5TklOzubo48+mqqlaB1FKk2bNuWWW27hjTfeICsrK7SdJyebcO9du8zfu+CI+CBLGMnMzGTTpk2xukQHqsOAU4EuqOYCuzkyirpYbAaGOMVTZ1QolrdlS5lieU6JpjNGxfHggw+SnJxMenp66Dtv1w6eftrMRMePD33/Fsf4fD4gbPpF4UfkeuBC4JrA/cuAs5w0tc4oTmkQ2J/xxBkViuU98giEKC9XtDujRo0aMXjwYN555x2WLVsW+gEGDYILLjCifEuXhr5/iyN8Ph8tW7aMyuVkh3QtUk4HRgF/c9LQOqM4pUqVKhx11FHhd0aFYnl9+zoSy3NCXl4ea9asiWpnBPDAAw9QvXp1Ro0aFfrORWDSJKhVC66+GnIcLeNbQkh+fj5TpkyJ3SU6ANU7ipQBGLVYR1l1rDOKY8J+8LWcYnlOWbNmDfn5+VHvjBo0aMCQIUOYPHkyixYtCv0AKSnwxhuwZAk86IpytKUUFi5cyPbt22PbGR3JHsrIvFCIdUZxTNhTAhUVy2vatOz6DonWsO7iuPfee6lVqxYjR450Z4Bzz4XbbzeZLr791p0xLMVSuF/Up08fbw1xE5HPEfksUL7A5Kj71ElT64zimLA6oyDE8pwSrQdei6NOnTrce++9fPrpp8ybN8+dQR5/3EQx9u9vohotYcHn89GuXTsaNWrktSlu8iTwVKA8CvQORNiViXVGcUxKSgqbNm1yf6AgxfKckp2dTUJCAk0cSJNHA0OGDKFu3bqkpqa6M0DVqvDee7B1q0m/FAkpoWKc3Nxcvv/++9hfolOdWqRMR3Wt06bWGcUxhc6owO2zJ0OGBCWW55Ts7GyaNm1KpSAyfUciRx11FEOHDuXrr79m+vTp7gxy4onw6KPw6afw6qvujGE5wNy5c9m9e3csh3T/ELjdiciOIsU8doAjZyQi1UQkVUReCTxuLSIXBG24JSJISUkhPz+fbdu2uTfIhx+aTfMgxPKcEu1h3cUxePBgUlJS3JsdAdx1F/zlL+b2l1/cG8cS+/tFqr0CtzVRPapIMY8d4HRm9DqwD3OyFkwCvNHltdcSWbh+8HXtWhg4MGixPKfEojOqXr06Dz74IH6//8AXWchJSDBRjVWqmHDv/fvdGceC3+/npJNOol69el6b4i4irRCpHLjfB5E7EantpKlTZ9RKVR8HcgHU6FbEZGKleMJVZxQCsTwn5OTksH79+phzRgCDBg2icePGpKamuif1ccwxZplu/nxw43yThZycHKZPnx67S3SH8hGQj8hxwCSgBfCek4ZOndF+EalKQI9IRFphZkqWKMZVZ/TssxUSy3NKYabrWHRGVapU4aGHHmLGjBl888037g108cUmkerYsTBtmnvjxCkzZ85k3759sR+8YCjAJMm+GHgW1bsBR+GDTp3RSOBroKmIvIvJsP1AMJZaIgfXnNGiReZQZQXE8pxSGNYdLXLj5eWmm26iWbNm7s6OwPxoaNXKRD3++ad748QhPp+PxMREevfu7bUp4SAXkauA/sAXgWuOlkUcOSNV/S9wCXAD8D7QRVWnlNtMS0RRr149RCS0zignJyRieU6JpTNGxZGcnMyIESOYN28en7mpSVSjhgn3Xr8ebr3VhnuHEL/fT5cuXTjKhUjSCORGTGzBGFSzEWkBOFJjcBpNdzLQDFiPUWs9VkRaiYjVAI9iEhMTqVevXmidUYjE8pySnZ1N5cqVY/og4fXXX89xxx3HiBEj3A3D79rV7Bt98IHJpm6pMLt27WL27Nnxsl8Eqj+heieq7wceZ6M61klTp8t0LwKzgInAK8BM4APgFxEpMT24iJwjIstFJEtEjjiFKyL3i8jCQFkqIvkiUtehTZYQENIsDN9+C+PGhUQszynZ2dk0a9aMhBDluYtEkpKSGDVqFIsXL+bDDz90d7Bhw6BXL7jtNgjMOi3B88MPP5CXlxf7+0UiSxBZXEwx15104WQdWkQ+ADJUNTPwuD1G1zwD+LeqnlRMm0TgF+CvmFDwucBVqvpTCWNcCNytqqW+a9WrV9fdu3eXabPFGX379iU/P59pFd243rwZTjjBLM/NmxcSjSIndOnShfr16/P111+HZTyvyM/Pp1OnTqgqS5YsITEx0b3BVq+GTp3M+zllCiTZBZBgGTp0KM888wx//vkn1apV89QWEdmjqtVd6rx0TQzV1WV14fTn5PGFjsj0qz8BnVV1ZSltugFZqrpSVfdjZlKlKf5dhdmPsoSRkMyMVM15ohCK5Tll1apVMbtfVJTExETS0tJYtmwZ77/v8sekWTN46SWYPt1kabAEjc/no0ePHp47ItdRXX2gGFoH7m8Etjrpwqkz+kVEXhKRMwLlxcC1ygTOHhVDY2BNkcdrA9eOQESqAedgYtSLe36giMwTkXl5eXkOTbY4ISTO6LXX4OOPQyqW54SdO3eyZcuWuHBGAJdccgknnngio0aNIje3pI9diLj6ahOIkpYGs2a5O1aMsm3bNhYsWBD7S3RFERkAfAi8HLjSBPjESVOnzqg/kAXcBdwNrMRE1uUCJe3MFRdGVdKa4IXAdFUt1oOq6kRV7aKqXZLskkFISUlJYdu2bewP9vR9VlbIxfKcEuth3YeTkJBAeno6v/76K2+99Zb7A77wAjRpYsK9d+50f7wYY9q0aRQUFMSXM4LBQE/A5KNTXQGkOGlYpjMK7P18rqpPqerFqvp3VX1SVfeoaoGq7iqh6VqgqGhNE0wkXnFciV2i84TCs0abg5EScEkszymxHtZdHBdeeCFdu3YlPT2dfftcPndeqxa8/bYJZBgyxN2xYhC/30/VqlXp3r2716Y4Q6QpIn5EliGSiciQIs/dgcjywPXHS+llH2ZbprBdEiVPQg6hzG8PVc0H9ohILScdFmEu0FpEWohIMsbhHHFQItDvGTgUYLKElgodfB09GmbPDrlYnlPi0RmJCBkZGfz2229MmjTJ/QFPP90kuX39dZP01uIYn89Hz549qVy5stemOCUPuBfVdkAPYDAi7RHpi9nv74RqB4xmUUlMRWQ4UBWRvwL/Aj53MrjTn7I5wBIRmSQizxWW0hqoSQlxO/ANsAyYrKqZIjJIRAYVqXox8K2q2hA5D2gQOAtUbmc0c6ZrYnlOyc7OpkaNGrGffPIwzjrrLHr27MmYMWPYu3ev+wOOGAHdupkglbWO5Wnimk2bNrFkyZLoWqJTXY/qgsD9nZjv7cbArcBYVPcFnivty2IYsAlYAtwCfAk87GR4p87oP0AqMA2YX6SUiqp+qaptVLWVqo4JXJugqhOK1HlDVa90aIclxAQ1M9q501WxPKcURtKJy1keIg0RYfTo0fz+++9MmDCh7AYVpVIlk+x2/37z48Nt/asYYMqUKQDR5YyKItIc6AzMBtoApyMyG5GpiHQtpn4DRNqjWoDqK6hejuplmDOp9Z0M6TQd0JvFFaevyxK5BOWM7rwTVq1yTSzPKbEoHeGUPn360K9fP8aOHUtYzt21bm0ONPv98NRT7o8X5fh8PmrWrMkpp5zitSlFSSqMSg6UgcXWEqmBiWy+C9UdQBJQB7N0dz8wuZhfgM8DxaVcaQyMc2Kc03RArUXkQxH5SURWFhYnbS2RTa1atahUqZJzZxQGsTwnqCrZ2dlxE0lXHBkZGWzcuJHx48eHZ8D/+z+45BJ46CH48cfwjBml+Hw+evfuTYRF/+YVRiUHysQjaohUwjiid1H9d+DqWuDfqCqqc4ACjpztnIDq1CP6U/0G6OTEuPKI672E2eDqC7wFvO2wrSWCEZED8uNlsm5dWMTynLBlyxZ27doVtzMjgNNOO41zzz2Xxx9/nB07HCk7VwwRmDjR5By8+mrYs8f9MaOQdevW8csvv0TfEp2Z7UwClqH6dJFnPgH6Beq0AZKBw8NvS8vMHbqs3UBVVf0Okz5otaqOOmCcJepxdPC1oAD693ddLM8p8RhJVxzp6els3bqVZ599NjwD1qtnwvh//hnuuy88Y0YZfr8fIBqTo/YErgP6IbIwUM4DXgNaIrIUk0mnfzF6JisCdQ9F5FzMudQycTqHzBGRBGCFiNwOrMPhQSZL5OPIGRWK5U2c6KpYnlOsMzJ06dKFv//97zz11FPcfvvt1K0bhjzDf/kL3Huv2Ts67zy44AL3x4wifD4fderU4cQTT/TalPKh+gMlK3hfW0bru4EvEPkHB4PbumDkJBz9gzidGd0FVAPuBE7BeM/+DttaIpwyndHixWETy3OKdUYHSUtLY8eOHTwVzsCCMWPgxBPNPtKGDeEbNwrw+Xz07ds3pjPJH4HqL8AJwFSgeaBMxZxN+sVJF06j6eaq6i5VXauqN6rqJapqE1bFCKU6ozCL5Tll1apV1KtXj5o1a3ptiud06tSJK664gnHjxjnb+wsFlSubpLg7d8KNN1oxvgDZ2dmsXr06+vaLKoqIoLoP1ddRvTdQXkM155A6peA0mq6NiLwiIt+KiK+wVNB8S4SQkpLCnj17ig8RHjYMli4Nm1ieU+I5rLs4Ro0axd69e3nsscfCN2iHDvDkk/DVVyaPnQWfz3wtRuF+UUXxB1IGHXvIVZFkRPoh8iZlrKY5nUf+C1iAOUl7f5FiiQFKzMLggVieU+I9rPtwjj/+eK655hpeeOEF1q9fH76Bb7vN7Bvdd59R+I1zfD4fDRs2pF27dl6bEm7OAfKB9xH5HZGfEMkGVmDkgZ5B9Y3SOnDqjPJU9SVVnaOq8wtLhUy3RAzFHnzdvBluuAHat4dw/tp2QEFBQdzoGJWHkSNHkpuby6Ph1CASMRIiRx1lwr3dTt4awagqfr+ffv36xV1WEFRzUH0R1Z5AM+BMoDOqzVAdgOrCsroo1RmJSN2ADPjnInKbiDQqvGblwWOHI5xRoVje5s1hF8tzwvr169m/f791RofRqlUrbrzxRl5++WV+++238A3csKFZxl282ByGjlOWL1/O+vXr43GJ7lBUcwN57v4sT7OyZkbzgXmYtb77gRkczEs3LwgzLRHIEc7II7E8p9hIupJ5+OGHUVXGjBkT3oHPP98s2T39NPz3v+EdO0Io3C+Ku+CFEFGqM1LVFqraMnB7eGkZLiMt7lK4Z7Rp0yZPxfKcsmrVKsA6o+Jo1qwZAwcO5LXXXmPlyjBn7HriCWjXzhyO3rIlvGNHAH6/n2OPPZaWLe1XYzA4jaYbLCK1izyuIyK3uWaVJaxUq1aNGjVqsHn9ek/F8pxSODNq1qyZx5ZEJsOHDycpKYn09PTwDlytGrz3nlneHTAgrsK9CwoK4ne/6HBEmiHyl8D9qog4On/h9NtmgBZZ/1PVbcCA8tpoiVxSUlI4ze/3VCzPKdnZ2TRq1IgqVap4bUpEcswxx3Dbbbfx9ttvs3z58vAOftJJZnn344/Ncm+csGTJErZs2WL3i0QGAB8CLweuNMHktisTp84oQYq4+4AUeXI5TLREOGdWrcpFS5Z4KpbnFHvGqGyGDh1K1apVSUtLC//g99wD/foZqZEVK8I/vgfE8fmiwxmMyXFnMveqrsBh6jinzugbYLKInCki/YD3ga/LaiQi54jIchHJEpFhJdTpIyILRSRTRI5MQW5xn507Sc/O5o/kZE/F8pxinVHZpKSkcMcdd/DBBx+wdOnS8A6ekGCWeStXNtk7cnPDO74H+P1+WrduTdMIXlEIE/tQ3X/gkUgS4Gi91qkzGgp8h5GfHRy4/0BpDQKzpxeAc4H2wFUi0v6wOrWBF4G/qdFWv9yhPZZQcuedpOzdy201a3oqlueE3Nxc1qxZY52RA+6//35q1qzJyJEjwz94kyYmfdTcueDF7CyM5OXlMXXqVDsrMkxFZDhQFZG/YhImfO6koaOs3apaAEwAJojIyVqok1463YAsVV0JICIfABcBPxWpczXwb1X9LTBOOeRGLSEhIJY35bTT+HLOHAoKCsKa4PHpp59mxowZjuvn5ORQUFBgnZED6taty913301aWhoLFizg5JNPDq8Bl15q8tY9+iicfTacfnp4xw8TCxYsYMeOHTak2zAUuBlYAtwCfAm86qShHClLUUYDkQWqWuZ/tYhcBpyjqjcHHl8HdFfV24vUeRYjvNQBqAmMU9W3iulrIDAQIDk5+ZR9cXzKO6SsWwcnnADHHcdzV1zBkPvuY8uWLeGRIQD27NlD7dq1qVevHvXq1XPcrmrVqnzwwQe0atXKRetig+3bt9OiRQtOO+00vvjii/AbsHMndO5sluoWLYLatcNvg8s89thjDBs2jD/++IOGDRt6bU6JiMgeVa3u4gAJwGJUOwbTPBhNXKdxi8XVO9zzJWEkKc4EqgIzRWSWHpZyPCCPOxGgevXq8RMv6iaHieXVn2fOMG/cuDFszmj69Onk5uby+uuvc06E5b6LFWrVqsX999/P8OHDmTVrFj169AivATVrmiwePXvC4MHmfozh8/no0KFDRDuisKBagMgiRI4lsNpVHspKB/R24HZIkctOF4DXAkV385oAvxdT52tV3a2qm4FpQJQpUkUphWJ5zz4LbdoUn5/OZXw+H0lJSfTq1StsY8Yjd9xxBw0aNCA1NdUbA7p3h5EjzRmkGHNG+/fv54cffrBLdAdpBGQi8h0inx0oDihrc+AUEWkG/F/goGtdYJrD3HRzgdYi0kJEkoErgcON+hQ4XUSSRKQa0B1Y5sRwSwVYtOgIsTwvnJHf76d79+7UqFEjbGPGIzVq1GDYsGH873//Y+pUjwJWH3zQzI5uuw0CGTRigTlz5rBnzx7rjA6ShlF2TQeeKlLKpCxnNAETwn08B3PSOcpNp6p5wO2YsPBlwGRVzRSRQSIyKFBnWaD/xcAc4FVVDXMcapxRglheoTMKlzjb9u3bmTt3rv0Qh4lbb72VRo0akZqaSnn3iUNCUhK8/bbJynDddZCfH34bXMDn8yEinHHGGV6bEhmoTi22OKCs3HTPqWo74LVictSVmYBJVb9U1Taq2kpVxwSuTVDVCUXqPKGq7VW1o6o+68RoSwUYNszozhwmlle/fn0gfDOj77//noKCAhsOGyaqVq3K8OHD+f777/nf//7njREtWsCLL8IPP8DYsd7YEGJ8Ph+dO3emTp06XpsSGYjsRGRHoOQgko/IDidNncqO3yoiJ4rI7YHSqWIWWzyhFLG8pKQk6tWrFzZn5PP5qFy5MqeeempYxrPAgAEDaNq0qXezIzCz8iuvhFGjYM4cb2wIEXv37mXmzJl2dl8U1ZqoHhUoVYBLgfFOmjpNlHon8C4mrUMK8K6I3BGsvRYP2LzZRM+VIpaXkpISNmfk9/vp2bOnzS8XRipXrkxqaiqzZ8/mP//5jzdGiMBLL8ExxxjHtGuXN3aEgBkzZrB//37rjEpD9RPA0R/I6enGmzFnhEao6gigBzZRavRQKJa3ZUupYnkNGjQIizPasmULCxcutEt0HnDDDTfQsmVLRowYQUFBgTdG1K5t9o9+/RXuussbG0KAz+cjMTHRRoMWReSSIuUyRMYS4nRAgtE3LyQf5+eNLF5TKJY3ZkypYnnhmhlNmTIFsCJkXlCpUiVGjhzJjz/+yMcff+ydIb17m/3LSZPg3//2zo4K4PP56NatGzVrOlJIiBcuLFLOBnZiMu+UiVNn9DowW0RGiUgaMAuYFIShlnCzYsVBsbx77y21arickd/vp3r16nTt2tX1sSxHcs0119C2bVtGjhxJvpdRbaNGQZcuRvto3Trv7AiCnTt32mjQ4nkV1RsDZQAmcK21k4ZOAxieBm4EtgbKjTbyLQrIzS2XWF5KSgpbt24l1+Usyz6fj9NPP51KlSq5Oo6leBITE0lLSyMzM5N//vOf3hmSnGyWjXNy4IYbTFaQKOH7778nPz/fOqMjKS7tvyMpAMcZMVV1gao+B/yqqj86bWfxkNGjTcSSQ7G8wrNGmzdvds2k9evXs2zZMvsh9pjLL7+cE044gVGjRpGXl+edIW3amCwg//ufuY0SfD4fycnJNhq0EJFTEbkXaIDIPUXKKCDRSRfBpGcOs5axJShmzDDOqBxieeHIwmD3iyKDhIQE0tPTWbFiBe+88463xtx8M/z97yZLw6JF3triEL/fz2mnnUbVEoKB4pBkoAYm32jNImUHcJmTDoJxRjZwIdLZscMszx17bLnE8sKRhcHn81G7dm1OKiWQwhIeLrroIk455RTS0tLYv39/2Q3cQsRkA6lXD66+Gvbu9c4WB2zdupUff/zR/qAqism0kAb0QDWtSHk6oPZaJsE4o1uCaGMJJ0OGwOrV8M475RLLC8fMyOfzccYZZ5CY6GjmbnERESE9PZ1Vq1bx+uuve2tM/frwxhvw00/wQKm6nZ4zdepUVNUeTSiePYg8gciXiPgOFAc4PfRaTURSReQVVZ0jIq1F5IKK2WxxhYBYHsOHm8SU5cBtZ7R69WpWrlxpf1FGEOeeey6nnnoqGRkZ5OTkeGvMWWfB3XfD+PHw5Zfe2lIKfr+fatWq0a1bN69NiUTeBX4GWmCSpq7CJM0uk/KEdu8DCnfr1gKjy2WixX3WrjWHW7t2hREjyt28du3aJCUlueaM/H4/gP1FGUGICBkZGaxbt46JEyd6bQ488ogRfLzxRghjBvnyUBgNmpyc7LUpoUWkKSJ+RJYhksmh0kEgch8iikj9Unqph+okIDewdPd/mCQJZeLUGbVS1ceBXABV3YvdO4osCgpMeGxALI8gwqZFxNUsDD6fjwYNGtChQwdX+rcER79+/ejTpw+PPPIIe/bs8daYKlWM7tH27fB//2eyh0QQGzZsIDMzM1Z/UOUB92KSY/cABiPSHjCOCv4KlCWaV3guZD0i5yPSGaNlVyZOndF+EalKIK2DiLTCzJQskcJhYnnB4tbBV1XF7/fTt29fEso472QJL4Wzow0bNvDCCy94bQ507AhPPAH/+Y/JYxdBxHQ0qOp6VBcE7u/ESP80Djz7DPAAZaf2GY1ILeBe4D7gVeBuJ8M7/VYYhdEdaioi7wLfAUMdtrW4TTFiecHiljPKyspi7dq1sfqLMurp1asXZ511Fo899hg7d+702hy4/XaTWf7ee2FZ5Oht+nw+atWqRefOnb02JRiSRGRekTKwxJoizYHOwGxE/gasQ7X0uHuRRKA1qttRXYpqX1RPQTUkSq8AqOq3wCXADcD7QBdV9Ttpa3GZomJ5r756QCwvWNxyRj6fCaiJyV+UMUJGRgZbtmxh3LhxXpti/o9ffx1q1DDh3vsiYyGmMBo0KSnJa1OCIU9VuxQpxW8SitQAPgLuwizdPQSUvQmtmg/8LVjjnEbTfaeqW1T1P6r6hapuFpHvHLQ7R0SWi0iWiAwr5vk+IrJdRBYGSvl33eOdomJ59UvbV3SGW87I7/fTuHFjWrd2lKbK4gHdunXjwgsv5Mknn2Tbtm1emwNHH22S/C5cCA8/7LU1rFmzhqysrNie3YtUwjiid1H9N9AKExm3CJFVmP2fBYgcXUIPMxAZj8jpiJx8oDigVGckIlVEpC5QX0TqiEjdQGkOHFNG20TgBeBcoD1wlRRuhh3K96p6UqDY7A7loRSxvGBJSUlh9+7dId3IVlV8Ph/9+vVDKjhzs7hLeno627dv5+mnn/baFMOFF8KgQfDkk2ZP1EMKo0FjdnZvPpyTgGWYfKSgugTVFFSbo9ocE0l9Mqp/lNDLaUAHTKaepwLlSSfDlzUzugWYDxwfuC0sn2IcTWl0A7JUdaWq7gc+wGEqcYsDHIjlBYMbWRgyMzPZtGlTbP+ijBFOOukkLrvsMp599llXcxSWi6eegrZtzf/71q2emeHz+ahfvz4dO3b0zAaX6QlcB/RDZGGgnFeuHsw+0eGl4uJ6qjpOVVsA96lqS1VtESgnqmpZUrKNgTVFHq/lYGRGUU4VkUUi8pWIFBvzKyIDCzfdPE3qGCmomrT7ZYjlBYMbB1/tflF0kZaWxu7du3niiSe8NsVQrZoJ99640Zyj8yDcu3B236dPn9iNBlX9AVVBtROqJwXKl4fVaY5qyb9SRBoiMgmRrwKP2yNyk5PhnQYwPC8iHUXkHyJyfWEpo1lx6zGH/xctAJqp6omYNOOflDD+xMJNtyjdOAwtr70Gn3xiDgiGOMebG87I7/fTsmVLmjVrFrI+Le7Rvn17rr76ap5//nn++KOk1Zgwc/LJJvHvRx+ZDCNhZuXKlaxZs8b+oCqbN4BvOLiN8wsmEKJMnAYwjMQ4i+eBvsDjlB01sRYoqlvQBPi9aAVV3aGquwL3vwQqSemney1FxfLuuSfk3Tdo0AAInTPKz89nypQpdokuyhg5ciT79+9n7NixXptykPvuM//3d9wBWVlhHdrO7h1TH9XJgBGnUs3jUJXwEnE637wMOBP4Q1VvBE4EKpfRZi7QWkRaiEgycCVwSLy5iBwtgR1tEekWsGeLQ5vij6JieW+9VaZYXjCEema0cOFC/vzzT/shjjJat25N//79mTBhAmvXrvXaHENCghGJrFTJfA5cFoEsis/no1GjRrSpwIHyOGE3IvUoXAUT6QFsd9LQ6bfZXlUtAPJE5ChgI9CytAZqPOLtmCnbMmCyqmaKyCARGRSodhmwVEQWAc8BV6pGWP6PSKKoWF4TRxk2yk316tWpVq1ayJyRzUcXvaSmplJQUMCYMWO8NuUgTZvCxIkwezZkZIRlyMLsITYa1BH3YCYdrRCZDrwF3OGopaqWWYAXgdrAIGAF8CPwupO2oS7VqlXTuGT6dNWEBNXrr3d9qObNm+u1114bkr7OPfdcPf7440PSlyX83HrrrVqpUiVduXKl16Ycyg03mM/D99+7PlRmZqYCOmnSJNfHchNgt4bjexqSFDoodFSo5LSd0wCG21T1T1WdgEmW11/Ncp0lHOzcGZRYXrCE6uBrbm4u06ZNs0t0UcxDDz1EQkICGWGahTjmueegeXO47jqTVNVF7H5RORCpAtwJZGAkJAYHrpWJ4wwMhfdVdZWqLnaSgcESIu68MyixvGAJlTOaN28eu3fvth/iKKZx48YMGjSIt956ixUrHAl2hoeaNc3nYc0ak8fORfx+P82bN6d58+aujhMjvIU59Po8MB6T8OBtJw1dy8BgCREVEMsLllA5o8JflGeccUaF+7J4x7Bhw6hcuTJpaWlem3Iop54KqanGKb3/vitDFBQUHNgvsjiiLao3oeoPlIGAo6iP8mZgmBcoTjIwWCrKunUVEssLlpSUFDZt2lS4Xxg0Pp+PE088kfohyJln8Y6jjz6a22+/nffee4/MzEyvzTmUhx4yTunWW83qQYhZtGgR27Zts87IOT8GIugMIt2B6U4aluWMZmByDd2nqi0xa4BLganAe0GZanFGQYFJf1IBsbxgSUlJITc3l+0VWIvPyclhxowZ9kMcIzzwwAPUqFGDUaNGeW3KoSQlmc9HQYHZP8p3dKTFMTYatNx0xyRLXRVIrDoTOAORJYgsLq1hWc7oZWCfmgwMvYFHgTcxceMRoFEcw4RILC8YQnHwddasWeTk5NgPcYxQr1497rrrLj788EMWLlzotTmH0rIljB8P338f0jyNYGb3bdu25Zhj7K6EQ87BZPk+I1BaAOcBFwAXltawLGeUqKqFmQmvACaq6keqmgocVyGTLSUTQrG8YAjFwVefz0dCQgK9e/cOlVkWj7nnnnuoXbs2I8K4ZOyY666DK66AkSNh7tyQdJmXl2ejQcuL6mpgB1ALqHegqK4OPFciZTojESlMBncm4CvynE0S5wYhFssLhlA4I7/fT5cuXahVq1aozLJ4TO3atbnvvvv4/PPPmTNnjtfmHIqIkShv1Mh8fnbtqnCX8+fPZ+fOndYZlQeRDGAxJolBSCUk3gemisinwF7gezOeHIfDFA+WchJisbxgqKgz2r17N7NmzbJLdDHInXfeSb169SJzdlSnjkmTlZUFd99d4e4Ko0H79OlT4b7iiH8ArVDtE2oJiTHAvZhMrL30YHhVAk5TPFic44JYXjAURr8F64x++OEH8vLy7C/KGKRmzZoMGzaMb775hh9++MFrc46kTx8YOtSsKnz8cYW68vl8dOrUyUaDlo+lmGw95abMQ6+qOktVP1bV3UWu/aKqC4IZ0FICLonlBUNycjJ16tQJ2hn5/X4qVapEzzCdi7KEl9tuu42jjz6a1NRUr00pnrQ0Izlx883w++9l1y+Gffv2MX36dPuDqvw8ignv/gaRzw4UB8SoSlSUoWrOE7kglhcsFTn46vP56N69O9WrVw+xVZZIoFq1agwfPpwpU6YcWMqKKJKTjRjf3r3mB15BQbm7mD17Nnv37rVLzeXnTeAxYCwH94yectLQOqNI4LXXzJKCC2J5wRKsM/rzzz+ZP3++/UUZ4wwYMIAmTZrw8MMPV/hwtCu0bQvPPAP/+585HlFObDRo0GxG9blA9oWpB4oDrDPymqwsV8XygqUwC0N5mTZtGgUFBdYZxThVqlTh4YcfZubMmXz99ddem1M8AwfC3/5mjkksWlSupj6fj1NOOYXatWu7Y1vsMh+RRxE5FZGTDxQHWGfkJUXF8t580xWxvGAJdmbk9/upUqUKPXr0KLuyJaq58cYbadGiBampqZE5OxIxgQx165pw7717HTXbs2ePjQYNns5AD+ARQhzaXSFE5BwRWS4iWSIyrJR6XUUkX0Quc9OeiGP0aCMS9vLLRjQsgmjQoAFbtmwhLy+vXO18Ph89e/akcuWyhIAt0U5ycjIjRoxg/vz5fPrpp16bUzwNGphEw5mZJsrOAdOnTyc3N9fO7oPhYDh335CGdlcEEUnEJFM9F5NG/CoRaV9CvccwirDxw4wZxhldfz384x9eW3MEKSkpqCpbtjhXgd+0aROLFy+2H+I44tprr6VNmzaMGDGCgiACBcLC2WebpfDnn4evviqzus/nIykpiV69eoXBuBhDpCEikxD5KvC4PSI3OWnqZhaFbkCWqq40NskHwEXAT4fVuwP4COjqoi2RRZjF8oKh8ODrV1995VjHZebMmYAVIYsnkpKSGDVqFFdffTX/+te/uOKKK7w2qXjGjjW5Hm+8ERYvhsD/d3H4/X569Ohho0GD4w3gdeChwONfgH8Ck8ps6Zb0LHAZ8GqRx9cB4w+r0xiTATwx8CIuK6GvgQTkK5KTkx1J7EY0hZLJP/zgtSUlMmfOHAXKXerUqaP79+/32nxLGMnPz9eOHTtq27ZtNS8vz2tzSmbxYtXKlVUvuEC1oKDYKtu3b9fExERNTU0Ns3Hug5uy45AUuJ0buP2xyHMLnfTh5syouKRqh+9yPgsMVdV8KSUHm6pOJJAlvHr16hG4U1oOCsXyHn44bGJ5wdClSxfmzp3LrnLm+GrWrBmVwih3YfGehIQE0tLSuPTSS3nvvfe47rrrvDapeE44wRwov+sus087aNARVaZNm0Z+fr6d3ZefOcDJwG5E6lH4XW+0jRyljhN1KQpGRE4FRqnq2YHHDwKo6qNF6mRz0GnVB/YAA1X1k5L6rV69uu7evbukpyObtWuhUyc47jiYPj2sGkUWi5uoKqeccgrbt2/n559/jtwfJAUFcN55MG0azJ8P7dod8vS9997Liy++yLZt26hSpYpHRrqDiOxRVXfWHkV+RLVzIIz7eaAjJjVQA+AyVEvVMgJ3nVESZr3wTGAdMBe4WlWLlYoUkTeAL1T1w9L6jVpnVFAAZ50FM2fCjz+GXaPIYnGb//znP1xwwQW88sor3OyB9Ilj1q83PwqbNoVZs0zGhgCdO3embt26fPfddx4a6A4uO6O1wNOBRwlAZcxEYx+Qj+rTJTUtxLVoOlXNA27HRMktAyaraqaIDBKRI+fHsY6HYnkWSzg477zz6N69O+np6ezbt89rc0qmUSNz/ujHH6FIfr0tW7awcOFCu0QXHIlADaAmUB0THJcIVAtcKxvXNrRcKtWqVXOyVxdZLFyompysetFFJW6cWiyxwLfffquAjh8/3mtTymbgQFURVZ9PVVU/+ugjBXTGjBkeG+YOuBvAsKCifbi2TOcWUbdMl5MDXbqYJKiLF5tDeBZLjKKq9OnThxUrVvDrr79SNQKS/pbI7t0mu/fu3bB4MbePGMEbb7zBtm3bInfPqwKEZc+oAkRO/plYpahYnnVElhhHRMjIyGD9+vW89NJLXptTOtWrm+zeGzbALbfg++47evfuHZOOyBEiTRHxI7IMkUxEhgSuP4HIz4gsRuRjRGoX0/rMig5vnZGbRIhYnsUSTnr37s1f/vIXxo4dW+6jAWHnlFMgIwM+/JBuP/8c7/tFecC9qLbD5JcbjMma81+gI6qdMEFpDx7RUnVrRQe3zsgtIkgsz2IJNxkZGWzatInnIzTDyCHcfz8b2rXjeeDs1q29tsY7VNdTKJqquhMTeNYY1W8xAWkAs4AmbgxvnZEbqMKAAREllmexhJMePXpw/vnn88QTT7B9u6Mzj96RmMhTJ55IvggdH30UypkcOIpIEpF5RcrAEmuKNMdk4J592DP/B5Sd4C8IrDNyg9deg08+iSixPIsl3KSnp7Nt2zaeeeYZr00pk4/mzOHVU05BZs82CYxjkzxV7VKkTCy2lkgNTL7Qu1DdUeT6Q5ilvHfdMM5G04WaFSugc2fo1s2oTEaQRpHFEm4uvfRS/ve//5GdnU3dunW9NqdYVq9eTfPmzRk3bhx3zp8P77xjMjREcLquYHAUTSdSCfgC+OaQg6oi/YFBwJmo7nHDPvtNGUoiWCzPYvGCtLQ0du7cyZNPOtJX8wS/3w8Ess0//zw0a2Y+xzt2lNEyxjAJQicByw5zROcAQ4G/ueWIwDqj0DJ6NMyZE5FieRaLF3Ts2JErr7yScePGBaUcHA58Ph8NGjSgQ4cOcNRRZmb0228mCja+6IlRV+iHyMJAOQ8Yj8mi8N/AtQluDG6X6ULFjBlw+unmF9Wbb3ptjcUSMSxfvpz27dtz11138dRTT3ltziGoKk2bNqVXr1588MEHB58YNQrS0uD99+HKKz2zL5S4eug1BFhnFAp27DCBCqqwaJH5dWWxWA5www038M9//pNff/2VY445xmtzDrBixQratGnDhAkTuOWWWw4+kZdnflwuW2Yypxx7rHdGhohId0Z2mS4UDBkCq1eb6b11RBbLEYwYMYK8vDweeeQRr005BJ/PBxSjTpyUZD7P+flw/fXm1uIq1hlVlEKxvOHDYy76xmIJFS1btuT//u//mDhxIqtXr/banAP4fD6aNGnCcccdd+STrVqZgIapU+GJJ8JvXJxhl+kqghXLs1gcs2bNGo477jiuv/56XnnlFa/NQVVp2LAh55xzDm+99VZJleCKK+Djj4320SmnhNfIEGKX6WKVggK44QbYt89M560jslhKpWnTptxyyy28/vrrZGVleW0OmZmZbNq0qfR8dCIwYQIcfTRcfbXJ8G1xBeuMgsWK5Vks5ebBBx+kUqVKpKene23Kgf2ivn37ll6xbl146y1zoP2ee8JgWXziqjMSkXNEZLmIZInIsGKev0hEFovIwkCupF5u2hMyFi+GBx+Eiy6CSJZXtlgijEaNGjF48GDeffddli1b5qktfr+fli1b0qxZs7Ir9+0L998PEyfCp5+6b1wc4tqekYgkYtKN/xVYC8wFrlLVn4rUqYFRH1QR6YSRJj++tH493zPKyYGuXU1W7iVLoH5972yxWKKQTZs20aJFC84//3z++c9/emJDfn4+9evX57LLLnO+f7V/P/ToYQ7ELlli5MujiHjeM+oGZKnqSlXdD3wAXFS0gqru0oPesDoQ+dEUw4bB0qVGLM86Ioul3DRo0IAhQ4YwefJkFi9e7IkNCxcu5M8//yyfflFyssnCv2eP2S8uKHDNvnjETWfUGFhT5PHawLVDEJGLReRn4D+Y9ORHICIDC9Oe53mZ3t2K5VksIeG+++6jVq1ajBw50pPxC/eL+vTpU76G7drBU0+Z74Jo0GqKItx0RlLMtSNmPqr6cWBp7u9ARnEdqerEwrTnSUlJobXSKZs3m19DHTpYsTyLpYLUqVOHe+65h08++YR58+aFfXy/30+7du1oFMxS26BBcMEF8MADZv/YEhLcdEZrgaLZQpsAv5dUWVWnAa1EJPLWvlRh4EArlmexhJC77rqLunXrMmLEiLCOm5uby7Rp04KXGBeBSZOgdm245hqzj2ypMG46o7lAaxFpISLJwJXAZ0UriMhxYtKWIyInA8nAFhdtCo7XXzeH3saMgRNP9NoaiyUmOOqoo3jggQf46quvmDFjRtjGnTt3Lrt37y47pLs0UlJM5pWlS80+sqXCuOaM1Gim3w58g9FSn6yqmSIySEQGBapdCiwVkYXAC8AVGmkpIbKy4M47oV8/e8bAYgkxt99+OykpKaSmpoZtzEL9onLvFx3Oueea/eNx4+DrrytuWJxj0wGVRm6uydz7yy9mbbhJk/CMa7HEEc8++yx33303Pp+vYrMVh5x55pls3bqVH3/8seKd7d176FGPBg0q3qdLxHNod/QzZgzMnm3E8qwjslhcYdCgQRxzzDGkpqbi9o/jnJwcpk+fHvx+0eFUrWr2kbdtMwfgo+zHfSRhnVFJzJwJGRkmffzll3ttjcUSs1SpUoWHHnqI6dOn8+2337o61qxZs9i3b19oZ2AnngiPPgqffWYyNFiCwi7TFcfOnQfF8hYutBpFFovL7Nu3j7Zt25KSksLs2bMJxDWFnBEjRvDII4+wdetWjgrl57qgAM4+22TvX7AAji81kYwn2GW6aOTOO2HVKnj7beuILJYwULlyZVJTU5k7dy6ff/65a+P4fD66dOkSWkcEkJAAb75plu2uucakDrKUC+uMDseK5VksnnD99ddz3HHHMWLECApcSLWza9cuZs+e7V6QxDHHwKuvmplRmM9OxQLWGRVl3TpzuLVbN/vPZLGEmUqVKjFy5EgWLVrERx99FPL+p0+fTl5eXuiCF4rj4otNIMPjj8OUKe6NE4PYPaNCCgrgrLOMmuOPP0Lr1qEfw2KxlEp+fj4nnHACAEuWLCExMTFkfQ8dOpRnnnmGP//8k2rVqoWs3yPYtQtOPtmEfS9eDHXquDdWObB7RtFCUbE864gsFk9ITEwkLS2NZcuW8cEHH4S0b5/PR48ePdx1RAA1aphw7z/+MHnsouwHv1dYZwSHiuXddJPX1lgscc2ll15Kp06dGDVqFKHK0v/nn3+yYMECd5foitK1K6SlweTJJhDKUibWGeXkmOiXunXN5qNLIaUWi8UZCQkJZGRkkJWVxVtvvRWSPqdNm0ZBQUH4nBHA0KEmg8vgwbByZfjGjVKsMyoUy3vjDSuWZ7FECBdeeCFdu3YlPT2d/SEIk/b5fFSpUoXu3buHwDqHJCaaWVFiIlx7LXipxRYFxLczKiqWd/bZXltjsVgCiAgZGRmsXr2aSZMmVbg/n89Hr169qFy5cgisKwfNmsFLL5mMLmPGhHfsKCN+o+k2b4YTToB69WDuXKtRZLFEGKrK6aefTnZ2NllZWVQN8jO6adMmUlJSeOSRR3jwwQdDbKVDrr0W3n8ffvgBTj3VExNsNF0kUiiWt3WrFcuzWCIUEWH06NH8/vvvvPzyy0H3MyVw3iccGcFL5IUXoGlTsz+9Y4d3dkQw8emMXnvNiuVZLFFAnz596NevH48++ijBroj4fD5q1qxJly5dQmxdOahVC955B1avNunGLEcQf85oxQoYMsSK5VksUUJGRgYbN27khRdeCKq93++nd+/eJCUlhdiyctKrl0kz9uabJuTbcgiuOiMROUdElotIlogcoc0rIteIyOJAmSEi7k5TcnPN2m2lSuYfIiH+fLHFEm2cdtppnHvuuTz22GPsKOcS17p161i+fLm3S3RFGTHCpBu75RZYs8Zraw5FpCkifkSWIZKJyJDA9bqI/BeRFYFbV1JKuPZtLCKJGCnxc4H2wFUi0v6watnAGaraCcgA3BUDGT0a5syxYnkWS5SRnp7O1q1bGTduXLnaFUqMh/V8UWlUqmT2qXNzoVMnOPZYs5fUtKn5Tmrc2CRcbdQIjj4aGjY0JSXFqMhmZLhpXR5wL6rtgB7AYMx39jDgO1RbA98FHocc16LpRORUYJSqnh14/CCAqj5aQv06wFJVbVxav0FH082YYQ6gXXutmRVZLJao4uKLL+brr7+mZcuWjtts3LiR/Px8Nm/eTEIkrYR8993BzAwiJZfDnz/rLPj734MastzRdCKfAuMDpQ+q6xFpBExBtW1QRpSCm4uojYGi89C1QGknzm4CviruCREZCAwESE5ODs6aypXhL3+B558Prr3FYvGUJ554gqpVq5Kbm+u4Tfv27Tn77LMjyxEBnHmmKeElSUTmFXk8UVWLX40SaQ50BmYDDVFdDxBwSCluGOfmzOhy4GxVvTnw+Dqgm6reUUzdvsCLQC9V3VJav2FRerVYLJYYw/HMSKQGMBUYg+q/EfkT1dpFnt+Gasj3jdz8ubAWaFrkcRPg98MriUgn4FXgorIckcVisVhcRKQS8BHwLqr/DlzdEFieI3C70Y2h3XRGc4HWItJCRJKBK4HPilYQkWOBfwPXqeovLtpisVgsltIQEWASsAzVp4s88xnQP3C/P/CpK8O7mQ5IRM4DngUSgddUdYyIDAJQ1Qki8ipwKbA60CRPVUs9mWaX6SwWi6X8lLlMJ9IL+B5YAhTqvg/H7BtNBo4FfgMuR3VryO2L29x0FovFEkfY3HQWi8VisZSBdUYWi8Vi8RzrjCwWi8XiOdYZWSwWi8Vzoi6AQUQKgL1BNk/C5F+KV+L59cfza4f4fv32tRuqqmrETkCizhlVBBGZV1boeCwTz68/nl87xPfrt689Ol57xHpJi8ViscQP1hlZLBaLxXPizRm5q5cU+cTz64/n1w7x/frta48C4mrPyGKxWCyRSbzNjCwWi8USgVhnZLFYLBbPiRtnJCLniMhyEckSEVc03CMVEVklIktEZOFhSo8xiYi8JiIbRWRpkWt1ReS/IrIicBtycbBIoITXPkpE1gXe/4WBbPoxh4g0FRG/iCwTkUwRGRK4Hi/vfUmvPyre/7jYMxKRROAX4K8Y0b+5wFWq+pOnhoUJEVkFdFHVzV7bEg5EpDewC3hLVTsGrj0ObFXVsYEfI3VUdaiXdrpBCa99FLBLVZ/00ja3ESP81khVF4hITWA+8HfgBuLjvS/p9f+DKHj/42Vm1A3IUtWVqrof+AC4yGObLC6hqtOAw/VWLgLeDNx/E/MhjTlKeO1xgaquV9UFgfs7gWVAY+LnvS/p9UcF8eKMGgNrijxeSxS9SSFAgW9FZL6IDPTaGI9oqKrrwXxogRSP7Qk3t4vI4sAyXkwuUxVFRJoDnTHCcHH33h/2+iEK3v94cUZSzLXYX588SE9VPRk4FxgcWMqxxA8vAa2Ak4D1wFOeWuMyIlID+Ai4S1V3eG1PuCnm9UfF+x8vzmgt0LTI4ybA7x7ZEnZU9ffA7UbgY8yyZbyxIbCmXri2vtFje8KGqm5Q1XxVLQBeIYbffxGphPkifldV/x24HDfvfXGvP1re/3hxRnOB1iLSQkSSgSuBzzy2KSyISPXAZiYiUh04C1haequY5DOgf+B+f+BTD20JK4VfxAEuJkbffxERYBKwTFWfLvJUXLz3Jb3+aHn/4yKaDiAQzvgskAi8pqpjvLUoPIhIS8xsCEw6+fdi/bWLyPtAH6A+sAEYCXwCTAaOBX4DLlfVmNvoL+G198Es0SiwCrilcA8llhCRXsD3wBKgIHB5OGbfJB7e+5Je/1VEwfsfN87IYrFYLJFLvCzTWSwWiyWCsc7IYrFYLJ5jnZHFYrFYPMc6I4vFYrF4jnVGFovFYvEc64wsMYWI1CuSnfiPItmKd4nIiy6NeZeIXB+4P0VEurgxTglj3y4iN4ZrPIvFLWxotyVmCUe2ahFJAhYAJ6tqnohMAe5T1ZBKdYhIoqrmF3O9GjBdVTuHcjyLJdzYmZElLhCRPiLyReD+KBF5U0S+DWg9XSIijwc0n74OpFRBRE4RkamBBLPfHHaSvZB+wAJVzSty7XIRmSMiv4jI6YG+qojI64ExfhSRvoHrN4jI+CJ2fiEifQL3d4lIuojMBk4VkbEi8lMg4eWTAKq6B1glIhGZ4sVicYp1RpZ4pRVwPkZe4B3Ar6onAHuB8wMO6XngMlU9BXgNKC5zRU+MbkxRklS1G3AXJgMCwGCAwBhXAW+KSJUybKwOLFXV7sBPmFQuHVS1EzC6SL15wOllvmKLJYJJ8toAi8UjvlLVXBFZgkkR9XXg+hKgOdAW6Aj816T8IhGT8fhwGmF0Y4pSmKBzfqAvgF4Y54aq/iwiq4E2ZdiYj0l6CbADyAFeFZH/AF8UqbcROL6MviyWiMY6I0u8sg9AVQtEJFcPbp4WYD4XAmSq6qll9LMXOHyGsy9wm8/Bz1hxMiYAeRy6QlG0r5zCfaLAflQ34ExMot/bMUuEhW32lmGnxRLR2GU6i6V4lgMNRORUMKn5RaRDMfWWAcc56G8acE2grzaYpJ3LMYkrTxKRBBFpSgnp/QMaNbVU9UvM8t9JRZ5uQ4RmYrZYnGJnRhZLMajqfhG5DHhORGphPivPApmHVf0KeNtBly8CEwLLgnnADaq6T0SmA9mY5cGlmMi84qgJfBrYZxLg7iLP9QTSHL0wiyVCsaHdFksFEZGPgQdUdYUHY3cG7lHV68I9tsUSSqwzslgqiIi0BRqq6jQPxv4rsEJVV4V7bIsllFhnZLFYLBbPsQEMFovFYvEc64wsFovF4jnWGVksFovFc6wzslgsFovnWGdksVgsFs/5fxx4FPcJNpRcAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "years = 10\n", + "hours = years * 365 * 24\n", + "t_hours = np.arange(hours + 1)\n", + "soc = np.tile(\n", + " np.array(\n", + " [1, 1, 1, 1, 1, 1,\n", + " 0.4, 0.4, 0.6, 0.6, 1, 1,\n", + " 0.9, 0.8, 0.7, 0.6, 0.5, 0.4,\n", + " 0.3, 0.2, 0.2, 0.4, 0.6, 0.8]\n", + " ),\n", + " int(len(t_hours/24))\n", + ")\n", + "soc = np.append(soc, 1)\n", + "\n", + "TdegC = (\n", + " np.tile(np.concatenate([np.linspace(25, 35, 12), np.linspace(35, 25, 12)]),\n", + " int(len(t_hours)/24))\n", + " + np.tile(np.concatenate([np.linspace(-5, 5, 24*182), np.linspace(5, -5, 24*183)]),\n", + " int(len(t_hours)/(24*365)))\n", + ")\n", + "TdegC = np.append(TdegC, 20)\n", + "\n", + "t_secs = t_hours * 3600\n", + "\n", + "fig, ax1 = plt.subplots()\n", + "ax1.plot(t_hours[:25], soc[:25], '-k')\n", + "ax1.set_xlabel('Time (hours)')\n", + "ax1.set_ylabel('State-of-charge')\n", + "\n", + "ax2 = ax1.twinx()\n", + "ax2.plot(t_hours[:25], TdegC[:25], '-r')\n", + "ax2.tick_params(axis='y', labelcolor='r')\n", + "ax2.set_ylabel('Temperature (Celsius)', color='r')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(t_hours/(24*365), TdegC)\n", + "plt.xlabel('Time (years)')\n", + "plt.ylabel('Temperature (Celsius)')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instantiate the battery model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "cell = Nmc111_Gr_Kokam75Ah_Battery()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All battery models have five properties. The first is `_cap`, which is the nominal discharge capacity of the cell in Amp hours." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "75" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cell._cap" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next four track battery lifetime values, and store the history of the battery as lifetime is simulated at each timestep/iteration:\n", + "- `states`: internal states of the battery model\n", + " - Ex., time-dependent capacity loss\n", + "- `outputs`: battery properties calculated from states\n", + " - Ex., relative discharge capacity\n", + "- `stressors`: values of stressors used by the model\n", + " - Ex., temperature, depth-of-discharge, charge-throughput\n", + " - Note that degradation rates are calculate from stressor timeseries, and then normalized for the timestep; for example, an Arrhenius expression would be evaluated from the temperature timeseries for the entire timestep, and then normalized by taking the time-based average - this gives a different value than if the Arrhenius expression was evaluated on the averager temperature. Other normalizations can include using the minimum or maximum value over the timestep, or using the root-mean-square.\n", + "- `rates`: values of degradation rates\n", + " - Ex., time-dependent degradation rate due to temperature and state-of-charge\n", + "\n", + "Battery models may have other properties, such as the open-circuit voltage as a function of state-of-charge, nominal DC resistance values, or first-life/second-life capacity definitions.\n", + "\n", + "This specific battery model is relatively complex, and has many states and outputs that describe the degradation state of the battery. Properties `states`, `outputs`, `stressors`, and `rates` are all stored in dicts:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'q': array([1]),\n", + " 'q_LLI': array([1]),\n", + " 'q_LLI_t': array([1]),\n", + " 'q_LLI_EFC': array([1]),\n", + " 'q_LAM': array([1.01]),\n", + " 'r': array([1]),\n", + " 'r_LLI': array([1]),\n", + " 'r_LLI_t': array([1]),\n", + " 'r_LLI_EFC': array([1]),\n", + " 'r_LAM': array([1])}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cell.outputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Output descriptions are in the class definition, replicated here:\n", + "- q: relative capacity\n", + "- q_LLI: relative lithium inventory\n", + "- q_LLI_t: relative lithium inventory, time dependent loss\n", + "- q_LLI_EFC: relative lithium inventory, charge-throughput dependent loss\n", + "- q_LAM: relative active material, charge-throughput dependent loss\n", + "- r: relative resistance\n", + "- r_LLI: relative SEI resistance\n", + "- r_LLI_t: relative SEI resistance, time dependent growth\n", + "- r_LLI_EFC: relative SEI resistance, charge-throughput dependent growth\n", + "- r_LAM: relative electrode resistance, q_LAM dependent growth" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Accesing one output/state/rate/stressor is simple:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cell.outputs['q']" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The battery model should be run in timesteps relavent to battery degradation, such as once per day. Larger or smaller timesteps could be used if desired, but timesteps should avoid splitting up cycles, or at least be long enough that miscounting cycles due to splitting them up does not introduce much error.\n", + "\n", + "Each battery model tracks the history of it's inputs (`stressors`), calculated degradation rates (`rates`), internal states (`states`), and outputs (`outputs`) each time `update_battery_state` is called. Debugging models is easier because the values of all inputs, internal calculations, and outputs are tracked." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "t_days = np.arange(years*365)\n", + "for day in t_days:\n", + " hour_start = day*24\n", + " hour_end = (day+1)*24 + 1\n", + " # Update battery state\n", + " cell.update_battery_state(t_secs=t_secs[hour_start:hour_end], soc=soc[hour_start:hour_end], T_celsius=TdegC[hour_start:hour_end])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cell.stressors['t_days']/365, cell.outputs['q'])\n", + "plt.xlabel('Time (years)')\n", + "plt.ylabel('Relative discharge capacity')\n", + "plt.ylim((0.7, 1.02))\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The cell resistance and capacity trajectories are wiggily because the temperature of the battery is varying throughout each year, varying the degradation rate. Dispatch is the same each day, so that is constant.\n", + "\n", + "The model keeps track of how much charge-throughput has occured throughout life, as well, based on the input state-of-charge timeseries. Conversion from charge-throughput, in Amp-hours, to changes of cell state-of-charge, which is dependent on battery performance (health, temperature and SOC dependent resistances), is assumed to happen externally to the model. This simple simulation is essentially assuming that the current magnitude is continuously being adjusted based on the the state-of-health of the battery." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cell.stressors['efc'], cell.outputs['q'])\n", + "plt.xlabel('Equivalent full cycles')\n", + "plt.ylabel('Relative discharge capacity')\n", + "plt.ylim((0.7, 1.02))\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This dispatch has a little more than 1 EFC per day.\n", + "\n", + "We can plot the separate contributions to capacity or resistance fade, as well." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.7, 1.02)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cell.stressors['t_days']/365, cell.outputs['q_LLI'])\n", + "plt.plot(cell.stressors['t_days']/365, cell.outputs['q_LAM'])\n", + "plt.plot(cell.stressors['t_days']/365, cell.outputs['q'], '--k')\n", + "plt.xlabel('Time (years)')\n", + "plt.ylabel('Relative discharge capacity')\n", + "plt.legend([r'q$_{LLI}$', r'q$_{LAM}$', 'q'])\n", + "plt.ylim((0.7, 1.02))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the result, the cell will experience sudden failure very shortly; considering this is near 70% remaining capacity, this is physically reasonable." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cell.stressors['t_days']/365, cell.outputs['r_LLI'])\n", + "plt.plot(cell.stressors['t_days']/365, cell.outputs['r_LAM'])\n", + "plt.plot(cell.stressors['t_days']/365, cell.outputs['r'], '--k')\n", + "plt.xlabel('Time (years)')\n", + "plt.ylabel('Relative DC resistance')\n", + "plt.legend([r'r$_{LLI}$', r'r$_{LAM}$', 'r'])\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Repeat with other battery life models." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\pgasper\\Documents\\GitHub\\BLAST-Py\\functions\\state_functions.py:16: RuntimeWarning: invalid value encountered in double_scalars\n", + " dydx = k*p*((y0/k)**((p-1)/p))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from lfp_gr_SonyMurata3Ah_2018 import Lfp_Gr_SonyMurata3Ah_Battery\n", + "from nmc111_gr_Sanyo2Ah_2014 import Nmc111_Gr_Sanyo2Ah_Battery\n", + "from nmc811_grSi_LGMJ1_4Ah_2020 import Nmc811_GrSi_LGMJ1_4Ah_Battery\n", + "from nca_gr_Panasonic3Ah_2018 import Nca_Gr_Panasonic3Ah_Battery\n", + "from nmc_lto_10Ah_2020 import Nmc_Lto_10Ah_Battery\n", + "from lmo_gr_NissanLeaf66Ah_2ndLife_2020 import Lmo_Gr_NissanLeaf66Ah_2ndLife_Battery\n", + "\n", + "cell_nmc_kokam = Nmc111_Gr_Kokam75Ah_Battery()\n", + "cell_lfp = Lfp_Gr_SonyMurata3Ah_Battery()\n", + "cell_nmc_sanyo = Nmc111_Gr_Sanyo2Ah_Battery()\n", + "cell_nmc811_grSi = Nmc811_GrSi_LGMJ1_4Ah_Battery()\n", + "cell_nca = Nca_Gr_Panasonic3Ah_Battery()\n", + "cell_nmc_lto = Nmc_Lto_10Ah_Battery()\n", + "cell_lmo = Lmo_Gr_NissanLeaf66Ah_2ndLife_Battery()\n", + "\n", + "for day in t_days:\n", + " hour_start = day*24\n", + " hour_end = (day+1)*24 + 1\n", + " # NMC Kokam\n", + " cell_nmc_kokam.update_battery_state(t_secs=t_secs[hour_start:hour_end], soc=soc[hour_start:hour_end], T_celsius=TdegC[hour_start:hour_end])\n", + " # LFP\n", + " cell_lfp.update_battery_state(t_secs=t_secs[hour_start:hour_end], soc=soc[hour_start:hour_end], T_celsius=TdegC[hour_start:hour_end])\n", + " # NMC Sanyo\n", + " cell_nmc_sanyo.update_battery_state(t_secs=t_secs[hour_start:hour_end], soc=soc[hour_start:hour_end], T_celsius=TdegC[hour_start:hour_end])\n", + " # LG MJ1 NMC811 GrSi\n", + " cell_nmc811_grSi.update_battery_state(t_secs=t_secs[hour_start:hour_end], soc=soc[hour_start:hour_end], T_celsius=TdegC[hour_start:hour_end])\n", + " # NCA Panasonic\n", + " cell_nca.update_battery_state(t_secs=t_secs[hour_start:hour_end], soc=soc[hour_start:hour_end], T_celsius=TdegC[hour_start:hour_end])\n", + " # NMC LTO\n", + " cell_nmc_lto.update_battery_state(t_secs=t_secs[hour_start:hour_end], soc=soc[hour_start:hour_end], T_celsius=TdegC[hour_start:hour_end])\n", + " # LMO Nissan Leaf\n", + " cell_lmo.update_battery_state(t_secs=t_secs[hour_start:hour_end], soc=soc[hour_start:hour_end], T_celsius=TdegC[hour_start:hour_end])\n", + "\n", + "plt.plot(cell_nmc_kokam.stressors['t_days']/365, cell_nmc_kokam.outputs['q'])\n", + "plt.plot(cell_lfp.stressors['t_days']/365, cell_lfp.outputs['q'])\n", + "plt.plot(cell_nmc_sanyo.stressors['t_days']/365, cell_nmc_sanyo.outputs['q'])\n", + "plt.plot(cell_nmc811_grSi.stressors['t_days']/365, cell_nmc811_grSi.outputs['q'])\n", + "plt.plot(cell_nca.stressors['t_days']/365, cell_nca.outputs['q'])\n", + "plt.plot(cell_nmc_lto.stressors['t_days']/365, cell_nmc_lto.outputs['q'])\n", + "plt.plot(cell_lmo.stressors['t_days']/365, cell_lmo.outputs['q'])\n", + "plt.xlabel('Time (years)')\n", + "plt.ylabel('Relative discharge capacity')\n", + "plt.legend(['NMC-Gr (Kokam)','LFP-Gr (Sony Murata)', 'NMC-Gr (Sanyo)', 'NMC811-GrSi (LG MJ1)', 'NCA-Gr (Panasonic)', 'NMC-LTO', 'LMO-Gr (2nd Life) (Leaf)'])\n", + "plt.ylim((0.7, 1.02))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(t_days/365, cell_metrics[5,:])\n", + "plt.plot(t_days/365, cell_lfp_metrics[4,:])\n", + "plt.plot(t_days/365, cell_nmc_metrics[3,:])\n", + "plt.xlabel('Time (years)')\n", + "plt.ylabel('Relative DC resistance')\n", + "plt.legend(['NMC-Gr (Kokam)','LFP-Gr', 'NMC-Gr (Sanyo)'])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the LFP-Gr cell has much lower resistance growth, relative to the capacity loss. This is more like the magnitude of resistance growth seen by most cells. The NMC-Gr cell from Kokam has much higher resistance growth relative to its capacity loss, likely due to a high power cell design and details of the testing protocol and curve fitting to calculate the DC resistance value from pulse data. NMC-Gr cell from Sanyo has very poor predicted lifetime, with high resistance growth and rapid capacity loss. This reflects the experimentally measured aging data (Sanyo: ~500 EFC cycle life at 80% DOD, Kokam: > 4000 EFC cycle life at 80% DOD)." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Try the NMC|Gr Kokam life model on another simple profile with low lithium loss rate but rapid active material loss driven by low temperature cycling." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Temperature (Celsius)')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "years = 10\n", + "hours = years * 365 * 24\n", + "t_hours = np.arange(hours)\n", + "soc = np.tile(\n", + " np.array(\n", + " [1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1,\n", + " 0.5, 0, 0, 0.5, 1, 1]\n", + " ),\n", + " int(len(t_hours/24))\n", + ")\n", + "TdegC = 0 * np.ones(t_hours.shape)\n", + "t_secs = t_hours * 3600\n", + "\n", + "fig, ax1 = plt.subplots()\n", + "ax1.plot(t_hours[:25], soc[:25], '-k')\n", + "ax1.set_xlabel('Time (hours)')\n", + "ax1.set_ylabel('State-of-charge')\n", + "\n", + "ax2 = ax1.twinx()\n", + "ax2.plot(t_hours[:25], TdegC[:25], '-r')\n", + "ax2.tick_params(axis='y', labelcolor='r')\n", + "ax2.set_ylabel('Temperature (Celsius)', color='r')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "cell_2 = Nmc111_Gr_Kokam75Ah_Battery()\n", + "\n", + "t_days = np.arange(years*365)\n", + "cell_2_metrics = np.zeros((len(cell_2.outputs), len(t_days)))\n", + "\n", + "for day in t_days:\n", + " hour_start = day*24\n", + " hour_end = (day+1)*24\n", + " cell_2.update_battery_state(t_secs=t_secs[hour_start:hour_end], soc=soc[hour_start:hour_end], T_celsius=TdegC[hour_start:hour_end])\n", + " cell_2_metrics[:,day] = np.array(list(cell_2.outputs.values()))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.9, 5.0)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(t_days/365, cell_2_metrics[6,:])\n", + "plt.plot(t_days/365, cell_2_metrics[9,:])\n", + "plt.plot(t_days/365, cell_2_metrics[5,:])\n", + "plt.xlabel('Time (years)')\n", + "plt.ylabel('Relative DC resistance')\n", + "plt.legend([r'r$_{LLI}$', r'r$_{LAM}$', 'r'])\n", + "plt.ylim((0.9, 5))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.7, 1.02)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAAye0lEQVR4nO3dd3gc5bn38e+tbhXLaq6ykStuFBdMMT1AgFADxEBCAiE4BEiAhJNAeHOAtAMHkiskcEILNYADoZnQTDG26e64GyM3WbJVbDWrS/f7x4zstbySxmU00u79ua69dqfub084vjXPzPM8oqoYY4wxbcUEHcAYY0z3ZAXCGGNMWFYgjDHGhGUFwhhjTFhWIIwxxoQVF3SAgyk7O1vz8vKCjmGMMT3GwoULS1U1J9y2iCoQeXl5LFiwIOgYxhjTY4jIxva2WROTMcaYsKxAGGOMCcsKhDHGmLCsQBhjjAkrom5S77c3/wuaGwABEecddn8Wd7nT7ftzjLS/LjYe4pJ2v+JDPiekQK9MSM6EpD4QY7XeGHNwWYEAWPsONNYCCrsGL2z97C63ft41tmHI9k6PCbM9dN2BkhinSKT2hT5DoM8hkHEIZI2EAUdA7wEH/h3GmKhjBQLgpi+DTrC7YIQWkOYGaKrb/WoM+dywE2q2Q+12572mDKq3QflG2PQ51FfsPndqPxg0CYadAiO+AZnD9rzqMcaYMKxAdBcie74DxMZBQvL+na9mO5SsgaIlULgENn8Oa950tmWNhCOmweGXQp/BB5LaGBPBJJLmg5g8ebJaR7kObM+Hde/Dildh40eAwNjz4YSfO01RxpioIyILVXVyuG2+3dkUkcdFpFhElrezXUTkryKyTkS+FJGJIdvOFJE17rZb/coYdTKHwZRr4Ko34MalcPzN8PUH8PCJ8MIPoKIg6ITGmG7Ez0dfngTO7GD7WcBI9zUd+DuAiMQCD7rbxwKXichYH3NGp4w8OO0OuHk5nHybc6P+gaPg0wehpSXodMaYbsC3AqGqc4HtHexyPvC0Oj4D+ojIAGAKsE5V81W1AZjh7mv8kJQOJ98KN3wBQ0+Cd34Nz0+DnaVBJzPGBCzIh+cHAZtDlgvcde2tD0tEpovIAhFZUFJSss8hahqauOiBOdz30kf7fGxE6TMELnsezr4P8ufAY6dB2ddBpzLGBCjIAhHuOUvtYH1YqvqIqk5W1ck5OWFHrO1QckIcH/z5p9z1syupqavf5+Mjiohzj+LKN6C+Ev5xuvMElDEmKgVZIAqA0Gcsc4HCDtb75ifX/5Tqwq8Zc9wZbN5mTSsMPgqufhfiU+CZC6F4VdCJjDEBCLJAzAS+7z7NdAxQoapFwHxgpIgMFZEE4FJ3X9/88RfX8L2b72TTko8YcehYbrnn7zQ3R/mN2qzh8P1XITYBnr7AnnAyJgr5+Zjr88CnwKEiUiAiV4vItSJyrbvLm0A+sA54FLgOQFWbgBuAd4BVwAuqusKvnK2e+fMdPPXK2yQkp/HAAw9w1v3zmPHFJip21vr91d1Xa5Fo2AkzvusOR2KMiRbWUa6NpqZmnpu3gmeXlLPy600UPXEDR5z4Ta7+/nf50cVnkxAfhZ3PV78JMy6DIy6HC/8edBpjzEEUSEe5niouLpbvn3I4b990Ag9cOp4RE45j8Xuvcf3l55Oa1Y+jz/kuL81bSn1Tc9BRu87os+HEX8LS52DFK0GnMcZ0EbuC8GBbWTl/+sfzvPjCC2xc+gkDr3mEtKx+HFL7Ff0o5+pLL+D4ieOIieQht5sb4R9nwI4NcN2nkNY/6ETGmIOgoysIKxD7qKyiiiWFNXy4poTH/udWtn7xBgAJ6TkMHT+ZE086mV/ddB3DslOQSBsxtWQtPHwCjDoTvvNU0GmMMQeBFQiftLS0MPuLpTz179f55KOP2LhiATEpmQy48n6yUxOJWfISg3PSOf2kqVz0zRPJyUjvsmy++fBu+PB/4Aevw9ATg05jjDlAViC6SEtLC4u/2szaCuGzr0t57OaLqdm23tkoMaQNGMbRZ13Mj378E44cnMGw7GTi42IDy7tfGmvhwSmQkAo/nucMSW6M6bGsQARoxdebeHXWHD786FNWLFlIy8DDSJp0IS31NWz5vx+QPmgYeaPGMmHCBE45bgpnn3g0mempQcfu2MqZ8MIVcP6DMOF7QacxxhwAKxDdSEuLsr5sJ3OWfs0jf72P/NUrKNu0lpb6nQBknX4tE868lCFJ9VQsn83xUyZz2vGTGDtsSPe5Ca4Kj5wMtTvgpwudubONMT2SFYhurqWlhU+XrubtuZ+hGYewVXsz7/23WfvMf+/aJ7ZXGhmDhnHB9b/hhKMn0T+pmbyMJEbltTuOob/WzoLnLoFz/wqTfhBMBmPMAbMC0UN9tbGQN+d8xueLlrJyxQo2568l+5xfUN8rm8oFr7Hj/UeJS0knM3cEh4w4lPHjxnLlD77PuCF9yUxJ8PcpKlVnxNedJfCzxRDTw+6lGGMAKxARRVXZVlnPW/O+4K2332H1ypUUrF9LReF6WhrqGPzzF4mJT6Lu83/RsHERA4cMY/jIURw+bgzHTjiMU4+bSNLB6g2+6nX41/dg2j9hzLkH55zGmC5lBSIKNDe3sGjV11THp5NfspMXn/kHi+e8xY7CjTRWlQEQ06s3h9z4HIMzk9k5/2USGyoZPXo0k44Yx4lHHb7v9zlamuGvR0L6YLjqTX9+mDHGV1YgotyW4jLmzv+S1RsK6T1yMvklO3n5T//FtmUfo02758DolTuWk255iLysZIo+m0m/PqkcMX40xx45jsNH5hEbG6Z4fPIAzLodps+BgUd23Y8yxhwUHRUIe4g9Cgzqm8Vl3zplj3UPfvd9mpqaWbhqHR8t+JLFy1ZS1RRLVnoSa7ZVMfepB2muLtu1v8QnMeiYb/HNq3/FkMwUiha9x5gReRwzeiqT43oRs+BxOO+vXf3TjDE+sisIE1Z9QyMLVqzl8yUr+HLlGtZ9tY7Y7CH0Gn8667fuYO09F+zaNzE+lokDYhhxy2sMzs1lcGYyuRm9GJyRzODMZDKS4yNv2BFjIoRdQZh9lpgQz9QJ45g6Ydxe25qbm1l0+So+W7KCpStWs37h+8x+fzbjlz7HmzuuYEdN4x77pyTEkpuRzODMXu57MoMzeu1al5Zk/SiM6Y7sCsIcMG1poej3hzFwyFC48j9U1TVSsKOWzdtrnPcdNWzeXkvBjho2b69hZ8OeQ6X3SY5ncIZ71dFaPNz3QX2S6ZVgj9Aa4xe7gjC+kpgYBp70A5j9B6goIC09lzED4hkzoPde+6oq5TWNu4rG5h01buGoZc22Kt5fXUxD057TvWamJDCoTy8G9kliYJ9eDHJfA91XdqrPfT6MiVJWIMxBUTv8W1xw9a85u/xmbvzLi+3uJyJkpCSQkZLA4bl99tre0qKUVNfvKhpbyt3XjlryS3Yy76tSatpcgSTExewqIKGFI9d975+eRFK8XYUYs6+sickcNEcdkobExPDF+grfvkNVqaxtoqC8hsLyOgrLdxeRQvdVXFVP2/+ss1MTGZTRi0F9khiY3otBGW4hSXcKSFZKAjExdhVioo81MZku8e1vHs+vH32bgpXzyR17lC/fISKkJ8eTnpzOuIHh59eob2pmW0X9XoVjS3ktq7dW8cHqYuoa92zGio8V+vVO2lUwBqQnhbz3YmB6ElmpicRaETFRxK4gzEGz+tO3GXPcWTx4yzSuu3dG0HHaparsqGlky45aiipq2VpZR1FFHVsrnCuS1uW290LiYpwi0t8tHgPd4hFaTHJSE4kL16HQmG7KelKbLjO6fy+GZKcya3lJ0FEOSGsRKaqopai8jqLKOrZW1O4qJEUVdRRV1O51JRIbI/RNS9x99dHbKSAD+iTRv3cS/Xon0bd3Iok9baIoE7EOqIlJRMar6vKDH8tEopunfYPq1R9AXSUk7f0UU08hImSmJJCZktBuU5aqUlHbuKtYhBaPrRV1rN5axezVJdQ2Nu91bEZyPP3cgtGvdyL9eyfR113u766zJi0TNC/3IB4SkQTgSeA5VS33NZHp0X58823w5DzI/xDGnhd0HF+JCH2SE+iTnBD2kV5wb6rXNbmFo5biynq2VtaxrbKObZX1bKusY1VRJaXV9bS0uZiPjRFyUhPp1zuRviGFY/dnZzm9l/VUN/7otECo6vEiMhL4IbBARL4AnlDVd31PZ3qewVOo0DTy3/knEyK8QHghIqT3iie9VzyH9k9rd7+m5hZKqxvcwrFnAdlaWcemshrmb9hOeZte6gCJcTG7ikW/kKuQvu5yazGxDodmX3m+ByEiscAFwF+BSkCAX6vqyx0ccyZwPxALPKaqd7fZngE8DgwH6oAftjZnicgGoApoBpraayMLZfcguofvHJvHp6u2sGl7PdJdpkmNEHWNzRRX1rOtyikiWyvqKK6q3+Pz1oq6sM1aaYlx5PROpG9aIn3TkuiblkhOWiJ9e++5bFck0eVA70EcDlwFfAt4FzhXVReJyEDgUyBsgXALyoPA6UABMF9EZqrqypDdfg0sUdULRWS0u/83Qrafoqqlnf5C062ccfrpvPjZY6ya9xpjT7ow6DgRJSk+liFZyQzJSm53H1Wlqr6JYvcqZGtFHduq6iiurKe4qo6SqnqWFpRTXFkftpAkxMWQk+oUjtb3PQpKmnN1kpWSYE9sRTgv9yAeAB7FuVqobV2pqoUi8v86OG4KsE5V8wFEZAZwPhBaIMYC/+Oeb7WI5IlIP1Xdto+/w3Qjp3/nGvjdY8x6+Z9WIAIgIvROiqd3Ujwj+rbfrKWqVNc3UVJVT3Hrq7KOkup6Siqd5Q1lO5m/YfteAzA63wNZKQnkuMVjdwFx7pOEFhRr3uqZvBSIl1X1mdAVInKjqt7fdn0bg4DNIcsFwNFt9lkKfBv4SESmAIcAucA2QIFZIqLAw6r6SLgvEZHpwHSAIUOGePg5xm+HjJ/CoX0TeefDT7gp6DCmXSJCWlI8aUnxDMtJ7XDf+qZmSqsbnAISUlBKqnYvr9laRWl1PU1t77azu3nLuSLZXTxyUhPJ3vWeQFaKPbnVnXgpEN8H/tJm3ZU49xY6Eu5/5bb/5dwN3C8iS4BlwGKgyd021b1K6Qu8KyKrVXXuXid0Cscj4NyD6CST6SKnTR7Fk+8tp7G+jvjEpKDjmAOUGBe7a5DEjrS0KDtqGva6IimurHcLSR3LCsoprqrfa0wtcK5KMpMTyElLJDs1kezU0M+Juz9bMekS7RYIEbkMuBwYKiIzQzalAWXhj9pDATA4ZDkXKAzdQVUrce5vIM5dsfXuC1UtdN+LReQVnCarvQqE6Z5uuu4afjzkNmKLl8PgTp8vMBEiJkbISnX6cIwZ0PG+1fVNlFbVU1rtFI/S6npKqht2fS6trmfjpp2UVNXv1SERIEackX73LB4JexYSKyYHpKMriE+AIiAb+FPI+irgSw/nng+MFJGhwBbgUpyCs4uI9AFqVLUB+BEwV1UrRSQFiFHVKvfzGcBvvf0k0x2MOPESmP//YNMnViBMWKmJcaQmxpGXndLhfqrKzoZmSqvqKamu36OolFQ37Pq8ocwpJvVNHReT9q5OWrdlpiRYMXG1WyBUdSOwETh2f06sqk0icgPwDs5jro+r6goRudbd/hAwBnhaRJpxbl5f7R7eD3jFfdQuDqeD3tv7k8MEJK0//9nal02PPsl1U38WdBrTg4nIPhWT6vomSkMKR6lbVEqq6ympctbnl+yktNp7MclKSXCvjBJ2XaVkuesjeSj5dvtBiMhHbie5Kva8dyCAqmq3G0fB+kF0Lz88fRwzP1lNcUU9MXE2cLDpXkKf4motKHs0d1U1UFJdT5m7PlwzFzhXQlmpCWSl7C4c2e7y7qLiFJo+veK73bDy+9UPQlWPd9/bf07OmA6ceMIJPPHeSlZ98ibjTrRe1aZ72fMprs73r2loomxXIWmgrLqesp3Ocll1A2U769m0vYZFm8rZvnPvoVOg9erELSCpzr2R7JArk6yU3QUlKzWB5IRg/7Dy0lHuGGCFqla5y6nAOFX93O9wpmc74axL4I6HmfvWS1YgTI+XnBBHcmYcgzPb76TYqrlFKa9p2LOA7CoorevqWbqjnLLqBqrrm8KeJzkhNqSQ7C4grVcprYUkK8VpDjvYvJSnvwMTQ5ZrwqwzZi/DJp1C/7RYPv3sc34SdBhjulBsyNNco/p13ghT19hM2U63iFS3Nm3teZVSWF7Hsi0VlFU37NXXJDMlgUW/Of2g/w4vBUI05EaFqraIiDUom05JTAxHjejLlsKioKMY060lxXvrZwK7h5kPbeZqbA5/f+RAefmHPl9EfoZz1QBwHZDvSxoTcV685wYSP74HasuhV5+g4xjT44UOMz+ib8c94A+Ul5G2rgWOw+nL0DpcxnQ/Q5nIkTjMfUp6y8Jggxhj9pmX+SCKcTq5GbPPmvodwWUv1nB61YNM/9M3Oj/AGNNteHmKKQmnA9s4YNegOqr6Qx9zmQgRl5rJ4uJYWubNt8tOY3oYL01MzwD9gW8Cc3DGVKryM5SJLFMOHcQXa7cGHcMYs4+8FIgRqvobYKeqPoUzcdBh/sYykWTKpCMoqGii6OsVQUcxxuwDLwWidaaQchEZD6QDeb4lMhFn0nEnA7D4w5kd72iM6Va8FIhH3LmjfwPMxBlU7x5fU5mIcviJ53HUwBjYvj7oKMaYfeDlKabH3I9zgGH+xjGRKH1AHl/cMhZy95620hjTfXV6BSEiWSLyNxFZJCILReQvIpLVFeFMBBlwOFq0NOgUxph94KWJaQZQDFwEXAyUAv/yM5SJPI8sqKPPLxdTW14cdBRjjEdeCkSmqv5OVde7r98DfXzOZSJM1pAxVNbD8nn/CTqKMcYjLwVitohcKiIx7us7wBt+BzOR5YjjzwBg6efzAk5ijPHKS4H4MfAc0OC+ZgA/F5EqEan0M5yJHMOOmEpqgrD0Sy/TmRtjugMvTzHZjHLmgMXExnJYbhpL12wIOooxxiNP8zq4/SBGsudYTHP9CmUi01XfnMiOjcuCjmGM8cjLYH0/Am7EGYNpCXAM8Clwqq/JTMS55nsXwaxFsLMMUuxJaWO6Oy/3IG4EjgI2quopwASgxNdUJjL1HU15nVKZvyDoJMYYD7wUiDpVrQMQkURVXQ0c6m8sE4kKmzLIuKeKZ//5dNBRjDEeeLkHUSAifYBXgXdFZAdQ6GcoE5kGjJpAWqKwcuXKoKMYYzzw8hTThe7HO0VkNs5orm/7mspEJImJYfSANFZ9vTnoKMYYD7yMxXSMiKQBqOocYDbOfYhOiciZIrJGRNaJyK1htmeIyCsi8qWIfOEOJ+7pWNMzjRk6gFVbyoOOYYzxwMs9iL8D1SHLO911HRKRWOBB4CxgLHCZiIxts9uvgSWqejjwfeD+fTjW9EBjDx1FYWUzFVs3Bh3FGNMJLwVCVFVbF1S1BW/3LqYA61Q1X1Vbe2Cf32afscD77nlXA3ki0s/jsaYH+tZZZ/LwOUnElFuBMKa781Ig8kXkZyIS775uBPI9HDcICG1sLnDXhVoKfBtARKYAh+D0t/ByLO5x00VkgYgsKCmxp2+7u/HHnsb0SQmk1RcFHcUY0wkvBeJa4DhgC84/1EcD0z0cJ2HWaZvlu4EMEVkC/BRYDDR5PNZZqfqIqk5W1ck5OTkeYplAZeSxokRZsfCjoJMYYzrh5SmmYuDS/Th3ATA4ZDmXNo/HqmolcBWAiAiw3n0ld3as6aHiErjkpQbGLJjJSz/8W9BpjDEd8HIFsb/mAyNFZKiIJOAUmT1mrReRPu42gB8Bc92i0emxpucaMTCTr7aUBh3DGNMJT4P17Q9VbRKRG4B3gFjgcVVdISLXutsfAsYAT4tIM7ASuLqjY/3KarrWiEMG8d7yIrSlBYnx828UY8yB8K1AAKjqm8CbbdY9FPL5U5xRYj0dayLDiJGjqG1cQNFXSxh46MSg4xhj2uGlo1w/EfmHiLzlLo8Vkav9j2Yi1chxRwKwbsnHwQYxxnTIy/X9kzhNPQPd5bXATT7lMVFg8kln8sblvTjMHjozplvzUiCyVfUFoAWc+wNAs6+pTETLGDKOs8ekkdG4NegoxpgOeCkQO0UkC7cfgogcA1T4mspEtpgY5pZm8uYH1sRkTHfm5Sb1z3EeMR0uIh8DOcDFvqYyEe+eD8spLNvM2fcEncQY0x4vHeUWichJOJMECbBGVRt9T2Yi2ohDBjJ31WJ71NWYbszLnNTfbrNqlIhUAMvcXtbG7LMRw4dR3bCIbRvW0H/YmKDjGGPC8PKn29XAY8B33dejOM1OH4vIFT5mMxFsxGhn6o91Sz8JOIkxpj1eCkQLMEZVL1LVi3CG6K7HGbTvV36GM5Fr6BhnzqmNa5YFnMQY0x4vN6nzVHVbyHIxMEpVt4uI3Ysw+2X4hONZ9pMUhk3qH3QUY0w7vBSIeSLyH+BFd/kiYK6IpADlfgUzkS0+NZPxef2g1gbpNaa78vIU03UichFwPM5TTE8DL7mzzJ3icz4TwV5en0zZ6rlcc17QSYwx4XRYIEQkBvhSVccDL3VNJBMt/rW0msXrCrkm6CDGmLA6vEntzj+9VESGdFEeE0Xyhgxi4/YGWhobgo5ijAnDy1NMA4AVIvK+iMxsffkdzES+vKHDaWiGrV8tCTqKMSYMLzep7/I9hYlKeSPHArBh5QIGjp0ScBpjTFteblLP6YogJvrkjTkSgE1fr+a4YKMYY8LwMmHQMSIyX0SqRaRBRJpFpLIrwpnINmrCVHb8Ko1Ljx0cdBRjTBhe7kE8AFwGfAX0An7krjPmgMQmpdInMwcqCoKOYowJw9Mwmqq6DohV1WZVfQI42ddUJmo8tDSG/3nm/aBjGGPC8HKTukZEEoAlIvK/QBGQ4m8sEy1m5zew6OvN3BZ0EGPMXrxcQVzh7ncDsBMYjDPchjEHbMigfhTsqMfpmG+M6U68PMW00f1Yhz3yag6y3EG51DXNZ3vhBrIGDQ06jjEmhJenmKaKyLsislZE8ltfXRHORL7cvOEAFKxZFHASY0xbXu5B/AO4GVgINPsbx0SbwSPG0jsRthd8HXQUY0wbXgpEhaq+tT8nF5EzgfuBWOAxVb27zfZ04J/AEDfLfe5TUojIBqAKpyg1qerk/clgurejTjyDilt7w5isoKMYY9pot0CIyET342wRuRd4GWcmOQBUtcM2ARGJBR4ETgcKgPkiMlNVV4bsdj2wUlXPFZEcYI2IPKuqraO3naKqpfv8q0yPIWn9ISbO+kIY0w11dAXxpzbLoX/BK3BqJ+eeAqxT1XwAEZkBnA+EFggF0kREgFRgO9DkIbeJFDGx3PSe0G/tG9x22h1BpzHGhGi3QKjqgU4GNAjYHLJcgDOPdagHgJlAIZAGTHOHGAeneMwSEQUeVtVHwn2JiEwHpgMMGWKjkvdEXxQ206s03/pCGNPNeHmK6Y8i0idkOUNEfu/h3BJmXduH3b8JLAEGAkcCD4hIb3fbVFWdCJwFXC8iJ4b7ElV9RFUnq+rknJwcD7FMdzO4XwYFpVVBxzDGtOGlo9xZqlreuqCqO4CzPRxXgNOprlUuzpVCqKuAl9WxDlgPjHa/p9B9LwZewWmyMhEod0A/Csob0GZ7SM6Y7sRLgYgVkcTWBRHpBSR2sH+r+cBIERnqDtVxKU5zUqhNwDfc8/YDDgXyRSRFRNLc9SnAGcByD99peqDc3FxqGqG80LrXGNOdeHnM9Z/A+yLyBE4T0Q+Bpzo7SFWbROQG4B2cx1wfV9UVInKtu/0h4HfAkyKyDKdJ6leqWioiw4BXnHvXxAHPqerb+/7zTE8wYuQoxubEUF74FRmDRwYdxxjjEi9j4Lj9GU7D+Ud8lqq+43ew/TF58mRdsGBB0DHMvtr8BfzjdLj8RRh1RtBpjIkqIrKwvX5mnV5BuE08s1T1bRE5FDhUROJVtfFgBzVRKq2/815VFGwOY8wevNyDmAskicgg4D2cG8tP+hnKRBdN6cepT+3kL0/8O+goxpgQXgqEqGoN8G3gb6p6ITDW31gmmkh8Imu3w9LVNh6TMd2JpwIhIscC3wXecNd5ubltjGcD+vSiqGRH0DGMMSG8FIibgNuAV9ynkIYBs31NZaLOgKw0isqss5wx3YmXCYPmAHNClvOBn/kZykSfATkZfLa2OOgYxpgQHY3m+hdVvUlEXmfvITJQ1fN8TWaiysSxI9iUvxZtakTi4oOOY4yh4yuIZ9z3+7oiiIluP778PH6c/iHUlEDvgUHHMcbQ8WiuC933Oe3tY8xB01oUqoqsQBjTTXTUxLSMME1LrVT1cF8Smai0elstZ99fxYMD/8NZ0ycFHccYQ8dNTOe479e7761NTt8FanxLZKJSat881pcrm/K/CjqKMcbVURPTRgARmaqqU0M23SoiHwO/9TuciR79ho5FgKLCLUFHMca4vPSDSBGR41sXROQ4IMW/SCYaxScmkZ0SS9E2e9TVmO7CS4/oq4HHRSQd555EBc6Q38YcVAMykigq2R50DGOMy0tHuYXAEe5UoKKqFf7HMtHovElDSGzZGXQMY4zL85hKqlrpZxBjfnfVqfDVrKBjGGNcXu5BGNM1Uvui1SU2N7Ux3YQVCNNtPP7BOhJ/V07pZnvU1ZjuoNMCISLJIvIbEXnUXR4pIud0dpwx+6p3Vl8aW6Bo/aqgoxhj8HYF8QRQDxzrLhcAv/ctkYla/XOHAlC4wa4gjOkOvBSI4ar6v0AjgKrWAuJrKhOVBuQdCkDR5g3BBjHGAN4KRIOI9MIdl0lEhuNcURhzUPUb6hSIkm2FAScxxoC3x1zvBN4GBovIs8BU4EofM5kolZI1iOumJHH4oOSgoxhj8NZRbpaILASOwWlaulFVS31PZqKOxMTw4LShMDQ96CjGGDwUCBGZCTwPzFRV6+ZqfNXcK5udpVvoHXQQY4ynexB/Ak4AVorIiyJysYgkeTm5iJwpImtEZJ2I3Bpme7qIvC4iS0VkhYhc5fVYE5kufHQdJ/32g6BjGGPwUCBUdY6qXgcMAx4BvgN0OuSmiMQCDwJnAWOBy0RkbJvdrgdWquoRwMnAn0QkweOxJgLlZKZTXGnPQBjTHXjqSe0+xXQRcC1wFPCUh8OmAOtUNV9VG4AZwPlt9lEgTUQESAW2A00ejzURqG9ONsXVTTbchjHdgJee1P8CVgGn4vxVP1xVf+rh3IOAzSHLBe66UA8AY4BCYBnODfAWj8e25psuIgtEZEFJSYmHWKY769u3H00tUL51Y9BRjIl6XntSD1fVa1X1A/cfcC/CdaZrO8f1N4ElwEDgSOCB1mHFPRzrrFR9RFUnq+rknJwcj9FMd9V3gPN3QPHG1QEnMca0+xSTiJyqqh8AycD5TivQbqr6cifnLgAGhyzn4lwphLoKuFtVFVgnIuuB0R6PNRFo4qTJ3HVyIr1j6oKOYkzU6+gx15OAD4Bzw2xToLMCMR8YKSJDgS3ApcDlbfbZBHwDmCci/YBDgXyg3MOxJgKNOXIK/31SIqR4vVA1xvil3QKhqne4H3+rqutDt7n/cHdIVZtE5AbgHSAWeFxVV4jIte72h4DfAU+KyDKcZqVftXbCC3fsPv860+NocjZFVS0kbskn67Cg0xgT3cRp3elgB5FFqjqxzbqFqjrJ12T7YfLkybpgwYKgY5gD0NTYSHxCAndccTJ3Pj076DjGRDz33/PJ4bZ1dA9iNDAOSBeRb4ds6g146ihnzL6Ki48nKzmG4tKyoKMYE/U6ugdxKHAO0Ic970NUAdf4mMlEub69EykuKw86hjFRr6N7EK8Br4nIsar6aRdmMlGub3ovindUBx3DmKjnZbjvxSJyPU5z066mJVX9oW+pTFTrm5HGl/lbg45hTNTz0lHuGaA/Tqe2OTh9Eqr8DGWi24/OnsR/n5oWdAxjop6XK4gRqnqJiJyvqk+JyHM4j5/2CI2NjRQUFFBXF9kdr5KSksjNzSU+Pj7oKAfsjOMnQfP70NIMMbFBxzEmankpEI3ue7mIjAe2Anm+JTrICgoKSEtLIy8vj7a9wSOFqlJWVkZBQQFDh3baRaXbq2hJYc2WJg7bXkiv7MGdH2CM8YWXJqZHRCQD+A0wE1gJ/K+vqQ6iuro6srKyIrY4AIgIWVlZEXOV9MHyLRz92E5WL50fdBRjopqXKUcfcz/OwZkToseJ5OLQKpJ+Y3b/XADKijYFnMSY6NZRR7mfd3Sgqv754McxBrIH5AFQurUg2CDGRLmOriDsMRITiKxBzn2U0m1FAScxJrp11FHurq4MYkyrzEHDASgrtQmgjAlSp/cgRGQU8Hegn6qOF5HDgfNU9fe+pzvI7np9BSsLKw/qOccO7M0d547rdL8//OEPPP300wwePJicnBwmTZrELbfcclCzRIq4pGSen5bJYUfbE0zGBMnLU0yPArfhPu6qql/izM9gPFq4cCEzZsxg8eLFvPzyy8yfb0/ndObSYwczLjvoFMZENy/9IJJV9Ys2T8k0+ZTHV17+0vfDvHnzuPDCC0lOTgbgvPPO27Xt3HPP5fXXX293+cILL+SVV17purDdxNLtiVSXrGXqxUEnMSZ6eSkQpSIyHHdOaBG5GLC7h/so3GOoGzZsIC8vr93lzZs3M2jQoC5I1/3cPnMzhWWVLOpxDZnGRA4vTUzXAw8Do0VkC3ATcK2foSLNiSeeyCuvvEJtbS1VVVW7rhAWLVrExIm752Jqu7xw4UImTep28zJ1ieyM3pRW1Qcdw5io1mmBUNV8VT0NyAFGAycDx/ucK6JMnDiRadOmceSRR3LRRRdxwgknAHsXgHDLoQUjmmRnZlC2swk6mfHQGOOfjjrK9ca5ehgEvAa85y7fAiwFnu2KgJHi9ttv5/bbbwfgzjvvBJwrhrKyMuLi4rjkkkv2Wl6xYgV33HFHB2eNXNnZ2dQ0Qk15MckZ/YKOY0xU6ugexDPADuBTnBnkfgkkABeo6hL/o0W+t956a4/lk046qcPlaJKV0xeAsoKvrUAYE5COCsQwVT0MQEQeA0qBIapqc0EcoNYrCNO+s08/hfc3zSA7yZqYjAlKRwWidZhvVLVZRNZbcTBdZdCw0QwaGgdqU48aE5SOblIfISKV7qsKOLz1s4gc3O7IxrSxsyWRF1Y08tXqlUFHMSZqtVsgVDVWVXu7rzRVjQv53LsrQ5ros7MlgWn/rmXW3M+DjmJM1PLSD8KYLpc5MA+AUhuwz5jA+FogRORMEVkjIutE5NYw2/9LRJa4r+Ui0iwime62DSKyzN22wM+cpvuJS0ikT5JQWrY96CjGRC0vQ23sFxGJBR4ETgcKgPkiMlNVdzUqq+q9wL3u/ucCN6tq6L8Ip6hqqV8ZTfeWnRpP6Y6KoGMYE7X8vIKYAqxze2I3ADOA8zvY/zLgeR/zmB4mu3cSZRX2FJMxQfHtCgKnB/bmkOUC4OhwO4pIMnAmcEPIagVmiYgCD6vqI+0cOx2YDjBkyJCDENt0F49Pn0JSsz0wZ0xQ/CwQew9f6o4IG8a5wMdtmpemqmqhiPQF3hWR1ao6d68TOoXjEYDJkyd33KvqrVth6zJP4T3rfxicdXenu9mEQftuzIg8KPgi6BjGRC0/m5gKgNApwXKBwnb2vZQ2zUuqWui+FwOv4DRZ9Ug2YdD+WVBQz1/f2xR0DGOilp9XEPOBkSIyFNiCUwQub7uTiKQDJwHfC1mXAsSoapX7+QzgtwecyMNf+n7YlwmDAKZNm8aUKVP4xS9+AThNZw888ADnnXcef/zjH3n33XeZPXt21/2AgLy7fBu//k8511RX0Ss1Leg4xkQd364gVLUJ557CO8Aq4AVVXSEi14pI6HwSFwKzVHVnyLp+wEcishT4AnhDVd/2K2tX8DJhEMBrr73GOeecw5dffgk4kwYdd9xxLFu2jA0bNvD1118zYcKErogcuMwsZ87RHVs3BpzEmOjkaz8IVX1TVUep6nBV/YO77iFVfShknydV9dI2x+Wr6hHua1zrsT2V1wmD6urqePHFF7niiiuoqHAe71y4cCHnnnsu27Zt47777uPkk0+OmkmEMrKcEV23F1kzkzFBsJ7UXcDrhEH33nsv1dXVXHvttaxYsYLa2tpd+2zZsoVjjz2WtWvXRk2ByMzpD8CObZs72dMY4wc/70GYEF4mDNqwYQOvvvoqAHfddRdffvkla9euZdSoUcyYMYP4+HimTZvGqFGjAvoVXSujrzMf9/ZimwLdmCBYgQhQRxMGtc4k969//QuAmJiYPZajwfgjJ7L+xlQGHDU86CjGRCUrEAGwCYO8SezTn7w+MdBk05AYEwS7B2G6r6Q+3PtxA+/Mtc5yxgTBCoTpvmJiuOeTBmbOWxJ0EmOikhUI061lJMexo9yamIwJghUI061lpiaxvdJGdDUmCFYgTLeWkdaLHVW1QccwJipZgTDdWmZ6Ktur64OOYUxUssdcTbf28E3nkLDypaBjGBOV7ArCdGtpWf1JbK6E5qagoxgTdaLuCuLkk0/ea913vvMdrrvuOmpqajj77LP32n7llVdy5ZVXUlpaysUXX7zHtg8//LDT77TJgvbfp+t28PxbdfzxJwWk9ssLOo4xUcWuIHxmkwUdmDVF1fztiwZKCvKDjmJM1Im6K4iO/uJPTk7ucHt2dranK4ZQHU0WZDqXkd0PgO1bNzM04CzGRBu7gugC4SYLMt60Dvm9vbi92WqNMX6xAuGz9iYLMt5k9HOG/N5RWhxwEmOiT9Q1MXW10MmCDjnkkF2TBRlvMvsPJkagumJ70FGMiTp2BdEFbr/9dtasWcOsWbMYMmRI0HF6lAF5o2j8TRo/PGN80FGMiTp2BWG6NYlPQuKToa4i6CjGRB0rEF3MJgvad7d+0MghBR/xkzOCTmJMdImKJiZVDTqC7yL5N/5ndS3vLrJ+EMZ0tYgvEElJSZSVlUX0P6CqSllZGUlJSUFH8UVmaiLbK2uCjmFM1In4Jqbc3FwKCgooKSkJOoqvkpKSyM3NDTqGLzLSktmwze5BGNPVIr5AxMfHM3So9cHtyTLTU1mUH9kF3pjuyNcmJhE5U0TWiMg6Ebk1zPb/EpEl7mu5iDSLSKaXY030GJCTQVJs5DYRGtNd+VYgRCQWeBA4CxgLXCYiY0P3UdV7VfVIVT0SuA2Yo6rbvRxroscff3wuX/00FVpago5iTFTx8wpiCrBOVfNVtQGYAZzfwf6XAc/v57EmkiWlg7ZAQ1XQSYyJKn7egxgEbA5ZLgCODrejiCQDZwI37Mex04Hp7mK1iKzZz7zZQOl+HttT9azffFefg3GWnvWbD1y0/V6w37yvDmlvg58FItwQpu01JJ8LfKyqrQPueD5WVR8BHtn3eHsSkQWqOvlAz9OT2G+OfNH2e8F+88HkZxNTATA4ZDkXaG/M5kvZ3by0r8caY4zxgZ8FYj4wUkSGikgCThGY2XYnEUkHTgJe29djjTHG+Me3JiZVbRKRG4B3gFjgcVVdISLXutsfcne9EJilqjs7O9avrK4Dbqbqgew3R75o+71gv/mgkUgegsIYY8z+i/ixmIwxxuwfKxDGGGPCivoCEW1DeojIYBGZLSKrRGSFiNwYdKauIiKxIrJYRP4TdJauICJ9ROTfIrLa/d/72KAz+U1Ebnb/u14uIs+LSMQNcSwij4tIsYgsD1mXKSLvishX7nvGwfiuqC4QUTqkRxPwC1UdAxwDXB8Fv7nVjcCqoEN0ofuBt1V1NHAEEf7bRWQQ8DNgsqqOx3nA5dJgU/niSZyOxaFuBd5X1ZHA++7yAYvqAkEUDumhqkWqusj9XIXzj8agYFP5T0RygW8BjwWdpSuISG/gROAfAKraoKrlgYbqGnFALxGJA5KJwP5TqjoX2N5m9fnAU+7np4ALDsZ3RXuBCDekR8T/Y9lKRPKACcDnAUfpCn8BfglEy4h/w4AS4Am3We0xEUkJOpSfVHULcB+wCSgCKlR1VrCpukw/VS0C549AoO/BOGm0F4h9GQ4koohIKvAScJOqVgadx08icg5QrKoLg87SheKAicDfVXUCsJOD1OzQXbnt7ucDQ4GBQIqIfC/YVD1btBeIqBzSQ0TicYrDs6r6ctB5usBU4DwR2YDTjHiqiPwz2Ei+KwAKVLX16vDfOAUjkp0GrFfVElVtBF4Gjgs4U1fZJiIDANz34oNx0mgvEFE3pIeICE679CpV/XPQebqCqt6mqrmqmofzv/EHqhrRf1mq6lZgs4gc6q76BrAywEhdYRNwjIgku/+df4MIvzEfYibwA/fzD9hz6KL9FvFTjnYkoCE9gjYVuAJYJiJL3HW/VtU3g4tkfPJT4Fn3j5984KqA8/hKVT8XkX8Di3Ce1ltMBA67ISLPAycD2SJSANwB3A28ICJX4xTKSw7Kd9lQG8YYY8KJ9iYmY4wx7bACYYwxJiwrEMYYY8KyAmGMMSYsKxDGGGPCsgJhooaIZInIEve1VUS2uJ+rReT/fPrOm0Tk+36cu5PvzRGRt7v6e01kscdcTVQSkTuBalW9z8fviMN5Jn+iqjb59R3tnVtEngAeU9WP/fhuE/nsCsJEPRE5uXWOCBG5U0SeEpFZIrJBRL4tIv8rIstE5G13mBJEZJKIzBGRhSLyTuswB22cCixyO2QOF5FFId85UkQWdnQuEblGROaLyFIReUlEkt31T4rIn0VkNnCPiJwUcmW0WETS3K95FfiuX/93M5HPCoQxexuOMzT4+cA/gdmqehhQC3zLLRJ/Ay5W1UnA48AfwpxnKrAQQFW/BipE5Eh321XAk52c62VVPUpVW+dyuDrk3KOA01T1F8AtwPWqeiRwgpsTYIG7bMx+ieqhNoxpx1uq2igiy3CGYGlty18G5AGHAuOBd50hf4jFGV66rQHsORbQY8BVIvJzYBrOfCQdnWu8iPwe6AOk4gwJ0+pFVW12P38M/FlEnsUpKgXu+mKcUU2N2S9WIIzZWz2AqraISKPuvlHXgvP/MwKsUNXOpvCsBUKnvHwJZ9ycD4CFqlomIgM7ONeTwAWqulRErsQZf6fVztYPqnq3iLwBnA18JiKnqepq97trMWY/WROTMftuDZDTOseziMSLyLgw+60CRrQuqGodzlXA34EnPJwrDShym6HavZcgIsNVdZmq3oPTrDTa3TQKWN7eccZ0xgqEMfvInZ72YpwbxEuBJYSfd+AtnGk/Qz2LMynVLA/n+g3ObH/vAqs7iHSTiCx3j691vxfgFOCNffltxoSyx1yN8ZGIvAL8UlW/cpdvAdJV9Tdd8N1zgfNVdYff32UikxUIY3zkTtjTT1XnusViOHCqqpb6/L05wFRVfdXP7zGRzQqEMcaYsOwehDHGmLCsQBhjjAnLCoQxxpiwrEAYY4wJywqEMcaYsP4/fvve6B8qJXoAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(t_days/365, cell_2_metrics[1,:])\n", + "plt.plot(t_days/365, cell_2_metrics[4,:])\n", + "plt.plot(t_days/365, cell_2_metrics[0,:], '--k')\n", + "plt.xlabel('Time (years)')\n", + "plt.ylabel('Relative discharge capacity')\n", + "plt.legend([r'q$_{LLI}$', r'q$_{LAM}$', 'q'])\n", + "plt.ylim((0.7, 1.02))" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "40f086751e8f8f5a467e9309d1f7c4260661a6c2944e5db2eb5ae43b985dbc0f" + }, + "kernelspec": { + "display_name": "Python 3.7.4 ('base')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/functions/extract_stressors.py b/functions/extract_stressors.py new file mode 100644 index 0000000..90efb37 --- /dev/null +++ b/functions/extract_stressors.py @@ -0,0 +1,32 @@ +import numpy as np +import functions.rainflow as rainflow + +def extract_stressors(t_secs, soc, T_celsius): + # Extract stressors + t_days = t_secs / (24*60*60) + delta_t_days = t_days[-1] - t_days[0] + delta_efc = np.sum(np.abs(np.ediff1d(soc, to_begin=0)))/2 # sum the total changes to SOC / 2 + dod = np.max(soc) - np.min(soc) + abs_instantaneous_crate = np.abs(np.diff(soc)/np.diff(t_secs/(60*60))) # get instantaneous C-rates + abs_instantaneous_crate[abs_instantaneous_crate < 1e-2] = 0 # get rid of extremely small values (storage) before calculating mean + Crate = np.trapz(abs_instantaneous_crate, t_days[1:]) / delta_t_days + # Check storage condition, which will give nan Crate: + if np.isnan(Crate): + Crate = 0 + T_kelvin = T_celsius + 273.15 + # Estimate Ua (anode to reference potential) from SOC. + # Uses the equation from Safari and Delacourt, https://doi.org/10.1149/1.3567007. + # Anode stoichiometry is assumed to be the same for any chemistry/cell, and is calculated using the equation from Schimpe et al https://doi.org/10.1149/2.1181714jes + # While this will not be precise, it still helps get a guess as to where the plateaus of the anode-reference potential are. + def get_Xa(soc): + return 8.5*10**-3 + soc*(0.78 - 8.5*10**-3) + def get_Ua(Xa): + return (0.6379 + 0.5416*np.exp(-305.5309*Xa) + + 0.044*np.tanh(-1*(Xa-0.1958)/0.1088) - 0.1978*np.tanh((Xa-1.0571)/0.0854) - + 0.6875*np.tanh((Xa+0.0117)/0.0529) - 0.0175*np.tanh((Xa-0.5692)/0.0875)) + Ua = get_Ua(get_Xa(soc)) + + cycles = rainflow.count_cycles(soc) + cycles = sum(i for _, i in cycles) + + return delta_t_days, delta_efc, T_kelvin, soc, Ua, dod, Crate, cycles \ No newline at end of file diff --git a/functions/rainflow.py b/functions/rainflow.py new file mode 100644 index 0000000..a873d78 --- /dev/null +++ b/functions/rainflow.py @@ -0,0 +1,176 @@ +""" +Implements rainflow cycle counting algorythm for fatigue analysis +according to section 5.4.4 in ASTM E1049-85 (2011). +""" +from __future__ import division +from collections import deque, defaultdict +import math + +try: + from importlib import metadata as _importlib_metadata +except ImportError: + import importlib_metadata as _importlib_metadata + +# __version__ = _importlib_metadata.version("rainflow") + + +def _get_round_function(ndigits=None): + if ndigits is None: + def func(x): + return x + else: + def func(x): + return round(x, ndigits) + return func + + +def reversals(series): + """Iterate reversal points in the series. + A reversal point is a point in the series at which the first derivative + changes sign. Reversal is undefined at the first (last) point because the + derivative before (after) this point is undefined. The first and the last + points are treated as reversals. + Parameters + ---------- + series : iterable sequence of numbers + Yields + ------ + Reversal points as tuples (index, value). + """ + series = iter(series) + + x_last, x = next(series, None), next(series, None) + if x_last is None or x is None: + return + + d_last = (x - x_last) + + yield 0, x_last + index = None + for index, x_next in enumerate(series, start=1): + if x_next == x: + continue + d_next = x_next - x + if d_last * d_next < 0: + yield index, x + x_last, x = x, x_next + d_last = d_next + + if index is not None: + yield index + 1, x_next + + +def extract_cycles(series): + """Iterate cycles in the series. + Parameters + ---------- + series : iterable sequence of numbers + Yields + ------ + cycle : tuple + Each tuple contains (range, mean, count, start index, end index). + Count equals to 1.0 for full cycles and 0.5 for half cycles. + """ + points = deque() + + def format_output(point1, point2, count): + i1, x1 = point1 + i2, x2 = point2 + rng = abs(x1 - x2) + mean = 0.5 * (x1 + x2) + return rng, mean, count, i1, i2 + + for point in reversals(series): + points.append(point) + + while len(points) >= 3: + # Form ranges X and Y from the three most recent points + x1, x2, x3 = points[-3][1], points[-2][1], points[-1][1] + X = abs(x3 - x2) + Y = abs(x2 - x1) + + if X < Y: + # Read the next point + break + elif len(points) == 3: + # Y contains the starting point + # Count Y as one-half cycle and discard the first point + yield format_output(points[0], points[1], 0.5) + points.popleft() + else: + # Count Y as one cycle and discard the peak and the valley of Y + yield format_output(points[-3], points[-2], 1.0) + last = points.pop() + points.pop() + points.pop() + points.append(last) + else: + # Count the remaining ranges as one-half cycles + while len(points) > 1: + yield format_output(points[0], points[1], 0.5) + points.popleft() + + +def count_cycles(series, ndigits=None, nbins=None, binsize=None): + """Count cycles in the series. + Parameters + ---------- + series : iterable sequence of numbers + ndigits : int, optional + Round cycle magnitudes to the given number of digits before counting. + Use a negative value to round to tens, hundreds, etc. + nbins : int, optional + Specifies the number of cycle-counting bins. + binsize : int, optional + Specifies the width of each cycle-counting bin + Arguments ndigits, nbins and binsize are mutually exclusive. + Returns + ------- + A sorted list containing pairs of range and cycle count. + The counts may not be whole numbers because the rainflow counting + algorithm may produce half-cycles. If binning is used then ranges + correspond to the right (high) edge of a bin. + """ + if sum(value is not None for value in (ndigits, nbins, binsize)) > 1: + raise ValueError( + "Arguments ndigits, nbins and binsize are mutually exclusive" + ) + + counts = defaultdict(float) + cycles = ( + (rng, count) + for rng, mean, count, i_start, i_end in extract_cycles(series) + ) + + if nbins is not None: + binsize = (max(series) - min(series)) / nbins + + if binsize is not None: + nmax = 0 + for rng, count in cycles: + quotient = rng / binsize + n = int(math.ceil(quotient)) # using int for Python 2 compatibility + + if nbins and n > nbins: + # Due to floating point accuracy we may get n > nbins, + # in which case we move rng to the preceeding bin. + if (quotient % 1) > 1e-6: + raise Exception("Unexpected error") + n = n - 1 + + counts[n * binsize] += count + nmax = max(n, nmax) + + for i in range(1, nmax): + counts.setdefault(i * binsize, 0.0) + + elif ndigits is not None: + round_ = _get_round_function(ndigits) + for rng, count in cycles: + counts[round_(rng)] += count + + else: + for rng, count in cycles: + counts[rng] += count + + return sorted(counts.items()) \ No newline at end of file diff --git a/functions/state_functions.py b/functions/state_functions.py new file mode 100644 index 0000000..b4efaad --- /dev/null +++ b/functions/state_functions.py @@ -0,0 +1,48 @@ +# Paul Gasper, NREL +# Functions for updating time-varying states +import numpy as np + +def update_power_state(y0, dx, k, p): + if y0 == 0: + if dx == 0: + dydx = 0 + else: + y0 = k*(dx**p) + dydx = y0/dx + else: + if dx == 0: + dydx = 0 + else: + dydx = k*p*((y0/k)**((p-1)/p)) + return dydx * dx + +def update_power_B_state(y0, dx, k, p): + if y0 == 0: + if dx == 0: + dydx = 0 + else: + y0 = (k*dx)**p + dydx = y0/dx + else: + if dx == 0: + dydx = 0 + else: + z = (y0 ** (1/p)) / k + dydx = (p * (k*z)**p)/z + return dydx * dx + +def update_sigmoid_state(y0, dx, y_inf, k, p): + if y0 == 0: + if dx == 0: + dydx = 0 + else: + dy = 2 * y_inf * (1/2 - 1 / (1 + np.exp((k * dx) ** p))) + dydx = dy / dx + else: + if dx == 0: + dydx = 0 + else: + x_inv = (1 / k) * ((np.log(-(2 * y_inf/(y0-y_inf)) - 1)) ** (1 / p) ) + z = (k * x_inv) ** p + dydx = (2 * y_inf * p * np.exp(z) * z) / (x_inv * (np.exp(z) + 1) ** 2) + return dydx * dx \ No newline at end of file diff --git a/lfp_gr_SonyMurata3Ah_2018.py b/lfp_gr_SonyMurata3Ah_2018.py new file mode 100644 index 0000000..12805fe --- /dev/null +++ b/lfp_gr_SonyMurata3Ah_2018.py @@ -0,0 +1,271 @@ +# Paul Gasper, NREL +import numpy as np +from functions.extract_stressors import extract_stressors +from functions.state_functions import update_power_B_state, update_sigmoid_state +import scipy.stats as stats + +# EXPERIMENTAL AGING DATA SUMMARY: +# Aging test matrix varied temperature and state-of-charge for calendar aging, and +# varied depth-of-discharge, average state-of-charge, and C-rates for cycle aging. +# There is NO LOW TEMPERATURE cycling aging data, i.e., no lithium-plating induced by +# kinetic limitations on cell performance; CYCLING WAS ONLY DONE AT 25 CELSIUS AND 45 CELSIUS, +# so any model predictions at low temperature cannot incorporate low temperature degradation modes. +# Discharge capacity + +# MODEL SENSITIVITY +# The model predicts degradation rate versus time as a function of temperature and average +# state-of-charge and degradation rate versus equivalent full cycles (charge-throughput) as +# a function of average state-of-charge during a cycle, depth-of-discharge, and average of the +# charge and discharge C-rates. + +# MODEL LIMITATIONS +# There is no influence of TEMPERATURE on CYCLING DEGRADATION RATE due to limited data. This is +# NOT PHYSICALLY REALISTIC AND IS BASED ON LIMITED DATA. + +class Lfp_Gr_SonyMurata3Ah_Battery: + # Model predicting the degradation of Sony-Murata 3 Ah LFP-Gr cylindrical cells. + # Data is from Technical University of Munich, reported in studies led by Maik Naumann. + # Capacity model identification was conducted at NREL. Resistance model is from Naumann et al. + # Naumann et al used an interative fitting procedure, but it was found that lower model error could be + # achieved by simply reoptimizing all resistance growth parameters to the entire data set. + # Calendar aging data source: https://doi.org/10.1016/j.est.2018.01.019 + # Cycle aging data source: https://doi.org/10.1016/j.jpowsour.2019.227666 + # Model identification source: https://doi.org/10.1149/1945-7111/ac86a8 + # Degradation rate is a function of the aging stressors, i.e., ambient temperature and use. + # The state of the battery is updated throughout the lifetime of the cell. + # Performance metrics are capacity and DC resistance. These metrics change as a function of the + # cell's current degradation state, as well as the ambient temperature. The model predicts time and + # cycling dependent degradation. Cycling dependent degradation includes a break-in mechanism as well + # as long term cycling fade; the break-in mechanism strongly influenced results of the accelerated + # aging test, but is not expected to have much influence on real-world applications. + # Parameters to modify to change fade rates: + # q1_b0: rate of capacity loss due to calendar degradation + # q5_b0: rate of capacity loss due to cycling degradation + # k_ref_r_cal: rate of resistance growth due to calendar degradation + # A_r_cyc: rate of resistance growth due to cycling degradation + + def __init__(self): + # States: Internal states of the battery model + self.states = { + 'qLoss_LLI_t': np.array([0]), + 'qLoss_LLI_EFC': np.array([0]), + 'qLoss_BreakIn_EFC': np.array([1e-10]), + 'rGain_LLI_t': np.array([0]), + 'rGain_LLI_EFC': np.array([0]), + } + + # Outputs: Battery properties derived from state values + self.outputs = { + 'q': np.array([1]), + 'q_LLI_t': np.array([1]), + 'q_LLI_EFC': np.array([1]), + 'q_BreakIn_EFC': np.array([1]), + 'r': np.array([1]), + 'r_LLI_t': np.array([1]), + 'r_LLI_EFC': np.array([1]), + } + + # Stressors: History of stressors on the battery + self.stressors = { + 'delta_t_days': np.array([np.nan]), + 't_days': np.array([0]), + 'delta_efc': np.array([np.nan]), + 'efc': np.array([0]), + 'TdegK': np.array([np.nan]), + 'soc': np.array([np.nan]), + 'Ua': np.array([np.nan]), + 'dod': np.array([np.nan]), + 'Crate': np.array([np.nan]), + } + + # Rates: History of stressor-dependent degradation rates + self.rates = { + 'q1': np.array([np.nan]), + 'q3': np.array([np.nan]), + 'q5': np.array([np.nan]), + 'q7': np.array([np.nan]), + 'r_kcal': np.array([np.nan]), + 'r_kcyc': np.array([np.nan]), + } + + # Nominal capacity + @property + def _cap(self): + return 3 + + # Define life model parameters + @property + def _params_life(self): + return { + # Capacity fade parameters + 'q2': 0.000130510034211874, + 'q1_b0': 0.989687151293590, # CHANGE to modify calendar degradation rate + 'q1_b1': -2881067.56019324, + 'q1_b2': 8742.06309157261, + 'q3_b0': 0.000332850281062177, + 'q3_b1': 734553185711.369, + 'q3_b2': -2.82161575620780e-06, + 'q3_b3': -3284991315.45121, + 'q3_b4': 0.00127227593657290, + 'q8': 0.00303553871631028, + 'q9': 1.43752162947637, + 'q7_b0': 0.582258029148225, + 'q7_soc_skew': 0.0583128906965484, + 'q7_soc_width': 0.208738181522897, + 'q7_dod_skew': -3.80744333129564, + 'q7_dod_width': 1.16126260428210, + 'q7_dod_growth': 25.4130804598602, + 'q6': 1.12847759334355, + 'q5_b0': -6.81260579372875e-06, # CHANGE to modify cycling degradation rate + 'q5_b1': 2.59615973160844e-05, + 'q5_b2': 2.11559710307295e-06, + # Resistance growth parameters + 'k_ref_r_cal': 3.4194e-10, # CHANGE to modify calendar degradation rate + 'Ea_r_cal': 71827, + 'C_r_cal': -3.3903, + 'D_r_cal': 1.5604, + 'A_r_cyc': -0.002, # CHANGE to modify cycling degradation rate + 'B_r_cyc': 0.0021, + 'C_r_cyc': 6.8477, + 'D_r_cyc': 0.91882 + } + + # Battery model + def update_battery_state(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Check some input types: + if not isinstance(t_secs, np.ndarray): + raise TypeError('Input "t_secs" must be a numpy.ndarray') + if not isinstance(soc, np.ndarray): + raise TypeError('Input "soc" must be a numpy.ndarray') + if not isinstance(T_celsius, np.ndarray): + raise TypeError('Input "T_celsius" must be a numpy.ndarray') + if not (len(t_secs) == len(soc) and len(t_secs) == len(T_celsius)): + raise ValueError('All input timeseries must be the same length') + + self.__update_states(t_secs, soc, T_celsius) + self.__update_outputs() + + def __update_states(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Extract stressors + delta_t_secs = t_secs[-1] - t_secs[0] + delta_t_days, delta_efc, TdegK, soc, Ua, dod, Crate, cycles = extract_stressors(t_secs, soc, T_celsius) + + # Grab parameters + p = self._params_life + + # Calculate the degradation coefficients + q1 = np.abs( + p['q1_b0'] + * np.exp(p['q1_b1']*(1/(TdegK**2))*(Ua**0.5)) + * np.exp(p['q1_b2']*(1/TdegK)*(Ua**0.5)) + ) + q3 = np.abs( + p['q3_b0'] + * np.exp(p['q3_b1']*(1/(TdegK**4))*(Ua**(1/3))) + * np.exp(p['q3_b2']*(TdegK**3)*(Ua**(1/4))) + * np.exp(p['q3_b3']*(1/(TdegK**3))*(Ua**(1/3))) + * np.exp(p['q3_b4']*(TdegK**2)*(Ua**(1/4))) + ) + q5 = np.abs( + p['q5_b0'] + + p['q5_b1']*dod + + p['q5_b2']*np.exp((dod**2)*(Crate**3)) + ) + q7 = np.abs( + p['q7_b0'] + * skewnormpdf(soc, p['q7_soc_skew'], p['q7_soc_width']) + * skewnormpdf(dod, p['q7_dod_skew'], p['q7_dod_width']) + * sigmoid(dod, 1, p['q7_dod_growth'], 1) + ) + k_temp_r_cal = ( + p['k_ref_r_cal'] + * np.exp((-p['Ea_r_cal'] / 8.3144) * (1/TdegK - 1/298.15)) + ) + k_soc_r_cal = p['C_r_cal'] * (soc - 0.5)**3 + p['D_r_cal'] + k_Crate_r_cyc = p['A_r_cyc'] * Crate + p['B_r_cyc'] + k_dod_r_cyc = p['C_r_cyc']* (dod - 0.5)**3 + p['D_r_cyc'] + + # Calculate time based average of each rate + q1 = np.trapz(q1, x=t_secs) / delta_t_secs + q3 = np.trapz(q3, x=t_secs) / delta_t_secs + #q5 = np.trapz(q5, x=t_secs) / delta_t_secs # no time varying inputs + q7 = np.trapz(q7, x=t_secs) / delta_t_secs # no time varying inputs + k_temp_r_cal = np.trapz(k_temp_r_cal, x=t_secs) / delta_t_secs + k_soc_r_cal = np.trapz(k_soc_r_cal, x=t_secs) / delta_t_secs # no time varying inputs + #k_Crate_r_cyc = np.trapz(k_Crate_r_cyc, x=t_secs) / delta_t_secs # no time varying inputs + #k_dod_r_cyc = np.trapz(k_dod_r_cyc, x=t_secs) / delta_t_secs # no time varying inputs + + # Calculate incremental state changes + states = self.states + # Capacity + dq_LLI_t = update_sigmoid_state(states['qLoss_LLI_t'][-1], delta_t_days, q1, p['q2'], q3) + dq_LLI_EFC = update_power_B_state(states['qLoss_LLI_EFC'][-1], delta_efc, q5, p['q6']) + if delta_efc / delta_t_days > 2: # only evalaute if more than 2 full cycles per day + dq_BreakIn_EFC = update_sigmoid_state(states['qLoss_BreakIn_EFC'][-1], delta_efc, q7, p['q8'], p['q9']) + else: + dq_BreakIn_EFC = 0 + + # Resistance + dr_LLI_t = k_temp_r_cal * k_soc_r_cal * delta_t_secs + dr_LLI_EFC = k_Crate_r_cyc * k_dod_r_cyc * delta_efc / 100 + + # Accumulate and store states + dx = np.array([dq_LLI_t, dq_LLI_EFC, dq_BreakIn_EFC, dr_LLI_t, dr_LLI_EFC]) + for k, v in zip(states.keys(), dx): + x = self.states[k][-1] + v + self.states[k] = np.append(self.states[k], x) + + # Store stressors + t_days = self.stressors['t_days'][-1] + delta_t_days + efc = self.stressors['efc'][-1] + delta_efc + stressors = np.array([delta_t_days, t_days, delta_efc, efc, np.mean(TdegK), np.mean(soc), np.mean(Ua), dod, Crate]) + for k, v in zip(self.stressors.keys(), stressors): + self.stressors[k] = np.append(self.stressors[k], v) + + # Store rates + rates = np.array([q1, q3, q5, q7, k_temp_r_cal * k_soc_r_cal, k_Crate_r_cyc * k_dod_r_cyc]) + for k, v in zip(self.rates.keys(), rates): + self.rates[k] = np.append(self.rates[k], v) + + def __update_outputs(self): + # Calculate outputs, based on current battery state + states = self.states + p = self._params_life + + # Capacity + q_LLI_t = 1 - states['qLoss_LLI_t'][-1] + q_LLI_EFC = 1 - states['qLoss_LLI_EFC'][-1] + q_BreakIn_EFC = 1 - states['qLoss_BreakIn_EFC'][-1] + q = 1 - states['qLoss_LLI_t'][-1] - states['qLoss_LLI_EFC'][-1] - states['qLoss_BreakIn_EFC'][-1] + + # Resistance + r_LLI_t = 1 + states['rGain_LLI_t'][-1] + r_LLI_EFC = 1 + states['rGain_LLI_EFC'][-1] + r = 1 + states['rGain_LLI_t'][-1] + states['rGain_LLI_EFC'][-1] + + # Assemble output + out = np.array([q, q_LLI_t, q_LLI_EFC, q_BreakIn_EFC, r, r_LLI_t, r_LLI_EFC]) + # Store results + for k, v in zip(list(self.outputs.keys()), out): + self.outputs[k] = np.append(self.outputs[k], v) + +def sigmoid(x, alpha, beta, gamma): + return 2*alpha*(1/2 - 1/(1 + np.exp((beta*x)**gamma))) + +def skewnormpdf(x, skew, width): + x_prime = (x-0.5)/width + return 2 * stats.norm.pdf(x_prime) * stats.norm.cdf(skew * (x_prime)) \ No newline at end of file diff --git a/lmo_gr_NissanLeaf66Ah_2ndLife_2020.py b/lmo_gr_NissanLeaf66Ah_2ndLife_2020.py new file mode 100644 index 0000000..900ba9f --- /dev/null +++ b/lmo_gr_NissanLeaf66Ah_2ndLife_2020.py @@ -0,0 +1,159 @@ +# Paul Gasper, NREL +# This model is fit to SECOND LIFE data on Nissan Leaf half-modules (2p cells) by Braco et al. +# https://doi.org/10.1109/EEEIC/ICPSEUROPE54979.2022.9854784 (calendar aging data) +# https://doi.org/10.1016/j.est.2020.101695 (cycle aging data) +# Note that these cells are already hugely degraded, starting out at an average relative capacity +# of 70%. So the model reports q and qNew, where qNew is relative to initial + +import numpy as np +from functions.extract_stressors import extract_stressors +from functions.state_functions import update_power_state + +# EXPERIMENTAL AGING DATA SUMMARY: +# Calendar aging widely varied SOC and temperature. +# Cycle aging is only at a single condition (25 Celsius, 100% DOD, 1C-1C). + +# MODEL SENSITIVITY +# The model predicts degradation rate versus time as a function of temperature and average +# state-of-charge and degradation rate is only a function equivalent full cycles. + +# MODEL LIMITATIONS +# Cycling degradation IS ONLY A FUNCTION OF CHARGE THROUGHPUT due to limited aging data. +# Cycling degradation predictions ARE ONLY VALID NEAR 25 CELSIUS, 100% DOD, 1 C CHARGE/DISCHARGE RATE. + +class Lmo_Gr_NissanLeaf66Ah_2ndLife_Battery: + + def __init__(self): + # States: Internal states of the battery model + self.states = { + 'qLoss_t': np.array([0]), + 'qLoss_EFC': np.array([0]), + } + + # Outputs: Battery properties derived from state values + self.outputs = { + 'q': np.array([1]), + 'q_t': np.array([1]), + 'q_EFC': np.array([1]), + 'qNew': np.array([0.7]), + } + + # Stressors: History of stressors on the battery + self.stressors = { + 'delta_t_days': np.array([np.nan]), + 't_days': np.array([0]), + 'delta_efc': np.array([np.nan]), + 'efc': np.array([0]), + 'TdegK': np.array([np.nan]), + 'soc': np.array([np.nan]), + } + + # Rates: History of stressor-dependent degradation rates + self.rates = { + 'k_cal': np.array([np.nan]), + } + + # Nominal capacity + @property + def _cap_2ndLife(self): + return 46 + + @property + def _cap(self): + return 66 + + # Define life model parameters + @property + def _params_life(self): + return { + # Capacity fade parameters + 'qcal_A': 3.25e+08, + 'qcal_B': -7.58e+03, + 'qcal_C': 162, + 'qcal_p': 0.464, + 'qcyc_A': 7.58e-05, + 'qcyc_p': 1.08, + } + + # Battery model + def update_battery_state(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Check some input types: + if not isinstance(t_secs, np.ndarray): + raise TypeError('Input "t_secs" must be a numpy.ndarray') + if not isinstance(soc, np.ndarray): + raise TypeError('Input "soc" must be a numpy.ndarray') + if not isinstance(T_celsius, np.ndarray): + raise TypeError('Input "T_celsius" must be a numpy.ndarray') + if not (len(t_secs) == len(soc) and len(t_secs) == len(T_celsius)): + raise ValueError('All input timeseries must be the same length') + + self.__update_states(t_secs, soc, T_celsius) + self.__update_outputs() + + def __update_states(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Extract stressors + delta_t_secs = t_secs[-1] - t_secs[0] + delta_t_days, delta_efc, TdegK, soc, Ua, dod, Crate, cycles = extract_stressors(t_secs, soc, T_celsius) + + # Grab parameters + p = self._params_life + + # Calculate the degradation coefficients + k_cal = p['qcal_A'] * np.exp(p['qcal_B']/TdegK) * np.exp(p['qcal_C']*soc/TdegK) + + # Calculate time based average of each rate + k_cal = np.trapz(k_cal, x=t_secs) / delta_t_secs + + # Calculate incremental state changes + states = self.states + # Capacity + dq_t = update_power_state(states['qLoss_t'][-1], delta_t_days, k_cal, p['qcal_p']) + dq_EFC = update_power_state(states['qLoss_EFC'][-1], delta_efc, p['qcyc_A'], p['qcyc_p']) + + # Accumulate and store states + dx = np.array([dq_t, dq_EFC]) + for k, v in zip(states.keys(), dx): + x = self.states[k][-1] + v + self.states[k] = np.append(self.states[k], x) + + # Store stressors + t_days = self.stressors['t_days'][-1] + delta_t_days + efc = self.stressors['efc'][-1] + delta_efc + stressors = np.array([delta_t_days, t_days, delta_efc, efc, np.mean(TdegK), np.mean(soc)]) + for k, v in zip(self.stressors.keys(), stressors): + self.stressors[k] = np.append(self.stressors[k], v) + + # Store rates + rates = np.array([k_cal]) + for k, v in zip(self.rates.keys(), rates): + self.rates[k] = np.append(self.rates[k], v) + + def __update_outputs(self): + # Calculate outputs, based on current battery state + states = self.states + + # Capacity + q_t = 1 - states['qLoss_t'][-1] + q_EFC = 1 - states['qLoss_EFC'][-1] + q = 1 - states['qLoss_t'][-1] - states['qLoss_EFC'][-1] + qNew = 0.7 * q + + # Assemble output + out = np.array([q, q_t, q_EFC, qNew]) + # Store results + for k, v in zip(list(self.outputs.keys()), out): + self.outputs[k] = np.append(self.outputs[k], v) \ No newline at end of file diff --git a/nca_gr_Panasonic3Ah_2018.py b/nca_gr_Panasonic3Ah_2018.py new file mode 100644 index 0000000..baa8df8 --- /dev/null +++ b/nca_gr_Panasonic3Ah_2018.py @@ -0,0 +1,169 @@ +# Paul Gasper, NREL +# This model is fit to Panasonic 18650B NCA-Gr cells. +# Calendar data is reported by Keil et al (https://dx.doi.org/10.1149/2.0411609jes) +# Cycling data is reported by Preger et al (https://doi.org/10.1149/1945-7111/abae37) and +# is available at batteryarchive.com. +# I'm not aware of any study conducting both calendar aging and cycle aging of these cells. + +import numpy as np +from functions.extract_stressors import extract_stressors +from functions.state_functions import update_power_state + +# EXPERIMENTAL AGING DATA SUMMARY: +# Calendar aging widely varied SOC at 25, 40, and 50 Celsius. 300 days max. +# Cycle aging varied temperature and C-rates, and DOD. Some accelerating fade is observed +# at room temperature and high DODs but isn't modeled well here. That's not a huge problem, +# because the modeled lifetime is quite short anyways. + +# MODEL SENSITIVITY +# The model predicts degradation rate versus time as a function of temperature and average +# state-of-charge and degradation rate versus equivalent full cycles (charge-throughput) as +# a function of C-rate, temperature, and depth-of-discharge (DOD dependence is assumed to be linear, no aging data) + +# MODEL LIMITATIONS +# Cycle degradation predictions WILL NOT PREDICT KNEE-POINT due to limited data. +# Cycle aging is only modeled at 25, 35, and 45 Celsius, PREDICTIONS OUTSIDE THIS +# TEMPERATURE RANGE MAY BE OPTIMISTIC. + +class Nca_Gr_Panasonic3Ah_Battery: + + def __init__(self): + # States: Internal states of the battery model + self.states = { + 'qLoss_t': np.array([0]), + 'qLoss_EFC': np.array([0]), + } + + # Outputs: Battery properties derived from state values + self.outputs = { + 'q': np.array([1]), + 'q_t': np.array([1]), + 'q_EFC': np.array([1]), + } + + # Stressors: History of stressors on the battery + self.stressors = { + 'delta_t_days': np.array([np.nan]), + 't_days': np.array([0]), + 'delta_efc': np.array([np.nan]), + 'efc': np.array([0]), + 'TdegK': np.array([np.nan]), + 'soc': np.array([np.nan]), + 'dod': np.array([np.nan]), + 'Crate': np.array([np.nan]), + } + + # Rates: History of stressor-dependent degradation rates + self.rates = { + 'k_cal': np.array([np.nan]), + 'k_cyc': np.array([np.nan]), + } + + # Nominal capacity + @property + def _cap(self): + return 3.2 + + # Define life model parameters + @property + def _params_life(self): + return { + # Capacity fade parameters + 'qcal_A': 75.4, + 'qcal_B': -3.34e+03, + 'qcal_C': 353, + 'qcal_p': 0.512, + 'qcyc_A': 1.86e-06, + 'qcyc_B': 4.74e-11, + 'qcyc_C': 0.000177, + 'qcyc_D': 3.34e-11, + 'qcyc_E': 2.81e-09, + 'qcyc_p': 0.699, + } + + # Battery model + def update_battery_state(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Check some input types: + if not isinstance(t_secs, np.ndarray): + raise TypeError('Input "t_secs" must be a numpy.ndarray') + if not isinstance(soc, np.ndarray): + raise TypeError('Input "soc" must be a numpy.ndarray') + if not isinstance(T_celsius, np.ndarray): + raise TypeError('Input "T_celsius" must be a numpy.ndarray') + if not (len(t_secs) == len(soc) and len(t_secs) == len(T_celsius)): + raise ValueError('All input timeseries must be the same length') + + self.__update_states(t_secs, soc, T_celsius) + self.__update_outputs() + + def __update_states(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Extract stressors + delta_t_secs = t_secs[-1] - t_secs[0] + delta_t_days, delta_efc, TdegK, soc, Ua, dod, Crate, cycles = extract_stressors(t_secs, soc, T_celsius) + + # Grab parameters + p = self._params_life + + # Calculate the degradation coefficients + k_cal = p['qcal_A'] * np.exp(p['qcal_B']/TdegK) * np.exp(p['qcal_C']*soc/TdegK) + k_cyc = ( + (p['qcyc_A'] + p['qcyc_B']*Crate + p['qcyc_C']*dod) + * (np.exp(p['qcyc_D']/TdegK) + np.exp(-p['qcyc_E']/TdegK)) + ) + + # Calculate time based average of each rate + k_cal = np.trapz(k_cal, x=t_secs) / delta_t_secs + k_cyc = np.trapz(k_cyc, x=t_secs) / delta_t_secs + + # Calculate incremental state changes + states = self.states + # Capacity + dq_t = update_power_state(states['qLoss_t'][-1], delta_t_days, k_cal, p['qcal_p']) + dq_EFC = update_power_state(states['qLoss_EFC'][-1], delta_efc, k_cyc, p['qcyc_p']) + + # Accumulate and store states + dx = np.array([dq_t, dq_EFC]) + for k, v in zip(states.keys(), dx): + x = self.states[k][-1] + v + self.states[k] = np.append(self.states[k], x) + + # Store stressors + t_days = self.stressors['t_days'][-1] + delta_t_days + efc = self.stressors['efc'][-1] + delta_efc + stressors = np.array([delta_t_days, t_days, delta_efc, efc, np.mean(TdegK), np.mean(soc), dod, Crate]) + for k, v in zip(self.stressors.keys(), stressors): + self.stressors[k] = np.append(self.stressors[k], v) + + # Store rates + rates = np.array([k_cal, k_cyc]) + for k, v in zip(self.rates.keys(), rates): + self.rates[k] = np.append(self.rates[k], v) + + def __update_outputs(self): + # Calculate outputs, based on current battery state + states = self.states + + # Capacity + q_t = 1 - states['qLoss_t'][-1] + q_EFC = 1 - states['qLoss_EFC'][-1] + q = 1 - states['qLoss_t'][-1] - states['qLoss_EFC'][-1] + + # Assemble output + out = np.array([q, q_t, q_EFC]) + # Store results + for k, v in zip(list(self.outputs.keys()), out): + self.outputs[k] = np.append(self.outputs[k], v) \ No newline at end of file diff --git a/nmc111_gr_Kokam75Ah_2017.py b/nmc111_gr_Kokam75Ah_2017.py new file mode 100644 index 0000000..04db281 --- /dev/null +++ b/nmc111_gr_Kokam75Ah_2017.py @@ -0,0 +1,217 @@ +# Paul Gasper, NREL +import numpy as np +from functions.extract_stressors import extract_stressors +from functions.state_functions import update_power_state, update_sigmoid_state + +# EXPERIMENTAL AGING DATA SUMMARY: +# Aging test matrix varied primarly temperature, with small DOD variation. +# Calendar and cycle aging were performed between 0 and 55 Celsius. C-rates always at 1C, +# except for charging at 0 Celsius, which was conducted at C/3. Depth-of-discharge was 80% +# for nearly all tests (3.4 V - 4.1 V), with one 100% DOD test (3 V - 4.2 V). +# Reported relative capacity was measured at C/5 rate at the aging temperatures. Reported +# relative DC resistance was measured by HPPC using a 10s, 1C DC pulse, averaged between +# charge and discharge, calculated using a simple ohmic fit of the voltage response. + +# MODEL SENSITIVITY +# The model predicts degradation rate versus time as a function of temperature and average +# state-of-charge and degradation rate versus equivalent full cycles (charge-throughput) as +# a function of temperature and depth-of-discharge. Sensitivity to cycling degradation rate +# at low temperature is inferred from physical insight due to limited data. + +# MODEL LIMITATIONS +# There is NO C-RATE DEPENDENCE for degradation in this model. THIS IS NOT PHYSICALLY REALISTIC +# AND IS BASED ON LIMITED DATA. + + +class Nmc111_Gr_Kokam75Ah_Battery: + # Model predicting the degradation of a Kokam 75 Ah NMC-Gr pouch cell. + # https://ieeexplore.ieee.org/iel7/7951530/7962914/07963578.pdf + # It is uncertain if the exact NMC composition is 1-1-1, but it this is definitely not a high nickel (>80%) cell. + # Degradation rate is a function of the aging stressors, i.e., ambient temperature and use. + # The state of the battery is updated throughout the lifetime of the cell. + # Performance metrics are capacity and DC resistance. These metrics change as a function of the + # cell's current degradation state, as well as the ambient temperature. The model predicts time and + # cycling dependent degradation, using Loss of Lithium Inventory (LLI) and Loss of Active + # Material (LAM) degradation modes that interact competitively (cell performance is limited by + # one or the other.) + # Parameters to modify to change fade rates: + # Calendar capacity loss rate: q1_0 + # Cycling capacity loss rate (LLI): q3_0 + # Cycling capacity loss rate (LAM): q5_0, will also effect resistance growth onset due to LAM. + # Calendar resistance growth rate (LLI), relative to capacity loss rate: r1 + # Cycling resistance growth rate (LLI), relative to capacity loss rate: r3 + + def __init__(self): + # States: Internal states of the battery model + self.states = { + 'qLoss_LLI_t': np.array([0]), # relative Li inventory change, time dependent (SEI) + 'qLoss_LLI_EFC': np.array([0]), # relative Li inventory change, charge-throughput dependent (SEI) + 'qLoss_LAM': np.array([1e-8]), # relative active material change, charge-throughput dependent (electrode damage) + 'rGain_LLI_t': np.array([0]), # relative SEI growth, time dependent (SEI) + 'rGain_LLI_EFC': np.array([0]), # relative SEI growth, charge-throughput dependent (SEI) + } + + # Outputs: Battery properties derived from state values + self.outputs = { + 'q': np.array([1]), # relative capacity + 'q_LLI': np.array([1]), # relative lithium inventory + 'q_LLI_t': np.array([1]), # relative lithium inventory, time dependent loss + 'q_LLI_EFC': np.array([1]), # relative lithium inventory, charge-throughput dependent loss + 'q_LAM': np.array([1.01]), # relative active material, charge-throughput dependent loss + 'r': np.array([1]), # relative resistance + 'r_LLI': np.array([1]), # relative SEI resistance + 'r_LLI_t': np.array([1]), # relative SEI resistance, time dependent growth + 'r_LLI_EFC': np.array([1]), # relative SEI resistance, charge-throughput dependent growth + 'r_LAM': np.array([1]), # relative electrode resistance, q_LAM dependent growth + } + + # Stressors: History of stressors on the battery + self.stressors = { + 'delta_t_days': np.array([np.nan]), + 't_days': np.array([0]), + 'delta_efc': np.array([np.nan]), + 'efc': np.array([0]), + 'TdegK': np.array([np.nan]), + 'soc': np.array([np.nan]), + 'Ua': np.array([np.nan]), + 'dod': np.array([np.nan]), + } + + # Rates: History of stressor-dependent degradation rates + self.rates = { + 'q1': np.array([np.nan]), + 'q3': np.array([np.nan]), + 'q5': np.array([np.nan]), + } + + # Nominal capacity + @property + def _cap(self): + return 75 + + # Define life model parameters + @property + def _params_life(self): + return { + 'q1_0' : 2.66e7, # CHANGE to modify calendar degradation rate (larger = faster degradation) + 'q1_1' : -17.8, + 'q1_2' : -5.21, + 'q2' : 0.357, + 'q3_0' : 3.80e3, # CHANGE to modify cycling degradation rate (LLI) (larger = faster degradation) + 'q3_1' : -18.4, + 'q3_2' : 1.04, + 'q4' : 0.778, + 'q5_0' : 1e4, # CHANGE to modify cycling degradation rate (LAM) (accelerating fade onset) (larger = faster degradation) + 'q5_1' : 153, + 'p_LAM' : 10, + 'r1' : 0.0570, # CHANGE to modify change of resistance relative to change of capacity (calendar degradation) + 'r2' : 1.25, + 'r3' : 4.87, # CHANGE to modify change of resistance relative to change of capacity (cycling degradation) + 'r4' : 0.712, + 'r5' : -0.08, + 'r6' : 1.09, + } + + # Battery model + def update_battery_state(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Check some input types: + if not isinstance(t_secs, np.ndarray): + raise TypeError('Input "t_secs" must be a numpy.ndarray') + if not isinstance(soc, np.ndarray): + raise TypeError('Input "soc" must be a numpy.ndarray') + if not isinstance(T_celsius, np.ndarray): + raise TypeError('Input "T_celsius" must be a numpy.ndarray') + if not (len(t_secs) == len(soc) and len(t_secs) == len(T_celsius)): + raise ValueError('All input timeseries must be the same length') + + self.__update_states(t_secs, soc, T_celsius) + self.__update_outputs() + + def __update_states(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Extract stressors + delta_t_secs = t_secs[-1] - t_secs[0] + delta_t_days, delta_efc, TdegK, soc, Ua, dod, Crate, cycles = extract_stressors(t_secs, soc, T_celsius) + TdegC = TdegK - 273.15 + TdegKN = TdegK / (273.15 + 35) # normalized temperature + UaN = Ua / 0.123 # normalized anode-to-reference potential + + + # Grab parameters + p = self._params_life + + # Calculate degradation rates + q1 = p['q1_0'] * np.exp(p['q1_1'] * (1 / TdegKN)) * np.exp(p['q1_2'] * (UaN / TdegKN)) + q3 = p['q3_0'] * np.exp(p['q3_1'] * (1/TdegKN)) * np.exp(p['q3_2'] * np.exp(dod**2)) + q5 = p['q5_0'] + p['q5_1'] * (TdegC - 55) * dod + # Calculate time based average of each rate + q1 = np.trapz(q1, x=t_secs) / delta_t_secs + q3 = np.trapz(q3, x=t_secs) / delta_t_secs + q5 = np.trapz(q5, x=t_secs) / delta_t_secs + + # Calculate incremental state changes + states = self.states + # Capacity + dq_LLI_t = update_power_state(states['qLoss_LLI_t'][-1], delta_t_days, 2*q1, p['q2']) + dq_LLI_EFC = update_power_state(states['qLoss_LLI_EFC'][-1], delta_efc, q3, p['q4']) + dq_LAM = update_sigmoid_state(states['qLoss_LAM'][-1], delta_efc, 1, 1/q5, p['p_LAM']) + + # Resistance + dr_LLI_t = update_power_state(states['rGain_LLI_t'][-1], delta_t_days, p['r1']*q1, p['r2']) + dr_LLI_EFC = update_power_state(states['rGain_LLI_EFC'][-1], delta_efc, p['r3']*q3, p['r4']) + + # Accumulate and store states + dx = np.array([dq_LLI_t, dq_LLI_EFC, dq_LAM, dr_LLI_t, dr_LLI_EFC]) + for k, v in zip(states.keys(), dx): + x = self.states[k][-1] + v + self.states[k] = np.append(self.states[k], x) + + # Store stressors + t_days = self.stressors['t_days'][-1] + delta_t_days + efc = self.stressors['efc'][-1] + delta_efc + stressors = np.array([delta_t_days, t_days, delta_efc, efc, np.mean(TdegK), np.mean(soc), np.mean(Ua), dod]) + for k, v in zip(self.stressors.keys(), stressors): + self.stressors[k] = np.append(self.stressors[k], v) + + # Store rates + rates = np.array([q1, q3, q5]) + for k, v in zip(self.rates.keys(), rates): + self.rates[k] = np.append(self.rates[k], v) + + def __update_outputs(self): + # Calculate outputs, based on current battery state + states = self.states + p = self._params_life + + # Capacity + q_LLI = 1 - states['qLoss_LLI_t'][-1] - states['qLoss_LLI_EFC'][-1] + q_LLI_t = 1 - states['qLoss_LLI_t'][-1] + q_LLI_EFC = 1 - states['qLoss_LLI_EFC'][-1] + q_LAM = 1.01 - states['qLoss_LAM'][-1] + q = np.min(np.array([q_LLI, q_LAM])) + + # Resistance + r_LLI = 1 + states['rGain_LLI_t'][-1] + states['rGain_LLI_EFC'][-1] + r_LLI_t = 1 + states['rGain_LLI_t'][-1] + r_LLI_EFC = 1 + states['rGain_LLI_EFC'][-1] + r_LAM = p['r5'] + p['r6'] * (1 / q_LAM) + r = np.max(np.array([r_LLI, r_LAM])) + + # Assemble output + out = np.array([q, q_LLI, q_LLI_t, q_LLI_EFC, q_LAM, r, r_LLI, r_LLI_t, r_LLI_EFC, r_LAM]) + # Store results + for k, v in zip(list(self.outputs.keys()), out): + self.outputs[k] = np.append(self.outputs[k], v) \ No newline at end of file diff --git a/nmc111_gr_Sanyo2Ah_2014.py b/nmc111_gr_Sanyo2Ah_2014.py new file mode 100644 index 0000000..2a936c1 --- /dev/null +++ b/nmc111_gr_Sanyo2Ah_2014.py @@ -0,0 +1,225 @@ +# Paul Gasper, NREL +# This model is replicated as reported by Schmalsteig et al, J. Power Sources 257 (2014) 325-334 +# http://dx.doi.org/10.1016/j.jpowsour.2014.02.012 + +import numpy as np +from functions.extract_stressors import extract_stressors +from functions.state_functions import update_power_state + +# EXPERIMENTAL AGING DATA SUMMARY: +# Calendar aging varied SOC at 50 Celsius, and temperature at 50% state-of-charge. +# Cycle aging varied depth-of-discharge and average state-of-charge at 35 Celsius at +# charge and discharge rates of 1C. +# Relative discharge capacity is reported from measurements recorded at 35 Celsius and 1C rate. +# Relative DC resistance is reported after fitting of 10s 1C discharge pulses near 50% state-of-charge. + +# MODEL SENSITIVITY +# The model predicts degradation rate versus time as a function of temperature and average +# state-of-charge and degradation rate versus equivalent full cycles (charge-throughput) as +# a function of average voltage and depth-of-discharge. + +# MODEL LIMITATIONS +# Cycle degradation predictions are NOT SENSITIVE TO TEMPERATURE OR C-RATE. Cycling degradation predictions +# are ONLY ACCURATE NEAR 1C RATE AND 35 CELSIUS CELL TEMPERATURE. + +class Nmc111_Gr_Sanyo2Ah_Battery: + # Model predicting the degradation of Sanyo UR18650E cells, published by Schmalsteig et al: + # http://dx.doi.org/10.1016/j.jpowsour.2014.02.012. + # More detailed analysis of cell performance and voltage vs. state-of-charge data was copied from + # Ecker et al: http://dx.doi.org/10.1016/j.jpowsour.2013.09.143 (KNEE POINTS OBSERVED IN ECKER ET AL + # AT HIGH DEPTH OF DISCHARGE WERE SIMPLY NOT ADDRESSED DURING MODEL FITTING BY SCHMALSTEIG ET AL). + # Voltage lookup table here use data from Ecker et al for 0/10% SOC, and other values were extracted + # from Figure 1 in Schmalsteig et al using WebPlotDigitizer. + + def __init__(self): + # States: Internal states of the battery model + self.states = { + 'qLoss_t': np.array([0]), + 'qLoss_EFC': np.array([0]), + 'rGain_t': np.array([0]), + 'rGain_EFC': np.array([0]), + } + + # Outputs: Battery properties derived from state values + self.outputs = { + 'q': np.array([1]), + 'q_t': np.array([1]), + 'q_EFC': np.array([1]), + 'r': np.array([1]), + 'r_t': np.array([1]), + 'r_EFC': np.array([1]), + } + + # Stressors: History of stressors on the battery + self.stressors = { + 'delta_t_days': np.array([np.nan]), + 't_days': np.array([0]), + 'delta_efc': np.array([np.nan]), + 'efc': np.array([0]), + 'TdegK': np.array([np.nan]), + 'soc': np.array([np.nan]), + 'Vrms': np.array([np.nan]), + 'dod': np.array([np.nan]), + } + + # Rates: History of stressor-dependent degradation rates + self.rates = { + 'q_alpha': np.array([np.nan]), + 'q_beta': np.array([np.nan]), + 'r_alpha': np.array([np.nan]), + 'r_beta': np.array([np.nan]), + } + + # Nominal capacity + @property + def _cap(self): + return 2.15 + + # SOC index + @property + def _soc_index(self): + return np.array([0,0.008637153,0.026779514,0.044921875,0.063064236,0.081206597,0.099348958,0.117491319,0.135633681,0.153776042,0.171918403,0.190060764,0.208203125,0.226345486,0.244487847,0.262630208,0.280772569,0.298914931,0.317057292,0.335199653,0.353342014,0.371484375,0.389626736,0.407769097,0.425911458,0.444053819,0.462196181,0.480338542,0.498480903,0.516623264,0.534765625,0.552907986,0.571050347,0.589192708,0.607335069,0.625477431,0.643619792,0.661762153,0.679904514,0.698046875,0.716189236,0.734331597,0.752473958,0.770616319,0.788758681,0.806901042,0.825043403,0.843185764,0.861328125,0.879470486,0.897612847,0.915755208,0.933897569,0.952039931,0.970182292,0.988324653,0.998220486,1]) + + # OCV + @property + def _ocv(self): + return np.array([3.331,3.345014187,3.37917149,3.411603677,3.440585632,3.466289865,3.490268982,3.511315401,3.529946658,3.547197821,3.561688798,3.574972194,3.586357962,3.597053683,3.605506753,3.613442288,3.620342753,3.626380661,3.632073544,3.63690387,3.642079219,3.646909545,3.652084894,3.657605266,3.663470662,3.670198615,3.677444104,3.686759732,3.696420384,3.708323686,3.720572012,3.734372943,3.749553967,3.765252525,3.781123596,3.797857224,3.814590852,3.832532062,3.849783226,3.866861877,3.884458064,3.900846669,3.917752809,3.934831461,3.953462717,3.971921462,3.991415276,4.011771649,4.03195551,4.05196686,4.070770628,4.087849279,4.104237884,4.120108955,4.135980025,4.152541142,4.160649189,4.162]) + + # Voltage lookup table + def calc_voltage(self, soc): + # calculate cell voltage from soc vector + return np.interp(soc, self._soc_index, self._ocv, left=self._ocv[0], right=self._ocv[-1]) + + # Define life model parameters + @property + def _params_life(self): + return { + # Capacity fade parameters + 'qcal_A_V': 7.543, + 'qcal_B_V': -23.75, + 'qcal_C_TdegK': -6976, + 'qcal_p': 0.75, + 'qcyc_A_V': 7.348e-3, + 'qcyc_B_V': 3.667, + 'qcyc_C': 7.6e-4, + 'qcyc_D_DOD': 4.081e-3, + 'qcyc_p': 0.5, + + # Resistance growth parameters + 'rcal_A_V': 5.270, + 'rcal_B_V': -16.32, + 'rcal_C_TdegK': -5986, + 'rcal_p': 0.75, + 'rcyc_A_V': 2.153e-4, + 'rcyc_B_V': 3.725, + 'rcyc_C': -1.521e-5, + 'rcyc_D_DOD': 2.798e-4, + } + + # Battery model + def update_battery_state(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Check some input types: + if not isinstance(t_secs, np.ndarray): + raise TypeError('Input "t_secs" must be a numpy.ndarray') + if not isinstance(soc, np.ndarray): + raise TypeError('Input "soc" must be a numpy.ndarray') + if not isinstance(T_celsius, np.ndarray): + raise TypeError('Input "T_celsius" must be a numpy.ndarray') + if not (len(t_secs) == len(soc) and len(t_secs) == len(T_celsius)): + raise ValueError('All input timeseries must be the same length') + + self.__update_states(t_secs, soc, T_celsius) + self.__update_outputs() + + def __update_states(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Extract stressors + delta_t_secs = t_secs[-1] - t_secs[0] + delta_t_days, delta_efc, TdegK, soc, Ua, dod, Crate, cycles = extract_stressors(t_secs, soc, T_celsius) + # Calculate RMS voltage, charge throughput + V_rms = np.sqrt(np.mean(self.calc_voltage(soc)**2)) + Ah_throughput = delta_efc * 2 * self._cap + + # Grab parameters + p = self._params_life + + # Calculate the degradation coefficients + alpha_cap = (p['qcal_A_V'] * self.calc_voltage(soc) + p['qcal_B_V']) * 1e6 * np.exp(p['qcal_C_TdegK'] / TdegK) + alpha_res = (p['rcal_A_V'] * self.calc_voltage(soc) + p['rcal_B_V']) * 1e5 * np.exp(p['rcal_C_TdegK'] / TdegK) + beta_cap = ( + p['qcyc_A_V'] * (V_rms - p['qcyc_B_V']) ** 2 + + p['qcyc_C'] + + p['qcyc_D_DOD'] * dod + ) + beta_res = ( + p['rcyc_A_V'] * (V_rms - p['rcyc_B_V']) ** 2 + + p['rcyc_C'] + + p['rcyc_D_DOD'] * dod + ) + + # Calculate time based average of each rate + alpha_cap = np.trapz(alpha_cap, x=t_secs) / delta_t_secs + alpha_res = np.trapz(alpha_res, x=t_secs) / delta_t_secs + + # Calculate incremental state changes + states = self.states + # Capacity + dq_t = update_power_state(states['qLoss_t'][-1], delta_t_days, alpha_cap, p['qcal_p']) + dq_EFC = update_power_state(states['qLoss_EFC'][-1], Ah_throughput, beta_cap, p['qcyc_p']) + # Resistance + dr_t = update_power_state(states['rGain_t'][-1], delta_t_days, alpha_res, p['rcal_p']) + dr_EFC = beta_res * Ah_throughput + + # Accumulate and store states + dx = np.array([dq_t, dq_EFC, dr_t, dr_EFC]) + for k, v in zip(states.keys(), dx): + x = self.states[k][-1] + v + self.states[k] = np.append(self.states[k], x) + + # Store stressors + t_days = self.stressors['t_days'][-1] + delta_t_days + efc = self.stressors['efc'][-1] + delta_efc + stressors = np.array([delta_t_days, t_days, delta_efc, efc, np.mean(TdegK), np.mean(soc), V_rms, dod]) + for k, v in zip(self.stressors.keys(), stressors): + self.stressors[k] = np.append(self.stressors[k], v) + + # Store rates + rates = np.array([alpha_cap, beta_cap, alpha_res, beta_res]) + for k, v in zip(self.rates.keys(), rates): + self.rates[k] = np.append(self.rates[k], v) + + def __update_outputs(self): + # Calculate outputs, based on current battery state + states = self.states + p = self._params_life + + # Capacity + q_t = 1 - states['qLoss_t'][-1] + q_EFC = 1 - states['qLoss_EFC'][-1] + q = 1 - states['qLoss_t'][-1] - states['qLoss_EFC'][-1] + + # Resistance + r_t = 1 + states['rGain_t'][-1] + r_EFC = 1 + states['rGain_EFC'][-1] + r = 1 + states['rGain_t'][-1] + states['rGain_EFC'][-1] + + # Assemble output + out = np.array([q, q_t, q_EFC, r, r_t, r_EFC]) + # Store results + for k, v in zip(list(self.outputs.keys()), out): + self.outputs[k] = np.append(self.outputs[k], v) + + diff --git a/nmc811_grSi_LGMJ1_4Ah_2020.py b/nmc811_grSi_LGMJ1_4Ah_2020.py new file mode 100644 index 0000000..d3b4ca1 --- /dev/null +++ b/nmc811_grSi_LGMJ1_4Ah_2020.py @@ -0,0 +1,166 @@ +# Paul Gasper, NREL +# This model is fit to LG MJ1 cell aging data reported as part of the EU EVERLASTING battery project, report D2.3 +# https://everlasting-project.eu/wp-content/uploads/2020/03/EVERLASTING_D2.3_final_20200228.pdf +# Cell tests were reported in early 2020, so likely 2018 or 2019 LG MJ1 cells. + +import numpy as np +from functions.extract_stressors import extract_stressors +from functions.state_functions import update_power_state + +# EXPERIMENTAL AGING DATA SUMMARY: +# Calendar aging varied SOC (10%, 70%, 90%) and temperature. +# Cycle aging varied temperature and C-rates; all DOD is 80% (10%-90%). NO ACCELERATED FADE OBSERVED. +# Relative discharge capacity is reported from measurements recorded at 25 Celsius and C/20 rate. + +# MODEL SENSITIVITY +# The model predicts degradation rate versus time as a function of temperature and average +# state-of-charge and degradation rate versus equivalent full cycles (charge-throughput) as +# a function of C-rate, temperature, and depth-of-discharge (DOD dependence is assumed to be linear, no aging data) + +# MODEL LIMITATIONS +# Cycle degradation predictions WILL NOT PREDICT KNEE-POINT due to limited data. +# OPERATION AT HIGH DOD PREDCTIONS ARE LIKELY INACCURATE (it is unclear what voltage window corresponds to SOCs defined in the test data). +# NMC811 is known to degrade quickly at voltages above 4.1 V. + +class Nmc811_GrSi_LGMJ1_4Ah_Battery: + + def __init__(self): + # States: Internal states of the battery model + self.states = { + 'qLoss_t': np.array([0]), + 'qLoss_EFC': np.array([0]), + } + + # Outputs: Battery properties derived from state values + self.outputs = { + 'q': np.array([1]), + 'q_t': np.array([1]), + 'q_EFC': np.array([1]), + } + + # Stressors: History of stressors on the battery + self.stressors = { + 'delta_t_days': np.array([np.nan]), + 't_days': np.array([0]), + 'delta_efc': np.array([np.nan]), + 'efc': np.array([0]), + 'TdegK': np.array([np.nan]), + 'soc': np.array([np.nan]), + 'dod': np.array([np.nan]), + 'Crate': np.array([np.nan]), + } + + # Rates: History of stressor-dependent degradation rates + self.rates = { + 'k_cal': np.array([np.nan]), + 'k_cyc': np.array([np.nan]), + } + + # Nominal capacity + @property + def _cap(self): + return 3.5 + + # Define life model parameters + @property + def _params_life(self): + return { + # Capacity fade parameters + 'qcal_A': 0.0353, + 'qcal_B': -1.03e+03, + 'qcal_C': 57.7, + 'qcal_p': 0.743, + 'qcyc_A': 1.77e-07, + 'qcyc_B': 8.08e-13, + 'qcyc_C': 2.21e-07, + 'qcyc_D': 2.25e+03, + 'qcyc_E': 1.14e+04, + 'qcyc_p': 0.695, + } + + # Battery model + def update_battery_state(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Check some input types: + if not isinstance(t_secs, np.ndarray): + raise TypeError('Input "t_secs" must be a numpy.ndarray') + if not isinstance(soc, np.ndarray): + raise TypeError('Input "soc" must be a numpy.ndarray') + if not isinstance(T_celsius, np.ndarray): + raise TypeError('Input "T_celsius" must be a numpy.ndarray') + if not (len(t_secs) == len(soc) and len(t_secs) == len(T_celsius)): + raise ValueError('All input timeseries must be the same length') + + self.__update_states(t_secs, soc, T_celsius) + self.__update_outputs() + + def __update_states(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Extract stressors + delta_t_secs = t_secs[-1] - t_secs[0] + delta_t_days, delta_efc, TdegK, soc, Ua, dod, Crate, cycles = extract_stressors(t_secs, soc, T_celsius) + + # Grab parameters + p = self._params_life + + # Calculate the degradation coefficients + k_cal = p['qcal_A'] * np.exp(p['qcal_B']/TdegK) * np.exp(p['qcal_C']*soc/TdegK) + k_cyc = ( + (p['qcyc_A'] + p['qcyc_B']*Crate + p['qcyc_C']*dod) + * (np.exp(p['qcyc_D']/TdegK) + np.exp(-p['qcyc_E']/TdegK)) + ) + + # Calculate time based average of each rate + k_cal = np.trapz(k_cal, x=t_secs) / delta_t_secs + k_cyc = np.trapz(k_cyc, x=t_secs) / delta_t_secs + + # Calculate incremental state changes + states = self.states + # Capacity + dq_t = update_power_state(states['qLoss_t'][-1], delta_t_days, k_cal, p['qcal_p']) + dq_EFC = update_power_state(states['qLoss_EFC'][-1], delta_efc, k_cyc, p['qcyc_p']) + + # Accumulate and store states + dx = np.array([dq_t, dq_EFC]) + for k, v in zip(states.keys(), dx): + x = self.states[k][-1] + v + self.states[k] = np.append(self.states[k], x) + + # Store stressors + t_days = self.stressors['t_days'][-1] + delta_t_days + efc = self.stressors['efc'][-1] + delta_efc + stressors = np.array([delta_t_days, t_days, delta_efc, efc, np.mean(TdegK), np.mean(soc), dod, Crate]) + for k, v in zip(self.stressors.keys(), stressors): + self.stressors[k] = np.append(self.stressors[k], v) + + # Store rates + rates = np.array([k_cal, k_cyc]) + for k, v in zip(self.rates.keys(), rates): + self.rates[k] = np.append(self.rates[k], v) + + def __update_outputs(self): + # Calculate outputs, based on current battery state + states = self.states + + # Capacity + q_t = 1 - states['qLoss_t'][-1] + q_EFC = 1 - states['qLoss_EFC'][-1] + q = 1 - states['qLoss_t'][-1] - states['qLoss_EFC'][-1] + + # Assemble output + out = np.array([q, q_t, q_EFC]) + # Store results + for k, v in zip(list(self.outputs.keys()), out): + self.outputs[k] = np.append(self.outputs[k], v) \ No newline at end of file diff --git a/nmc_lto_10Ah_2020.py b/nmc_lto_10Ah_2020.py new file mode 100644 index 0000000..c644595 --- /dev/null +++ b/nmc_lto_10Ah_2020.py @@ -0,0 +1,177 @@ +# Paul Gasper, NREL +# This model is fit to data reported by Bank et al from commercial NMC-LTO cells. +# https://doi.org/10.1016/j.jpowsour.2020.228566 + +import numpy as np +from functions.extract_stressors import extract_stressors +from functions.state_functions import update_power_state + +# EXPERIMENTAL AGING DATA SUMMARY: +# Calendar aging varies temperature and SOC. There is almost no calendar aging impact +# at all until 80 Celsius. +# Cycle aging varies temperature, C-rate, and depth-of-discharge. + +# MODEL SENSITIVITY +# The model predicts degradation rate versus time as a function of temperature and average +# state-of-charge and degradation rate versus equivalent full cycles (charge-throughput) as +# a function of C-rate, temperature, and depth-of-discharge (DOD dependence is assumed to be linear, no aging data) + +# MODEL LIMITATIONS +# Calendar aging has competition between capacity gain and capacity loss. There is an experimental +# case (80 Celsius, 5% SOC) that has complex behavior not modeled here. +# Astonishingly enough, the cycling degradation model is actually _overestimating_ capacity fade for most cases. +# The exception here is at very high temperature (60+ Celsius), where the fade is high, but not quite as high as observed degradation. + +class Nmc_Lto_10Ah_Battery: + + def __init__(self): + # States: Internal states of the battery model + self.states = { + 'qLoss_t': np.array([0]), + 'qGain_t': np.array([0]), + 'qLoss_EFC': np.array([0]), + } + + # Outputs: Battery properties derived from state values + self.outputs = { + 'q': np.array([1]), + 'q_t_loss': np.array([1]), + 'q_t_gain': np.array([1]), + 'q_EFC': np.array([1]), + } + + # Stressors: History of stressors on the battery + self.stressors = { + 'delta_t_days': np.array([np.nan]), + 't_days': np.array([0]), + 'delta_efc': np.array([np.nan]), + 'efc': np.array([0]), + 'TdegK': np.array([np.nan]), + 'soc': np.array([np.nan]), + 'dod': np.array([np.nan]), + 'Crate': np.array([np.nan]), + } + + # Rates: History of stressor-dependent degradation rates + self.rates = { + 'alpha': np.array([np.nan]), + 'beta': np.array([np.nan]), + 'gamma': np.array([np.nan]), + } + + # Nominal capacity + @property + def _cap(self): + return 10.2 + + # Define life model parameters + @property + def _params_life(self): + return { + # Capacity fade parameters + 'alpha_0': 3.11e+11, + 'alpha_1': -34.8, + 'alpha_2': 1.07, + 'alpha_p': 0.473, + 'beta_0': 7.86e+10, + 'beta_1': -35.8, + 'beta_2': 3.94, + 'beta_p': -0.553, + 'gamma_0': 1.29, + 'gamma_1': 7.83e-05, + 'gamma_2': 4.02, + 'gamma_3': -8.33, + 'gamma_p': 0.526, + } + + # Battery model + def update_battery_state(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Check some input types: + if not isinstance(t_secs, np.ndarray): + raise TypeError('Input "t_secs" must be a numpy.ndarray') + if not isinstance(soc, np.ndarray): + raise TypeError('Input "soc" must be a numpy.ndarray') + if not isinstance(T_celsius, np.ndarray): + raise TypeError('Input "T_celsius" must be a numpy.ndarray') + if not (len(t_secs) == len(soc) and len(t_secs) == len(T_celsius)): + raise ValueError('All input timeseries must be the same length') + + self.__update_states(t_secs, soc, T_celsius) + self.__update_outputs() + + def __update_states(self, t_secs, soc, T_celsius): + # Update the battery states, based both on the degradation state as well as the battery performance + # at the ambient temperature, T_celsius + # Inputs: + # t_secs (ndarry): vector of the time in seconds since beginning of life for the soc_timeseries data points + # soc (ndarry): vector of the state-of-charge of the battery at each t_sec + # T_celsius (ndarray): the temperature of the battery during this time period, in Celsius units. + + # Extract stressors + delta_t_secs = t_secs[-1] - t_secs[0] + delta_t_days, delta_efc, TdegK, soc, Ua, dod, Crate, cycles = extract_stressors(t_secs, soc, T_celsius) + TdegKN = TdegK / (273.15 + 45) + + # Grab parameters + p = self._params_life + + # Calculate the degradation coefficients + alpha = p['alpha_0'] * np.exp(p['alpha_1']/TdegKN) * np.exp(p['alpha_2']*soc/TdegKN) + beta = p['beta_0'] * np.exp(p['beta_1']/TdegKN) * np.exp(p['beta_2']*soc/TdegKN) + gamma = ( + (p['gamma_0'] + p['gamma_1']*Crate + p['gamma_2']*(dod**3)) + * np.exp(p['gamma_3']/TdegKN) + ) + + # Calculate time based average of each rate + alpha = np.trapz(alpha, x=t_secs) / delta_t_secs + beta = np.trapz(beta, x=t_secs) / delta_t_secs + gamma = np.trapz(gamma, x=t_secs) / delta_t_secs + + # Calculate incremental state changes + states = self.states + # Capacity + dq_t_gain = update_power_state(states['qGain_t'][-1], delta_t_days, alpha, p['alpha_p']) + dq_t_loss = update_power_state(states['qLoss_t'][-1], delta_t_days, beta, p['beta_p']) + dq_EFC = update_power_state(states['qLoss_EFC'][-1], delta_efc, gamma, p['gamma_p']) + + # Accumulate and store states + dx = np.array([dq_t_loss, dq_t_gain, dq_EFC]) + for k, v in zip(states.keys(), dx): + x = self.states[k][-1] + v + self.states[k] = np.append(self.states[k], x) + + # Store stressors + t_days = self.stressors['t_days'][-1] + delta_t_days + efc = self.stressors['efc'][-1] + delta_efc + stressors = np.array([delta_t_days, t_days, delta_efc, efc, np.mean(TdegK), np.mean(soc), dod, Crate]) + for k, v in zip(self.stressors.keys(), stressors): + self.stressors[k] = np.append(self.stressors[k], v) + + # Store rates + rates = np.array([alpha, beta, gamma]) + for k, v in zip(self.rates.keys(), rates): + self.rates[k] = np.append(self.rates[k], v) + + def __update_outputs(self): + # Calculate outputs, based on current battery state + states = self.states + + # Capacity + q_t_loss = 1 - states['qLoss_t'][-1] + q_t_gain = 1 + states['qGain_t'][-1] + q_EFC = 1 - states['qLoss_EFC'][-1] + q = 1 - states['qLoss_t'][-1] + states['qGain_t'][-1] - states['qLoss_EFC'][-1] + + # Assemble output + out = np.array([q, q_t_loss, q_t_gain, q_EFC]) + # Store results + for k, v in zip(list(self.outputs.keys()), out): + self.outputs[k] = np.append(self.outputs[k], v) \ No newline at end of file