diff --git a/examples/notebooks/change-settings.ipynb b/examples/notebooks/change-settings.ipynb index 3f4ff01350..b494ce30ea 100644 --- a/examples/notebooks/change-settings.ipynb +++ b/examples/notebooks/change-settings.ipynb @@ -28,7 +28,18 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/scott/Projects/PyBaMM/venv/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py:146: RuntimeWarning: invalid value encountered in greater_equal\n", + " up = (g <= 0) & (g_new >= 0)\n", + "/home/scott/Projects/PyBaMM/venv/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py:147: RuntimeWarning: invalid value encountered in less_equal\n", + " down = (g >= 0) & (g_new <= 0)\n" + ] + } + ], "source": [ "import pybamm\n", "import numpy as np\n", @@ -77,7 +88,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAELCAYAAAAoUKpTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXxddZ3/8dcne9JmaZp0TZO2QKF0h8giIyKCFhcQGBlw9KeD/nAcx/GnzriPLI7jOM7gjL8fD2ccB0FHkWXQKSAiQhHZCi1daKF0b9N0S7O12dPk8/vj3KRpmuSetHdN3s/H4z5y7z3nnvPhGvvO93y/5/s1d0dERGQkGckuQEREUp/CQkREolJYiIhIVAoLERGJSmEhIiJRZSW7gFgoKyvz2bNnJ7sMEZG0smbNmsPuXh5m3zERFrNnz2b16tXJLkNEJK2Y2e6w++oylIiIRKWwEBGRqBQWIiISlcJCRESiUliIiEhUCgsREYlq3IdFR3dPsksQEUl54zosfvHyHpb/y7McPNKR7FJERFLauA2LYz293PdKDbvq2/jIf66isbUr2SWJiKSscRsWWZkZ3POxt3DWlIlsOdjCx+55hZbOY8kuS0QkJY3bsACYNCGHn378Qiom5bO+polbfrJafRgiIkMY12EBMK04j5994kLKC3N5YXs9f/nztTS3dye7LBGRlDLuwwKgavIEfnLzBRTlZfG7Nw5y2XdX8tMXd3GspzfZpYmIpASFRcT86UU89Km3cuGcUhrbuvnb/9nEVf/6B1ZuPoS7J7s8EZGksrHwD2F1dbXHaopyd+eJTQf59uNvsLu+DYCFM4v49GVn8u4F08jIsJicR0Qk2cxsjbtXh9pXYTG0zmM9/PTF3fzb73dwuKUTgDPKJ/DJt5/B1UtmkJedGdPziYgkmsIihjq6e3hwdQ3/9vsd1Da1A1A2MYc/vbCKP72okimFeXE5r4hIvCks4qC7p5cV6/bxn8/t5PX9RwDIzjTet3gGH7m4imWzSjDTJSoRSR8Kizhyd1btbODu53by5BsH6fv6Fswo4sMXVXHN0hkU5IyJ1WpFZIxTWCRITUMbP1u1hwdW19AQmS6kMDeLq5fO4KYLKlk4szjhNYmIhKWwSLCO7h4e37if/3ppD2t2N/a/v2hmMTdeMIv3L5lBUV520uoTERmKwiKJthw8yn0v7+HhV2v77wTPy87gqoXTuaF6FhfOKdXwWxFJCQqLFNDR3cNvNh7g/ldqeHFHff/7s0rzuW5ZBdefV0Hl5IIkVigi453CIsXsqW/jwTU1PLRmL/ubj6+dccHsUq47byZXLZpOcb4uU4lIYiksUlRPr/Pi9nr++9W9PL5xPx3dwdxTOVkZXDF/Ctcuq+Dt88rJydIsLCISfwqLNHC0o5vHNx7gV2treXFHff8Q3OL8bK5aOI2rl87gwjmTyVT/hojEScqGhZnlAc8CuUAW8JC73zpon+8B74i8LACmuHvJSMdNx7AYaH9zOyvW7eOXa2vZfOBo//tTCnN5z6LpvG/xdM6rnKSOcRGJqVQOCwMmuHuLmWUDzwGfdfeXhtn/M8Ayd795pOOme1gMtOXgUVas28eK9fvY09DW//704jyuWjid9yyapuAQkZhI2bA44cRmBQRh8Sl3XzXMPi8At7r7kyMdayyFRR93Z8PeZh57bT+PbdjfPy8VBC2Ody+YxlULp3HBnFKyMtXHISKjl9JhYWaZwBrgTOAud//SMPtVAS8BFe5+0lqnZnYLcAtAZWXl+bt3745f0Unm7ry6p4nHX9vP4xsPnBAcJQXZXH7OFN517jQunVemqUZEJLSUDov+E5uVAL8EPuPuG4fY/iWCoPhMtGONxZbFcNyd12qbeXzjAZ7YeIAdh1v7t+VmZXDJmWW8c/4U3nnOVKYVa0ZcERleWoQFgJl9A2hz938aYtta4NPu/kK044ynsBhs26EWfvv6AZ7YdJD1NU0nbFswo4h3nD2Fd5xTztJZkzSySkROEJOwMLMRO5VH8Ct3bxjmmOVAt7s3mVk+8FvgO+7+6KD9zgF+A8zxEGk2nsNioENHO1i5+RC/e+MQz209THv38at3JQXZvO2sci49q4xL55UztUitDpHxLlZh0XsK53bgLe7+6jDHXAzcC2QSrP/9gLvfYWZ3AKvdfUVkv9uAPHf/cpiTKixO1tHdw6qdDazcfIiVbx7qXyK2zznTCnnbWWX80VnlXDC7lPwcrfwnMt7EMiwuBV4Jed4s4ChQPVxYxIvCYmTuzs7DrTy7pY5ntx7mxe31J7Q6cjIzOK+qhIvnlnHxGZNZOqtEd5GLjAOxCosXgZvd/Y2QJ80Angc+6u5bwhYbCwqL0ek81sOaXY08t+0wz287zIbaZgb+GuRlZ1BdVcpFc0u5cO5kFlcUk5ullofIWJM2HdyxorA4PU1tXby0o54Xt9fz4o56thxsOWF7blYGyypLuGB2KdWzS1lWWUKh1ucQSXuxall8Brjf3Q/Fsrh4UFjEVt3RTlbtrGfVjgZW7Tw5PDIM5k8v4vyqSZxfNYnzKidRMSlfa5CLpJlYhUUP0As8A/wceNjdm2NVZCwpLOKrobWLV3Y1sHpXA6/samRjbTPHek/8vSkvzGXZrBKWVU5iWWUJiyuKdYOgSIqLVVhUADcCfwKcD3QCTxAExyPu3j7kB5NAYZFY7V09rKtp4tU9jby6u5E1exppaus+YZ8Mg3lTC1k6q4Sls0pYMquEs6ZM1NQkIikk5n0WZnYGcBNBcCwAWoEVBMHxhLsfO/VyT5/CIrn6Rlutq2li7Z4m1tY0snn/0ZNaH/nZmSyaWcySWcUsrghCRJevRJInrh3cZraAoMVxA8H8Tk0EU41/crSFxorCIvV0dPewaV8za/c0sa6miQ17m0+YRbfP5Ak5LJlVwpKKEpZWlrC0ooTiAnWeiyRCQkZDmVkx8C3gUwDunrSxlQqL9NDQ2sX6vU2s29PEhr1NrN/bTENr10n7zS2bwHmRzvPzqyZxZvlETckuEgdxC4vItOJXE7Qs3g3kAH8A7nP3fz+FWmNCYZGe3J29je2srQkCZF1NIxv3HaHr2ImTBxTnZ/OW2ZO4aO5kLpo7mfnTizTPlUgMxDQszCwHeC9BQLyXYPW6NcB9BENra0+v3NOnsBg7uo718sb+I7y6p5HVuxtZs6uRA0c6TtinKC+LS84s4+3zyrl0XjkzSvKTVK1IeovVaKirCALiGqAI2EwQEPe5+7YY1RoTCouxbW9jG6t2NPDSjnpe2llPTcOJA/HmTZ3Iu86dxvKF01gwo0gd5iIhxXJuqD3ALwgCYn3sSowthcX4UtPQxu+31PH7LXW8sO0wrV3H57mqLC3gqoXT+MCymcyfXpTEKkVSX6zC4q1h1pJIBQqL8avrWC+rdtbz+MYD/HbTAQ63HO8wP3d6EdefX8E1S2dQNjE3iVWKpKZYhUWOu588VGXkE4/6M7GgsBCAnl5nze5GVqyvZcW6fRzpCG7/yc40li+czkcuquItsyfpMpVIRCyn+7jY3V8OedJMoIsR1rOIF4WFDNbR3cNTbxziv1/dyzNvHqLv/sBzphXy4YuquO68mZqORMa9WPZZ/CVBx3YYGQQr32k9C0kptU3t3LdqD794ZU//Zari/GxuuqCS/3VxlUZTybiVsivlxYvCQsLoOtbL4xv3c88Lu1i7J1ivPDPDWL5gGh+7ZDbVVbpEJeNLrMLi7FM8/y537zzFz54ShYWM1to9jfz4+V38+rX9/XNYLZhRxEffOpurl8wgL1uLPcnYp8WPRELa39zOz17aw89f3tM/9UhxfjbXLpvJB6srWDCjOMkVisSPwkJklDq6e3hk/T7ufXEXG2uP9L+/YEYR151XwfKF05ipvg0ZYxQWIqdhY20zD66u4Vfr9tHcfnydjsUVxSxfOI3Lz5nC2VML1b8haU9hIRIDHd09/O6Ng/z6tf2s3FxHe/fxO8XLJuby1jMmc8mZk6meXcqcyRM0M66kHYWFSIy1d/Xw7NY6nth0gOe2HubQ0RPHcBTlZfWvyzF/ehHnTC9k9uQJmh1XUlrcw8LMSoEmdx/V8FozywOeBXKBLIJFk24dYr8bgNsIhuKud/cPjXRchYUkkruzva6F57fV8+L2etbVNJ00My5AblYGZ02dyBnlwWNu+QTmlk1kdlmBbgiUlBCXsDCzdwLfIFiPOw+4wN1fNbO7gGfd/f4QxzBggru3mFk28BzwWXd/acA+ZwEPAJe7e6OZTXH3QyMdV2EhyXaguSOyImATbx44yuYDR6ltGn6Z+vLCXGZPLqCydAKzSvOZNamAWaUFzCrNZ2phni5pSUKMJixC/XljZjcB/wU8BHwB+MGAzXuAW4CoYeFBMrVEXmZHHoPT6n8Dd7l7Y+QzIwaFSCqYVpzH8uJgmvQ+Rzq62XrwKNsPtbL9cAvbD7Wy43ALexvaqTvaSd3RTl7Z1XjSsbIzjRkl+czse0zK7389oySf6cV5ug9EEi5sW/gbwPfc/a8jc0ANDIuNwOfCnjDy+TUE63ff5e6rBu0yL7Lf80AmcJu7/ybs8UVSRVFeNudXlXJ+VekJ7/f0OgeOdLD7cCu7G9qoaWijprGdmoY29ja2cbili931beyuP3nN8j6lE3KYUZLH9OIgPKYV5zGjOJ9pxXlML85japECRWIrbFjMAX49zLY2IPSdS+7eAyw1sxLgl2a20N03DqrpLOAyoAJ41swWuXvTwOOY2S0ELRoqKyvDnl4k6TIzrL/V8NYhtrd39VDb1M7exjb2NXWwr6mdfU3t7G1qZ39zOweaO2ho7aKhteuEe0IGm1SQzdSiIEimFuYxtTiPqUW5wfOi4PnkibnqhJdQwoZFLbAYeHqIbecBO0Z7YndvMrOVwHKC1kmfvcAqd+8GdprZFoLweGXQ538I/BCCPovRnl8kVeXnZHLmlImcOWXikNt7e53DLZ3UNgXBsa+5gwPN7exr7uBgcwf7mzs4eKSDxrZuGtu62Xzg6LDnyjAonZDLlMJcygc8yiZGfk7IYfLEXMom5lBSkKNgGcfChsU9wG1mthd4NPKem9klwJeAfwhzEDMrB7ojQZEPXAl8Z9BuvwJuAn5sZmUEl6VGHUYiY1VGhjGlKI8pRXnD7tPb6xxu7eRgcycHj3Rw4EgQIAePdHDoaCcHj3Ry6EgHDW1dHG7p5HBLJ+yPcl6DSQU5lE7IYfLEHCZPyGXShGxKC3KYNCGHSQU5lBRkUzrg+cTcLN28OEaEDYtvAbMJRin1jRF8jmBU1D3ufmfI40wH7o30W2QAD7j7o2Z2B7Da3VcATwDvMrPXgR7gb9y9PuTxRYRIoBTmMaUwj0UjXCXu7umlvqWLQ0c7OHSksz846o52UtfSSX1LECb1rV00tXVT39pFfWsXW0MOO8nKMEoKsikpyGHSgJ+TIgHTFzSlE7IpnRC0YBQwqWlU91mY2QLgnUAZ0AA87e4b4lRbaBo6KxJ/3T29NLZ1Ud8S9JcEAdLV33/S2NZNU1sXjW1dNLZ209jWRduA9dHDysnKoGxCDuVFeUwtzGVKpJ9lRmQ0WMWkfKYW5ZGTlRGH/8rxJeZDZ/u4+yZg0ylVJSJpLTszo7+1ElbnsR6a2oLgaOoPk24a+oMm2Fbf2kVDa9CSaevqYV+kL2Y4GQYzJ+Uze/IEqiYXMKdsImdPLeTsaYWUTcxRyyQOwt5nccEIm3uBI8D2yEgnEREAcrMymVqUydQR+lcGa+s61n9prK9v5cCRTvY3t1PbGIwMO3Ckg5qGdmoa2vnD1hM/Xzohh/nTC1lSUcKSWSUsnVUyqvPL0MK2LF7i5JvnBmsxs38DvjLaaUBERPoU5GRRUJrFrNKCYffpOtZLTWMbu+tb2Xm4jW2HWth68ChvHjhKQ2sXz2+r5/ltx7s6Z5bkc+HcUi6eO5mLz5hMxaThjy1DCxsWVwH/DjwFrADqgHLgGoI+jC8BC4G/BtoJ5nUSEYmLnKyM/jm3BnJ39jV3sKm2mfV7m1hf08z6miZqm9p5+NVaHn61FoC5ZRO48typXHHuVM6rnKQhwSGE6uA2sweALe7+9SG2fQs4192vNbO/A/7U3efEvtThqYNbRIbT2+tsPnCUF3fU8+L2w6za2cDRjmP92ydPyOFdC6Zx/XkzOX+crcMe84kEzewocK27/26IbVcCv3T3iZHJBn/t7rmjLfp0KCxEJKxjPb2s3t3Ik68f5MnXD7Kn4fi0KlWTC7huWQUfrK5gxjhYGTEeYbEXuN/dvzDEtjuBG9y9wszeS3DfRfloiz4dCgsRORXuzpsHj/LLtbX8am0tB48E65RkZhjvXTSdT7xtDosrSpJcZfzEIyw+D/wTwayzj3Bin8V1wBfc/Xtm9o/AYndffqrFnwqFhYicrp5e5/lth7l/dQ2/2XiAnt7g38YLZpfyl5efyaXzEvo3cELEaz2Lm4CvEHRk99kIfNvd74vsMwPocPeG0ZV8ehQWIhJLtU3t3PvCLu5btYejnUH/xh+dWcaXrzqHhTNDz5ua8uK6Ul5ktbupwEF3H/6umQRSWIhIPLR0HuMnL+7iB89s7+8Uv2bpDL5y1XymFaf/vRtag1tEJIYaW7u4a+U2fvLibrp6einKy+L2axbwgaUz03r0VLwuQ80kmA12HsEEgidw9/81miJjSWEhIolQ09DGrSs28fTmYCbFd507lW9du4jywoQOAI2ZeCyrugT4A3AYqAI2A5OAaQQTG+8+tVJFRNLHrNIC/vOj1Ty4Zi93PPI6v339IKt3N/J/b1rGJWeWJbu8uAo7beM/EYyCmgcY8BF3nwFcQTCN+N/GpzwRkdRiZtxQPYsnPncpl5w5mYbWLj5698s8uLom2aXFVdiwWAb8lGDSQIhchnL3p4FvAt+NfWkiIqlrZkk+P735Qj556VyO9Tp/89AG7nxyC2OhH3goYcMig2BIbC/BPRazBmzbCZwd68JERFJdRobxlffM55vXLCDD4PtPbeULD6ynu2fszaUaNizeAOZGnq8CPmtms8xsKvA5YFccahMRSQsfuXg2P/poNQU5mTy8tpavPvzamGthhA2L/wQqI8+/RrDE6i5gH3AZ8MUY1yUiklYuP2cqP/vEheRnZ/Lgmr3836e3JbukmAoVFu5+t7vfFnn+GnAu8AEiQ2nd/bG4VSgikiaWVU7i+zctwwzufHILv1y7N9klxUyosDCzG8xsUt9rd29y90fc/QGg1cxuiFuFIiJp5Mpzp3Lr+84F4IsPbeCF7YeTXFFshL0MdR9w1jDbzohsFxER4GOXzOHmS+bQ3eN88qdrqBkwDXq6ChsWI93PPgk4GoNaRETGjK+9dz5XzJ/C0Y5j/O3/bEz7Du9h7+COrE3x3gFvfdHMDg3aLQ94B7AmDrWJiKStzAzj769bxMv//HueebOORzfs5/1LZiS7rFM2UsuiEnhb5AGwdMDrvscS4AXgz+NYo4hIWppSmMdX3jMfgNsf2URzW3eSKzp1w4aFu//A3Re5+yKCeyuu7ns94HG+u/+pu28NczIzyzOzl81svZltMrPbh9jnY2ZWZ2brIo9PnPp/nohIcv1J9SwumF3K4ZYuvv34G8ku55SFHTp7sbu/HoPzdQKXu/sSgpbKcjO7aIj97nf3pZHHj2JwXhGRpMjIMP7+uoXkZGbwi1dqWLWjPtklnZKR+ixuHs2B3P3uEPs40BJ5mR15pHevj4hIFGdOKeRTl53Bvz61la/88jV+89lLyckKO74oNYw0Rflo/qJ3IGpYAJhZJkGH+JnAXe6+aojdrjezS4EtwOfc/aTpHM3sFuAWgMrKysGbRURSyl+84wweWb+PHXWtPPbaPq5dVpHskkZlpGjLH8WjIOwJ3b3H3ZcCFcAFZrZw0C6PALPdfTHwJHDvMMf5obtXu3t1efnYW0hdRMaW3KxMPvn2YIq9H/1hZ9oNpR2pg7tzNI/Rntjdm4CVwPJB79cPON6PgPNHe2wRkVR0zdKZTJ6Qw6Z9R1i1syHZ5YxK6ItmZlZoZp81swfN7KnIz78ys4mjOEa5mZVEnucDVxKsujdwn+kDXl5NMOOtiEjay8vO5CMXVwFB6yKdhJ0bajawgWDFvJnAkcjPfwY2mFlVyPNNB1aa2QbgFeBJd3/UzO4ws6sj+/xVZFjteuCvgI+FPLaISMr78EVV5GRl8NTmg+yoa4n+gRRhYa6bmdnDBDPNXuXuOwe8Pwd4DHjD3a+PW5VRVFdX++rVq5N1ehGRUfnSQxu4f3UNH7moim9+YHC3beKY2Rp3rw6zb9jLUO8EvjYwKAAir28lWItbRERC+Pjb5gDw0Jq9NLV1JbmacEYzkeBwTZBeRp5oUEREBpg3tZBL55XT3t3Dz1/ek+xyQgkbFr8HbjezE2bBinRG3wo8E+O6RETGtE/8UdC6uPeFXRxLgzW7w4bF54ASYIeZPWNm95vZSmBn5P3PxatAEZGx6G1nlTF7cgEHj3Ty6p6mZJcTVdi5obYRLH70ZaAWKCdYf/uLwNnuvj1uFYqIjEFmxpXnTgXgd28cTHI10YW+z8LdO9z9XyKzzF4e+fl9d2+PZ4EiImPVFfMjYfH6GAkLM/utmf1Z3w11IiJy+s6vmkRJQTY7DreyPcXvuQjbsugEfgAcMLNHzOxDo7lzW0RETpaVmcHlZ08BUr91EbbP4v3AVOBTBDPV3gMcNLOHzOyDZpYXvxJFRMauK9Kk32I0fRbN7v5jd7+KYNqOvhFSPwNS+79SRCRFXTqvnJzMDNbsbqS+ZdRzsibMKa2+4e71BGtSrAUaAF2SEhE5BRNzs7jojMn0Oqx8sy7Z5QxrVGFhZovN7FtmthV4GbgG+A9gcTyKExEZD66cn/r9FmFHQ91uZm8QtCQ+BDwMvMXd57n737r7pngWKSIylr0zMoT22a11dHT3JLmaoYVtWXwCeAK4xN3nuPuX3P3VONYlIjJuzCjJZ8GMItq6enhxR32yyxlS2LCocPf/4+4vxbUaEZFx6p0pfoNe2KGz6bVYrIhImrkyEhZPbz6Ukutzn9JoKBERia2FM4soystif3MHB4+k3hBahYWISAowMxZXBDMqrd+berPQKixERFLEoopiAF7b25zkSk6msBARSRFLImGRii2LrOE2mNnlozmQuz99+uWIiIxfiyKXoV6rbcbdMUudFauHDQvgdwTrboep1oHMmFQkIjJOzSjOo2xiDodbuqhpaKdyckGyS+o3UljMT1gVIiKCmbFoZjEr36xjQ21TeoSFu7+ZyEJERAQWV5QEYbG3mfctnpHscvqN1LI4iQUX0KYDJ61f4e47Qnw+D3gWyI2c+yF3v3WYfa8HHiKYg2r1aOoUEUlXiyOd3BtSrJM7VFiYWRbwXeBmhp+OPEyfRSdwubu3mFk28JyZPT54GhEzKwQ+C6wKU5+IyFjRN3x2Y+0RenudjIzU6OQOO3T2q8CfAP+HoMP788BfAM8Du4DrwxzEA30LzWZHHkPd1/5N4DtAR8j6RETGhCmFeUwvzqOl8xg7Drcmu5x+YcPiQ8BtwE8ir59z939390sJ/vq/MuwJzSzTzNYBh4An3X3VoO3nAbPc/bEox7nFzFab2eq6utRdMEREZLQWzYzcnFebOpeiwoZFJfCGu/cQXEoqGbDtXuCGsCd09x53XwpUABeY2cK+bWaWAdwJfCHEcX7o7tXuXl1eXh729CIiKW/JrMi0HzWpcyd32LA4ABRHnu8CLhmwrWoUx+nn7k3ASmD5gLcLgYXAM2a2C7gIWGFm1aM9vohIujreskidsAg7GupZgoB4FLgb+JaZzSZoZXyYYOW8qMysHOh29yYzyye4fPWdvu3u3gyUDdj/GeCvNRpKRMaTvhFRm/Y1c6ynl6zM5M/MFDYsvg5MiTz/p8jn/hjIJwiPr4c8znTgXjPLJGiNPODuj5rZHcBqd18RunIRkTGqpCCHytIC9jS0sfVQC/OnFyW7pHBh4e57gb2R5w58O/IYFXffACwb4v1vDLP/ZaM9h4jIWLC4opg9DW1s2NuUEmGR/LaNiIic5PjNeanRbxH2prxM4FPAdQSjmIa6g7sytqWJiIxfi2Yen4E2FYTts/hn4DPAb4FHgK64VSQiIpwzrRCAHXWtKTFdediwuBH4qrt/J+qeIiJy2koKsinMy+JoxzHqW7som5ib1HrC9llkAWviWYiIiBxnZlRFpijfXd+W5GrCh8XdwAfjWYiIiJyoqnQCAHsakj9HVNjLUNuBr5jZ48CTwEkTlrj73bEsTERkvKtMoZZF2LD4QeRnJfDuIbY7QetDRERipKo0CIs9aRQW+XGtQkRETtLfsmhIk7Bw9854FyIiIieqmhz0WaT0ZSgzmwvUuHt35PmIwiyrKiIi4U0ryiMnM4PDLZ20dh5jQu6oVsKOqZHOvI1givCXI8+HWtEOgpXznHDLqoqISEiZGUZFaT476lrZ09CW1DmiRgqLq4A3BjwXEZEEqyotYEddK7vrUzQs3P2JoZ6LiEjiBP0WdUm/1+KULoBFlj89gbv3nn45IiIyUGVpatxrEeoObjObaGZ3mtlOM+sEuod4iIhIjPVN+bEnycNnw7Ysfgy8C7iHoLNbs86KiCRAqswPFTYs3gV82t3/K57FiIjIiSomFWAGtU3tdPf0kp2k9bjDnrUWSI0VOERExpG87EymFeXR0+vsa2pPWh1hw+IrwNfMbHo8ixERkZOlQid32Ok+/sfM3gbsNLMtDD3r7KWxLk5ERIJ+i1U7G5I6R1TYNbj/Hvg88Brq4BYRSai+OaL21CfvXouwHdyfAm5399vjWYyIiJwsFS5Dhe2z6AReON2TmVmemb1sZuvNbJOZnRQ+ZvbnZvaama0zs+fM7NzTPa+ISDpLhXstwobF/wNujsH5OoHL3X0JsBRYbmYXDdrn5+6+yN2XAv8I3BmD84qIpK3jy6u24T7cnK7xFfYyVB5wiZm9Bqzk5A5ud/dbox3Eg//KlsjL7MjDB+1zZMDLCYO3i4iMN8UF2RTnZ9Pc3k1dSydTCvMSXkPYsPh45GcZ8MEhtjsQNSwAzCwTWAOcCdzl7quG2OfTBB3qOcDlwxznFrzd8mIAAAvLSURBVOAWgMrKyjCnFhFJW1WTC9iwt5k99W1JCYtQl6HcfXqUx4ywJ3T3nsglpgrgAjNbOMQ+d7n7GcCXgK8Pc5wfunu1u1eXl5eHPb2ISFpKdid31LCIdEqvMLOY3kfh7k0El7SWj7DbL4APxPK8IiLpqCrJ63FHDQt37wAu5RSnMx/IzMrNrCTyPB+4Etg8aJ+zBrx8L7D1dM8rIpLu+ju5k3SvRdgAeAx4H/D0aZ5vOnBvpN8iA3jA3R81szuA1e6+AvhLM7uCYNrzRuCjp3lOEZG0NytyGWpvY3LmhwobFr8CvmdmU4BfAwc5eRRT1CBx9w3AsiHe/8aA558NWZOIyLgxpSgXgLqWzqScP2xY3B/5+aHIYzAHMmNSkYiInKS8MAiLw0dTOyzmx7UKEREZUWFuFjlZGbR29dDWdYyCnNPuRh6VsLPOvhnvQkREZHhmRvnEXGqb2jl8tIvKyYkNi9BLLplZlpn9mZndFRlKe0bk/WsHjWASEZE4KCvs67foSPi5Q4WFmc0F3gC+DywhGNJaHNl8JfDVuFQnIiL9yidGwuJo4leJCNuy+D5QD8wBLgNswLZnCO7DEBGROCovzAGSMyIq7EWvy4Ab3f1w5B6JgQ4Q3D8hIiJx1NeySMaIqLAti26CGWKHMh04Msw2ERGJkeN9FqkbFr8DvmxmEwa852aWBXwa+E3MKxMRkRMks2UR9jLU3xCslLeVIBgc+DKwACgBbopLdSIi0i/lWxbuvotgFNTPCFa4qwXOBp4Aznf32ngVKCIigf6WRSp1cEemJH/V3VsA3L2OoIUhIiJJ0N+yONqJu2NmUT4ROyO1LFYC5yaqEBERGdmEnEzyszPp6O6ltasnoeceKSwSF1kiIhKVmVHWd69Fgju5Q0/3ISIiyZesfotoo6HeY2bnhDmQu/8kBvWIiMgIyiYe77dIpGhh8Y0o2/s4oLAQEYmz/nUtUqxl8Q5gdSIKERGR6FK1ZdHu7slZHVxERE6SrJaFOrhFRNJIsloWCgsRkTRS3j/lR2LXtBj2MpS7K0hERFJMsiYTVCCIiKSRsgELILl7ws6rsBARSSMFOVlMyMmk61gvRzqOJey8CQ0LM8szs5fNbL2ZbTKz24fY5/Nm9rqZbTCzp8ysKpE1ioikumSMiEp0y6ITuNzdlxBMdb7czC4atM9aoNrdFwMPAf+Y4BpFRFJaMkZEJTQsPNASeZkdefigfVa6e1vk5UtARQJLFBFJeeOhZYGZZZrZOuAQ8KS7rxph948Djw9znFvMbLWZra6rq4tHqSIiKaksCSOiEh4W7t7j7ksJWgwXmNnCofYzsw8D1cB3hznOD9292t2ry8vL41ewiEiKKU/C8qpJGw3l7k0ECywtH7zNzK4AvgZc7e6JXz9QRCSFHW9ZJO7GvESPhio3s5LI83zgSmDzoH2WAf9OEBSHElmfiEg6SEbLItpEgrE2HbjXzDIJguoBd3/UzO4AVrv7CoLLThOBByPry+5x96sTXKeISMoqmxjcmJfIDu6EhoW7bwCWDfH+NwY8vyKRNYmIpJv+lsVY7uAWEZHTUzZgadVETfmhsBARSTN52ZkU5mXR3eM0t3cn5JwKCxGRNFQ+MbE35iksRETSUFmk3+JQgvotFBYiImnoeMsiMfdaKCxERNJQokdEKSxERNJQou+1UFiIiKQhtSxERCSq8sJcivKyyM60hJwv0dN9iIhIDLzj7ClsuO3dCTufWhYiImkoMndewigsREQkKoWFiIhEpbAQEZGoFBYiIhKVwkJERKJSWIiISFQKCxERicoStcpSPJlZHbD7FD9eBhyOYTmJko51q+bEUM2Jk451D6y5yt3Lw3xoTITF6TCz1e5enew6Risd61bNiaGaEycd6z7VmnUZSkREolJYiIhIVAoL+GGyCzhF6Vi3ak4M1Zw46Vj3KdU87vssREQkOrUsREQkKoWFiIhENW7CwsyWm9mbZrbNzL48xPZcM7s/sn2Vmc1OfJUn1RSt5kvN7FUzO2Zmf5yMGgcLUfPnzex1M9tgZk+ZWVUy6hwsRN1/bmavmdk6M3vOzM5NRp2Dahqx5gH7XW9mbmZJH+IZ4nv+mJnVRb7ndWb2iWTUOaimqN+zmd0Q+b3eZGY/T3SNQ9QT7Xv+3oDveIuZNUU9qLuP+QeQCWwH5gI5wHrg3EH7/AXwb5HnNwL3p0HNs4HFwE+AP06T7/kdQEHk+aeS/T2Pou6iAc+vBn6T6jVH9isEngVeAqpTvWbgY8D/S/bvxChrPgtYC0yKvJ6S6jUP2v8zwN3RjjteWhYXANvcfYe7dwG/AK4ZtM81wL2R5w8B77REL0V1oqg1u/sud98A9CajwCGEqXmlu7dFXr4EVCS4xqGEqfvIgJcTgGSPDAnzOw3wTeA7QEciixtG2JpTSZia/zdwl7s3Arj7oQTXONhov+ebgPuiHXS8hMVMoGbA672R94bcx92PAc3A5IRUN7QwNaea0db8ceDxuFYUTqi6zezTZrYd+EfgrxJU23Ci1mxm5wGz3P2xRBY2grC/H9dHLlM+ZGazElPasMLUPA+YZ2bPm9lLZrY8YdUNLfT/DyOXgecAT0c76HgJC0kxZvZhoBr4brJrCcvd73L3M4AvAV9Pdj0jMbMM4E7gC8muZZQeAWa7+2LgSY639lNZFsGlqMsI/kr/DzMrSWpF4d0IPOTuPdF2HC9hUQsM/AulIvLekPuYWRZQDNQnpLqhhak51YSq2cyuAL4GXO3unQmqbSSj/a5/AXwgrhVFF63mQmAh8IyZ7QIuAlYkuZM76vfs7vUDfid+BJyfoNqGE+Z3Yy+wwt273X0nsIUgPJJlNL/PNxLiEhQwbjq4s4AdBM2tvg6fBYP2+TQndnA/kOo1D9j3HlKjgzvM97yMoPPtrGTXO8q6zxrw/P3A6lSvedD+z5D8Du4w3/P0Ac+vBV5Kg5qXA/dGnpcRXAKanMo1R/Y7B9hF5ObsqMdN5v8QCf4C30OQ+NuBr0Xeu4Pgr1uAPOBBYBvwMjA3DWp+C8FfNa0EraBNaVDz74CDwLrIY0Wyaw5Z978CmyI1rxzpH+ZUqXnQvkkPi5Df87cj3/P6yPd8ThrUbASX/F4HXgNuTPWaI69vA/4h7DE13YeIiEQ1XvosRETkNCgsREQkKoWFiIhEpbAQEZGoFBYiIhKVwkLGvMiMq9Eel0VmPHUzm5jEWu8ZUNO/DHp/dYjP7xrw+ffFt1oZT7KSXYBIAlw84Hk+wTw4fwcMnDPpdYLx/RcDbSTXZuDPgP2n8NlrCWYjfjiWBYkoLGTMc/eX+p4PaDVsH/j+AHWJqWpErcPUFpW7rzWzxlgXJKLLUCIRgy9DmdnsyOsbzezHZnbEzPZGJkHEzL5oZvsii/V8JzJ538DjLTSzx8zsaOTxoJlNO80ar4zMyNoaWYRpwekcTyQshYVIdN8huCR0PfAH4F4z+2eCdQNuBv4F+CJwQ98HzOxM4HmCaWQ+TLCozwLgkdNYJ6WSYJbebxHMbjoFuD/J667IOKHLUCLRPe3uXwUws1XAHxOslneOB1M7/8bMriHoL/hF5DO3AgeAqzxYgAYz20DQH/EeTuwvCasUuMTdt0aOlwH8Ejg7clyRuFHLQiS6p/qeeLBiXh3wez9xDYBtnLjAzBUE/5D3mllWZNr7nQSzfJ7qNOG7+oIi4vXIz1RYbVDGOIWFSHSDF7PvGua9vAGvywgWSeoe9JjLiWsNnG4dDDqvSFzoMpRIfDQQtCx+NMS2wwmuReS0KSxE4uMpgg7tNa51AGQMUFiIxMdtBItoPWZmdxO0JmYCVwL3uPszyStNZPTUZyESB+6+hWDd6zbgh8DjwO1AJ0FnuEha0Up5IinEzO4BFhIETa+7947y85kE031sA97v7o/GukYZn9SyEEk95xOMnLrzFD67HbVcJA7UshBJIWY2m2DYLcBBd68Z5ecXAbmRl1vdvTl21cl4prAQEZGodBlKRESiUliIiEhUCgsREYlKYSEiIlEpLEREJKr/Dz9w/LkXE/Z0AAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -120,95 +131,94 @@ "text": [ "PARAMETER VALUE\n", "-------------------------------------------------------------------------------------------------\n", - "Reference temperature [K] 298.15\n", - "Negative current collector thickness [m] 2.5e-05\n", - "Negative electrode thickness [m] 0.0001\n", - "Separator thickness [m] 2.5e-05\n", - "Positive electrode thickness [m] 0.0001\n", - "Positive current collector thickness [m] 2.5e-05\n", - "Electrode height [m] 0.13699999999999998\n", - "Electrode width [m] 0.207\n", "Negative current collector thickness [m] 2.5e-05\n", + "Negative electrode thickness [m] 0.0001\n", + "Separator thickness [m] 2.5e-05\n", + "Positive electrode thickness [m] 0.0001\n", "Positive current collector thickness [m] 2.5e-05\n", + "Electrode height [m] 0.13699999999999998\n", + "Electrode width [m] 0.207\n", "Negative tab width [m] 0.04\n", "Negative tab centre y-coordinate [m] 0.06\n", "Negative tab centre z-coordinate [m] 0.13699999999999998\n", "Positive tab width [m] 0.04\n", "Positive tab centre y-coordinate [m] 0.147\n", "Positive tab centre z-coordinate [m] 0.13699999999999998\n", - "Number of electrodes connected in parallel to make a cell 1.0\n", - "Number of cells connected in series to make a battery 1.0\n", - "Lower voltage cut-off [V] 3.105\n", - "Upper voltage cut-off [V] 4.7\n", - "Typical electrolyte concentration [mol.m-3] 1000.0\n", - "Cation transference number 0.4\n", - "Typical lithium ion diffusivity [m2.s-1] 5.34e-10\n", - "Negative electrode conductivity [S.m-1] 100.0\n", - "Positive electrode conductivity [S.m-1] 10.0\n", - "Maximum concentration in negative electrode [mol.m-3] 24983.261993843702\n", - "Maximum concentration in positive electrode [mol.m-3] 51217.9257309275\n", - "Negative electrode diffusion coefficient [m2.s-1] 3.9e-14\n", - "Positive electrode diffusion coefficient [m2.s-1] 1e-13\n", "Negative current collector conductivity [S.m-1] 59600000.0\n", "Positive current collector conductivity [S.m-1] 35500000.0\n", + "Negative current collector density [kg.m-3] 8954.0\n", + "Positive current collector density [kg.m-3] 2707.0\n", + "Negative current collector specific heat capacity [J.kg-1.K-1] 385.0\n", + "Positive current collector specific heat capacity [J.kg-1.K-1] 897.0\n", + "Negative current collector thermal conductivity [W.m-1.K-1] 401.0\n", + "Positive current collector thermal conductivity [W.m-1.K-1] 237.0\n", + "Cell capacity [A.h] 0.68\n", + "Negative electrode conductivity [S.m-1] 100.0\n", + "Maximum concentration in negative electrode [mol.m-3] 24983.2619938437\n", + "Negative electrode diffusivity [m2.s-1] \n", + "Negative electrode OCP [V] \n", "Negative electrode porosity 0.3\n", - "Separator porosity 1.0\n", - "Positive electrode porosity 0.3\n", "Negative particle radius [m] 1e-05\n", - "Positive particle radius [m] 1e-05\n", "Negative electrode surface area density [m-1] 180000.0\n", - "Positive electrode surface area density [m-1] 150000.0\n", - "Bruggeman coefficient 1.5\n", + "Negative electrode Bruggeman coefficient 1.5\n", "Negative electrode cation signed stoichiometry -1.0\n", - "Positive electrode cation signed stoichiometry -1.0\n", "Negative electrode electrons in reaction 1.0\n", - "Positive electrode electrons in reaction 1.0\n", "Negative electrode reference exchange-current density [A.m-2(m3.mol)1.5] 2e-05\n", - "Positive electrode reference exchange-current density [A.m-2(m3.mol)1.5] 6e-07\n", "Reference OCP vs SHE in the negative electrode [V] nan\n", - "Reference OCP vs SHE in the positive electrode [V] nan\n", - "Charge transfer coefficient 0.5\n", - "Double-layer capacity [F.m-2] 0.2\n", - "Negative current collector density [kg.m-3] 8954.0\n", + "Negative electrode charge transfer coefficient 0.5\n", + "Negative electrode double-layer capacity [F.m-2] 0.2\n", "Negative electrode density [kg.m-3] 1657.0\n", - "Separator density [kg.m-3] 397.0\n", - "Positive electrode density [kg.m-3] 3262.0\n", - "Positive current collector density [kg.m-3] 2707.0\n", - "Negative current collector specific heat capacity [J.kg-1.K-1] 385.0\n", "Negative electrode specific heat capacity [J.kg-1.K-1] 700.0\n", - "Separator specific heat capacity [J.kg-1.K-1] 700.0\n", - "Positive current collector specific heat capacity [J.kg-1.K-1] 897.0\n", - "Negative current collector thermal conductivity [W.m-1.K-1] 401.0\n", "Negative electrode thermal conductivity [W.m-1.K-1] 1.7\n", - "Separator thermal conductivity [W.m-1.K-1] 0.16\n", + "Negative electrode OCP entropic change [V.K-1] \n", + "Reference temperature [K] 298.15\n", + "Negative electrode reaction rate \n", + "Negative reaction rate activation energy [J.mol-1] 37480.0\n", + "Negative solid diffusion activation energy [J.mol-1] 42770.0\n", + "Positive electrode conductivity [S.m-1] 10.0\n", + "Maximum concentration in positive electrode [mol.m-3] 51217.9257309275\n", + "Positive electrode diffusivity [m2.s-1] \n", + "Positive electrode OCP [V] \n", + "Positive electrode porosity 0.3\n", + "Positive particle radius [m] 1e-05\n", + "Positive electrode surface area density [m-1] 150000.0\n", + "Positive electrode Bruggeman coefficient 1.5\n", + "Positive electrode cation signed stoichiometry -1.0\n", + "Positive electrode electrons in reaction 1.0\n", + "Positive electrode reference exchange-current density [A.m-2(m3.mol)1.5] 6e-07\n", + "Reference OCP vs SHE in the positive electrode [V] nan\n", + "Positive electrode charge transfer coefficient 0.5\n", + "Positive electrode double-layer capacity [F.m-2] 0.2\n", + "Positive electrode density [kg.m-3] 3262.0\n", + "Positive electrode specific heat capacity [J.kg-1.K-1] 700.0\n", "Positive electrode thermal conductivity [W.m-1.K-1] 2.1\n", - "Positive current collector thermal conductivity [W.m-1.K-1] 237.0\n", - "Heat transfer coefficient [W.m-2.K-1] 10.0\n", - "Typical temperature variation [K] 2.4\n", - "Lumped effective thermal density [J.K-1.m-3] 1811600.0\n", - "Effective thermal conductivity [W.m-1.K-1] 59.3964\n", - "Negative reaction rate activation energy [J.mol-1] 37500.0\n", - "Positive reaction rate activation energy [J.mol-1] 39800.0\n", - "Negative solid diffusion activation energy [J.mol-1] 42800.0\n", - "Positive solid diffusion activation energy [J.mol-1] 18600.0\n", - "Electrolyte diffusion activation energy [J.mol-1] 37000.0\n", + "Positive electrode OCP entropic change [V.K-1] \n", + "Positive electrode reaction rate \n", + "Positive reaction rate activation energy [J.mol-1] 39570.0\n", + "Positive solid diffusion activation energy [J.mol-1] 18550.0\n", + "Separator porosity 1.0\n", + "Separator Bruggeman coefficient 1.5\n", + "Separator density [kg.m-3] 397.0\n", + "Separator specific heat capacity [J.kg-1.K-1] 700.0\n", + "Separator thermal conductivity [W.m-1.K-1] 0.16\n", + "Typical electrolyte concentration [mol.m-3] 1000.0\n", + "Cation transference number 0.4\n", + "Electrolyte diffusivity [m2.s-1] \n", + "Electrolyte conductivity [S.m-1] \n", + "Electrolyte diffusion activation energy [J.mol-1] 37040.0\n", "Electrolyte conductivity activation energy [J.mol-1] 34700.0\n", - "Initial concentration in electrolyte [mol.m-3] 1000.0\n", + "Heat transfer coefficient [W.m-2.K-1] 10.0\n", + "Number of electrodes connected in parallel to make a cell 1.0\n", + "Number of cells connected in series to make a battery 1.0\n", + "Lower voltage cut-off [V] 3.105\n", + "Upper voltage cut-off [V] 4.7\n", + "C-rate 1.0\n", + "Current function Constant current\n", "Initial concentration in negative electrode [mol.m-3] 19986.609595075\n", - "Initial concentration in positive electrode [mol.m-3] 30730.755438556498\n", + "Initial concentration in positive electrode [mol.m-3] 30730.7554385565\n", + "Initial concentration in electrolyte [mol.m-3] 1000.0\n", "Initial temperature [K] 298.15\n", - "Typical current [A] 1\n", - "Current function Constant current\n", - "Electrolyte diffusivity /home/user/Documents/Batteries/PyBaMM/input/parameters/lithium-ion/electrolyte_diffusivity_Capiglia1999.py\n", - "Electrolyte conductivity /home/user/Documents/Batteries/PyBaMM/input/parameters/lithium-ion/electrolyte_conductivity_Capiglia1999.py\n", - "Negative electrode OCV /home/user/Documents/Batteries/PyBaMM/input/parameters/lithium-ion/graphite_mcmb2528_ocp_Dualfoil.py\n", - "Positive electrode OCV /home/user/Documents/Batteries/PyBaMM/input/parameters/lithium-ion/lico2_ocp_Dualfoil.py\n", - "Negative electrode diffusivity /home/user/Documents/Batteries/PyBaMM/input/parameters/lithium-ion/graphite_mcmb2528_diffusivity_Dualfoil.py\n", - "Positive electrode diffusivity /home/user/Documents/Batteries/PyBaMM/input/parameters/lithium-ion/lico2_diffusivity_Dualfoil.py\n", - "Negative electrode reaction rate /home/user/Documents/Batteries/PyBaMM/input/parameters/lithium-ion/graphite_electrolyte_reaction_rate.py\n", - "Positive electrode reaction rate /home/user/Documents/Batteries/PyBaMM/input/parameters/lithium-ion/lico2_electrolyte_reaction_rate.py\n", - "Negative electrode OCV entropic change /home/user/Documents/Batteries/PyBaMM/input/parameters/lithium-ion/graphite_entropic_change_Moura.py\n", - "Positive electrode OCV entropic change /home/user/Documents/Batteries/PyBaMM/input/parameters/lithium-ion/lico2_entropic_change_Moura.py\n" + "Typical current [A] 0.68\n" ] } ], @@ -241,7 +251,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Typical current [A] was 1\n", + "Typical current [A] was 0.68\n", "Typical current [A] now is 1.4\n" ] } @@ -303,7 +313,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -337,7 +347,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -357,7 +367,7 @@ "print(format_str.format('DOMAIN', 'DISCRETISED BY'))\n", "print(\"-\"*82)\n", "for key, value in model.default_spatial_methods.items():\n", - " print(format_str.format(key, value.__name__))" + " print(format_str.format(key, value.__class__.__name__))" ] }, { @@ -369,12 +379,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "spatial_methods = model.default_spatial_methods\n", - "spatial_methods[\"negative particle\"] = pybamm.FiniteVolume" + "spatial_methods[\"negative particle\"] = pybamm.FiniteVolume()" ] }, { @@ -393,12 +403,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -438,7 +448,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -462,12 +472,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABMUAAAJ6CAYAAAAo4vX7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzde7xcdX3v/9fbhEuVO4mSEy5JNYpULeoGtWqlnOpBzjkClaOkF6X1NKWK9oZH/J0+gEPrqWit1EKh0aYRa4kWq01tFKlCsS1YglzkUiSAlESUlKs5iBD4/P5Ya8Owmb13Evbsmcy8no/HPLLW9/tda31mMrP2dz7zXd+VqkKSJEmSJEkaJc/odwCSJEmSJEnSbDMpJkmSJEmSpJFjUkySJEmSJEkjx6SYJEmSJEmSRo5JMUmSJEmSJI0ck2KSJEmSJEkaOSbFtkKSSvKRjvWTkpzWg+P8fxPW/2Wmj7Etkhyd5KCO9dOT/OwU7Q9L8sXZiQ6S7JTkH5JcneSts3XcfkmyR5J3buO2A/ke02hJ8mj7eR1/nNyWX5JkbBv2d3CSI7dhu2nPVRPPf9ujbX0O7evzUx3rJyR528xGJ22ZjvPGdUn+Oskzt2Efnxj/LAzq30P7XIPFPpckDS+TYlvnR8DPJZnX4+M86Y9nVf3UZA1nS5K5wNHA4x20qjqlqv6hf1E9oY3vpQBVdXBVfabPIc2GPYCuHbT29ZjKwL3HNJJ+2H5exx8ffJr7OxjomhTbgs/EdJ50/ttOTfocpnl9DgMeP0dU1blVdd7MhiZtsfHzxouAh4ETtnYHVfU/q+qGdnXg/h7a5xpI9rmkHkiyT5JVSW5JcmWSNUmeP8sxTJr0TrIoyQ+TXD2h/Oh2wMyBHWXPbX8o2NTrmDWzTIptnc3AcuC3JlYkmZ/kc0muaB+v7ii/KMn17S+Tt48n1ZJ8of3wX59kWVv2QeDH2g/Up9uyTe2/q5L8145jrkxybJI5ST7cHvfaJL/WJb5FSf4tyaeT3JjkgvFfV5Oc0m57XZLlSdKWX5LkzCRrgfcBbwI+3Mb23PHjt20PSfIvSa5J8q9Jdp1w/GclWdHWXZXkqC4xLkhyaccvwK/tfP7t8rFJVnY8/3OTfKP9f/lL4JCO+CZ7Xs9rf928Jsk3kzy3LX9vx2v4f7q9AZIc0W5zTZKvtmV7tf+X1ya5PMlL2vLT2ud8SZJbk7ynYz9va9tfk+RT07yHJtvPB4Hxk++H0/xK/PUkq4EbtvE9lnZf1yX5Vtpff9t9X9K+b8bfR+n2GkkzKckbklzWfu7+OskubfnEc87uwOnAW9v39lvbz86nkvwz8KkkOyf5i/a9fVWSn5lwrGckuTnJ/I71dUlex1PPf89N8uX28/X1dHSKOva3S8fxrk3y5rZ8aVt2XZIzOtpvSvKB9jldnuQ5bflzkny+Lb8m7aitJL/YPverk/xZkjmT7afdZuJz6DzH/0aS/57kG+1r8w/tdotokg6/1W732vZ1Pak91sHtMa5tY9yzLb8kyRltfN9Oez6XZtjXgecBJPnt9jN1XZLfbMueleTv28/CdR1/0y5JMjbN30P7XPa57HNJPdS+rz8PXFJVz62qlwPvB56zFfuYM2F9W34EnTTp3bqlqg6eULYU+Kf2XwCqqls7bQ+qyscWPoBNwG7Ad4DdgZOA09q6vwJe0y7vD9zYLp8FvL9dPgIoYF67vlf7748B1wF7jx9n4nHbf48BPtku7wjc0W67DPjdtnwnYC2weMI+FrXHfnW7vgI4qTOOdvlTwH9vly8B/rSjbiVw7MT1NpZbgUPa8t2AuTSjC77Ylv1f4Bfb5T2AbwPPmhDj7wD/u12eA+w68fVoj7ey4/hfBOa0648fb5rn9Q3gmHZ5Z+CZwBtoOnmhSRZ/EfjpCfHNb1/zxRP+//4EOLVdPhy4ul0+DfiX9v9kHnA3sAPwE+3zn/g+mOw9NNl+FgHXdcR3GPD/Ov/v2fr32JuBi9rX/znAvwML2n3fD+zbvj6Xjcfqw8e2PoBHgas7Hm9tyy8Bxtr3+6Xj5wqaL4qnMPk553jgrI79nwZcCfxYu/47wIp2+cD2/b0zTz5XnQr8Zrv8BuBz7fJKnnz++yqwpF1+BfC1Ls/vDODMjvU9gf/UHnd+G/PXgKPb+uKJ89SHeOK8/pmOmObQ/P15IfB3wA5t+Z8Cb5tmPxOfwyU8+Ry/J5B2+X8CH+l4HU+a8LqO//24Fnhdu3z6+PNt9z2+/ZHAP/T7/eZjOB488fdqLvC3wK8DLwe+BTwL2AW4nmYk05uBj3dsu3v77yXAWOf+uuzfPpd9LvtcPnz08NF+hi+dpG7iOeYs4Ph2+Ts0faxvAsfRnD/PpDkf/057/vgccEX7GD8Xn0ZzPr6E5jz6nrZ8FfBDmr7ohyfE8aTPflu2C7ABeD5wU5fYN23ta+Gjv4+neznJyKmqB5KcB7yH5sMz7meBgzp+yNktzYiG19B0rKiqLye5t2Ob9yQ5pl3eD1hC88d3Ml8C/jjJTjQJtkur6odJ3gC8ZPwXRJovTEuA2yZsf0dV/XO7/Jftc/hD4GeS/C+ajspeNJ3Jv2vbbcmQ+BcAd1bVFe3zfABgwo9abwDelHZ0AU3HaH/gxo42VwArkuwAfKGqnjRMdRJ/XVWPTlL3lOeV5BJgYVV9vo31oTbWN7QxXtVuuwvNa3hpx/5eSfOa39Zue09b/hqajg1V9bUkeyfZra37+6r6EfCjJHfRdHoOb+P+jwn7mew9NNl+uvnX8fhaW/seew1wfvuafj/JPwKHAA+0+17fvl5X0/yR+Kcp9iVN54c19S9qr6S5fOif28/FjjRfDrbknDNudVWNn6tfQ/OFiqr6tyS303RoOq2g+aJ9JvArwF9M3GH7ufwp4K87jrlTl2P/LE1njfaY9yb5aZpfRDe2+/o08NPAF2guBRufE+hK4PXt8uHA29p9PArcn+SXaBIBV7Qx/BhwV9t+sv1003mO3xf4TJIFNK/1xL8hT5JmdN4eVfWPbdEngb/uaPI3HTEsmmpf0lb4sTxxGcvXgT+nSYx9vqr+H0CSvwFeC3wZ+EiaEZlfrKqvb8Vx7HM9lX2uJ7PPJT09L6LpI2yLu6vqZdDMdQrsWFVj7fpfAR+tqn9Ksj9wIc2PidD8KPozwK7ATUnOAU4GXjRNn7TTUcCXq+rbSe5O8vKq2tbnoQFgUmzbnEmTme78svQM4JXjf/DHTTbaOclhNH+QX1VVD7Ydh52nOmhVPdS2+y/AW2my2tD80vbuqrpwmrhr4nqSnWlGGIxV1R1pbhzQGcf/m2afWyrAm6vqpkmDq7q0/cL4X4GVSf6omnlrOuOe+Bp1jW8Lnle3+P6gqv5s+qeyVX7UsfwoU3/mpnoPbel+Hn89tuU9No2teS7STAhwUVUtfVJh8uKt2MdWncPa88X3kxwOHAr8QpdmzwDu24rO05Z6pKrGz3fTfcZCM4rl/U9zP52vz58Af1RVq9vzx2lbFPXkxs8Zni80k56STJ+sr9V+YXkZzWjF30/y1ao6fUsOYp8LsM813X7sc0n9M/FHhM71mUh6T2Up8Mft8qp23aTYdsw5xbZB+yvTZ4F3dBR/BXj3+EqS8Q7bPwNvacveQHN5CjS/LN7b/uE8kOYXsXGPtL/cdfMZ4Jd54hdQaLLfvz6+TZLnJ3lWl233T/KqdvnnaX5xGv+D/R/tyeLYLtuN+wFNVn2im4AFSQ5pj79rl+u5LwTePT4nQpKXTtxJkgOA71fVx4FPAC9rq76f5IVJnkE76m4LdH1eVfUDYH2So9tj7pRmno8LgV/JE/MVLUzy7An7vBz46SSL2zZ7teVfp/3i3HaK/mP8l9tJfA34H0n2nrCfyd5Dk5ns/2PctrzHvk4zJ9OcNPMq/TTwr9PEIfXK5cCrk4zPGfSsNJOvTnbOme4z0flZfT7NyIluXxo/QTOyo3NUxOP7bj/ftyX5H+2+kuQnu+znIuBd4ytp5tv6V+B1SealmQdjKfCPXbbt9FWakTC0n83d27Jjx89TaebZOWCa/WzJOWNDu/z26barqvuBe/PEfGG/tAXPReqFrwNHJ3lm2/85Bvh6kv8EPFhVfwl8mCf6FZ3sc9nnss8l9cf1NKPeu9nMk3MV0yXpO9fHk97jN3JaWFXj8yU+rYRzew45HPhEku8A7wXeMn6+1fbJpNi2+wjNXAPj3gOMpZnI8waeuBvS/wHekOQ64H8A36P5w/plYG6SG2km77y8Y1/LgWvTTsg5wVeA19HMz/JwW/YJmkk+v9ke58/o/gG/CXhXe8w9gXOq6j7g4zRzH1xIM5x+MquA96aZtPW544VtHG8F/iTJNTRfBCeeuH6PZk6Ga5Nc365PdBhwTZKr2v2NZ+BPprkU6F+AO6eI73HTPK9fohnifm27z32q6is080tcluRbwAVM6Py0lzstA/6mfZ7jv0icBry83d8HefKXyW6xXQ98APjHdj9/1FZN9h6abD9301xWdl2SD3dpsi3vsc/TzBF0DU1H8n9V1femikN6GsYnHx5/POnuk+1n7njg/PbzdRlw4BTnnItpfhm8Ou2ExRP8KfCM9jP+GZq5KX7Upd1qmst5OkcDTzz//QLwjvb419MMpZ/o94E928/oNcDPVNWdNOe0i2k+Z1dW1d9O8zr9Bs2lSd+i+SXyoGrunPe7wFfa1+YimrloptL1HN7hNJpLQq8E/qOj/O+AY9rXdeKE+W+nmQz8Wpq7f27RKBxpJlXVN2nmvPpXmjmsPlFVVwEvBv41zeVnp9J8Jieyz2Wfyz6X1B9fA3ZKe2MKgCQvafsat9P06XZKsgfwn7divzOd9O50LPCpqjqgqhZV1X40l897Q6Ht2PiEuuqRNHNRPFpVm9tfDM/pwSU3WxLHIpr5NF4028eWpO1JkjGauSjs4Ejaava5JGnLtCN6z6QZMfYQzST6v1lVNyf5EM2I1dtobni3uqpWtiO0xsbnCkxzufJJVbW2XZ8HnE0zj9hcmvkJT0hzafemqvrDtt11wH+rqu+kmYfsJcCXquq9HfEtouN8nuRi4Iyq+nJHm/cAL6yq8VH9m6pq/HJNbQdMivVYkiU0l1o+g2by43eOT446y3Eswg6aJE0pyck0lyr+QlU5qbGkrWafS5KGw7acz02KbX9MikkaaUlWAP8NuKvbH7x2bpC/oJlv5X+P/7rU1h1Bc8nJHJrLdT44cXtJkiRJ258k+9Fc+n33dFd7tZe6fw7Ytaq6TVOhAWVSTNJIS3P3rU3AeZMkxZ4NHAAcTTOJ7viQ6znAt4HXA+tp5lBZ2s71JEmSJEkacE60L2mkVdWlwD1T1N/VXvL8yISqQ4F1VXVrO/HxKrpPti5JkiRJGkBbdQvSQTFv3rxatGhRv8OQ1CdXXnnlf1TV/D6HsRC4o2N9PfCKbg3bu+osA3jWs5718gMPPLD30UkaSANy/tom9r+k0bY9n7922GGH+smf/Ml+hyGpT6Y6f22XSbFFixaxdu3afochqU+S3N7vGLZGVS2nuSU7Y2Nj5flLGl3b2/mrk/0vabRtz+evnXfe2fOXNMKmOn95+aQkbZsNwH4d6/u2ZZIkSZKk7YBJMUnaNlcAS5IsTrIjcBywus8xSZIkSZK20HZ5+aQkzZQk5wOHAfOSrAdOBXYAqKpzk+wDrAV2Ax5L8pvAQVX1QJITgQuBOcCKqrq+H89BkiRJk9trr736HYKkAWVSTNJIq6ql09R/j+bSyG51a4A1vYhLkiRJM2P+/O3y/gCSZoGXT0qSJEmShtZjjz3W7xAkDSiTYpIkSZKkoXXzzTf3OwRJA8qkmCRJkiRJkkaOSTFJkiRJkiSNHJNikiRJkiRJGjkmxSRJkiRJkjRyTIpJkiRJkobWvHnz+h2CpAFlUkySJEmSNLT23nvvfocgaUCZFJMkSZIkDa3Nmzf3OwRJA8qkmCRJkiRpxiVZkeSuJNdNUn9YkvuTXN0+TmnL90tycZIbklyf5Dc6tjktyYaObY6cLo5bbrll5p6UpKEyt98BSJIkSZKG0krgLOC8Kdp8var+24SyzcDvVNU3k+wKXJnkoqq6oa3/aFX94cyHK2nUOFJMkiRJkjTjqupS4J5t2O7Oqvpmu/wD4EZg4QyHJ0kmxSRJkiRJffOqJNck+VKSn5hYmWQR8FLgGx3FJya5tr08c89uO02yLMnaJGsfeeSRngQuaftnUkySJEmS1A/fBA6oqp8E/gT4Qmdlkl2AzwG/WVUPtMXnAM8FDgbuBD7SbcdVtbyqxqpqbIcdduhV/JK2cybFJEmSJEmzrqoeqKpN7fIaYIck8wCS7ECTEPt0Vf1Nxzbfr6pHq+ox4OPAodMd59nPfnZP4pe0/TMpJkmSJEmadUn2SZJ2+VCa76d3t2V/DtxYVX80YZsFHavHAF3vbNlpzz27XmEpSd59UpIkSZI085KcDxwGzEuyHjgV2AGgqs4FjgV+Pclm4IfAcVVVSV4D/BLwrSRXt7v7/9rRZB9KcjBQwHeAX5sujocffnhGn5ek4WFSTJIkSZI046pq6TT1ZwFndSn/JyCTbPNLWxvHbbfdtrWbSBoRXj4pSZI0RNq7sd2VpOslRWl8LMm69u5tL5vtGCVJkgZBz5NiSY5IclPb8Tq5S/3+SS5OclXbMTuy1zFJkiQNsZXAEVPUvxFY0j6W0dzJTZIkaeT0NCmWZA5wNk3n6yBgaZKDJjT7XeCzVfVS4DjgT3sZkyRJ0jCrqkuBe6ZochRwXjUuB/aYMHG1JEnSSOj1nGKHAuuq6laAJKtoOmI3dLQpYLd2eXfgu9Pu9corIV0vMZckSdLUFgJ3dKyvb8vunNgwyTKa0WTsv//+sxKcJEnSbOn15ZOTdbo6nQb8Yns3kjXAu7vtKMmyJGuTrO1FoJIkSXqyqlpeVWNVNTZ//vx+hyNJ22SfffbpdwiSBtQg3H1yKbCyqj6S5FXAp5K8qKoe62xUVcuB5QBjY2PFWnNj0shypKgkPR0bgP061vdtyyRpKO2+++79DkHSgOr1SLEt6XS9A/gsQFVdBuwMzOtxXJIkSaNqNfC29i6UrwTur6qnXDopScPioYce6ncIkgZUr5NiVwBLkixOsiPNRPqrJ7T5d+A/AyR5IU1SbGOP45IkAJKsSHJXkusmqU+Sj7V30L02ycs66j6U5PokN7ZtHMImqe+SnA9cBrwgyfok70hyQpIT2iZrgFuBdcDHgXf2KVRJmhW33357v0OQNKB6evlkVW1OciJwITAHWFFV1yc5HVhbVauB3wE+nuS3aCbdP76qqpdxSVKHlcBZwHmT1L8RWNI+XgGcA7wiyU8BrwZe0rb7J+B1wCU9jFWSplVVS6epL+BdsxSOJEnSwOr5nGJVtYbmF8nOslM6lm+g+WIpSbOuqi5NsmiKJkcB57VfIi9PskeSBTRJ/J2BHYEAOwDf73G4kiRJkqQZ0uvLJyVpe9f1LrrtHIgXA3e2jwur6sZuO+i8e+7GjV4dLkmSJEmDwKSYJG2DJM8DXkhzA5GFwOFJXtutbVUtr6qxqhqbP3/+bIYpSZIkSZqESTFJmtpkd9E9Bri8qjZV1SbgS8Cr+hCfJEmSprBgwYJ+hyBpQJkUk6SprQbe1t6F8pXA/VV1J82dc1+XZG6SHWgm2e96+aQkSZL6Z7fddut3CJIGVM8n2pekQZbkfOAwYF6S9cCpNJPmU1Xn0two5EhgHfAg8MvtphcAhwPfopl0/8tV9XezGrwkSZKm9eCDD/Y7BEkDyqSYpJFWVUunqS/gXV3KHwV+rVdxSZIkaWbccccd0zeSNJK8fFKSJEmSJEkjx6SYJEmSJEmSRo5JMUmSJEmSJI0ck2KSJEmSJEkaOSbFJEmSJElDa+HChf0OQdKAMikmSZIkSZpxSVYkuSvJdZPUH5bk/iRXt49TOuqOSHJTknVJTu4oX5zkG235Z5LsOF0cu+yyy8w8IUlDx6SYJEmSJKkXVgJHTNPm61V1cPs4HSDJHOBs4I3AQcDSJAe17c8APlpVzwPuBd4xXRCbNm3axvAlDTuTYpIkSZKkGVdVlwL3bMOmhwLrqurWqnoYWAUclSTA4cAFbbtPAkdPt7MNGzZsQwiSRoFJMUmSJElSv7wqyTVJvpTkJ9qyhcAdHW3Wt2V7A/dV1eYJ5U+RZFmStUnWPvLII72KXdJ2bm6/A5AkSZIkjaRvAgdU1aYkRwJfAJbMxI6rajmwHGDXXXetmdinpOHjSDFJkiRJ0qyrqgeqalO7vAbYIck8YAOwX0fTfduyu4E9ksydUC5J28SkmCRJkiRp1iXZp50njCSH0nw/vRu4AljS3mlyR+A4YHVVFXAxcGy7i7cDfzv7kUsaFl4+KUmSJEmacUnOBw4D5iVZD5wK7ABQVefSJLd+Pclm4IfAcW3ia3OSE4ELgTnAiqq6vt3t+4BVSX4fuAr48+ni2G+//aZrImlEmRSTJEmSJM24qlo6Tf1ZwFmT1K0B1nQpv5Xm7pRb7JnPfObWNJc0Qrx8UpIkSZI0tB544IF+hyBpQJkUkyRJkiQNrTvvvLPfIUgaUCbFJEmSJEmSNHJMikmSJEmSJGnkmBSTJEmSJEnSyOl5UizJEUluSrIuycld6j+a5Or28e0k9/U6JkmSJEmSJI22ub3ceZI5wNnA64H1wBVJVlfVDeNtquq3Otq/G3hpL2OSJEmSJI2OAw44oN8hSBpQvR4pdiiwrqpuraqHgVXAUVO0Xwqc3+OYJEmSJEkjYuedd+53CJIGVK+TYguBOzrW17dlT5HkAGAx8LVJ6pclWZtk7caNG2c8UEmSJEnS8Ln//vv7HYKkATVIE+0fB1xQVY92q6yq5VU1VlVj8+fPn+XQJEmSJEnbo+9973v9DkHSgOp1UmwDsF/H+r5tWTfH4aWTkmZZkhVJ7kpy3ST1SfKx9mYh1yZ5WUfd/km+kuTGJDckWTRbcUuSJEmSnp5eJ8WuAJYkWZxkR5rE1+qJjZIcCOwJXNbjeCRpopXAEVPUvxFY0j6WAed01J0HfLiqXkgzh+JdPYpRkiRJkjTDepoUq6rNwInAhcCNwGer6vokpyd5U0fT44BVVVW9jEeSJqqqS4F7pmhyFHBeNS4H9kiyIMlBwNyquqjdz6aqenAWQpYkSZIkzYC5vT5AVa0B1kwoO2XC+mm9jkOSttFkNwzZF7gvyd/Q3CTkH4CTu82LmGQZzSgz9t9//54HLEmSJEma3iBNtC9J25O5wGuBk4BDgB8Hju/W0BuFSJIk9c/ixYv7HYKkAWVSTJKmNtkNQ9YDV1fVre2l4l8AXtZle0mSJPXRjjvu2O8QJA0ok2KSNLXVwNvau1C+Eri/qu6kuZHIHknGh34dDtzQryAlSZLU3b333tvvECQNqJ7PKSZJgyzJ+cBhwLwk64FTgR0AqupcmjkRjwTWAQ8Cv9zWPZrkJOCrSQJcCXx81p+AJEmSpnTXXd4gXFJ3JsUkjbSqWjpNfQHvmqTuIuAlvYhLkiRJktRbXj4pSZIkSZKkkWNSTJIkSZIkSSPHpJgkSZIkacYlWZHkriTXTdPukCSbkxzbrv9Mkqs7Hg8lObqtW5nkto66g2fjuUgaTibFJEmShkySI5LclGRdkpO71B+Q5KtJrk1ySZJ9+xGnpKG3EjhiqgZJ5gBnAF8ZL6uqi6vq4Ko6mOYO3w921gPvHa+vqqunC+K5z33utsQuaQSYFJMkSRoi7RfMs4E3AgcBS5McNKHZHwLnVdVLgNOBP5jdKCWNgqq6FLhnmmbvBj4HTHaLyGOBL1XVg9sax9y53l9OUncmxSRJkobLocC6qrq1qh4GVgFHTWhzEPC1dvniLvWS1HNJFgLHAOdM0ew44PwJZR9oR7p+NMlOk+x7WZK1SdZ+5zvfmZmAJQ0dk2KSJEnDZSFwR8f6+ras0zXAz7XLxwC7Jtl74o46v1Ru3LixJ8FKGmlnAu+rqse6VSZZALwYuLCj+P3AgcAhwF7A+7ptW1XLq2qsqsZ+9KMfzWzUkoaGSTFJkqTRcxLwuiRXAa8DNgCPTmzU+aVy/vz5sx2jpOE3BqxK8h2ayyT/dHxC/dZbgM9X1SPjBVV1ZzV+BPwFzehYSdomXlwtSZI0XDYA+3Ws79uWPa6qvks7UizJLsCbq+q+WYtQkoCqWjy+nGQl8MWq+kJHk6U0I8PoaLegqu5MEuBoYMo7W0rSVEyKSZIkDZcrgCVJFtMkw44Dfr6zQZJ5wD3tJUvvB1bMepSShl6S84HDgHlJ1gOnAjsAVNW502y7iCbB/48Tqj6dZD4Q4GrghBkNWtJIMSkmSZI0RKpqc5ITaebgmQOsqKrrk5wOrK2q1TRfUv8gSQGXAu/qW8CShlZVLd2KtsdPWP8OT50Pkao6/GkHJkktk2KSJElDpqrWAGsmlJ3SsXwBcMFsxyVJ/bBkyZJ+hyBpQDnRviRJkiRpaD3jGX7tldSdZwdJkiRJ0tDauHFjv0OQNKBMikmSJEmShtY999zT7xAkDSiTYpIkSZIkSRo5JsUkSZIkSZI0ckyKSZIkSZIkaeSYFJMkSZIkSdLIMSkmSZIkSRpaL3jBC/odgqQB1fOkWJIjktyUZF2Skydp85YkNyS5Pslf9TomSZIkSZIkjba5vdx5kjnA2cDrgfXAFUlWV9UNHW2WAO8HXl1V9yZ5di9jkiRJkiSNju9///v9DkHSgOr1SLFDgXVVdWtVPQysAo6a0OZXgbOr6l6AqrqrxzFJkiRJkkbEfffd1+8QJA2oXifFFgJ3dKyvb8s6PR94fpJ/TnJ5kiO67SjJsiRrk6zduHFjj8KVJEmSJEnSKBiEifbnAkuAw4ClwMeT7DGxUVUtr6qxqhqbP3/+LIcoSZIkSZKkYdLrpNgGYL+O9X3bsk7rgdVV9UhV3QZ8myZJJkk9l2RFkruSXDdJfZJ8rL1ZyLVJXjahfrck65OcNTsRS5IkSZJmQq+TYlcAS5IsTrIjcBywekKbL9CMEiPJPJrLKW/tcVySNG4l0PWy7dYbaRL1S4BlwDkT6n8PuLQnkUmSJOlpe8YzBuECKUmDqKdnh6raDJwIXAjcCHy2qq5PcnqSN7XNLgTuTqqRCh0AACAASURBVHIDcDHw3qq6u5dxSdK4qroUuGeKJkcB51XjcmCPJAsAkrwceA7wld5HKkmSpG2xZIkXIknqbm6vD1BVa4A1E8pO6Vgu4LfbhyQNmq43DEnyfeAjwC8CPzvVDpIsoxllxv7779+jMCVJkiRJW8NxpJK0bd4JrKmq9dM19EYhkiRJ/XPnnXf2OwRJA6rnI8UkaTs32Q1DXgW8Nsk7gV2AHZNsqqqT+xCjJEmSJvHAAw/0OwRJA8qkmCRNbTVwYpJVwCuA+6vqTuAXxhskOR4YMyEmSZIkSdsPL5+UNNKSnA9cBrwgyfok70hyQpIT2iZraO6Iuw74OM1lk5IkSZpGkhVJ7kpy3TTtDkmyOcmxHWWPJrm6fazuKF+c5BtJ1iX5TJIde/kcJA03R4pJGmlVtXSa+gLeNU2blcDKmYtKkiRpKKwEzgLOm6xBkjnAGTz1bt4/rKqDu2xyBvDRqlqV5FzgHcA5MxOupFHjSDFJkiRJ0oyrqkuBe6Zp9m7gc8Bd0+0vSYDDgQvaok8CR0+33dy5jgWR1J1JMUmSJEnSrEuyEDiG7iO9dk6yNsnlScYTX3sD91XV5nZ9PbBwkn0va7dfu9tuu8147JKGgylzSZIkSVI/nAm8r6oeawaBPckBVbUhyY8DX0vyLeD+Ld1xVS0HlgOMjY3VTAUsabiYFJMkSZIk9cMYsKpNiM0Djkyyuaq+UFUbAKrq1iSXAC+lucxyjyRz29Fi+wIbpjvIhg3TNpE0orx8UpIkSZI066pqcVUtqqpFNPOEvbOqvpBkzyQ7ASSZB7wauKG9AdLFwPhdKt8O/O10x9m0aVNP4pe0/XOkmCRJkiRpxiU5HzgMmJdkPXAqsANAVZ07xaYvBP4syWM0Azk+WFU3tHXvoxld9vvAVcCf9yh8SSPApJgkSZIkacZV1dKtaHt8x/K/AC+epN2twKFPOzhJwssnJUmSJEmSNIJMikmSJEmShtaOO+7Y7xAkDSiTYpIkSZKkobV48eJ+hyBpQJkUkyRJkiRJ0sgxKSZJkiRJGlp33HFHv0OQNKBMikmSJEmShtaDDz7Y7xAkDSiTYpIkSZIkSRo5JsUkSZIkSZI0ckyKSZIkSZIkaeSYFJMkSZIkDa2dd9653yFIGlAmxSRJkiRJQ+uAAw7odwiSBpRJMUmSJEmSJI0ck2KSJEmSpKF1++239zsESQPKpJgkSZIkaWg99NBD/Q5B0oDqeVIsyRFJbkqyLsnJXeqPT7IxydXt43/2OiZJkqRhtgX9r/2TXJzkqiTXJjmyH3FKkiT109xe7jzJHOBs4PXAeuCKJKur6oYJTT9TVSf2MhZJkqRRsIX9r98FPltV5yQ5CFgDLJr1YCVJkvqo1yPFDgXWVdWtVfUwsAo4qsfHlCRJGmVb0v8qYLd2eXfgu7MYnyRJ0kDodVJsIXBHx/r6tmyiN7dD9y9Isl+3HSVZlmRtkrUbN27sRaySRlCSFUnuSnLdJPVJ8rH2EqRrk7ysLT84yWVJrm/L3zq7kUvSpLak/3Ua8ItJ1tOMEnt3tx3Z/5I0DJ75zGf2OwRJA2oQJtr/O2BRVb0EuAj4ZLdGVbW8qsaqamz+/PmzGqCkobYSOGKK+jcCS9rHMuCctvxB4G1V9RPt9mcm2aOHcUrSTFoKrKyqfYEjgU8leUq/0P6XpGGw335dx11IUs+TYhuAzjPQvm3Z46rq7qr6Ubv6CeDlPY5Jkh5XVZcC90zR5CjgvGpcDuyRZEFVfbuqbm738V3gLsBvjJIGwbT9L+AdwGcBquoyYGdg3qxEJ0mSNCB6nRS7AliSZHGSHYHjgNWdDZIs6Fh9E3Bjj2OSpK0x7WVISQ4FdgRu6bYDLz+SNMum7X8B/w78Z4AkL6RJinmCkjSUbrvttn6HIGlA9TQpVlWbgROBC2mSXZ+tquuTnJ7kTW2z97Rz8lwDvAc4vpcxSdJMahP7nwJ+uaoe69bGy48kzaYt7H/9DvCrbf/rfOD4qqr+RCxpWE03d2tHu0OSbE5ybLs+6dytSVYmuS3J1e3j4OniePjhh5/+k5E0lOb2+gBVtYZmAtfOslM6lt8PvL/XcUjSNpr0MqQkuwF/D/zv9tJKSRoIW9D/ugF49WzHJWnkrATOAs6brEGSOcAZwFc6isfnbr05yX8CrkxyYVXd19a/t6ou6FHMkkbIIEy0L0mDbDXwtvYulK8E7q+qO9tLkj5PM9+YnTJJkqQJtmDuVmjufvs5mvlZx7dz7lZJs8KkmKSRluR84DLgBUnWJ3lHkhOSnNA2WQPcCqwDPg68sy1/C/DTwPFbM3xfkiRJjSQLgWN44u7e3dp0m7v1A+1llR9NstMk2z0+p+sjjzwyo3FLGh49v3xSkgZZVS2dpr6Ad3Up/0vgL3sVlyRJ0gg4E3hfVT2W5CmVHXO3vr1j7tb3A9+jSZQtB94HnD5x26pa3tazYMEC50yU1JVJMUmSJElSP4wBq9qE2DzgyCSbq+oLk83dWlV3tos/SvIXwEnTHWThwoXTNZE0okyKSZIkSZJmXVUtHl9OshL4YpsQm3Tu1iQL2vldAxwNTHlnS0maikkxSZIkSdKMa+duPQyYl2Q9cCqwA0BVnTvFpuNzt+6d5Pi27Piquhr4dJL5QICrgRO67+IJt9xyy3RNJI0ok2KSJEmSpBk33dytE9oe37E86dytVXX41saxefPmrd1E0ojw7pOSJEmSJEkaOSbFJEmSJEmSNHJMikmSJEmSJGnkmBSTJEmSJA2t3Xbbrd8hSBpQJsUkSZIkSUNrwYIF/Q5B0oAyKSZJkiRJkqSRY1JMkiRJkjS0br755n6HIGlAmRSTJEmSJA2txx57rN8hSBpQJsUkSZIkSZI0ckyKSZIkSZIkaeSYFJMkSZIkSdLIMSkmSZIkSRpae+yxR79DkDSgTIpJkiRJkobWc57znH6HIGlAmRSTJEmSJEnSyDEpJkmSJEkaWjfddFO/Q5A0oEyKSZIkSZIkaeSYFJMkSZIkSdLIMSkmSZIkSZKkkdPzpFiSI5LclGRdkpOnaPfmJJVkrNcxSZIkSZIkabT1NCmWZA5wNvBG4CBgaZKDurTbFfgN4Bu9jEeSJEmSNFr22muvfocgaUD1eqTYocC6qrq1qh4GVgFHdWn3e8AZwEM9jkeSniTJiiR3Jblukvok+Vg72vXaJC/rqHt7kpvbx9tnL2pJkqTBN10/q6PdIUk2Jzm2o6xrPyvJy5N8q+2bfSxJpotj/vz5T++JSBpavU6KLQTu6Fhf35Y9rv2CuV9V/f1UO0qyLMnaJGs3btw485FKGlUrgSOmqH8jsKR9LAPOAUiyF3Aq8AqaHwBOTbJnTyOVJEnavqxk6n7W+NVFZwBf6Sibqp91DvCrPNE/m3L/AI899tg2hC5pFMzt58GTPAP4I+D46dpW1XJgOcDY2Fj1NjJJo6KqLk2yaIomRwHnVVUBlyfZI8kC4DDgoqq6ByDJRTSdsvOnPOCVV8L0P2hKkiRt97agnwXwbuBzwCEdZf+FLv2sJJcAu1XV5W35ecDRwJemOsDNV11l/0tSV70eKbYB2K9jfd+2bNyuwIuAS5J8B3glsNrJ9iUNkMlGvE47EnZc50jXnkUpSZK0nUmyEDiGdiR+h6n6X+u7lHfbt/0vSdPq9UixK4AlSRbTJMOOA35+vLKq7gfmja+3mf+TqsoTl6Sh8ZSRrms9xUkjy5EKktTpTOB9VfXYFkwNtlU6+1+77rpr8YMfzOj+JW1Hpji/9DQpVlWbk5wIXAjMAVZU1fVJTgfWVtXqXh5fkmbAZCNeN9BcQtlZfsmsRSVJkrT9GwNWtQmxecCRSTYzeT9rQ7vcWd55JZIkbZWezylWVWuANRPKTpmk7WG9jkeSttJq4MQkq2gme72/qu5MciHwfzsmfX0D8P5+BSlJkrS9qarF48tJVgJfrKovtBPtP6WfVVX3JHkgySuBbwBvA/5ktuOWNDz6OtG+JPVbkvNpfomcl2Q9zZ2OdgCoqnNpkvpHAuuAB4FfbuvuSfJ7NJeJA5w+PhmsJEmStqif1dU0/ax30tzV8sdoJtifcpJ9gHnz5k3XRNKIMikmaaRV1dJp6gt41yR1K4AVvYhLkiRpezddP2tC2+MnrHftZ7XzT79oa+LYe++9t6a5pBHS67tPSpIkSZLUN5s3b+53CJIGlEkxSZIkSdLQuuWWW/odgqQBZVJMkiRJkiRJI8ekmCRJkiRJkkaOSTFJkiRJkiSNHJNikiRJkiRJGjkmxSRJkiRJQ+vZz352v0OQNKBMikmSJA2ZJEckuSnJuiQnd6n/aJKr28e3k9zXjzglaTbsueee/Q5B0oCa2+8AJEmSNHOSzAHOBl4PrAeuSLK6qm4Yb1NVv9XR/t3AS2c9UEmaJQ8//HC/Q5A0oBwpJkmSNFwOBdZV1a1V9TCwCjhqivZLgfNnJTJJ6oPbbrut3yFIGlAmxSRJkobLQuCOjvX1bdlTJDkAWAx8bZL6ZUnWJlm7cePGGQ9UkiSpn0yKSZIkja7jgAuq6tFulVW1vKrGqmps/vz5sxyaJElSb5kUkyRJGi4bgP061vdty7o5Di+dlCRJI8qkmCRJ0nC5AliSZHGSHWkSX6snNkpyILAncNksxydJkjQQTIpJkiQNkaraDJwIXAjcCHy2qq5PcnqSN3U0PQ5YVVXVjzglabbss88+/Q5B0oCa2+8AJEmSNLOqag2wZkLZKRPWT5vNmCSpX3bfffd+hyBpQDlSTJIkSZI0tB566KF+hyBpQJkUkyRJkiQNrdtvv73fIUgaUCbFJEmSJEmSNHJMikmSJEmSJGnkmBSTJEmSJEnSyDEpJkmSJEmacUlWJLkryXWT1B+V5NokVydZm+Q1bfnPtGXjj4eSHN3WrUxyW0fdwbP5nCQNl7n9DkCSJEmSNJRWAmcB501S/1VgdVVVkpcAnwUOrKqLgYMBkuwFrAO+0rHde6vqgi0NYsGCBdsQuqRR0PORYkmOSHJTknVJTu5Sf0KSb7VZ/n9KclCvY5IkSZIk9VZVXQrcM0X9pqqqdvVZQHVpdizwpap6cFvj2G233bZ1U0lDrqdJsSRzgLOBNwIHAUu7JL3+qqpeXFUHAx8C/qiXMUmSJEmSBkOSY5L8G/D3wK90aXIccP6Esg+0l11+NMlOk+x3WXtJ5trvfve7Mxy1pGHR65FihwLrqurWqnoYWAUc1dmgqh7oWJ3s1wFJ6oktGM16QJKvth2vS5Ls21H3oSTXJ7kxyceSZHajlyRJ2r5V1eer6kDgaOD3OuuSLABeDFzYUfx+4EDgEGAv4H2T7Hd5VY1V1dgPfvCDnsQuafvX66TYQuCOjvX1bdmTJHlXkltoRoq9p9uOOjP9Gzdu7EmwkkbLFo5m/UPgvKp6CXA68Afttj8FvBp4CfAimo7Z62YpdEmSpKHSXmr540nmdRS/Bfh8VT3S0e7OavwI+AuagRiStE0G4u6TVXV2VT2XJsv/u5O0eTzTP3/+/NkNUNKwmnY0K02y7Gvt8sUd9QXsDOwI7ATsAHy/5xFLkiQNiSTPGx9pn+RlNH2quzuaLGXCpZPt6DHa7Y4Gut7ZUpK2RK/vPrkB2K9jfd+2bDKrgHN6GpEkPaHbaNZXTGhzDfBzwB8DxwC7Jtm7qi5LcjFwJxDgrKq6sdtBkiwDlgHsv//+M/sMJEmSBlSS84HDgHlJ1gOn0vyQSFWdC7wZeFuSR4AfAm8dn3g/ySKa75L/OGG3n04yn6b/dTVwQs+fiKSh1euk2BXAkiSLaZJhxwE/39kgyZKqurld/a/AzUjS4DgJOCvJ8cClNOeyR5M8D3ghTbIf4KIkr62qr0/cQVUtB5YDjI2NOW+iJEkaCVW1dJr6M4AzJqn7Dl2m3qmqw2ckOEmix0mxqtqc5ESaiRHnACuq6vokpwNrq2o1cGKSnwUeAe4F3t7LmCSpw7SjWavquzQjxUiyC/Dmqrovya8Cl1fVprbuS8CrgKckxSRJktQ/Cxc+JbcmSUDvR4pRVWuANRPKTulY/o1exyBJk9iS0azzgHuq6jGaux2taKv+HfjVJH9AM3z/dcCZsxW4JEmStswuu+zS7xAkDaiBmGhfkvqhqjYD46NZbwQ+Oz6aNcmb2maHATcl+TbwHOADbfkFwC3At2jmHbumqv5uNuOXJEnS9DZt2tTvECQNqJ6PFJOkQbYFo1kvoEmATdzuUeDXeh6gJEmSnpYNG6a615ukUeZIMUmSJEmSJI0ck2KSJEmSJEkaOSbFJEmSJEmSNHJMikmSJEmSJGnkmBSTJEmSJA2t/fbbr98hSBpQJsUkSZIkSUPrmc98Zr9DkDSgTIpJkiRJkobWAw880O8QJA0ok2KSJEmSpKF155139jsESQPKpJgkSZIkSZJGjkkxSZIkSZIkjRyTYpIkSZIkSRo5JsUkSZIkSZI0ckyKSZIkSZKG1gEHHNDvECQNKJNikiRJkqShtfPOO/c7BEkDyqSYJEmSJGlo3X///f0OQdKAMikmSZIkSRpa3/ve9/odgqQBZVJMkiRJkiRJI8ekmCRJkiRpxiVZkeSuJNdNUn9UkmuTXJ1kbZLXdNQ92pZfnWR1R/niJN9Isi7JZ5LsOBvPRdJwMikmSZIkSeqFlcARU9R/FfjJqjoY+BXgEx11P6yqg9vHmzrKzwA+WlXPA+4F3jHDMUsaISbFJEmSJEkzrqouBe6Zon5TVVW7+iygJmsLkCTA4cAFbdEngaNnIFRJI8qkmCRJkiSpL5Ick+TfgL+nGS02buf2ksrLk4wnvvYG7quqze36emDhJPtd1m6/dvfdd+9Z/JK2bybFJEmSJEl9UVWfr6oDaUZ8/V5H1QFVNQb8PHBmkudu5X6XV9VYVY3ts88+MxixpGFiUkySJEmS1FftpZY/nmReu76h/fdW4BLgpcDdwB5J5rab7QtsmG7f9957by9CljQETIpJkiRJkmZdkue184SR5GXATsDdSfZMslNbPg94NXBDO//YxcCx7S7eDvztdMe56667ehG+pCHQ86RYkiOS3NTeMvfkLvW/neSG9la8X01yQK9jkqRxW3COOqA9N12b5JIk+3bU7Z/kK0lubM9ji2YzdkmSpEGW5HzgMuAFSdYneUeSE5Kc0DZ5M3BdkquBs4G3tomvFwJrk1xDkwT7YFXd0G7zPuC3k6yjmWPsz2fzOUkaLnOnb7LtksyhObm9nmYSxCuSrO44oQFcBYxV1YNJfh34EPDWXsYlSbDF56g/BM6rqk8mORz4A+CX2rrzgA9U1UVJdgEem8XwJWlSSY4A/hiYA3yiqj7Ypc1bgNNo7vZ2TVX9/KwGKWnoVdXSaerPAM7oUv4vwIsn2eZW4NAZCVDSyOv1SLFDgXVVdWtVPQysAo7qbFBVF1fVg+3q5TTXhUvSbJj2HAUcBHytXb54vD7JQcDcqroIHr+l+INIUp91JPzfSHMOW9qeszrbLAHeD7y6qn4C+M1ZD1SSJKnPejpSjOb2uHd0rK8HXjFF+3cAX+pWkWQZsAxg//33n6n4JI22LTlHXQP8HM2Ii2OAXZPsDTwfuC/J3wCLgX8ATq6qRycexPOXpFn2eMIfIMl4wr9zFOyvAmdX1b0AVTX9hDtXXgnN1D+SJElDYWAm2k/yi8AY8OFu9Z231J0/f/7sBidplJ0EvC7JVcDraO5w9CjNjwqvbesPAX4cOL7bDjx/SZpl3RL+Cye0eT7w/CT/nOTy9nLLp0iyLMnaJGv/f/buPEyuqkz8+PclKwghCxHCEsISRGQJ0CAjLgwCgjqAywi4gYqMjrszzsAwg4g6ovxmZNxGIqK4sTpiRpAtwrAvCYRVIGGTQCBhF1kD7++Pc5uuFN1JJ13dVV31/TzPeerWvefe+1bdrtO33jr33EGKVZIG3WabbdbsECS1qMHuKXY/sFHN815vmRsRewBHAm/JzOcGOSZJ6rbCNiozH6D0FKMaN+w9mfl4RCwE5tX0xDgL2AUHe5U0PIwEpgO7Udq+SyJim8x8vLZSZs4EZgJ0dXUlc8yNSR1rGPcUHTlysL/2ShquBrun2LXA9IjYJCJGAwcCs2orRMT2wAnAvv3qui9JjdOfNmqdiOhuK48ATqpZd3xEdHf92p1lL02SpGbpz4+SC4FZmflCZt4N3EFJkklS23nkkUeaHYKkFjWoSbHMXAp8GjgP+CNwembeEhHHRMS+VbXjgDWBMyJiXkTM6mNzktRQ/WyjdgNuj4g7gHWBr1frvki5dHJ2RNwEBPCjIX4JktSbFSb8gbMo7RsRsQ7lcsq7hjJISRoqDz/8cLNDkNSiBr0faWaeA5xTN++omuk9BjsGSepLP9qoM4Ez+1j3AmDbQQ1QklZSZi6NiO6E/wjgpO6EPzAnM2dVy/aKiFsp4yR+KTPtSiFJkjqKF1dLkiS1mX4k/BP4YlUkSZI6UsvcfVKSJEmSJEkaKibFJEmSJEmS1HFMikmSJEmS2tb06d5cV1LvTIpJkiRJktrWaqv5tVdS72wdJEmSJElta8mSJc0OQVKLMikmSZIkSWpbjz76aLNDkNSiTIpJkiRJkiSp45gUkyRJkiRJUscxKSZJkiRJkqSOY1JMkiRJkiRJHScys9kxrLSI+DNwe7PjUK/WAR5udhB6hXY7Lhtn5uRmB7EqbL+GVLv93bc63+/+Gc7t1xLg3mbH0QH8LLWuTj82w7n98vyrdXT656iVdNKx6LP9GjnUkTTI7ZnZ1ewg9EoRMcdj03o8Li3F9muI+Hc/tHy/299w/TI83PhZal0em2HN868W4eeodXgsCi+flCRJkiRJUscxKSZJkiRJkqSOM1yTYjObHYD65LFpTR6X1uGxGDq+10PL91tqDD9LrctjM3x57FqHx6J1eCwYpgPtS5IkSZIkSQMxXHuKSZIkSZIkSavMpJgkSZIkSZI6zpAlxSJi74i4PSIWRMThvSwfExGnVcuvjohpNcuOqObfHhFvW9E2I2KTahsLqm2OXtE+OlkrHJua5e+JiIyIjr81LLTGsYmIqRFxUURcHxE3RsTbB/dVt54WOQ4d0361yPvdEX/3Q/xef7qalxGxTt1+douIeRFxS0T83+C8Wmnw+FlqXUN8bH5Zzb85Ik6KiFHV/IiI71T1b4yIHQb3VXeWwTjGWjUDPBbbRsSVVft1U0SMHcrY200/jsWbI+K6iFgaEe+tmT+j5jjcGBEHDG3kTZCZg16AEcCdwKbAaOAGYKu6On8P/LCaPhA4rZreqqo/Btik2s6I5W0TOB04sJr+IfDJ5e2jk0urHJvq+VrAJcBVQFez35tml1Y5NpQBGD9Zs917mv3edOhx6Ij2q4Xe77b/u2/Ce709MA24B1inZh/jgVuBqdXzVzf7vbFYVqb4WWrd0oRj83YgqnJKzf+RtwO/r+bvAlzd7PemXcpgHONmv6bhWgZ4LEYCNwLbVc8neSwG/VhMA7YFfga8t2b+FsD0anp9YBEwvtmvaTDLUPUU2xlYkJl3ZebzwKnAfnV19gNOrqbPBN4aEVHNPzUzn8vMu4EF1fZ63Wa1zu7VNqi2uf8K9tHJWuXYAHwV+CbwbKNf5DDVKscmgXHV9NrAAw1+na2uVY5Dp7RfrfJ+d8Lf/ZC91wCZeX1m3tNLHO8H/icz/1TVW9zIFykNAT9LrWuoj805WQGuATas2cfPqkVXAeMjYspgvegOMxjHWKtmIMdiL+DGzLwBIDMfycwXhyjudrTCY5GZ92TmjcBLdfPvyMz51fQDwGJg8tCE3RxDlRTbALiv5vnCal6vdTJzKfAEJUPc17p9zZ8EPF5to35ffe2jk7XEsam6kW+UmWcP/CW1jZY4NsDRwAcjYiFwDvCZgbyoYahVjkOntF+t8n4fTfv/3Q/le708WwATIuLiiJgbER9eydchNZufpdbVlGNTXTb5IeDclYhDq2YwjrFWzUCOxRZARsR51SV9/zQE8bazhvxtR8TOlJ5mdzYorpbkQPtquohYDfhP4B+aHYt6dRDw08zckNL9/+fVMZPamX/3Q2cksCPwDuBtwL9FxBbNDUkalvwstY4fAJdk5qXNDkQaJkYCbwQ+UD2+KyLe2tyQOlvVm/XnwEcy86UV1R/OhuoE/35go5rnG1bzeq0TESMpl6s8spx1+5r/CKVL8she9tXXPjpZKxybtYCtgYsj4h7KWAuzwsH2W+HYAHyMMu4SmXklMBZYZmDfNtcqx6FT2q9Web874e9+KN/r5VkInJeZf8nMhyljS263Uq9Eai4/S61ryI9NRHyZcqnRF1cyDq2awTjGWjUDORYLKYnkhzPzaUovfW9IseoG9LcdEeOAs4Ejq0u+29uqDES2soWS+b2LMoBh90Bvr6ur8ymWHXTv9Gr6dSw7AOJdlIHj+twmcAbLDpz898vbRyeXVjk2dfu7GAfab5ljQxkY9pBq+rWUsZWi2e9PBx6Hjmi/Wuj9bvu/+6F+r2u2eQ/LDg7+WmB2te4awM3A1s1+fyyW/hY/S61bmvA/5VDgCmD1un28g2UH2r+m2e9Nu5TBOMbNfk3DtQzwWEwArqvarpHAhcA7mv2ahmvpz7GoqftTlh1of3T1v+TzzX4dQ/Z+DeGBeTtwB+V61COreccA+1bTYylfThZQBqbctGbdI6v1bgf2Wd42q/mbVttYUG1zzIr20cmlFY5NXTwXY1KsZY4N5c48l1eN6Txgr2a/Lx16HDqm/WqR97sj/u6H+L3+LOWX4KWUJOOJNcu+RLlr3s100EmYpX2Kn6XWLUN8bJZW8+ZV5ahqfgDfr5bdhOe5LX+MLU05Fh8Ebqnar281+7UM99KPY7FT9b/kL5TeerfUHIcXatqxecCMZr+ewSxRvXBJkiRJkiSpYzhosCRJkiRJkjqOSTFJkiRJkiR1HJNiTRIRGRH/UfP8HyPi6EHYz7/UPb+i0fuo2/49EbHSAyTRJAAAIABJREFUd2iLiN0i4g3N2v9KbH//iNhqAOtPi4j31zzviojvrGCd3SLid73MPyQilkTEiRGxRkQ8Ut0ppLbOWRFxQFUW9LYdqRVExIsRMa+mHF7Nv3hV7kQbETMi4u2rsF6vn7e6OgNqB/oZxzJtxSpu4/MRsUbN83MiYvwK1um1Da05PutHxE8i4u/qlu8fEb+PiNWres8PZlssNULN3/XNEXFG7edlJbZxYnd74DlXY3nOJTVXREyqOS97MCLur3k+uoH72SgiThvA+pdFxIwGxLEwIsZHxMSI+MRAt9eP/X2tek+PiojNI+LeiIi6OjdHxI4R8aWI+FNEHD/YcXUik2LN8xzw7iH40rDMCVpmDvgkaJDsBvQaW5Tb9baK/SkDcK+qacDLJ2iZOSczPzuA7Z2WmYdmuXXxecC7uhdExNrAG4H/zczTKHdEklrVM5k5o6YcO8DtzaAMMPoKDWhTBtoO9Mc0atqKVfR5yl2cAMjMt2fm46u4re7j8wBwCuWOUbUOBE7JzGcycwZl8G+p1XX/XW8NPA+s9Jeg6n/wrdVTz7kay3MuqYky85Hu8zLKHbq/XXOe9vyK1o+IEf3cz32ZecBA422giazC/4NVdFxmHpOZC4CHqGmbI2JrYHRmzs3M4yiD5GsQmBRrnqXATOAL9QsiYnJE/Doirq3KrjXzL4iIW6pfqu7tTqpVv07NrZYdVs07Fuj+1f6X1bynqsdTI+IdNfv8aUS8NyJGRMRx1X5vrO8NUFP/gxFxTbXtE3pr9PqqExF7R8R1EXFDRMyOiGmUhucLVd03VfH8MCKuBr5VZezPqmK6KiK2rbY1KSLO735PKHf3WZkY74mIb0XETVXdzav50yLiD9X+ZkfE1Ci/qu4LHFdtc7OqnFu995dGxJY17+d3IuKKiLgrIt5b7fJY4E3V+l+Iml8kI2LniLgyIq6v1ntNr385fav/ovou4Lzq5E0a9iJir+ozcl2UXh1rVvN3qj4zN1Sf47UpJw4HVJ+1AyLi6Ij4eURcDvw8IsZG6fF0U/WZ++u6fa0WEfMjYnLN8wUR8Rb62Q7Uba97/1dW2/14NT+qNvfmKpbuk8L6tqLXtrlqQy6OiDMj4raI+GW1zc8C6wMXRcRFVd2Xe3VEL/8zVsJsYMuImFJt61XAHsBZK7kdqZVcCnSfA3yx+kzeHBGfr+a9KiLOrtqZm7s/q9Xnrys85/Kcy3MudZCIOLjmM/+DKOdJIyPi8Yg4PiJuBHaO0vvq36s26NqI2KFqR+6MnnOhzSNiXjV9aHVOc16U86Vv1OxzZkTMqdqgo1YQ3zsj4pSa53tExFnV9AerdujmiPj3XlY/FnhN9dqOjYhxVRt1XdVOvbNmu1+JiNurNum06PmfMb16DXMj4pKI2KIfb2t9u3JgNU+Drdm3v+zUAjwFjAPuAdYG/hE4ulr2K+CN1fRU4I/V9PeAI6rpvYEE1qmeT6weV6fcxnZS937q91s9vgs4uZoeDdxXrXsY8K/V/DHAHGCTum28FvhfYFT1/AfAh6vpe4B1+qoDTK72tUld3EcD/1izj58CvwNGVM+/C3y5mt4dmFdNf4ee212/o/s9WV6Mda/lHnpuUfth4HfV9P8CB1fTHwXOqonrvTXrzwamV9OvB/5QU+8MSuJ5K2BBNX+37n3UP6f8PYyspvcAft3bOjXrHgJ8r+b5aMovDN3H/lzgnb3ty2JptQK8yLK3fj6gmn8x0FV9ri8BXlXN/2fgqOrv/i5gp2r+OGBkL5+Po4G5wOrV838ATqqmtwT+RLlNeO1n8svA56vpvWo+k/1qB+pe39HADZR2dh1KO7g+8B7gAmAEsG4Vx5Re2ope2+aq3hPAhlV7cyU9/z/uofofUf+cvv9nLLNOzbr1/0u+B3yumj4QOLNuea/bsVhaqdBzTjQS+C3wSWBH4CbgVcCawC3A9tVn9Uc1665dPV4MdNVur5fte87VE6/nXBbLMCy17QawNeWHsO7P0ExKr8yRVbvw7pr1FgIfr6a/C1xPaV/XBR6s5m9e084cCsyvPqOrV23Y+tWy7jZsJOWHjK2q55cBM+rifbmtrZ7/iHK+siE9beco4P+6P7tVrONr46nmjwLGVdOvBuZX07tQzi3HVPHeRc9540XAZtX0rsD5vbynX+uuXz1fH7gfWK16Ph/Ysmb5ocDxzf5baMfSSl2kO05mPhkRPwM+CzxTs2gPYKvouaR4XJQeEW+k6qqdmedGxGM163w2Irq7cW8ETAceWc7ufw/8V0SMoSTYLsnMZyJiL2Dbml/Z1q62dXfNum+lnDReW8W4OrC4bvt91dml2tfd1et4dDkxnpGZL1a/an4KuA34Smb+ofq1chzwZuDd1bbOrnlP3kppgJ6KiGeBB3uJsdspNY/frqb/qnu7wM+Bb9WvVB2TNwBn1ByrMTVVzsrMl4BbI2Ld5bzObmsDJ0fEdMo/lFH9WOdlmfl8RMwC3hsRv6acxJ+3MtuQmqj7sru+7EL5snN59XkbTUkAvQZYlJnXQmlXAWLZIRm6zcrM7rb2jZSTMzLztoi4F6j/Fe8kyhfl4ylf1H5Sv8EVtQNV+/VHSuJqZrX/Z6L03tq5iuOUzHwReCgi/g/YidJ+/nVE/C4z30lJyvXWNj8PXJOZC6v9zaNcMnRZb29AjZX9n1HvFOD/Af9FOcn8+UqsK7WK1bt7J1C+YP2Ykhj7TWb+BSAi/gd4EyXp8R8R8U1KsuPSldjPsDnnqqbfCLynar/OBkb045yrdv+vBg6MiPdV7Vctz7mk4W8PyrnKnJo2575q2fPAb+rqz6oeb6Ik0v4C/CUiXqo+2/UupHwmL6EkqW6qvs9lREykfGafoZwX3trL+t2f0QuAd0TEbylt7+erxz9k5sMAEfEr4M1RetJPoST/jwEmRsT3MvPTlF6xx0bEG4GXgE2j9AQ+kdL2PAc8V9MTdTyl/f11TXu1wrxLZj4QEXdQzv+eoPywctuK1tPAmRRrvuOB61j2y9ZqwC6Z+WxtxT6+5BERu1Eap7/KzKcj4mJKj4c+ZeazVb23AQcAp3ZvDvhMZi7vH3tQfvE8YmXrRMTfLC+uOn+pmX4OqD+xWp4ATqCcoPxjLydltbKP6RVZDXh8OV/kn6uLZ0W+ClyUme+qTkQvXolYup0C/Fu1v99m5gursA2pFQVwQWYetMzMiG1WYht/WXGVHpl5X0Q8FBG7UxJYH+il2oraAYA7gTN5ZTuwvPbmIkoirFuvbXPV/te2NS+ygv/tq/I/oxdXAFMiYjvKF9X6Mcak4eAVyfi+zrUy846I2IEyVuHXImJ2ZvZrfJdheM5V605KAml5XrH/qp35x17qes4lDX9B6W3/b8vMLGMSPpOZ9Z/t7s/nSyz7WX2J3s9ZnsvMR4AZEXEuZZzSxZTk+daZ+XhE/IIVn7ucSuld9TRwZWb+pa82vvIMpbNK/ZjfH6a0gztk5tKIWEhPErA3ATy8gnPDvnRfQvkEXjo5ZBxTrMmqX+1OBz5WM/t84DPdT6LnbhqXA++r5u0FTKjmrw08Vn252ZKSme72QkT09evXacBH6PkFFEoS6ZPd60TEFlHGi6k1m/LL2KurOhMjYuN+1rmKko3fpJr/1ijXnD9DycjfEmVQwXpPU30hjYgDKZcEfAfYGPhNlOvEb6nek+2790/5daGvGLsdUPN4ZTV9BT1f8j5A+QUZ4M/AWvByj5S7I+Jvq31E9QVxeV5evxdrU7rMQummvyoupvzK/ClsSNVergJ2jZ4xaF4VZXyG2ynJmZ2q+WtVJ2XL+6xB+Ux3tylbUC5Vv72XeicCv2DZXhR/Btaq9nkZcE+U8SluiYitl9MO7BcRr6l+BXw38J+U3hWfjIjLI+IuSrLqmmofq9es25+2uV5f78Hy/mf0S3XCexpwMvD7+h9xpGHsUmD/KHcYfBWlh/6lEbE+8HRm/gI4Dtihl3Vb/ZxrYlX/z5Txcm6MiLGUL6Xfrjn/erl9pFzm9HB1znM9cHWUMbwWUs653ly9rn+IiLfV7Kev3lqec0nD34XA+6JnnNJJETF1kPc5hvKZfjIi/kL5keG1UXrYvxb4XZTxvz4QZayzmyiXSb6e0gN4o4i4lpLI3ruKeSSl7fm/un39mZJwW79Kyn0D2KJKiO0JbFDVuwHYNyLGRMRaVDd4yszHgEVR9ciPMt7aitqrbmcCfwP8LT0/oGiQmRRrDf/BshnpzwJd1cnKrfTc/eIrwF4RcTPlg/Ig5UN7LjAyIv5IGRjwqpptzQRujGrQ1zrnA28BLsyeO4icSOmGel21nxOoy+BnucvSvwLnVwmtCyjdTVdYJzOXUMbQ+J+IuAE4nNKldotq/gR6kn21FgM7Vtv65yqm/6CcjGxCGUviCmAJ8IWa/f8/ygnbK2KsMaHa7ufoufHBZ4CPVPM/VC2D0jh9KcrArJtRTt4+Vr2WW4D9+thHtxuBF6MMNll/k4VvAd+IiOtZxV6c1aUDZwKTeGUDL7Wy7gGqu8syd5+s2o5DgFOqz+WVlHEWnqd8ufpu9Tm8gHIicxHlMvR50TN4fa0fAKtVJ02nAYdU3d/rzaKMK1Tbm/dU4EuU9vUSyuUAX6fcreh0+m4HbqR8cZpOaZumU75wjqV8QVsNWJiZD1Z1X6J8of0C/WibezETODeqgfZrLO9/xso4BdgOvwyqjWTmdZQxqq4BrgZOzMzrgW2Aa6Jcbvllylgw9Vr9nOu0apX/pXxRfDWlbduRcpnlzdXyo6t5v6cktw6u5v8X5fzijdWy5yljre1YLTu9Zv+TenkPwHMuadjLzJso30svrD6359N3IrxR7qe0l7dREmSXV/O3AxZQfsD4ECV5tTOlff17Slu1N2U8w50oN/BISlJ7HnBVZp5du6PMfIiSUHsnZQiMHSiXut9GSaLNr6reRDmnugk4p3p8olp2IPCJmvaqX1c8VR1m5gD3Zeaf+rOOBi5e2btRrSrKWBQvVlnqvwL+exW7ZbaUiBgNXAs8C7yhpjdG9/JplPE7tq55fkFmTq+e/4xyx59fRsSmwP90vy9Rdd/v6/LJiLiHMkDuww1/YYMsIg6hxP7pftbfjRVfSiqpRkR0UW5B/qY+lver/aJ8cXqqemxI+zWUIuKpzOxt3I++6t/DMG1bpU4x1Odfw7ld8JxLap6IOJoyvtb/q54/lZlrVp+zIzNzz2r+JZSb0l0eZeiLz2bm/hGxmHIJZrfJwGsy86mafRxCzWe8er5rZnbfIfP3wNcz87Lq+cWUS8Rvy8ynovTyvYxy05Ab+/m6vkbpiXt8P+sfSrl89PP9qa/+s6fY8DKVMojpDZRLBz/e5HgaZRKlJ8Za9H9cm/rr0WuvVe+UsfKeAfaJclv05ap6yvwAeGxFdSUVEXE48GtgeWP5dEr79WTV62795VWKiO6By0dRXo+k1tUp7VcjeM4ltab+tEnd43XPqMoGtQmxfm67rzFbf1yd98yl3DipXwmxyp+Bv4+Io1ZUMSK+RLlK4cmV2L76qSH/vCLiJEqXwMXdvybVLQ9Kt+q3U8aGOqTqnk5EHEzp8g3wtcw8uRExtaPMnE8ZL6vdnEC5vnsT4JtAv36Fa4TMnDZU+2q0zDyNnkshGlZXUpGZx1IuL1yefrVfmXk0vNzTYtjJzOUmw2rqPQMM+x7MUocY0vMvz7kkNUn3eN3HQRmvOzPnLX+V/snM3obo6O+636S0vf2pexxV/Gq8RvUU+ynlWt2+7EMZO2U6ZWyD/4aXB+L8MmVcg52BL0dEb+NJqU1FxIeBFzLzV5QvnztV3V0lqaXZfkkarmy/JHWQvsbrloAGjilWP+5A3bITgIsz85Tq+e3Abt0lM/+ut3oSLP9vqx/r7oZjOkhqEtsvScOV7ZekTrEK4wZeTGnj5gxmXBoaQ5UU+x1wbM3AdLMpdxDcDRibmV+r5v8b8Ez3IHp12ziM0suMV73qVTtuueWWDYlb0vAzd+7chzNzcrPjWBXrrLNOTps2rdlhSGoS2y9Jw9Vwbr9GjRqV2223XbPDkNQky2u/hs2AmJk5k3Kra7q6unLOHJOyUqeKiHubHcOqmjZtGrZfUuey/ZI0XA3n9mvs2LG2X1IHW177NVR3n7wf2Kjm+YbVvL7mS5IkSZIkSYNmqJJis4APR7EL8ERmLgLOA/aKiAnVAPt7VfMkSZIkSZKkQdOQyycj4hTK+GDrRMRCyh0lRwFk5g+Bc4C3AwuAp4GPVMsejYivAtdWmzomMx9tREySJEmSJE2cOLHZIUhqUQ1JimXmQStYnsCn+lh2EnBSI+KQJEmSJKnW5MnD8v4AkobAUF0+KUmSJEnSkHvppZeaHYKkFmVSTJIkSZLUtubPn9/sECS1KJNikiRJkiRJ6jgmxSRJkiRJktRxTIpJkiRJkiSp45gUkyRJkiRJUscxKSZJkiRJalvrrLNOs0OQ1KJMikmSJEmS2takSZOaHYKkFmVSTJIkSZLUtpYuXdrsECS1KJNikiRJkqS2deeddzY7BEktyqSYJEmSJEmSOo5JMUmSJEmSJHUck2KSJEmSJEnqOCbFJHWsiJgYERdExPzqcUIf9c6NiMcj4nd1898aEddFxLyIuCwiNh+ayCVJkiRJA2VSTFInOxyYnZnTgdnV894cB3yol/n/DXwgM2cAvwL+dVCilCRJ0ip79atf3ewQJLUok2KSOtl+wMnV9MnA/r1VyszZwJ97WwSMq6bXBh5odICSJEkamAkTer0YQJIY2ewAJKmJ1s3MRdX0g8C6K7n+ocA5EfEM8CSwS2+VIuIw4DCAqVOnrmKokiRJWhXPP/98s0OQ1KLsKSaprUXEhRFxcy9lv9p6mZmUnl8r4wvA2zNzQ+AnwH/2VikzZ2ZmV2Z2TZ48eZVehyStrIgYERHX14+HWC0bExGnRcSCiLg6IqYNfYSS1LtGt1933333YIQpqQ3YU0xSW8vMPfpaFhEPRcSUzFwUEVOAxf3dbkRMBrbLzKurWacB5w4sWklqqM8Bf6TnMu9aHwMey8zNI+JA4JvAAUMZnCQth+2XpCFhTzFJnWwWcHA1fTDw25VY9zFg7YjYonq+J+XkTZKaLiI2BN4BnNhHldoxFc8E3hoRMRSxSdLy2H5JGkomxSR1smOBPSNiPrBH9ZyI6IqIl0/EIuJS4AzKSdfCiHhbZi4FPg78OiJuoNyd8ktD/gokqXfHA/8EvNTH8g2A+wCq9uwJYFJ9pYg4LCLmRMScJUuWDFasklSr4e3XCy+8MFixShrmvHxSUsfKzEeAt/Yyfw5lEP3u52/qY/3fAL8ZtAAlaRVExDuBxZk5NyJ2G8i2MnMmMBOgq6trZcddlKSVMljt11prrWX7JalXDekpFhF7R8Tt1WCHh/ey/NsRMa8qd0TE4zXLXqxZNqsR8UiSJHWwXYF9I+Ie4FRg94j4RV2d+4GNACJiJLA28MhQBilJvRiU9mu99dZrfKSS2sKAk2IRMQL4PrAPsBVwUERsVVsnM7+QmTMycwbwXeB/ahY/070sM/cdaDySJEmdLDOPyMwNM3MacCDwh8z8YF212jEV31vVsSeFpKYarPZr7bXXbnisktpDI3qK7QwsyMy7MvN5SkZ/v+XUPwg4pQH7lSRJUj9FxDER0f0D5I+BSRGxAPgi8Iqe/pLUKgbafj377LODGZ6kYawRY4q9PNBhZSHw+t4qRsTGwCbAH2pmj42IOcBS4NjMPKuPdQ8DDgOYOnVqA8KWJElqb5l5MXBxNX1Uzfxngb9tTlSStGKNbL/uvffeRoYmqY0M9d0nDwTOzMwXa+ZtnJldwPuB4yNis95WzMyZmdmVmV2TJ08eilglSZIkSZLUphqRFHt5oMPKhtW83hxI3aWTmXl/9XgX5ZeA7RsQkyRJkiRJktSnRlw+eS0wPSI2oSTDDqT0+lpGRGwJTACurJk3AXg6M5+LiHUodxv5VgNikqTWNHcuRDQ7CkmSJEnqeANOimXm0oj4NHAeMAI4KTNviYhjgDmZOauqeiBwat2dQV4LnBARL1F6rR2bmbcONCZJkiRJkiRpeRrRU4zMPAc4p27eUXXPj+5lvSuAbRoRgyQNCzvuCHPmNDsKSc1iT1FJGnJTpkxpdgiSWtRQD7QvSZIkSdKQGTduXLNDkNSiTIpJkiRJktrW008/3ewQJLUok2KSJEmSpLZ13333NTsESS3KpJgkSZIkSZI6jkkxSZIkSZIkdRyTYpIkSZIkSeo4JsUkSZIkSZLUcUyKSZIkSZLa1gYbbNDsECS1KJNikiRJkqS2teaaazY7BEktyqSYJEmSJKltPfXUU80OQVKLMikmSZIkSWpb999/f7NDkNSiTIpJkiRJkiSp45gUkyRJkiRJUscxKSZJkiRJkqSOY1JMkiRJkiRJHcekmCRJkiSpbW200UbNDkFSizIpJkmSJElqW2ussUazQ5DUokyKSZIkSZLa1pNPPtnsECS1KJNikiRJkqS2tWjRomaHIKlFmRST1LEiYmJEXBAR86vHCb3UmRERV0bELRFxY0QcULNsk4i4OiIWRMRpETF6aF+BJEmSJGlVmRST1MkOB2Zn5nRgdvW83tPAhzPzdcDewPERMb5a9k3g25m5OfAY8LEhiFmSJEmS1AAmxSR1sv2Ak6vpk4H96ytk5h2ZOb+afgBYDEyOiAB2B85c3vqSJEmSpNZkUkxSJ1s3M7sHmXgQWHd5lSNiZ2A0cCcwCXg8M5dWixcCG/Sx3mERMSci5ixZsqQxkUuSJEmSBqQhSbGI2Dsibq/G1XnF5UcRcUhELImIeVU5tGbZwdV4PvMj4uBGxCNJ3SLiwoi4uZeyX229zEwgl7OdKcDPgY9k5ksrE0NmzszMrszsmjx58iq9DkmSJK2ajTfeuNkhSGpRIwe6gYgYAXwf2JPSU+LaiJiVmbfWVT0tMz9dt+5E4MtAF+XL6Nxq3ccGGpckAWTmHn0ti4iHImJKZi6qkl6L+6g3DjgbODIzr6pmPwKMj4iRVW+xDYH7Gxy+JEmSBmjs2LHNDkFSi2pET7GdgQWZeVdmPg+cShmnpz/eBlyQmY9WibALKANZS9JQmAV091A9GPhtfYXqjpK/AX6Wmd3jh3X3LLsIeO/y1pckSVJzPfHEE80OQVKLakRSbAPgvprnfY2r856IuDEizoyIjVZyXcfkkTQYjgX2jIj5wB7VcyKiKyJOrOq8D3gzcEjNJeAzqmX/DHwxIhZQxhj78dCGL0mSpBV58MEHmx2CpBY14Msn++l/gVMy87mI+DvKXdp2X5kNZOZMYCZAV1dXn+P+SFJ/ZeYjwFt7mT8HOLSa/gXwiz7Wv4vSW1aSJEmSNMw0oqfY/cBGNc9fMa5OZj6Smc9VT08EduzvupIkSZIkSVKjNSIpdi0wPSI2qcbeOZAyTs/LqgGsu+0L/LGaPg/YKyImRMQEYK9qniRJkiRJkjRoBnz5ZGYujYhPU5JZI4CTMvOWiDgGmJOZs4DPRsS+wFLgUeCQat1HI+KrlMQawDGZ+ehAY5IkSZIkSZKWpyFjimXmOcA5dfOOqpk+Ajiij3VPAk5qRBySJEmdLiLGApcAYyjnemdm5pfr6kyljPE6nvKj5uHV+ZwkNc1gtV+bbLLJ4AQsadhrxOWTkiRJah3PAbtn5nbADGDviNilrs6/Aqdn5vaUoS9+MMQxSlJvBqX9Gj16dMMDldQehuruk5IkSRoCmZnAU9XTUVWpv3N3AuOq6bWBB4YmOknq22C1X4899lijQpTUZkyKSZIktZmIGAHMBTYHvp+ZV9dVORo4PyI+A7wK2KOP7RwGHAYwderUQYtXkroNRvs1ZsyYQYtX0vDm5ZOSJEltJjNfzMwZwIbAzhGxdV2Vg4CfZuaGwNuBn0fEK84LM3NmZnZlZtfkyZMHP3BJHW8w2q9Ro0YNfuCShiWTYpIkSW0qMx8HLgL2rlv0MeD0qs6VwFhgnaGNTpL6ZvslaSiYFJMkSWojETE5IsZX06sDewK31VX7E/DWqs5rKV8qlwxlnJJUz/ZL0lBzTDFJkqT2MgU4uRqXZzXKXdp+FxHHAHMycxbwD8CPIuILlEGrD6kGuJakZrL9kjSkTIpJkiS1kcy8Edi+l/lH1UzfCuw6lHFJ0ooMVvu12WabDTw4SW3JyyclSZIkSW1r5Ej7gkjqnUkxSZIkSVLbeuSRR5odgqQWZVJMkiRJktS2Hn744WaHIKlFmRSTJEmSJElSxzEpJkmSJEmSpI7jiIOSJElasblzIaLZUUjSynv2WXjuORgzptmRSGox9hSTJEmSJLWvpUth333h6aebHYmkFmNPMUmSJK3YjjvCnDnNjkJSswzjnqLTR46E88+HffaB3/0O1lqr2SFJahH2FJMkSZIkta3VXvMaWH99uOQS2GMP8G6UkiomxSRJkiRJbWvJn/8Ml14K06bBNdfAppvCv/0bPPZYs0OT1GQmxSRJkiRJbevRRx8tibBLL4W99oI//xm+9rWSJPuXf4E//anZIUpqEpNikiRJkqT2t+GGcN55cNll5TLKJ5+Eb3wDNtkE9t+/LHvxxWZHKWkImRSTJEmSJHWOXXeFCy6Ayy+Hgw6CESPgt7+FvfeGjTeGww+HW29tdpSShoBJMUmSJElS53nDG+BXv4L77oOvf71cYnn//fDNb8LrXgfbbw/HHgt3393sSCUNkoYkxSJi74i4PSIWRMThvSz/YkTcGhE3RsTsiNi4ZtmLETGvKrMaEY8kSZIkSf2y7rplbLEFC8qllYcdBmuvDfPmwRFHlGTZzjuXZNmCBc2OVlIDDTgpFhEjgO8D+wBbAQdFxFZ11a4HujJzW+BM4Fs1y57JzBlV2Xeg8UiSJEmS1O01r3lN/ypGlEsrTzgBHnqoXFJ50EGwxhpw7bXlssrp02G77eDLX4brroPMwQ1e0qBqRE+xnYEFmXlXZj4jiGQrAAAgAElEQVQPnArsV1shMy/KzKerp1cBGzZgv5K0yiJiYkRcEBHzq8cJvdSZERFXRsQtVU/XA2qW/bLqIXtzRJwUEaOG9hVIkiRp0IwZA/vuWy6vXLIEfv1reP/7Ydw4uPFGOOYY2HHHMgbZpz4Fv/89PPNMs6OWtJIakRTbALiv5vnCal5fPgb8vub52IiYExFXRcT+fa0UEYdV9eYsWbJkYBFLEhwOzM7M6cDs6nm9p4EPZ+brgL2B4yNifLXsl8CWwDbA6sChgx+yJEmSVtZDDz00sA2ssQa8+93wy1/C4sUlAfaJT8CUKWU8sh/8AN7+dpg0Cf7mb8pzxyGThoUhHWg/Ij4IdAHH1czeODO7gPdTvnBu1tu6mTkzM7sys2vy5MlDEK2kNrcfcHI1fTLwiqR8Zt6RmfOr6QeAxcDk6vk5WQGuwR6wkiRJLenxxx9v3MbGjCl3qfzv/4aFC+Gaa+Coo2CHHUpPsd/9rvQc23RT2HJL+Nzn4Oyz4amnGheDpIZpRFLsfmCjmucbVvOWERF7AEcC+2bmc93zM/P+6vEu4GJg+wbEJEkrsm5mLqqmHwTWXV7liNgZGA3cWTd/FPAh4NzlrGtPV0mSpHaz2mqw007wla/A3LnlzpU//jG8971loP7bb4fvfAfe+U6YOBHe8pZy2eUVV8ALLzQ7ekk0Jil2LTA9IjaJiNHAgcAyd5GMiO2BEygJscU18ydExJhqeh1gV+DWBsQkSUTEhdWYX/WlftzDBPocJTUipgA/Bz6SmS/VLf4BcElmXtrX+vZ0lSRJ6gDrrw8f/SiccUYZh+zSS0svsl12gRdfhEsuKQP077prSZLtsw9861tlEP+lS5sdvdSRRg50A5m5NCI+DZwHjABOysxbIuIYYE5mzqJcLrkmcEZEAPyputPka4ETIuIlSoLu2Mw0KSapITJzj76WRcRDETElMxdVSa/FfdQbB5wNHJmZV9Ut+zLlcsq/a2DYkiRJGu5GjYI3vrGUr3wFHnsMLr4YZs+GCy8svcjOPbcUgDXXLMmyN78Z3vSm0gNt7NimvgSpEww4KQZlbB3gnLp5R9VM9/rFNDOvoAxSLUlDbRZwMHBs9fjb+gpV79ffAD/LzDPrlh0KvA14ay+9xyRJktQiVlttSIfS7t2ECfCud5UC5VLLiy8u5aKL4M474bzzSgEYPRq6ukqi7K/+qpT11mtW9FLbakhSTJKGoWOB0yPiY8C9wPsAIqIL+ERmHlrNezMwKSIOqdY7JDPnAT+s1ruy6gH7P5l5zNC+BEmSJK3I9OnTmx3CK22wAXzgA6UAPPBAudzykkvgssvgppvK2GNXXNGzziabwOtfX8ouu8CMGfYmkwbIpJikjpSZjwBv7WX+HODQavoXwC/6WN/2U5IkSY2x/vpwwAGlADz+OFx5ZUmKXXklXH013H13KaeeWuqMHAnbbFN6lHWXrbcuvcwk9Ytf6iRJkiRJbWvRokUrrtRqxo8vA/Hvs095/uKLcMstJTl21VXl8dZb4frrS/nRj0q90aNLomz77XvKNtuUMcskvYJJMUmSJElS23ryySebHcLAjRgB225bysc/XuY99VRJiF17LcyZA9ddB3fcAXPnltItAjbbrFxuud12PdvZeOOyTOpgJsUkSZIkSRpu1lyz3KnyTW/qmffkk3DDDSVZdt115fGPf4QFC0o5s+beUePGlV5k22677OO4cUP/WqQmMSkmSZIkSVI7GDfulYmy558vibF58+DGG0u54QZYsgQuv7yUWtOmlQTZdtv1lE03hVa4i6fUYCbFJEmSJElqV6NH9yS3aj30ULnLZXei7Kabyrhl99xTyqxZPXXXWquMT7bDDmVA/513hs039/JLDXsmxSRJkiRJbWvkSL/29mrddUvZY4+eeUuXlnHJunuT3XBD6WG2aBFcckkp3SZMgF12gTe+sfRM22knGDt26F+HNAC2DpIkSZKktrXZZps1O4ThY+RI2GqrUg48sGf+gw+W8cnmzi0D+199delp9vvflwIwZgy8+c2w116lbLONPcnU8kyKSZIkSZKkvq23HuyzTykAmXDffWU8sksvhcsuK5dfXnBBKV/6Emy0Eey3H+y/f0mWjRrV3Ncg9cKkmCRJkiSpbd1///3NDqH9RMDUqaUcdFCZt2QJXHghnH8+nHdeSZp973ulTJwI73lPqfvmN8OIEc2NX6p4+whJkiRJUtt66qmnmh1CZ5g8uSS9fvITWLiwXGL5L/8Cr30tPPoo/OhHsPvusOGG8MUvwnXXlR5nUhOZFJMkSZIkSY2z2mrlDpVf/zrcemu5tPLII2HTTcv4ZN/+Nuy4Yxm77KtfhQULmh2xOpRJMUmSpDYSEWMj4pqIuCEibomIr/RR730RcWtV51dDHack1bP9amNbbw1f+1pJfl11FXzmM6Vn2W23wVFHwfTp5e6Vxx1X7n4pDRHHFJMkSWovzwG7Z+ZTETEKuCwifp+ZV3VXiIjpwBHArpn5WES8ulnBSlIN2692FwGvf30p//EfZQyyU06Bs86COXNK+ad/gi23hL/5G9hzT9h1V1hjjWZHrjZlUkySJKmNZGYC3QPojKpK/aAtHwe+n5mPVessHroIJal3g9V+jR49upFhqlFGjeq5o+Uzz8A555Tk2Nlnlx5kt91Weo6NGgW77AJveEO5JHOnncq4ZBHNfgVqAybFJEmS2kxEjADmAptTvjxeXVdli6re5cAI4OjMPLeX7RwGHAYwderUQY1ZksD2q2Otvnq5O+V73gMvvACXXVaSZBddVAbkv/TSUrqtsw687nXlssyttoIttiiXYG60URnPTOonk2KSJEltJjNfBGZExHjgNxGxdWbeXFNlJDAd2A3YELgkIrbJzMfrtjMTmAnQ1dXlLcIkDTrbLzFqFPz1X5cC8NhjJSF2zTVw7bWlPPww/N//lVJrzBjYeGOYNq2UjTcuibLussEGMHbsUL8itTCTYpIkSW0qMx+PiIuAvYHaL5ULgasz8wXg7oi4g/Il89omhClJr9DI9uu+++4b1Fg1yCZMgH33LQUgExYuhFtugZtvhj/+EebPL4P4L1pUBupf3mD9kyaV5NgGG8D665cyZcqyZb31wMtuO4JJMUmSpDYSEZOBF6ovlKsDewLfrKt2FnAQ8JOIWIdyOdJdQxupJC1rsNqvp59+ejDCVbNE9PT82nvvZZc99RTcey/cfXcp9923bHngAXjkkVJuvHH5+5k4sSTH1lsP1l2353HddeHVr+6Znjy59FDTsGRSTJIkqb1MAU6uxuVZDTg9M38XEccAczJzFnAesFdE3Aq8CHwpMx9pXsiSBNh+aaDWXLOMNfa61/W+/KWXYPHi0tNs0aKSJHvggZ7pRYtKWbwYHn20lFtvXfF+x40rybH6ss46pUya1PM4aRKMHw8jRjT2tWuVmBSTJElqI5l5I7B9L/OPqplO4ItVkaSWYPulQbfaaj29v5bnxRdLb7JFi+Chh0p58MHyuHhxz7wlS8rzJ58s5c47+x/L+PGlN9qECcuW8eN7ytpr9zzWTq+5pnffbJCGJMUiYm/gvyh3/zgxM4+tWz4G+BmwI/AIcEBm3lMtOwL4GCXL/9nMPK8RMUmSJEmSJK20ESPKJZKvfvWK62aWmwEsWbJsefjhntJ9yWZ3efzxnrIqVlutJ0k2fnxPMm3ChNITbeLEUmp7ra27bunRZjJtGQNOilVdW79Pud57IXBtRMzKzNo+hh8DHsvMzSPiQMp14QdExFbAgcDrgPWBCyNii+qOI5IkSZIkDchY7zaowRTRk4R6zWv6t86LL5aE2GOPlfLoo+WxO1H22GPwxBM9z594YtnnzzzTs+7KWH31ciOB9deHqVPLuGxTp8Lmm5cydSqM7KwLChvxancGFmTmXQARcSqwH1CbFNsPOLqaPhP4XkRENf/UzHyOcueQBdX2rlzuHufONbspSZIkSVqhjTfeuNkhSMsaMaJnfLFV8cILyybJ6hNsjz5aeqR191pbvLhc/vn003DXXaX0ZuRImD69Z1y2bbeFHXaAjTdu2xxMI5JiGwC197hdCLy+rzqZuTQingAmVfOvqlt3g952EhGHAYdBuQZTkiRJkiSp44wa1TOI/8r485/LOGn33w9/+lO5I+c995Sx0BYsKDcg+OMfSznzzJ71Jk2CHXeEXXeFN70JXv96WGONhr6kZhk2/eIycyYwE6CrqyuZM6fJEUlqmjb9lUKSJEmNd++99zY7BKk1rLVWKVts0fvyp5+G226DW24pZd68cqXeww/D+eeXAiUpt8su8La3lbLDDmWcs2GoEUmx+4GNap5vWM3rrc7CiBgJrE0ZcL8/60qSJEmStEqeffbZZocgDQ9rrFESXDvs0DMvs/Qqu/pquOwyuPRSuOGG8njppfCv/1oG8X/Xu+A974HddhtW45I1IpV3LTA9IjaJiNGUgfNn1dWZBRxcTb8X+EN1K91ZwIERMSYiNgGmA9c0ICZJkiRJkiQNREQZU+x974PvfAeuv76MWfbrX8Nhh5XB+R96CH74Q9hzT1hvPfjc50ribBgYcFIsM5cCnwbOA/4InJ6Zt0TEMRGxb1Xtx8CkaiD9LwKHV+veApxOGZT/XOBT3nlSkiRJkiSpRY0fD+9+N5xwQhmT7Prr4cgjy903H3mkJM9mzCjjkJ14IrRwb82GXPSZmedk5haZuVlmfr2ad1Rmzqqmn83Mv83MzTNz5+47VVbLvl6t95rM/H0j4pEkSZIkSdIgiygJsK99rQzQP3cufPrTMGECXHcdfPzjMG0a/Pu/lx5mLWZ4joQmSQ0QERMj4oKImF89TuilzoyIuDIibomIGyPigF7qfCcinhqaqCVJkrQy1miTu+RJLS+ijEf23e/CAw/Az38O221XLq888kjYZBM49lh45plmR/oyk2KSOtnhwOzMnA7Mrp7Xexr4cGa+DtgbOD4ixncvjIgu4BXJNEmSJLWGjTbaaMWVJDXW2LHwwQ+WSysvuAD22AOefBKOOKJcZvmLX5RB/JvMpJikTrYfcHI1fTKwf32FzLwjM+dX0w8Ai4HJABExAjgO+KchiVaSJEmShpOIkhC74AI4/3zYdlu47z740Idgn31Kj7ImMikmqZOtm5mLqukHgXWXVzkidgZGA3dWsz4NzKrZRl/rHRYRcyJizpIlSwYasyRJklbC3Xff3ewQJEG5O+V118FJJ8GkSXDeebDNNnDGGU0LyaSYpLYWERdGxM29lP1q62VmAn32342IKcDPgY9k5ksRsT7wt8B3VxRDZs7MzK7M7Jo8efIAX5EkSZJWxvPPP9/sECR1GzECPvIRuOmm0lPs0Ufhfe+DT3wCli4d8nBGDvkeJWkIZeYefS2LiIciYkpmLqqSXov7qDcOOBs4MjOvqmZvD2wOLIgIgDUiYkFmbt7YVyBJkiRJbWbKFDj7bPjhD+GLX4QTToBFi+DUU2H11YcsDHuKSepks4CDq+mDgd/WV4iI0cBvgJ9l5pnd8zPz7MxcLzOnZeY04GkTYpIkSZLUTxHwyU/C7NkwYQLMmgV77QWPPTZkIZgUk9TJjgX2jIj5wB7VcyKiKyJOrOq8D3gzcEhEzKvKjOaEK0mSJElt5g1vgMsugw03LI9veQs88cSQ7NrLJyV1rMx8BHhrL/PnAIdW078AftGPba3Z8AAlSZI0YGuu6Wma1PK22gquuKL0FLvpJnj/+0vPsREjBnW39hSTJEmSJLWtDTbYoNkhSOqPjTYq44xNnAjnnANHHjnouzQpJkmSJEmSpObbdFM444zSQ+yb34Rf/WpQd2dSTJIkSZLUtu68885mhyBpZey+Oxx/fJn+2MfghhsGbVcmxSRJkiRJbWvp0qXNDkHSyvrUp+CjH4Vnny3TmYOyG5NikiRJkiRJah0R8J//CZMnw+WXw6mnDspuTIpJkiRJkiSptay9Nvz7v5fpL30J/vKXhu/CpJgkSZIkSZJaz0c+AjvsAPffD8ce2/DNmxSTJEmSJLWtcePGNTsESatqxAj4znfK9HHHwT33NHTzJsUkSZIkSW1rypQpzQ5B0kDsuiu8//3w3HNw5JEN3bRJMUmSJEmSJLWub3wDVlsNTj8dHnqoYZs1KSZJkiRJalvz589vdgiSBmrqVHjnO2HpUvjpTxu2WZNikiRJkqS29dJLLzU7BEmN8Hd/Vx5nzoQGfa5NikmSJEmSJKm1ve1tpcfYXXfB7NkN2aRJMUmSJEmSJLW2ESPg0EPL9MyZDdnkgJJiETExIi6IiPnV44Re6syIiCsj4paIuDEiDqhZ9tOIuDsi5lVlxkDikSRJkiRJUpv66EdLcuyss+DBBwe8uYH2FDscmJ2Z04HZ1fN6TwMfzszXAXsDx0fE+JrlX8rMGVWZN8B4JEmSJEl62fjx41dcSdLwsMEGPQPu/+QnA97cQJNi+wEnV9MnA/vXV8jMOzJzfjX9ALAYmDzA/UqSJEmStELrrrtus0OQ1EjdA+7/6EcDHnB/oEmxdTNzUTX9ILDc1iYidgZGA3fWzP56dVnltyNizHLWPSwi5kTEnCVLlgwwbEmSpPYUEWMj4pqIuKEavuIry6n7nojIiOgayhglqTe2X5L6Za+9So+xu++GG24Y0KZWmBSLiAsj4uZeyn619TIzgVzOdqYAPwc+kpndqbwjgC2BnYCJwD/3tX5mzszMrszsmjzZjmaSJEl9eA7YPTO3A2YAe0fELvWVImIt4HPA1UMcnyT1ZVDar9tvv72hQUpqshEjYO+9y/T55w9oUytMimXmHpm5dS/lt8BDVbKrO+m1uLdtRMQ44GzgyMy8qmbbi7J4DvgJsPOAXo0kSVKHq86tnqqejqpKbz9cfhX4JvDsUMUmSctj+yWp3/bcszxecMGANjPQyydnAQdX0wcDv62vEBGjgd8AP8vMM+uWdSfUgjIe2c0DjEeSJKnjRcSIiPj/7d15mFXVme/x368oRmWmhNJCEZkHCwOB2B01KESS2GraENNtEuwOapJrTGfoGzumvYmmn6utdryaSR7aiEOUbjJIayIRgiRt1ATDUAXKoMHIJEiUQRAo6r1/nF3pQ1nzqTNUne/nefZz9rDW3u/e69Si6mXvtVcr9R+WT0bEc/W2v0vS0Ih4vJn9MHwFgJzKRv919OjRLEYMIC8uuECypV//Wjp4sM27yTQpdoukmbY3SZqRLMv2FNvzkzIflXSupCttr06mScm2h2xXSaqSNEjSNzOMBwAAoOhFxLGImCSpQtJU2xPqttkukfRvkr7Ugv0wfAWAnMpG/9W1a9fsBQwgPwYNkt71LunIkVRirI1KM4khIvZIuqCB9SslzU3mH5T0YCP1z8/k+AAAAGhcRLxpe7mkWfqfO/J7S5og6anUzfoaImmx7YuT3+EAIO/ovwA0a+ZM6fnnU49QXnhhm3aR6Z1iAAAAKCC2y2z3S+Z7Spop6cW67RGxNyIGRcSwiBgm6VlJ/EEJIO+y1X8NGDAgi1EDyJv3vz/1mcFg+yTFAAAAOpdyScttr5X0O6XG5HnM9k22L85zbADQlKz0Xzz+DXRSf/EXUq9eUlWVtGNHm3aR0eOTAAAAKCwRsVbSWQ2sv7GR8u/LdkwA0BLZ6r9qa2szCwxAYereXTr3XOmJJ6SlS6VPfKLVu+BOMQAAAABAp7Vp06Z8hwAgW+oeoXzyyTZVJykGAAAAAACAjmfmzNTnk09KEa2uTlIMQFGyPcD2k7Y3JZ/9GygzyfYzttfZXmv78rRttv0vtjfafsH2dbk9AwAAAAAocuPHS+Xl0s6dUnV18+XrISkGoFhdL2lZRIyUtCxZru+gpE9GxHilXgd+Z90bkSRdKWmopDERMVbSI9kPGQAAAADwZ7Y0Y0Zq/qmnWl2dpBiAYnWJpAXJ/AJJl9YvEBEbI2JTMr9d0i5Jda8v+oykmyKiNtm+K+sRAwAAAACO9+53pz7XrGl1VZJiAIrV4Iioe2/vTkmDmypse6qkbpJeSladIely2ytt/9z2yCbqXp2UW7l79+72iB0AAAAtNGjQoHyHACCbzjwz9bl2baurlrZzKABQMGwvlTSkgU03pC9ERNhudFRG2+WSHpA0p+7OMEndJb0dEVNs/7WkeyWd01D9iJgnaZ4kTZkypfWjPwIAAKDNBg4cmO8QAGRTXVKsulo6dkzq0qXFVUmKAei0ImJGY9tsv2a7PCJ2JEmvBh9/tN1H0uOSboiIZ9M2bZX042T+J5J+0E5hAwAAoB3V1NTkOwQA2dS/vzR0qPTqq9LmzdLo0S2uyuOTAIrVYklzkvk5kh6tX8B2N6USXvdHxKJ6m38qaXoyf56kjVmKEwAAABl46aWXmi8EoGNr4yOUJMUAFKtbJM20vUnSjGRZtqfYnp+U+aikcyVdaXt1Mk1Kq3+Z7SpJ/1fS3NyGDwAAAACQJFVWpj5bOdg+j08CKEoRsUfSBQ2sX6kkwRURD0p6sJH6b0r6UDZjBAAAAAC0AHeKAQAAAAAAoOi08U4xkmIAAAAAAADouEaMkHr0kP74R+nNN1tcjaQYAAAAAKDTOumkk/IdAoBsKy2Vxo9PzVdVtbgaSTEAAAAAQKfVv3//fIcAIBfa8AglSTEAAAAAQKd15MiRfIcAIBfaMNg+STEAAAAAQKf1hz/8Id8hAMgFkmIAAAAAAAAoOnVJsaoq6dixFlUhKQYAAAAAAICObeBA6ZRTpIMHpZdfblGVjJJitgfYftL2puSzwREMbR+zvTqZFqetP932c7Y3215ou1sm8QAAAAAAAKBI1d0t1sLB9jO9U+x6ScsiYqSkZclyQw5FxKRkujht/a2SvhURIyS9IelTGcYDAAAAAACAYlT3BsoWjiuWaVLsEkkLkvkFki5taUXblnS+pEVtqQ8AAAAAQHOGDBmS7xAA5EqO7xQbHBE7kvmdkgY3Uq6H7ZW2n7Vdl/gaKOnNiKhJlrdKOqWxA9m+OtnHyt27d2cYNgAAAACgGPTt2zffIQDIlTFjUp8vvdSi4qXNFbC9VFJDqfUb0hciImxHI7s5LSK22R4u6Ze2qyTtbVGE/7P/eZLmSdKUKVMaOw4AAAAAAH/29ttv5zsEALly2mmpz1dekSIku8nizSbFImJGY9tsv2a7PCJ22C6XtKuRfWxLPl+2/ZSksyT9SFI/26XJ3WIVkrY1Fw8AAAAAAC31yiuv5DsEALnSv7904onSgQPSG29IAwY0WTzTxycXS5qTzM+R9Gj9Arb72+6ezA+S9JeS1kdESFou6SNN1QcAAAAAAACaZR9/t1gzMk2K3SJppu1NkmYky7I9xfb8pMxYSSttr1EqCXZLRKxPtn1F0hdtb1ZqjLF/zzAeAAAAAAAAFKtWJMWafXyyKRGxR9IFDaxfKWluMv8bSRMbqf+ypKmZxAAAAAAAAABIyumdYgAAAAAAAEBhICkGAAAAAIBUXl6e7xAA5BJJMQAAAAAApD59+uQ7BAC5VJcU27Kl2aIkxQAAAAAAndbBgwfzHQKAXOJOMQAAAAAApFdffTXfIQDIpSFDpG7dpD17pLfearIoSTEAAAAAAAB0DiUl0qmnpuabuVuMpBgAAAAAAAA6jxY+QklSDAAAAAAAAJ0HSTEAAIDiY7uH7d/aXmN7ne1vNFDmi7bX215re5nt0/IRKwCko/8C0G5IigEAABSlw5LOj4hKSZMkzbL9nnplVkmaEhFnSlok6V9zHCMANCQr/dcpp5zS7oECKHAkxQAAAIpPpBxIFrsmU9QrszwiDiaLz0qqyGGIANCgbPVfJ554YrvGCaADICkGAE2zPcD2k7Y3JZ/9GygzyfYzyS38a21fnrbtAtu/t73a9n/bHpHbMwCAhtnuYnu1pF2SnoyI55oo/ilJP29kP1fbXml75e7du7MRKgAcJxv919atW7MRKoBCRlIMAJp1vaRlETFS0rJkub6Dkj4ZEeMlzZJ0p+1+ybbvSboiIiZJ+qGkr+UgZgBoVkQcS/qmCklTbU9oqJztj0uaIum2RvYzLyKmRMSUsrKy7AUMAIls9F9vvfVW9gIGUJgqKqSSEmn79iaLkRQDUMwukbQgmV8g6dL6BSJiY0RsSua3K/W/lnV/GYakPsl8X0lN97gAkGMR8aak5Uol9Y9je4akGyRdHBGHcx0bADSF/gtARrp2lU4+WYposhhJMQDFbHBE7Ejmd0oa3FRh21MldZP0UrJqrqSf2d4q6ROSbmmkHo8fAcgZ22V1d7Ta7ilppqQX65U5S9I9Sv1BuSv3UQLAO9F/AWhXpzX/clqSYgA6NdtLbVc3MF2SXi4iQvUGcq23n3JJD0j6u4ioTVZ/QdIHI6JC0g8k/VtDdXn8CECOlUtabnutpN8pNSbPY7Zvsn1xUuY2SSdK+s9kXMTF+QoWANLQfwFoPy1IipXmIAwAyJuImNHYNtuv2S6PiB1J0qvB/2203UfS45JuiIhnk3VlkirTBn9dKOmJ9o0eAFovItZKOquB9TemzTfaNwJAvtB/AWhX3CkGAE1aLGlOMj9H0qP1C9juJuknku6PiEVpm96Q1Nf2qGR5pqQXshgrAAAA2mDo0KH5DgFAPgwb1mwR7hQDUMxukfQftj8l6RVJH5Uk21MkfToi5ibrzpU00PaVSb0rI2K17ask/ch2rVJJsr/P9QkAAACgab169cp3CADygccnAaBxEbFH0gUNrF+p1CD6iogHJT3YSP2fKHUXGQAAAArUvn378h0CgHzg8UkAAAAAQDHbsWNH84UAdD6nntpsEZJiAAAAAAAA6Fx69ZLKyposklFSzPYA20/a3pR89m+gzPTkVbl109u2L0223Wf7D2nbJmUSDwAAAAAAACBJuvnmJjdneqfY9ZKWRcRIScuS5eNExPKImBQRkySdL+mgpF+kFfnHuu0RsTrDeAAAAAAAAADpmmua3JxpUuwSSQuS+QWSLkN1QLgAABodSURBVG2m/Eck/TwiDmZ4XAAAAAAAAKDNMk2KDY6IulELd0oa3Ez5j0l6uN66f7G91va3bHdvrKLtq22vtL1y9+7dGYQMAAAAACgWp7XgDXQAilOzSTHbS21XNzBdkl4uIkJSNLGfckkTJS1JW/1PksZIerekAZK+0lj9iJgXEVMiYkpZMwOlAQAAAAAgST169Mh3CAAKVGlzBSJiRmPbbL9muzwidiRJr11N7Oqjkn4SEUfT9l13l9lh2z+Q9OUWxg0AAAAAQLP27t2b7xAAFKhMH59cLGlOMj9H0qNNlP0b1Xt0MkmkybaVGo+sOsN4AAAAAAD4s507d+Y7BAAFKtOk2C2SZtreJGlGsizbU2zPrytke5ikoZJW1Kv/kO0qSVWSBkn6ZobxAAAAAAAAAM1q9vHJpkTEHkkXNLB+paS5actbJJ3SQLnzMzk+AAAAAAAA0BaZ3ikGAAAAAAAAdDgkxQAAAAAAAFB0SIoBAAAAADqt008/Pd8hAChQJMUAAAAAAJ1Wt27d8h0CgAJFUgwAAAAA0Gm98cYb+Q4BQIEiKQYAAAAA6LR27dqV7xAAFCiSYgAAAAAAACg6JMUAAAAAAABQdEiKAQAAAAAAoOiQFAMAAAAAAEDRISkGAAAAAOi0zjjjjHyHAKBAkRQDAAAAAHRapaWl+Q4BQIEiKQYAAAAA6LT27NmT7xAAFCiSYgAAAACATuv111/PdwgAChRJMQAAAAAAABQdkmIAAAAAAAAoOiTFAAAAAAAAUHRIigEAAAAAAKDokBQDULRsD7D9pO1NyWf/BsqcZvv3tlfbXmf702nbJtuusr3Z9l22ndszAAAAQHNGjhyZ7xAAFCiSYgCK2fWSlkXESEnLkuX6dkg6OyImSZom6XrbJyfbvifpKkkjk2lW9kMGAABAa5SU8GcvgIbROwAoZpdIWpDML5B0af0CEXEkIg4ni92V9Ju2yyX1iYhnIyIk3d9QfQAAAOTX7t278x0CgAJFUgxAMRscETuS+Z2SBjdUyPZQ22slvSrp1ojYLukUSVvTim1N1jVU/2rbK22v5JcyAACA3PrTn/6U7xAAFCiSYgA6NdtLbVc3MF2SXi652ysa2kdEvBoRZ0oaIWmO7QaTZ42JiHkRMSUippSVlbX5XACgJWz3sP1b22uSsRC/0UCZ7rYXJmMiPmd7WO4jBYDj0X8ByLWMkmK2ZyedVa3tKU2Um2V7Q9JxXZ+2/vSkI9ucdGzdMokHAOqLiBkRMaGB6VFJryWPQdY9DrmrmX1tl1Qt6RxJ2yRVpG2uSNYBQL4dlnR+RFRKmiRplu331CvzKUlvRMQISd+SdGuOYwSAhtB/AcipTO8Uq5b015J+1VgB210kfUfSBySNk/Q3tsclm2+V9K2kQ3tDqQ4OAHJlsaQ5yfwcSY/WL2C7wnbPZL6/pPdK2pA8drnP9nuSt05+sqH6AJBrkXIgWeyaTPXvhE0fU3GRpAt4gy6AfKP/ApBrGSXFIuKFiNjQTLGpkjZHxMsRcUTSI5IuSTqu85XqyKRGBrkGgCy6RdJM25skzUiWZXuK7flJmbGSnrO9RtIKSbdHRFWy7bOS5kvaLOklST/PZfAA0BjbXWyvVuoO2Ccj4rl6RU5RapxERUSNpL2SBjawH8ZEBJBT2ei/jh49mu2wAXRQpTk4xp87rcRWSdOU6rjeTDqyuvUNDlItpTo1SVcni4dtV2chVmRukKTX8x0E3qGztctp7bGTiNgj6YIG1q+UNDeZf1LSmY3UXylpQmuO+fzzzx+w3dx/JqB9dLbvfaHjerdMu/RfzYmIY5Im2e4n6Se2J0REq393ioh5kuZJku3dtl9p51DxTvwsFa5ib5uO3H/t5/evglHsP0eFpJjaotH+q9mkmO2lkoY0sOmGZEyenKjXqa2MiEbHMEP+0DaFiXYpKBtoi9zge59bXO/CFBFv2l4uaZZSw17U2SZpqKSttksl9ZW0p5l98aaQHOBnqXDRNrnVnv2X+P2rYPBzVDhoi5Rmk2IRMSPDY9R1WnXqBqPeI6mf7dLkbjEGqQYAAMiQ7TJJR5M/KHtKmql3DkRdN6biM5I+IumXyVt4ASBv6L8A5FqmA+23xO8kjUzeNNlN0sckLU46ruVKdWRSI4NcAwAAoFXKJS23vVap38OejIjHbN9k++KkzL9LGmh7s6QvSrq+kX0BQC7RfwHIqYzGFLP9YUl3SyqT9Ljt1RFxoe2TJc2PiA9GRI3tayUtkdRF0r0RsS7ZxVckPWL7m5JWKdXBtcS8TOJGVtE2hYl2KRy0Re5wrXOL610gImKtpLMaWH9j2vzbkmbnMi60GD9LhYu2ybIs9l+0XeGgLQoHbSHJ3GkKAAAAAACAYpOLxycBAAAAAACAgkJSDAAAAAAAAEUnZ0kx27Nsb7C92fY7BkO03d32wmT7c7aHpW37p2T9BtsXNrfPZFD/55L1C5MB/ps8RjErhLZJ236Z7bBd9K+GlQqjbWyfanu57VW219r+YHbPuvAUSDsUTf9VINe7KL73Ob7W1ybrwvagesd5n+3VttfZXpGdswWyh5+lwpXjtnkoWV9t+17bXZP1tn1XUn6t7Xdl96yLSzbaGG2TYVucafuZpP+qst0jl7F3Ni1oi3Nt/952je2PpK2flNYOa21fntvI8yAisj4pNcD+S5KGS+omaY2kcfXKfFbS95P5j0lamMyPS8p3l3R6sp8uTe1T0n9I+lgy/31Jn2nqGMU8FUrbJMu9Jf1K0rOSpuT72uR7KpS2UWoAxs+k7XdLvq9NkbZDUfRfBXS9O/33Pg/X+ixJwyRtkTQo7Rj9JK2XdGqyfFK+rw0TU2smfpYKd8pD23xQkpPp4bR/Rz4o6efJ+vdIei7f16azTNlo43yfU0edMmyLUklrJVUmywNpi6y3xTBJZ0q6X9JH0taPkjQymT9Z0g5J/fJ9TtmccnWn2FRJmyPi5Yg4IukRSZfUK3OJpAXJ/CJJF9h2sv6RiDgcEX+QtDnZX4P7TOqcn+xDyT4vbeYYxaxQ2kaSbpZ0q6S32/skO6hCaZuQ1CeZ7ytpezufZ6ErlHYolv6rUK53MXzvc3atJSkiVkXElgbi+FtJP46IPybldrXnSQI5wM9S4cp12/wsEpJ+K6ki7Rj3J5ueldTPdnm2TrrIZKON0TaZtMX7Ja2NiDWSFBF7IuJYjuLujJpti4jYEqm3vdbWW78xIjYl89sl7ZJUlpuw8yNXSbFTJL2atrw1WddgmYiokbRXqQxxY3UbWz9Q0pvJPuofq7FjFLOCaJvkNvKhEfF45qfUaRRE20j6uqSP294q6WeSPpfJSXVAhdIOxdJ/Fcr1/ro6//c+l9e6KaMk9bf9lO3nbX+ylecB5Bs/S4UrL22TPDb5CUlPtCIOtE022hhtk0lbjJIUtpckj/T97xzE25m1y3fb9lSl7jR7qZ3iKkgMtI+8s10i6d8kfSnfsaBBfyPpvoioUOr2/weSNgM6M773uVMqabKkD0m6UNI/2x6V35CADomfpcLxXUm/iohf5zsQoIMolfReSVcknx+2fUF+Qypuyd2sD0j6u4ioba58R5arX/C3SRqatlyRrGuwjO1SpR5X2dNE3cbW71HqluTSBo7V2DGKWSG0TW9JEyQ9ZXuLUmMtLDaD7RdC20jSp5Qad0kR8YykHpKOG9i3kyuUdiiW/qtQrncxfO9zea2bslXSkoh4KyJeV2psycpWnQmQX/wsFa6ct43t/6PUo0ZfbGUcaJtstDHaJpO22KpUIvn1iDio1F36vJCi7TL6btvuI+lxSTckj3x3bm0ZiKy1k1KZ35eVGsCwbqC38fXK/C8dP+jefyTz43X8AIgvKzVwXKP7lPSfOn7g5M82dYxingqlbeod7ykx0H7BtI1SA8NemcyPVWpsJef7+hRhOxRF/1VA17vTf+9zfa3T9rlFxw8OPlbSsqRuL0nVkibk+/owMbV04mepcKc8/JsyV9JvJPWsd4wP6fiB9n+b72vTWaZstHG+z6mjThm2RX9Jv0/6rlJJSyV9KN/n1FGnlrRFWtn7dPxA+92Sf0v+Id/nkbPrlcOG+aCkjUo9j3pDsu4mSRcn8z2U+uNks1IDUw5Pq3tDUm+DpA80tc9k/fBkH5uTfXZv7hjFPBVC29SL5ymRFCuYtlHqzTxPJ53paknvz/d1KdJ2KJr+q0Cud1F873N8ra9T6n+Ca5RKMs5P2/aPSr01r1pF9EsYU+eZ+Fkq3CnHbVOTrFudTDcm6y3pO8m2KvF7bsG3MVNe2uLjktYl/de/5vtcOvrUgrZ4d/JvyVtK3a23Lq0djqb1Y6slTcr3+WRzcnLiAAAAAAAAQNFg0GAAAAAAAAAUHZJiAAAAAAAAKDokxQAAAAAAAFB0SIoBAAAAAACg6JAUAwAAAAAAQNEhKQYAAAAAAICiQ1IMBc/2MNuHbK9uZb3LbW+2/Vi2YgOAptB/Aeio6L8A5IvtgbZXJ9NO29vSln+TheNdaXu37flpy99upOxy2wdsT2nvOJAfpfkOAGihlyJiUmsqRMRC269J+nKWYgKAlqD/AtBR0X8ByLmI2CNpkiTZ/rqkAxFxe5YPuzAirm1BbNNtP5XlWJBD3CmGvLL9bttrbfewfYLtdbYnNFNnmO0Xbd9ne6Pth2zPsP207U22p+YqfgDFi/4LQEdF/wWgo7J9IPl8n+0Vth+1/bLtW2xfYfu3tqtsn5GUK7P9I9u/S6a/bOGhTrb9RNK//WvWTgh5x51iyKuI+J3txZK+KamnpAcjoroFVUdImi3p7yX9TtLfSnqvpIslfVXSpdmJGABS6L8AdFT0XwA6iUpJYyX9SdLLkuZHxFTbn5f0OUn/IOn/SfpWRPy37VMlLUnqNGeSpLMkHZa0wfbdEfFqNk4C+UVSDIXgJqV+sXpb0nUtrPOHiKiSJNvrJC2LiLBdJWlYVqIEgHei/wLQUdF/AejofhcROyTJ9kuSfpGsr5I0PZmfIWmc7bo6fWyfGBEHmtn3sojYm+x7vaTTJJEU64RIiqEQDJR0oqSuknpIeqsFdQ6nzdemLdeK7zWA3KH/AtBR0X8B6Oha0ieVSHpPRLydwb6PiT6u02JMMRSCeyT9s6SHJN2a51gAoDXovwB0VPRfAIrBL5R6lFKSZLtVLw9B50e2E3ll+5OSjkbED213kfQb2+dHxC/zHRsANIX+C0BHRf8FoIhcJ+k7ttcqlf/4laRP5zckFBJHRL5jAJpke5ikxyKiybciNVL3fZK+HBEXtXNYANAs+i8AHRX9F4BiYftKSVMi4toWln9KqT5uZTbjQm7w+CQ6gmOS+tpe3ZpKti+X9F1Jb2QlKgBoHv0XgI6K/gtAsTgk6QO25zdX0PZyScMlHc16VMgJ7hQDAAAAAABA0eFOMQAAAAAAABQdkmIAAAAAAAAoOiTFAAAAAAAAUHRIigEAAAAAAKDokBQDAAAAAABA0SEpBgAAAAAAgKJDUgwAAAAAAABFh6QYAAAAAAAAig5JMQAAAAAAABQdkmIAAAAAAAAoOiTFAAAAAAAAUHRIigEAAAAAAKDokBQDAAAAAABA0SEpBgAAAAAAgKJDUgwAAAAAAABFh6QYAAAAAAAAig5JMQAAAAAAABQdkmIAAAAAAAAoOiTFAAAAAAAAUHRIigEAAAAAAKDokBQDAAAAAABA0SnNdwAAAAAAAAD1Pf/88yeVlpbOlzRB3NSDptVKqq6pqZk7efLkXS2tRFIMAAAAAAAUnNLS0vlDhgwZW1ZW9kZJSUnkOx4UrtraWu/evXvczp0750u6uKX1yLQCAAAAAIBCNKGsrGwfCTE0p6SkJMrKyvYqdVdhy+tlKR4AAAAAAIBMlJAQQ0sl35VW5blIigEAAAAAAKDokBQDAAAAAABowFe+8pUhI0aMGD9q1KhxY8aMGffLX/7yBEm6/PLLT3v++ed7tGWfGzZs6DZy5MjxranTpUuXyWPGjBk3cuTI8R/4wAeG79+/v1X5nJtuuumk9DrnnXfeiNdff71LY+W/+MUvnnzjjTcObun+77rrroG2J//0pz/tXbfugQce6Gd78g9+8IP+Ld3PY4891nv69OkjMi3TUiTFAAAAAAAA6lm6dOkJS5Ys6VdVVbV+48aN65cvX75x+PDhRyRp4cKFr0yePPntXMXSvXv32hdffHH9pk2b1nXt2jXuuOOOspbWramp0T333DP4wIEDf84BrVixYvOgQYOOtWeMI0eOPPTwww8PqFt+5JFHBowePfpQex6jvZEUAwAAAAAAhc2enJWpCdu2bes6YMCAmp49e4YklZeX1wwbNuyoJE2dOnX0r371q16S1KtXr7M+97nPnTJ69OhxlZWVY1599dVSSVq3bl33ysrKMaNGjRp33XXXndyrV6+z6h+jpqZG11xzTcWECRPGjho1atxtt902qLlL8d73vvfA5s2bu0vSjBkzzhg/fvzYESNGjL/99tv/XLdXr15nXXXVVRWjR48ed/3115fv2rWr63nnnTdq2rRpoyTplFNOmbhjx45SSfr2t789cNSoUeNGjx497tJLLz29/vHWrVvX/Zxzzhk5fvz4sZMnTx69atWqBu+QmzZt2oFVq1adcPjwYe/du7dky5Yt3cePH3+wbvujjz7ae+zYseNGjRo1bvbs2cMOHTpkSVq0aFGf008/ffy4cePGLlq0qF9d+X379pXMnj172MSJE8eOHTt23IMPPtivoeNmgqQYAAAAAABAPZdeeum+7du3dxs2bNiEj3/846c+/vjjJzZU7tChQyVnn332gQ0bNqw/++yzD9x9991lknTttdcO/exnP7tr48aN6ysqKo42VPfOO+8c1Ldv32PV1dUvrFmz5oUFCxaUvfjii90ai+no0aNasmRJn4kTJx6SpIceemjLunXrXli9evX6e+65Z/DOnTu71MU0bdq0tzZs2LD+9ttv33HSSScdXbFixcbnnntuY/r+Vq5c2eP2228vX7FixcYNGzasv+eee/5Y/5hz58497bvf/e4f161b98Jtt9229TOf+cypDcVmW+eee+6+H//4x31++MMf9ps1a9abddsOHjzoa6655vSFCxe+tHHjxvU1NTW67bbbyg4ePOhrr7122OLFizdXV1e/sGvXrq51db761a+WT58+fV9VVdULv/71rzd87Wtfq9i3b1+75rFK23NnAAAAAAAA7S7i+Vwfsm/fvrXV1dXrn3jiid7Lli3rPWfOnDNuvPHGrdddd92e9HJdu3aNj33sY3slafLkyW8tXbq0jyStWrXqxF/84hebJWnu3Ll7vv71r1fUP8bSpUv7vPjii70WL17cX5L279/fZf369T3GjBlzJL3c4cOHS8aMGTNOkqZNm7b/85///OuSdOuttw5+/PHH+0nSzp07u65bt67HkCFD3urSpYuuvPLKN5o7xyVLlvT5q7/6qzfKy8trJGnw4MHHPVK5d+/eklWrVp04e/bsM+rWHTlyxI3t74orrvjTnXfeOXj//v1d7rzzzle/8Y1vlEvSmjVrelRUVBw+88wzD0vSlVdeuec73/nOSTNmzNhfUVFxeOLEiYeT+nvmz59fJklPPfVUnyVLlvS76667hiTXwJs3b240YdgWJMUAAAAAAAAaUFpaqosuumj/RRddtP/MM8889MADDwysnxQrLS2NkpKSP5evqalpNGlUX0T4jjvu+ONll122r6lydWOKpa977LHHeq9YsaL3ypUrX+zdu3ft1KlTRx86dKhEkrp161ZbWpp5yufYsWPq3bt3Tf1jN2b69OkHP/3pT/fs2bNnbV0CrK0iQosWLdpcWVl53H62b9/etbE6rcXjkwAAAAAAAPWsWbOme1VVVfe65VWrVvWsqKg40lSddJMmTTpw33339Zeke++9d0BDZWbOnLn3e9/7Xtnhw4ctSWvXru3e0kcE33zzzS59+/Y91rt379pVq1b1WLNmzQmNlT3hhBOO7d279x37vfDCC/f913/9V/+6xy5fe+21495IOWDAgNqKiooj9957b39Jqq2t1TPPPNOzqbhuvvnmrTfffPO29HWVlZVvb9u2rVt1dXV3Sbr//vsHnnPOOfsnTZr09rZt27qtW7euu5QanL+uzvTp0/fdcccdg2trayVJTz/9dJPHbQvuFAMAAAAAAKhn3759Xa677rpT9+3b16VLly4xbNiwwwsWLHilpfXvvvvuV6+44orTb7vttvLzzz9/34knnviOtz1+4QtfeH3Lli3dJ06cODYiPGDAgKM/+9nPXmrJ/i+77LK98+bNKxs+fPj44cOHv11ZWflWY2XnzJnz+qxZs0YNHjz4SPq4YlOmTHn7S1/60o5zzjlnTElJSUyYMOHgj370oy3pdR9++OGXr7rqqtNuvfXW8pqaGn/4wx/+09lnn93oWyU/+tGPvuOut169esX3v//9LbNnzz7j2LFjqqysPPjlL395d8+ePePuu+9+5aKLLhrRs2fP2mnTph04cOBAF0m65ZZbtl999dWnjhkzZlxtba2HDh16ePny5Ztbcm1ayhHRnvsDAAAAAADI2Jo1a7ZUVla+nu842mr//v0lJ5xwQm1JSYnmzZvXf+HChQOWLVvWooQX2mbNmjWDKisrh7W0PHeKAQAAAAAAtLOnn3661+c///lTI0J9+vQ5dt99923Jd0w4HkkxAAAAAACAdjZr1qwDGzZsaNEA9cgPBtoHAAAAAACFqLa2trbFb3JEcUu+K7WtqUNSDAAAAAAAFKLq3bt39yUxhubU1tZ69+7dfSVVt6Yej08CAAAAAICCU1NTM3fnzp3zd+7cOUHc1IOm1UqqrqmpmduaSrx9EgAAAAAAAEWHTCsAAAAAAACKDkkxAAAAAAAAFB2SYgAAAAAAACg6JMUAAAAAAABQdEiKAQAAAAAAoOj8f730W2/bJBRWAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -508,7 +518,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/notebooks/create-model.ipynb b/examples/notebooks/create-model.ipynb index ace959edd2..9b3c4089b1 100644 --- a/examples/notebooks/create-model.ipynb +++ b/examples/notebooks/create-model.ipynb @@ -600,7 +600,7 @@ "var_pts = {x: 100}\n", "mesh = pybamm.Mesh(geometry, submesh_types, var_pts)\n", " \n", - "spatial_methods = {\"SEI layer\": pybamm.FiniteVolume}\n", + "spatial_methods = {\"SEI layer\": pybamm.FiniteVolume()}\n", "disc = pybamm.Discretisation(mesh, spatial_methods)\n", "disc.process_model(model)" ] @@ -710,7 +710,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/notebooks/models/SPM.ipynb b/examples/notebooks/models/SPM.ipynb index 47a3dd06c0..4f61b697ee 100644 --- a/examples/notebooks/models/SPM.ipynb +++ b/examples/notebooks/models/SPM.ipynb @@ -291,7 +291,7 @@ ], "source": [ "for k, method in model.default_spatial_methods.items():\n", - " print(k,'is discretised using',method.__name__,'method')" + " print(k,'is discretised using',method.__class__.__name__,'method')" ] }, { @@ -309,7 +309,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 11, @@ -359,6 +359,16 @@ "Solving using ScipySolver solver...\n", "Finished.\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/scott/Projects/PyBaMM/venv/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py:146: RuntimeWarning: invalid value encountered in greater_equal\n", + " up = (g <= 0) & (g_new >= 0)\n", + "/home/scott/Projects/PyBaMM/venv/lib/python3.7/site-packages/scipy/integrate/_ivp/ivp.py:147: RuntimeWarning: invalid value encountered in less_equal\n", + " down = (g >= 0) & (g_new <= 0)\n" + ] } ], "source": [ @@ -615,9 +625,9 @@ "\t- Electrolyte current density\n", "\t- Electrolyte current density [A.m-2]\n", "\t- Negative electrolyte current density\n", - "\t- Negative electrolyte current density [V]\n", + "\t- Negative electrolyte current density [A.m-2]\n", "\t- Positive electrolyte current density\n", - "\t- Positive electrolyte current density [V]\n", + "\t- Positive electrolyte current density [A.m-2]\n", "\t- X-averaged concentration overpotential\n", "\t- X-averaged electrolyte ohmic losses\n", "\t- X-averaged concentration overpotential [V]\n", @@ -635,8 +645,6 @@ "\t- Positive electrode current density [A.m-2]\n", "\t- Electrode current density\n", "\t- Positive current collector potential\n", - "\t- Local current collector potential difference\n", - "\t- Local current collector potential difference [V]\n", "\t- Ohmic heating\n", "\t- Ohmic heating [W.m-3]\n", "\t- Irreversible electrochemical heating\n", @@ -650,8 +658,8 @@ "\t- Volume-averaged total heating\n", "\t- Volume-averaged total heating [W.m-3]\n", "\t- Positive current collector potential [V]\n", - "\t- Local potential difference\n", - "\t- Local potential difference [V]\n", + "\t- Local current collector potential difference\n", + "\t- Local current collector potential difference [V]\n", "\t- X-averaged open circuit voltage\n", "\t- Measured open circuit voltage\n", "\t- X-averaged open circuit voltage [V]\n", @@ -714,7 +722,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6YAAAEYCAYAAABP3evHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXwV5fX48c/JvpCNJLKFACKgiCwSIktFW7ugtiqKCFZlUxS0WrX9/qR1b23tprVWQFQ2qyAgKq2otdalCggBQWQR2XcIECBkX87vj5ngNQK5CbmZe5Pzfr3mlZlnZu49EbzcM89znkdUFWOMMcYYY4wxxithXgdgjDHGGGOMMaZps8TUGGOMMcYYY4ynLDE1xhhjjDHGGOMpS0yNMcYYY4wxxnjKElNjjDHGGGOMMZ6yxNQYY4wxxhhjjKcivA6gttLS0rR9+/Zeh2GM8cjy5csPqGq613HUN/tsM6bpaqjPNRGZCvwY2K+q3U5wXoCngMuAQmCkqq5wz40A7ncv/a2qzqjp/exzzZimrbafbSGXmLZv356cnByvwzDGeEREtnkdQyDYZ5sxTVcDfq5NB/4OzDzJ+UuBTu52ATAJuEBEmgMPAVmAAstFZIGq5p3qzexzzZimrbafbTaU1xhjjDGmCVDVj4BDp7jkSmCmOpYAySLSCvgR8K6qHnKT0XeBQYGP2BjTlFhiaowxxhhjANoAO3yOd7ptJ2s3xph6Y4mpMcYYY4ypFyIyVkRyRCQnNzfX63CMMSHEElNjjDHGGAOwC2jrc5zhtp2s/VtUdYqqZqlqVnp6o5unzhgTQJaYGmOMMcYYgAXATeLoCxxR1T3AO8APRSRFRFKAH7ptxhhTb0JuVl5jjDHGGFN7IjILuBhIE5GdODPtRgKo6mRgIc5SMRtxlosZ5Z47JCK/AZa5L/Woqp5qEiVjjKk1S0yNMaaWRGQQzlp/4cDzqvp4tfOZwAwg2b3mPlVd2OCBGmOMD1UdXsN5BW4/ybmpwNRAxGWMMWBDeY0xplZEJBx4Bme9v67AcBHpWu2y+4E5qtoLGAZMbNgojTHGGGPqj6riPLsKnEadmN41+zMmzF/NnGU72LAvn8rKwP7HNMY0CdnARlXdrKqlwGyctf98KZDo7icBu+vrzd9bt4+hkxdTUl5RXy9pjDHGGHNSFZXKg2+sYeIHmwL6Po12KK+qcqy4nPfX72fW0u0AJERH0L1tEue1SaZdahyZzZ2tVVIMEeGNOkc3xtSfE63nd0G1ax4G/i0iPwPige+f6IVEZCwwFiAzM9OvN4+KCGPp1kPMydnJjX3b1S5yY4wxxphaKC6r4M5Zn/Hvtfu4deCZqCoiEpD3arSJqYjwwsg+VFYqWw4W8Nn2w6zckcdn2w/z/P82U+7TexoeJrROjiEjOY7WybG0SYmlTXIMbZLjaJUcQ+ukWGKjwj38bYwxIWY4MF1V/yIi/YAXRaSbqlb6XqSqU4ApAFlZWX4N6fjOWWn0bpfCpPc3MjQrg+gI+2wyxhhjTP07XFjKmBk5rNiex4M/7sro73QI6Ps12sS0SliY0DG9GR3TmzGkdwYA5RWV7D1azPZDhew4VMiOQ0VsO1TI7sNFfLLxAPvyi6k+hDo5LpKWiTG0To6lVVIMLRJjaJkYwxmJ0bRIdI5T4iID9gTBGBM0/FnPbwwwCEBVF4tIDJAG7D/dNxcR7rqkEzdNXcrcnJ3cYL2mxhhjjKlnO/MKGTF1KTsOFfH34edzefdWAX/PRp+YnkhEeBgZKXFkpMRBx2+fL6uoZO+RYnYdLmL34SL2HClmz5Ei9h4pZs+RYlbuOMyhgtJv3RcZLqQ3iyY9IZr0hBj3ZzTpzaJIbRZNarzzM61ZFIkxkYSFWRJrTAhaBnQSkQ44Cekw4Ppq12wHLgGmi8g5QAyQW18BXNgpjfMzk5n4/kaGZrUlKsJKEYwxxhhTP9buPsrIaUspKqtg5phs+p6Z2iDv2yQT05pEhofRtnkcbZvHnfSakvIK9h8tYX9+MXuPlLD3aDG5+SXk5jttO/MKWbkjj4MFpd/qfQVn+HBKXCQpcVE0j3e25LgoUuIiSY6LJDk2iiT3fGJsBEmxkSTFRhIbGW69ssZ4SFXLReQOnMXlw4GpqrpGRB4FclR1AXAv8JyI3I0zEdJIrcep7ESEu77fmRFTlzJ3+Q5+eoH1mhpjjDHm9H2y8QC3vrichJgI5t3Wny4tExrsvS0xraPoiPAak1dwhg3nFZZxsKCEA/mlHCxwkte8wlIOFZSRV1DKocJSNu4/Rl5hKYcLy75R/1pdZLiQGBNJYmwkCTERzhbt7DeLiSAhJpKE6Ajio91jdz8+OpxmVe3REURHhFmCa0wduWuSLqzW9qDP/lpgQCBjGNgpjV6ZyUx8fxPX9rZeU2OMMcacnjdW7uIXc1dxZlozpo/uQ6uk2AZ9f0tMAywiPOz4kF5a1ny9qlJQWsFhN0k9XFjGkaIyjhY7P48UlXG0qIyjxeXkF5eRX1xObv4xjhY5xwWl/i0hER4mxEeFu0mru0U5yWuzGCd5rUpkE2MiSIx1kuGk2EgSY5yfKXGRNpuxMR6pqjUdOW0Z85bv5PoL/JvV1xhjjDHGl6oy5aPN/P6t9VzQoTlTbsoiKTayweOwxDTIiMjxpDAjpfb3V1YqBaXlFJRUcKzESVyd/XIKSsopKC3/er+k4nhb1f72gkKOlTjXHCsuP2XvLUBKXOTx+tk0t762RWIMLZOij08Q1TIphrgo+6tmTH27qHM6Pdsm88z7GxnSO8N6TY0xxhhTKxWVym/+tZbpi7ZyefdWPDG0h2cz/lu20MiEhYkznDcmEme+lbpTVUrKK8kvLv9Gr+1Rt+f24DFnaPLBY6UcPFbKuj1H+WhDCfkl5d96rYSYiONJqjOLcTTpzaJp7ia1zeOjSI2PIiU+ikjrhTUNRET6A+3x+SxU1ZmeBVRLTq1pJ0ZNW8arK3YyPNt6TY0xxhjjn+KyCu6Zs5KFq/cyekAH7r/8HE8nZ7XE1JyUiBATGU5MZLgzFNlPBSXl7D1azD53FuO9R4vZf9T5ufdoCRv3H2B/fgkVJ+mNjYkMc5Nrp2Y2MSaC2Mhw4qLCiY2KIC7K2a+KLSYyjJgIn/3IcKIjwoiOCCc6MozoiDCiIsKICg8jOjKcqPAwIsPFamybOBF5EWde7pVA1Rh4BUImMQW4uHM6Pdxe02vOt15TY4wxxtTsSGEZt7yYw9Ith7j/8nO4+cIzvQ7JElNT/+KjI46vHXsyFZXK4cJSDhWUcrDg6595BaXHa2fzi8s56u7vP1pCYVk5RaUVFJZWUFRWccLZjv0lAlHhXyesURHf3I8M992Xb7RFhocRGSHHjyPChYgw59qIMCEiPIyocOdnRJi47c7rREb4vIb7useT6GrJtCXOAZcFdK3P2XK9ICL83O01nbl4a1D8w2KMMcaY4LX7cBEjpy1ly4ECnhrWkyt7tvE6JMASU+OR8DBxalObRdOpDvdXDTMuKaukuLyC4rIKissqKS6roLTCaS8pr6Ck3G0rr/xGe2l5pXN/eSVlFZXHz5e6x1XthaXllFWo01759bVlFUrZ8TY9ae9vXYUJxPn0DsdFRZAYG+EsIxTrLCmUFBdJanwULZNiaZUUQ6ukGHcIt/HTFzhTku3xOpDTdXHndL539hn8buE6OqTFc8k5LbwOyRgTYKFeimCM8caXe/MZMXUpBSXlzBiVTf+z0rwO6ThLTE1I8h1mnIT3yVhlpVJeqZRVVLqbUl5ZSXmFUuq2lVfo8XO+ybCTYDtJdGm5k2gXlVZQUFJBUZkzMVVhaTlHi8rZcqCAw0Wl5BWWUVpe+a04EqIjaJUcQ6cWCZzbOpGurRI5t3VSrYZiNyFpwFoRWQqUVDWq6hXehVQ3IsLTw3sxbMoSbn95BbNu6UuvzDrMnmaMCQmNpRTBGNOwlmw+yC0zc4iLCmfObf04p1Wi1yF9gyWmxtSDsDAhyh2221CKyyo4cKyEvUeK2X2kmD2Hi9hzpJideUWs2nGYNz//uiMwPSGa7PbNuaJnay7uku7ZbGtB5mGvA6hP8dERTB3Zh2smLWLMjBxeHdefDmnxXodljAmMRlGKYIxpOG9+voe7X1lJZmocM0Zn0ya5Ydco9YclpsaEqJjIcDJS4shIiTvh+SNFZazdfZS1e46yZtcRPtyQy5ur95AYE8Fl57Xiip6tuaBDKuEezr7mJVX9UERaAH3cpqWqut/LmE5XekI0M0Znc82kRYyYupRXx/W33nJjGqdGU4pgjAm8qR9v4TdvrqV3ZgrPj8giOS7K65BOKGCJqYjEAB8B0e77zFPVh6pdMxL4E7DLbfq7qj4fqJiMaUqSYiPp1zGVfh1TASivqOTjjQdYsHI3/1y1m9nLdtA6KYbHrj6P73Y5w+NoG56IDMX5/PkAEOBpEfmlqs7zNLDT1CEtnhdGZDH8uSWMmbGMWbf0JT7ankEa08g0mlIEY0zgVFYqj7+9nikfbWbQuS3567CexEQG76i5QH5bKQG+p6rHRCQS+FhE3lLVJdWue0VV7whgHMYYICI8jIu7nMHFXc6gqLSC/6zbxzPvb2TUtGWMHXgmv/hhl6a21MivgT5VvaQikg78BwjpxBSgV2YKfx9+PmNfzGH8SyuYclNvG75tTOPysNcBGGOCW2l5Jb+ct4o3Vu7mpn7teOgn5wb9KLmAfQtVxzH3MNLdrBbCmCAQGxXOT3q05vXbB3Bj33ZM+Wgz105exLaDBV6H1pDCqg3dPUgAPxMb2ve7tuD3V5/HhxtyufXF5RSXVdR8kzEmJKjqh8B6IMHd1rltNRKRQSLypYhsFJH7TnC+nYi8JyKfi8gHIpLhc65CRFa624L6+n2MMfUrv7iMUdOX8sbK3fzfoC48ckXwJ6UQ4C9hIhIuIiuB/cC7qvrpCS67xv3wmycibU/yOmNFJEdEcnJzcwMZsjFNSkxkOL+5qhuTb+jNlgMFXP63j3lj5a6ab2wc3haRd0RkpFtW8Caw0OOY6tV1fTJ53E1Ob5mZQ1GpJafGNAZuKcJS4FpgKPCpiAzx475w4BngUqArMFxEula77M/ATFXtDjwK/N7nXJGq9nQ3GzZsTBDad7SYoc8u4dPNh/jLtT0Yf/FZiAR/UgoBTkxVtUJVewIZQLaIdKt2yT+B9u6H37vAjJO8zhRVzVLVrPT09ECGbEyTNKhbSxbedSFnt0zgrtkr+dt7X3kdUsCp6i+BKUB3d5uiqv/P26jq37DsTP40pAcfbzzA6OnLKCwt9zokY8zpqypFGKGqNwHZwAN+3JcNbFTVzapaCswGrqx2TVfgv+7++yc4b4wJUhv353P1xEVsP1jgzNTfO6Pmm4JIgwxbU9XDOB9ug6q1H1TVqqL954HeDRGPMebbMlLimD22Lz/p0Zq/vfcVX+7N9zqkgFPVV1X1Hnd7zet4AmVI7wyeHNqTT7ccZOTUZRwrseTUmBBX11KENsAOn+OdbpuvVcDV7v5gIEFEUt3jGHcE2xIRuepEb2Cj3IzxRs7WQ1wzaTEl5ZXMHtuPgZ1DrzMvYImpiKSLSLK7Hwv8AKcewveaVj6HVwDrAhWPMaZmEeFhPHLFuTSLieD+11dTWdn4ysJF5GP3Z76IHPXZ8kXkqNfxBcpVvdrwt+G9WL49j5te+JSjxWVeh2SMqbtAliL8ArhIRD4DLsJZOaGqDqCdqmYB1wN/FZGO1W+2UW7GNLy3v9jLT5//lObxUcwf15/zMpK8DqlOAtlj2gp4X0Q+B5bh1Jj+S0QeFZGquoQ7RWSNiKwC7gRGBjAeY4wfmsdH8atLz2HZ1jzmrdjpdTj1TlW/4/5MUNVEny1BVRO9ji+Qfty9Nc9c34vPdx5h2LNLyM0vqfkmY0zQOY1ShF2A73weGXy9ZF/Va+9W1atVtRfOkOGqkW+o6i7352acpbZ6nd5vYow5XTMXb2XcS8s5p1Uir47rT2bqide3DwWBnJX3c1XtpardVbWbqj7qtj+oqgvc/Qmqeq6q9lDV76rq+lO/qjGmIQzpnUGf9in8fuE68gpKvQ4nIETkRX/aGptB3Vrx/IgsNh84xrWTF7HjUKHXIRlj6qCOpQjLgE4i0kFEooBhwDdm1xWRNBGp+n44AZjqtqeISHTVNcAAYG19/C7GmNpTVf749noefGMNl5x9BrNu6Uvz+CivwzotjWZpBGNM/QkLE3571XnkF5fz+FuN9nnRub4HIhJBE6lzv7jLGbx0c1/yCssYMnkRG/Y1/npiYxqD0y1FUNVy4A7gHZzyqTmquqbaaLaLgS9FZAPQAnjMbT8HyHFHub0PPK6qlpga44GyikrunbuKiR9sYnh2JpNv6E1sVOivV26JqTHmhLq0TGDMhR14JWcHy7Ye8jqceiMiE0QkH+ju+6UO2Ae84XF4DaZ3uxTm3NoPVbh28mKWb8vzOiRjTA3qoxRBVReqamdV7aiqj7ltvqPZ5qlqJ/eam6smqVTVRap6njvK7TxVfSFQv6cx5uSOlZQzevoy5q/Yxd3f78zvBncjIrxxpHSN47cwxgTEXZd0ok1yLL9+bTVlFZVeh1MvVPX3qpoA/Knal7pUVZ3gdXwNqUvLBF4d15+UuEhueP5TPtxgM2gaEwqaaimCMU3d/vxihk1ZzKJNB/njNd256/udQmaNUn9YYmqMOam4qAgevuJcNuw7xgsfb/E6nHqlqhPcmqlsERlYtXkdV0Nr2zyOubf1p0NaPGOmL2N+I5zwyphGqMmWIhjTVG3OPcbVExexaX8Bz9+UxdA+bWu+KcRYYmqMOaUfdG3BD7q24Kn/fNWo1r8UkZuBj3BqrR5xfz7sx32DRORLEdkoIved4PyTIrLS3TaIyOH6jr2+pSdEM/vWvmR3aM49c1Yx6YNNqDa+pYKMCXVWimBM07Riex7XTFpEUWkFs8f25btnn+F1SAFhiakxpkajBrSnqKyCxZsOeh1KfboL6ANsU9Xv4ix7cMokUkTCgWeAS4GuwHAR6ep7jarerao9VbUn8DQwPxDB17fEmEimjerDFT1a84e31/PwgjVUNMJ1bI0JZVaKYEzT85+1+7j+uSUkxkby6rj+9Gib7HVIARPhdQDGmOCX1a45cVHhfLhhPz/o2sLrcOpLsaoWiwgiEq2q60WkSw33ZAMb3TX8EJHZwJWcfMmE4cBD9RdyYEVHhPPX63rSIjGa5/63hdxjJTwxtCcxkaE/058xjUlVKQLQCYjxaf/Iu6iMMfXt5U+3c//rq+nWJompI/uQ1iza65ACyhJTY0yNoiLC6N8xlQ835KKqjaXQfqeIJAOvA++KSB6wrYZ72gA7fF8DuOBEF4pIO6AD8N+TvZiIjAXGAmRmZvofeQCFhQm/vrwrLRJj+O2b6ziQv5TnbsoiKS7S69CMMS63FOEuIANYCfQFFgPf8zIuY0z9UFWe/M9X/O29r7i4SzrPXH8+8dGNP22zobzGGL8M7JzOjkNFbD1Y6HUo9UJVB6vqYVV9GHgAeAG4qh7fYhgwT1UrThHDFFXNUtWs9PT0enzr03fzhWfy1LCefLYjj2smL2JnXuP4czemkah1KYIxJjSUV1Ry36ur+dt7XzE0K4PnbspqEkkpWGJqjPHTRZ2dxOmjRrCkiIiEi8j6qmNV/VBVF6hqaQ237gJ8p8HLcNtOZBgw6/Qi9daVPdswY3Q2+44Wc/XERazZfcTrkIwxjmJVLQaOlyIANZUiGGOCXGFpObfMzOGVnB3ceUkn/nBNdyIbyRql/mg6v6kx5rS0S42nXWpco0hM3V7ML0WktuNnlwGdRKSDiEThJJ8Lql8kImcDKThD60Ja/45pzLutPxFhwtDJixvFn78xjUD1UoQ3qLkUwRgTxA4cK2H4lCV8uCGX3w0+j3t+0LmxlE75zRJTY4zfBnZKZ9Gmg5SUn3R0aihJAdaIyHsisqBqO9UNqloO3IGztMw6YI6qrhGRR0XkCp9LhwGztZGsudKlZQLzxw+gbfM4Rk9fxtycHTXfZIwJmAYoRTDGNKCtBwq4ZtIivtyXz5Qbs7j+guCYd6KhNY0By8aYenFR53ReXLKN5Vvz6H9WmtfhnK4H6nKTqi4EFlZre7Da8cN1Dys4tUyKYe5t/Rj/0gp+Oe9zdh8u5s5LzmpyT3ON8Zq7bNUaVT0bnFIEj0MyxpyGVTsOM3r6MipVefmWvpyfmeJ1SJ6xHlNjjN/6dUwlMlz4sHEM57zMrS09vgGXeR1UMEuIiWTqyD5cc34GT/5nA/8373PKKiq9DsuYJuU0ShGMMUHm/fX7GTZlCbFR4cwb179JJ6VgiakxphbioyPIate8sSSmPzhB26UNHkWIiQwP48/XdueuSzoxd/lORk9fRn5xmddhGdPU1LoUwRgTXOYs28HNM3M4Mz2e+eP70zG9mdchec6G8hpjamVg53T+8PZ69h0tpkViTM03BBkRGQeMB84Ukc99TiUAi7yJKrSICHf/oDNtUmL51fzVXDt5MdNHZdMyKfT+PhgToupUimCM8Z6q8vR/N/LEuxu4sFMak27oTbMmshxMTazH1BhTK41g2ZiXgZ/gzKb7E5+tt6r+1MvAQs3QrLZMHdmHnXlFDJ74Cev3HvU6JGOaCitFMCYElVdU8qvXvuCJdzdwda82vDCijyWlPiwxNcbUyjmtEkhPiOajrw54HUqdqOoRVd2qqsOBnUAZoEAzq9mqvYGd05lzaz8qVRkyaTH/+ypkH1gYE0qsFMGYEFNUWsFt/1jOrKXbGX9xR/4ytAdREZaK+bL/GsaYWhERBnZK539f5VJRGbqroYjIHcA+4F3gTXf7l6dBhaiurRN5bfwAMlJiGTXNlpMxJlBEZJyIrAa6iMjnPtsWYLXX8RljTuxQQSnXP7+E99bv59Erz+X/Bp1ts9qfgPUdG2NqbWDnNF5dsZPVu47Qs22y1+HU1c+BLqp60OtAGoPWybHMua0f4//hLCezI6+Iu7/fyf7hNaZ+vQy8BfweuM+nPV9VD3kTkjHmVHYcKmTE1KXsPFzEpJ/2ZlC3ll6HFLSsx9QYU2sXdkpHJKTrTAF2AEe8DqIxSYyJZNqoPgzpncHf3vuKe+euorTclpMxpr7URymCiAwSkS9FZKOI3HeC8+3c2X4/F5EPRCTD59wIEfnK3UbU1+9lTGP1xa4jDJ64iIMFpbx08wWWlNbAekyNMbXWPD6K7m2S+HBDLnde0snrcOpqM/CBiLwJlFQ1quoT3oUU+iLDw/jTkO5kNo/jiXc3sPdIMZNu6E1SbKTXoRnTaLilCA/jlCNUPf1RoHsN94UDz+DUqO4ElonIAlVd63PZn4GZqjpDRL6H0zt7o4g0Bx4Cstz3Wu7em1d/v5kxjcdHG3IZ94/lJMVGMuuWfnRqkeB1SEHPekyNMXUysHM6n23P40hhyK5huR2nvjQKZ6mYqs2cJhHhzks68cTQHizbeohrJy9i1+Eir8MypjGpKkU4V1XPc7dTJqWubGCjqm5W1VJgNnBltWu6Av9199/3Of8j4F1VPeQmo+8Cg077NzGmEZq/wlnnu23zOOaPH2BJqZ8ClpiKSIyILBWRVSKyRkQeOcE10SLyijuc5FMRaR+oeIwx9euizulUKnyyKWRn531EVR8B/lS17x6benL1+RnMGJXNniPFXPXMJ3yxy0ZOG1NP6lqK0Ma9t8pOt83XKuBqd38wkCAiqX7ei4iMFZEcEcnJzQ3pcg9jak1VmfTBJu6Zs4o+7Zsz57Z+tsZ3LQSyx7QE+J6q9gB6AoNEpG+1a8YAeap6FvAk8IcAxmOMqUc92yYTGS6sDtFkQ0T6ichaYL173ENEJnocVqPT/6w0Xh3Xn6jwMIY+u5j/rt/ndUjGNAZVpQgTROSeqq2eXvsXwEUi8hlwEbALqPD3ZlWdoqpZqpqVnp5eTyEZE/wqKpWHF6zhD2+v54oerZk+ug+JMVbGUhsBS0zVccw9jHS36mtLXAnMcPfnAZeITeFoTEiICA+jbUoc2w4WeB1KXf0VZ2jaQQBVXQUM9DSiRqpziwReG9+fM9PjuXlGDi8u2eZ1SMaEurqWIuwC2vocZ7htx6nqblW9WlV7Ab922w77c68xTVVxWQW3v7SCGYu3MXbgmfz1up5ER4R7HVbICejkR26R/XLgLOAZVf202iXHh4WoarmIHAFSgQPVXmcsMBYgM9OvSeeMMQ2gXWocWw8Ueh1GnanqjmrPwvzuFTC1c0ZiDK+M7cedsz7jgde/YMehQu4bdDZhYfYs0pjaqio7EJE4Va3Nh/AyoJOIdMBJKocB1/teICJpwCFVrQQmAFPdU+8AvxORFPf4h+55Y5q0w4Wl3DIzh5xteTzw466M+U4Hr0MKWQGd/EhVK1S1J85TtWwR6VbH17FhIcYEoXap8Ww7WIBq9cEQIWGHiPQHVEQiReQXwDqvg2rM4qMjePbG3tzYtx1TPtrMz2Z9RnGZPQswprbqWoqgquXAHThJ5jpgjqquEZFHReQK97KLgS9FZAPQAnjMvfcQ8Buc5HYZ8KitnWqaul2HixgyeTGrdhzh6eG9LCk9TQ2yXIyqHhaR93Fmb/vC51TVsJCdIhIBJOEOqzPGBL/2qXEUlFZw4Fgp6QnRXodTW7cBT+GM3NgF/Bu43dOImoCI8DAevfJcMpvH8djCdew9WsxzN2XRPD7K69CMCSVVpQgLwClFEBG/ShFUdSGwsFrbgz7783DKq05071S+7kE1pklbt+coI6ctpbC0ghmjs+nXMdXrkEJeIGflTReRZHc/FmfNrPXVLlsAVC3QPAT4r4Zo14sxTVG7tHiAkKwzVdUDqvpTVW2hqmeo6g2qag/GGoCIcMvAM5n40/NZvesIV0/8hK0HQu/vkDFeUtUd1Zps+IExDWTRpgMMnbwYQZh3W39LSutJIIfytgLeF5HPcYZ8vKuq/6o2XOQFIFVENgL3APcFMB5jTD1rn+okplsPhl6dqYjMqHp45h6niIj1BDSgy85rxaxbLuBocTmDJ37C8m02KtAYP1kpgjEeWbBqNyOmLqVVcgzzx/enS0tbo7S+BHJW3s9VtZeqdlfVbqr6qNv+oKpWDT0pVtVrVUMCnN0AACAASURBVPUsVc1W1c2BiscYU//aJMcSHiYh2WMKdHdnmgTAXTC+l4fxNEm92zVn/rj+JMdFMfy5T1m4eo/XIRkTCm7DKT2oKkXoiZUiGBNwz320mTtnfUavzBTm3tqf1smxXofUqAR08iNjTOMWFRFGm+TYkOwxBcJ8ZpdERJrTQHX35pvap8Xz6rj+dG+TxPiXVjDlo02hOqGWMQ3CShGMaViVlcqj/1zLYwvXcfl5rZg5OpukOFujtL5ZYmqMOS3tUkN2LdO/AItF5Dci8ltgEfBHj2NqsprHR/GPmy/g8u6t+N3C9TzwxheUV1R6HZYxQclKEYxpOCXlFfxs9mdM/WQLI/u35+nhvYiJtDVKA8F6B4wxp6V9ajyvr9yFqlJtTdCgpqozRWQ58F236WpVXetlTE1dTGQ4Tw/rRUZKLM9+uJldeUX8/frziY+2f6qMqeZbpQgiYqUIxtSzI0VljJ2Zw6dbDjHh0rMZO/DMkPquE2qsx9QYc1rapcaRX1zO4cIyr0Opi/XAfJwZwo+JSGZNN4jIIBH5UkQ2isgJJ2wTkaEislZE1ojIy/Ucc6MWFiZMuPQcfntVNz7ckMvQZxez72ix12EZE2ysFMGYANtzpIihkxezYnseTw3rya0XdbSkNMDsQ8wYc1q+npm3gJQQWotSRH4GPATsw1lmQQAFup/innDgGZzlr3YCy0RkgW9Pq4h0AiYAA9xejDMC91s0Xjf0bUeb5Fhuf3kFg5/5hGmjsm3mQ2O+VlWKMBfns2sI8Ji3IRnTeGzYl8+IqUvJLy5n+qhsBpyV5nVITYL1mBpjTkv7tDgAtoXeBEh3AV1U9Vx39vDzVPWkSakrG9ioqptVtRSYDVxZ7ZpbgGfcWX5R1f31HnkT8d2zz2DOrf0or1SGTFrEx18d8DokY4KCqs4ErsF5sLYXpxThRW+jMqZx+HTzQYZMWkR5pfLKrX0tKW1AlpgaY05LRkocIk6PaYjZARyp5T1t3Puq7HTbfHUGOovIJyKyREQGnezFRGSsiOSISE5ubm4tQ2kaurVJ4vXbB9A6OZaR05YyN2dHzTcZ0zTUuhTBGHNqC1fv4cYXlpKeEM38cf05t3WS1yE1KTaU1xhzWmIiw2mdFBuKPaabgQ9E5E2gpKpRVZ84zdeNADoBFwMZwEcicp7vRCU+7zUFmAKQlZVl66OcROvkWOaO68ftL63gl/M+Z0deEXd/v5PV+pgmqy6lCMaYU5v+yRYe+ddazs9M4YURWSTHhU55UmNhiakx5rS1S40LxR7T7e4W5W7+2AW09TnOcNt87QQ+VdUyYIuIbMBJVJedXrhNW2JMJFNH9uFX81fzt/e+YuehQh6/pjtRETbwxzRJVaUItnapMaepslL5wzvrefbDzfywawv+ZsvBeKbGxFREzsKZ7KOlqvYQke7A5ar6+4BHZ4wJCe1S43lnzV6vw6gVVX0EQESaucfH/LhtGdBJRDrgJKTDgOurXfM6MByYJiJpOEN7N9dX3E1ZZHgYfxzSnczmcfzl3Q3sOVLM5Bt62yLnpimqSymCMaaa0vJK/m/eKl5fuZsb+mbyyBXdCA+z0The8edR8/PAI0DVSuergRsCFpExJuS0T43jUEEpR4pCZ8kYEekmIp8Ba4A1IrJcRM491T2qWg7cAbwDrAPmqOoaEXlURK5wL3sHOCgia4H3gV9ar0b9ERF+dkknnryuBznbDnHN5EXsOBRyw8iNOV1VpQgTROSeqs3roIwJJfnFZYyavpTXV+7mlz/qwm+utKTUa/4M5Y1X1UVVtTyqqiISOt8+jTEB185dMmb7wULOywiZiQKmAPeo6vsAInIx8BzQ/1Q3qepCYGG1tgd99hW4x91MgAzulUHLxFhufTGHwRMXMXVkFt0zkr0Oy5iGUpdSBGOMa//RYkZMW8ZX+/L587U9GNI7w+uQDP4lpgfdYWsKICJX4UxNbowxwNdLxmw9WBBKiWl8VVIKoKofiEi8lwGZ2unXMZX54/szctoyrnt2CU8P78X3u7bwOixjAq6OpQjGGGDj/mOMmLqUvMJSXhjZh4s6p3sdknH5M5T3DuAF4GwR2QbcB4wLaFTGmJCS2bxqLdOQmgBps4g8ICLt3e1+rBY05Jx1RgLzx/enU4tmjH0xhxmLtnodkjEBV5dSBGMMLN92iCGTF1FSXsErY/tZUhpkakxMVXWjqn4PaAX0UNW+qrol8KEZY0JFXFQELRKj2RpaS8aMBtJx1gF8FUhz20yIOSMhhtlj+/K9s1vw0II1/PZfa6mstNV3TKNWVYrQTlXbAffilCIYY07inTV7uf65T0mJi2L+uAGhNMKryfBnVt47qx2DMxPcclX9IkBxGWNCTLvU+JDqMVXVPODOGi80ISEuKoJnb+zNb/61luc/3sLOvCKevK4nsVE25b9plOpciiAig4CngHDgeVV9vNr5TGAGkOxec5+qLhSR9jiTvn3pXrpEVW873V/EmIbw4pJtPPTGF5yXkczUEVmkNov2OiRzAv4M5e2Ps15WR3f7GXAFMFNE7g1gbMaYENI+NS6kekxF5F0RSfY5ThGRd7yMyZye8DDh4SvO5YEfd+WdtXsZ/twSDhwr8TosYwKhTqUIIhKOswTgpUBXYLiIdK122f04M473wlkSa6LPuU2q2tPdLCk1QU9V+dM763ng9S/4bpczmHXLBZaUBjF/EtNWQE9VvUtV7wLOxxny9h1gTCCDM8aEjvZp8eTml1BQUu51KP5KU9XDVQduD+oZHsZj6smY73Rg0k97s37vUQZP/IRNuTYvjGl06lqKkA1sVNXNqloKzAaurHaNAonufhKwu14iNqaBlVVU8st5n/PM+5sYnt2WZ2/sTVyUP/O+Gq/4k5i2AIp8jkuAFqpa6O4bYwzt3SVjtoVOr2mlO2QNABFphzv7uAl9g7q1ZNYtfSksqeDqiYtYuuWQ1yEZU29UNU9V71TV81W1t6r+3H24VpM2wA6f451um6+HgRtEZCfO0lg/8znXQUQ+E5EPReTC0/kdjAmkgpJyxszIYd7yndz9/c78bvB5RIT7k/YYL/nzJ/QKsFhEfi0ivwb+B7zi1jJ8eepbjTFNRbvUkJuZ99fAxyLyooj8A/gImOBxTKYe9cpM4bXxA0htFsUNz3/KGyt3eR2SMfUiwKUIw4HpqpoBXAa8KCJhwB4g0x3iew/wsogkVr9ZRMaKSI6I5OTm5tZTSMb4Lze/hGFTlvDJxgM8fvV53PX9TlVz5Jgg58+svA/hPC0rdre7VPUhVS1Q1WGBDtAYExrauT2moVJnqqpv45QmvIIznK23qlqNaSOTmRrH/HH96ZmZzF2zV/LM+xtRtY5xE/LqWoqwC2jrc5zhtvkaA8xxX3cxEOO+X4mqHnTblwObgM7V30BVp6hqlqpmpafbUhymYW3OPcbVkz5h4/5jTLmxN8OyM2u+yQQNv/q0VXUJMA2YBWwXkdYBjcoYE3KaRUeQ1iw6lHpMUdUDqvovdzvgdTwmMJLjonhxTDZX9mzNn975kgnzV1NWUel1WMacjrqWIiwDOolIBxGJwpncaEG1a7YDl7ivew5OYporIunu5EmIyJlAJ2ztZxNEPtuex5DJiykoqWDW2L5cck4Lr0MyteTPcjGXA0/iPFU7gFOL8BVwdmBDM8aEGmdm3tBJTE3TER0Rzl+v60lm8zie/u9Gdh8p5pnre5EQE+l1aMbURVUpwoeAABcCY2u6SVXLReQO4B2cpWCmquoaEXkUyFHVBbhroorI3TjJ7khVVREZCDwqImVAJXCbqlrxtgkK763bx+0vr+CMhBhmjM6mQ5pfqyeZIOPP1FSPAQOAf6tqLxH5ATC0pptEpC0wE2fyJAWmqOpT1a65GHgD2OI2zVfVR/0P3xgTTNqlxrNok3U8muAkItz7wy60TYnjV6+t5trJi5k2qg+tkmK9Ds2YWlHVt0XkfKCv2/Rzf0d9qOpCnEmNfNse9Nlfi/O9r/p9r+LMAGxMUJm1dDu/fm013dok8cKIPqQn2HIwocqfobzlqpoLhImIqOq7ONON13gfcK+qdsX54Lz9BGtlAfzPZ00sS0qNCWHtU+PYc6SY4rIKr0Pxi4h8R0RGufvpItLB65hM4A3t05apI/uwM6+Iq575hDW7j3gdkjG1ZqUIpqlTVZ58dwMT5q9mYOd0Zt3S15LSEOdPYnpERJoBHwMzReQvfHP5mBNS1T2qusLdzwfW8e0pyY0xjUg7d+jM9kPBPwGSiDwE/D++nok3EviHdxGZhjSwczrzxvUjTIShkxfzwZf7vQ7JGGOMn8orKpkwfzVPvfcV1/bO4LmbsoiPtjVKQ50/ielVOInoz4EPcGZv+3Ft3kRE2gO9gE9PcLqfiKwSkbdE5NzavK4xJri0d5eM2XogJOpMBwNXAAUAqrobSPA0ItOgzm6ZyGvjB9AuNZ4xM3J4+dPtXodkjDGmBoWl5Yx9cTmzl+3gZ987iz8O6U6krVHaKPjzpzhBVStUtUxVX1DVJ3DWr/KL29v6Kk79w9Fqp1cA7VS1B/A08PpJXsPWxDImBLRr7vSYbguNJWNK1Vk3RAHctZlNE9MyKYY5t/Xjwk5p/Oq11fzh7fVUVtpyMib4WSmCaYoOHith+JQlfPDlfh4b3I17f9jF1ihtRPxJTAedoO1yf15cRCJxktKXVHV+9fOqelRVj7n7C4FIEUk7wXW2JpYxISApLpKUuMhQmZl3jog8CySLyC3Af4DnPI7JeKBZdATP35TF9RdkMumDTdz1ysqQqZM2TZOVIpimaNvBAq6ZtIj1e/OZfENvfnpBO69DMvXspIOxReRW4Dags4is8DmVACyv6YXFeXzxArDO7WU90TUtgX3uNOTZOInywVrEb4wJMu1S40Oix1RV/+zOMn4U6AI86E7uZpqgiPAwHruqG5nN43j8rfXsPVLElBuzSImP8jo0Y05kME6JVNVcHrtFxEoRTKP1+c7DjJ6+jPJK5eVb+tK7XYrXIZkAOFWV8BzgPeD3wH0+7fmq6s8sEQOAG4HVIrLSbfsVkAmgqpOBIcA4ESnHqWMd5g6tM8aEqHapcazYnud1GDVyh739ryoZFZFYEWmvqlu9jcx4RUS47aKOtEmO5d65q7h60iKmj+pDu1Qb5W2CTqn7UN9KEUyj98GX+xn/0gqax0cxY3Q2HdObeR2SCZBTJaYVwH5gTPUTIpJ4gnrRb1DVj3EWfT7VNX8H/u5HnMaYENEiMYb9R0tQ1WCv+5gL9Pc5rnDb+ngTjgkWP+nRmpZJMdwyM4fBExfx3E1Z9nTeBJvqpQijsVIE0wjNzdnBffNX06VFAtNH9eGMxBivQzIBdKoa0zXAF+62ptr2ReBDM8aEorRmUZSUV3KspNzrUGoSoaqlVQfuvo3bNAD0ad+c18YPICEmguufW8LC1Xu8DsmY41T1z8A8nHk8qkoRnvY2KmPqj6ry9/9+xS/nfU6/M1N55da+lpQ2ASdNTFW1rapmulvbaltmQwZpjAkdac2cxa0PHCut4UrP5YrIFVUHInIlYIvUm+M6pMUzf1x/zm2dyO0vr+C5jzZj1SYmGPiUIvxSVX8BfOwuzWdMyKuoVB544wv+/O8NDO7Vhqkj+5AQE+l1WKYB+LXoj4hcJiKPu9uJZuk1xhgA0hOqEtMSjyOp0W3Ar0Rku4jswJnh8taabhKRQSLypYhsFJH7TnB+pIjkishKd7s5ALGbBpLaLJqXb+nLpd1a8tjCdTy0YA3lFZVeh2XMXMD3L2JVKYIxIa24rIJx/1jOP5Zs57aLOvKXa3sQFWFrlDYVp6oxBUBEHsOZyOhlt+n/ROQ7qnp/QCMzxoSkqh7T3PzgTkxVdRPQ111rmaqlq05FRMKBZ4AfADuBZSKyQFXXVrv0FVW9o75jNt6IiQzn78PP5w8p63n2o83syivib8N7ER9d4z+hxgTKt0oRRMRKEUxIyyso5eaZOazYnscjV5zLiP7tvQ7JNDB//lX9CdBLVSsARGQqzvTklpgaY77l66G8wZ2YAojI5cC5QEzVRE2q+ugpbskGNqrqZvf+2cCVQPXE1DQyYWHChMvOISMllocWrOG6KYuZOsIm4jCeyRWRK1R1AVgpggl9Ow4VMmLaUnbmFTHx+vO59LxWXodkPOBv33iiz76tk2WMOanm8VGECRwI8h5TEZkMXAf8DGcG8WuBmlbrbgPs8Dne6bZVd42IfC4i80SkbX3Ea4LDjf3a89xNWWzaX8DgiYvYsC/f65BM01SnUgRjgtGa3Ue4etIiDuSX8I8xF1hS2oT5k5j+EVghIs+LyAtADvB4YMMyxoSq8DCheXwUucE/+VF/Vb0JyFPVR4B+QOd6eN1/Au1VtTvwLjDjZBeKyFgRyRGRnNzc3Hp4a9MQLjmnBXNv60dpRSXXTFrEoo3WUWUalqpuUtW+QFfgHFXtr6obvY7LmNr6+KsDXPfsEiLDhHnj+pPdobnXIRkP1ZiYquo/gO8AC4E3gYGq+vKp7zLGNGVpzaJDYShvsfuzUERaA2VATY9pdwG+PaAZbttxqnpQVat++eeB3id7MVWdoqpZqpqVnp5eq+CNt7q1SeL12wfQKimGm6YuZd7ynV6HZJoYtxRhPHCPiDwoIg96HZMxtfHaZzsZOW0pGSmxzB8/gM4tbFBmU1djYioi83EWoX9LVeer6q6a7jHGNG0hkpj+U0SSgT/h1M1v5etJ3k5mGdBJRDq4E40MAxb4XiAivsntFcC6eovYBJU2ybHMG9efC85szi/mruLJdzfYcjKmQdSxFMGYoKCqTP5wE3e/soqs9inMua0fLZOsXt/4N5S3agbKL0VktohcZTO/GWNOJa1ZVNAmpiJyrbv7D1U9rKqv4nyhO1tVT9njoKrlwB3AOzgJ5xxVXSMij/qsiXqniKwRkVXAncDIgPwiJigkxkQybWQ2Q3pn8NR7X3Hv3FWUlttyMibgAlWKYExAVVQqj/xzLY+/tZ4fd2/FjNHZJNoapcZV46y8qvoe8J6IROAkqGOA6UByYEMzxoSq9IRocvNLUFWqZrsNIhNw1vt7FTgfwB1661cmraoLcUobfNse9Nmf4L6HaSKiIsL405DuZDaP44l3N7DncDGTb+xNUqx92TIBU70U4SA1lyIY46nisgrufmUlb32xl5u/04FfXXYOYWFB9x3BeMivWXlFJBpnSNpIIAuYFcCYjDEhLq1ZNMVllRSUVngdyokcFJF/A2eKyILqm9fBmdAkItx5SSeeGNqDnG2HGDJpETvzCr0OyzRedSlFAEBEBonIlyKyUUTuO8H5TBF5X0Q+c2cXv8zn3AT3vi9F5Ef19LuYJuBIYRk3vbCUt77Yy/2Xn8P9P+5qSan5lhp7TEXkZWAAzuySzwPXV61paowxJ3J8LdP8EppF+7NccoO6HKen9EXgLx7HYhqZq8/PoGVSDLe+uJzBExfxwogsumfYACNTP0TkWlWdi1uKALwqIv8CYlT1iB/3h/N1idZOYJmILFBV37WY78cpU5gkIl1xRoi0d/eH4az93Br4j4h0tu+Epia7DxcxYupSth0s5OnhvfhJj9Zeh2SClD89pi8BZ6nqzar6rn0AGWNqkpbgJqZBWGeqqqU4kxh9qKrf2ryOz4S+/h3TmD+uP1HhYVz37BLeW7fP65BM41FVJvBqVYOqlviTlLqygY2qutn9LJwNXFntGuXr9euTgN3u/pXAbPf9tgAb3dcz5qTW7TnK4ImfsPdoMTNGZ1tSak7Jn+Vi3lTVsoYIxhjTOKQ1c+ZHC8bEFMB9wHau13GYxqtTiwReu70/nVo045aZOcxcvNXrkEzjcLqlCG2AHT7HO902Xw8DN4jITpze0p/V4l5bn9kct2jTAYZOXowgzL2tH/06pnodkglyQTfGzhgT+tLdoby5x0o9juSUVrpf5OYCBVWNqjrfu5BMY3JGQgyzx/blzlkrefCNNew4VMiES22yD3NaGqIUYTgwXVX/IiL9gBdFpJu/N6vqFGAKQFZWlq2f1EQtWLWbX8xZRbvUOGaMzqZ1cqzXIZkQYImpMabeNY+PQsSpMQ1iMTgzWX7Pp00BS0xNvYmLiuDZG3vzm3+t5bn/bWFnXhFPXteTmMhwr0MzIUhVS0XkeClCHV5iF9DW5zjDbfM1Bhjkvt9iEYkB0vy81xie/99mfvvmOrLbN+e5m7JIirMZyo1/TpqYikj3U92oqp/XfzjGmMYgIjyMlLgocoN0KC+Aqo7yOgbTNISHCQ9fcS5tm8fx2zfXsve5JTx/Uxap7sgCY2pDVStEpK6lCMuATiLSASepHAZcX+2a7cAlwHQROQfnIV4usAB4WUSewJn8qBOwtI5xmEaoslJ5bOE6Xvh4C5ed15InhtpDOFM7p+oxfeYU5xQYWM+xGGMakbRmUUHdYyoi03A+y75BVUd7EI5pAsZ8pwNtkmO4a/ZKBk9cxPRRfTgzvZnXYZnQVKdSBFUtF5E7gHeAcGCqqq4RkUeBHFVdANwLPCcid+N8Ro5UVQXWiMgcYC1QDtxuE2KaKiXlFdwzZxVvfr6Hkf3b88CPuxJuZQumlk6amKrqhQ0ZiDGmcUlPiA7ayY9c//LZjwEG8/Xsk8YExKBurZg9NoabZ+Rw9aRFTLkxi+wOzb0Oy4SeOpciqOpCnEmNfNse9Nlfi7NM4InufQx4rA7xmkbsSFEZt76Yw5LNh5hw6dmMHXgmIpaUmtrzq8ZURM4GuuJ8EAKgqn4t5GyMaZrSmkXz2fbDXodxUqr6qu+xiMwCPvYoHNOE9MpM4bXxAxg5fSk3PP8pfx7agytsCQVTC1aKYILF3iPFjJy2lI37j/HkdT0Y3CvD65BMCKsxMRWR+4EfAmfjDP34Ec6XN0tMjTEnldYs6HtMq+sEnOF1EKZpyEyNY/64/ox9cTl3zvqMnXmFjLuoo/UyGL9YKYIJBhv25TNy6lKOFpczbVQfLuyU7nVIJsT502N6HdATWKGqN4pIK2B6QKMyxoS8tGbRFJZWUFhaTlxU8E0ALiL5fPOL3V7g/3kUjmmCkuOieHFMNv8373P++PaX7DhUxG+uPJeI8BqXGDfGShGMp5ZuOcTNM5YRHRnOK7f25dzWSV6HZBoBf74tFrkzwJWLSALOl7d2Nd0kIm2BmUALnC9/U1T1qWrXCPAUcBlQiFNgv6KWv4MxJgilNYsC4EB+KZmpwZeYqmqC1zEYEx0RzpNDe9I2JY6/v7+R3YeLeOan59MsOvj+nzHBw0oRjJfeWr2Hu15ZSUZKLDNGZdO2eZzXIZlGwp/Hsp+JSDIwFcjBmRrcn+nBy4F7VbUr0Be4XUS6VrvmUpzhc52AscAkfwM3xgS3tARnKYxgXTJGRAaISLy7f4OIPCEiNT50M6a+hYUJv/hRF/5wzXl8vPEA105ezN4jxV6HZUKLlSKYBjFj0VbGv7yCbq0TefW2/paUmnpVY2Kqqreq6mFVfQa4HLhVVW/y4749Vb2fqpoPrAPaVLvsSmCmOpYAye5QYWNMiEt312jMDd4lYyYBhSLSA2d5hE04ozyM8cR1fTKZNrIPOw4VctUzn7Buz1GvQzJBSkTyReRo1Qb8EytFMAFUWak8/tZ6Hlqwhu+f04KXb+lLSnyU12GZRsavQhYRaSki2ThP42JEpH9t3kRE2gO9gE+rnWoD7PA53sm3k1djTAhKcxPTIJ4Aqdxdm+9K4O/uwzcb3ms8NbBzOnNu7QfAtZMX8+GGXI8jMsFIVRNUNdFn61x9eK8x9aW0vJJ7565i8oebuKFvJpNv6E1MZLjXYZlGqMbEVER+hzN097fAA+52v79vICLNgFeBn6tqnR7/ishYEckRkZzcXPtH2phQkFpVYxq8iWm+iEwAbgDeFJEwINLjmIyha+tEXr99AG2bxzF6+jJmL93udUgmyFgpgmkox0rKGTNjGa99totf/qgLv7myG+FhNnu4CQx/ekyvATqr6g9V9VJ3u8yfFxeRSJyk9CVVPdGiz7uAtj7HGW7bN6jqFFXNUtWs9HSbitqYUBAZHkZKXGQwJ6bXASXAGFXdi/P58ydvQzLG0TIphjm39mXAWWncN381f3x7PZWV31odxDRdVopgAm7/0WKue3YxizYd5E9DunP7d8+yJa1MQPmTmG4Bat1f7864+wKwTlWfOMllC4CbxNEXOKKqe2r7XsaY4JTWLJoD+aVeh3FCqrpXVZ9Q1f+5x9tV1b7YmaCREBPJCyOyGJ7dlokfbOLnr6ykpLzC67BMcLBSBBNQm3KPcfWkRWw5UMALI7K4NqttzTcZc5r8mY8+H1ghIv/B6V0AQFXvqeG+AcCNwGoRWem2/QrIdO+fDCzEWSpmI85yMaNqFb0xJqilNYsO5h5TY4JeZHgYvxt8HpnN4/nD2+vZe6SYZ2/sbZOOGN9ShIFWimDq0/JteYyZsYyIMOGVsf04L8PWKDUNw5/E9G13qxVV/Rg4ZX+/+7Tv9tq+tjEmNKQlRLN652GvwzAmpIkI4y7uSEZKLPfOWcU1kxYxbVQf2qXGex2a8c51wPW4pQgikomVIph68O81e/nZrM9olRTDzNEXkJlqy8GYhlNjYqqqLzREIMaYxift/7d35+FRlXf/x99fQhZI2JKAG7uKCiIIYYtdtK3VLm64gRuCgoJLfWyt+mhbl99TbW21G4hoEdxwwaW0damtWquAEkAQVBBwAaUKAZF9Cd/fH3OCYwQySWbmnJl8Xtc118ycOefMJ2eSO+eecy9FeVGeLgYzawZ0dPdFYWcRqc0JvfZn31YFjLyvgsHjpnP3sDL6dGwTdiwJQdAv/va45x+iPqbSQA++9gE/e2oBPdu3ZuKwMkqC0fVF0mWPfUzNbEpwP9fM5tS8pS+iiGSq0qJ8Nm6rYvO26PWLM7MTgDcIWoSYWW8zm5bgtseb2SIzW2Jm1+xlvVPNSYZkJwAAIABJREFUzM2sLDmppbHr17mYx0eXU5jflKETZvLsAg3LICIN4+789h+LuO7JBRx9SDumjBygSqmEYm+DH10V3J8GnL6bm4jIXrWN9lymNwD9gc8A3P0NoEttG5lZDjAW+B7QHRhqZt13s14L4Ed8df5mkQY5sG0RT44pp/v+LRn94Bzu+c8yYj1jRETqZnvVTq6aOp8/vrCEIf06MOHcvjTPS6Snn0jy7bFi6u4rgvul7r4UWAmsiruJiOxV2xaxiumqaFZMt7v7uhrLEjm77w8scfdl7r4NeJjYyJg13Qz8CtjSsJgiX1VSlM+UkQM5vse+/L+/v80N0xZSpelkGhUza2Zmh4SdQzLXxq07uHByBVNnr+CK7xzMLYN70jQnkQk7RFKj1t8+M7vQzFYCi4EFwMLgXkRkr0qrr5hGs5/pQjM7C8gxs4PN7I/A9AS2OwBYHvd8RbBsFzPrA3Rw978nLa1IDQW5OYw9qw8jv96FyTM+4KL7K9i0bUfYsSQNGtIVQQRiLZmG3j2T/7y7ilsG9+SK73TTHKUSukS+Frka6OXu7d29o7t3cPeOqQ4mIpmvtEVsSovVGyI5l+llQA9i02BNAT4HrmjoToNpG24nNul9beuOMrMKM6tYtUoNUaTumjQxrvtBd246qQcvvPMpZ941k0/X6yJ9I3AD9eiKIALw/uqNnHrndBZ/sp67zytjaH+d1ks0JFIxXUbshE1EpE5KCqPbx9TdN7n7de7ez93LgseJnNF/BMTPNN4+WFatBXA48JKZvQ8MBKbtbgAkd58QvHdZ27Zt6//DSKN33qDO3H1eGUs+3cApY2MnnJLV6tsVodbB28zsDjN7I7gtNrPP4l6rintNV2gz0BvLP2PwndNZv2UHU0YO5NuH7RN2JJFdEundfA3wqpnNJHZlAQB3vzJlqUQkK+Q1bUKrZrmRmjLGzP7KXk7g3P3EWnYxCzjYzLoQq5AOITafYPX264DSuPd7CfiJu1c0ILZIrb592D48etEgRkyexal3Tueuc/tSfmBp7RtKJvpSVwTgchLoihA3eNuxxLohzDKzae7+VvU67v4/cetfBhwZt4vN7t47ST+DpNkL73zCJQ/OpW2LfCaP6E+XUs2FLNGSSMV0PPAq8CawM7VxRCTblBblRe2K6W8asrG77zCzS4HngBxgorsvNLObgAp311UECU3P9q14ckw5w++dxbCJr3Pr4CM4tW/7sGNJ8l0GXMcXXRGeIzbgWm12Dd4GYGbVg7e9tYf1hwK/aHBaCd3Dr3/IdU8toPt+LZl4fr9dgxOKREkiFdN8d7885UlEJCuVFuVHqmLq7v8GMLNCYt/+7wye5wAJ/ad296eBp2ss+/ke1j26IXlF6qp9m+ZMHV3O6Adm8+PH5rFi7WYu//ZBGtgki7j7JmIV0+vquOnuBm8bsLsVzawTsX6rL8QtLjCzCmAHcKu7P7Wb7UYBowA6dlTfxbC5O3/41xLu+OdivtmtLePO7kNhvqaDkWhK5Dfz72Y2AvgrX27Kq36nIlKr0hb5vPVxJIuLfwHfATYEz5sB/wDKQ0skkiStmuUyaXh/rn3iTe7452I+XLOJWwb3JK+ppoLIZEnoilAXQ4Cp7l4Vt6yTu39kZl2BF8zszWBKwfgME4AJAGVlZZrDKEQ7qnZy/VMLeHjWck7r255bBvckV9PBSIQlUjE9L7i/MW6ZA/oaTERq1bYoP6rTxRS4e3WlFHffYGbNwwwkkkx5TZvwm9OPoENxM373z3dZuW4zd57Tl1bNcsOOJvXXoK4I1D54W7whwCXxC9z9o+B+WdB//khg6Vc3lbBt2raDyx6ay7/e+ZRLjzmIH39X08FI9O21YhpMe3C6u89MUx4RyTJtW+SzfusOtmyvoiA3J+w48TaaWR93nwNgZn2BzSFnEkkqM+OK73SjQ5vmXP34fE4fP52J5/ejfRt9B5OJktAVYa+Dt1Uzs0OBNsCMuGVtgE3uvtXMSoGjgF837CeSVKjcsJULJlcwf8Vn3Hzy4Zw7sFPYkUQSstfr+UGBNz5NWUQkC5UWVc9lGrmrplcAj5nZf8zsFeAR4NKQM4mkxKl923PfiP6sXLeFU8ZN580VNWcakQzzLyD+24VmwD9r28jddxAr554D3gYerR68zczimwEPAR529/imuIcBFWY2D3iRWB/TPQ2aJCH5sHITp42fwdsrP+fOc/qqUioZJZGmvC+a2Unu/peUpxGRrFNaVD2X6bZIXaVx91nBVYFDgkWL3H17mJlEUqn8oFIeHx0bsfeMu2bwp7OO1ByGmaveXRESGbzN3W/YzXbTgZ71Sitp8eaKdQyf9Drbq5wHLxxAWefisCOJ1EkiPaDPB540s81mtsbM1prZmhTnEpEsUV0xjcpcpmb2reB+MHAC0C24nRAsE8la3fZpwZOXlHNQuyJG3lfB/TPeDzuS1M9GM+tT/URdEeTfi1dx5oQZ5DfN4fHRg1QplYyUyBVTzc4tIvVW2qL6imk0KqbAN4lNf3DCbl5z4In0xhFJr3YtCnjkooFcPmUuP/vLQpav3cw1xx9KkyYaGCWDVHdF+BgwYF/gzHAjSVimzl7BNY/P5+B9WjBpeD/2aVkQdiSReqm1YuruVWY2BOjq7r80s/bAPsDslKcTkYxXUhj0MY3IFVN3r54s/iZ3fy/+tWBAEJGs1zyvKXedW8aNf13IhJeXsXzNJu44s3fUBiiTPVBXBIHYHKXjXlrKbc8t4qiDShh/Tl9aFGjUbclctTblNbM/AccA5waLNqEBkUQkQQW5ObQoaBqlK6bVHt/NsqlpTyESkpwmxo0n9uD6HxzGswv/y9C7Z1IZvb9TiaOuCFKtaqfz878s5LbnFnFy7/259/z+qpRKxkukKW+5u/cxs7kA7r7GzPJSnEtEskjbonxWb9gWdgxg1zQIPYBWNU7kWgJq/ySNiplx4de70r5NM3708BucMm46k4b3o2vborCjye6pK4KwZXsVP3p4Ls8t/ISLvtmVq49TU3zJDolUTLcH85k6gJmVADtTmkpEskppi3xWRedKzCHAD4HWfPnkbj0wMpREIiE7/vD9mDKqgJGTKxh853QmnFtG/y4aPCVq1BVB1m7cxoX3VTDnw7X84oTuDD9KH7tkjz025TWz6krrWGJN3tqa2Y3AK8Cv0pBNRLJE7IppNCqmwdRXFwK/dffhcbfLg+kQRBqlPh3b8MSYcoqb53HOPa/x13kfhx1J9kxdERqhFWs3cdr46bz50TrGntVHlVLJOnu7Yvo60Mfd7zOz2cB3iI38drq7L0hLOhHJCqVFeZGZLgZ2Dep2MvDLsLOIREmnkkKeGFPOqPtmc9mUuaxYu5mLv9kVMzUTjAJ1RWi8Fn68juH3zmLL9iruH9GfAV1Lwo4kknR7q5ju+i/k7guBhamPIyLZqLQon/VbdrBle1WURv18NRjc7RFgY/VCd58TXiSR8LVunsd9F/Tnqqnz+dWz7/Dhmk3cfFIPmuYkMvW5pJi6IjRCry5ZzUX3z6ZFQVOmji6n2z4two4kkhJ7q5i2NbMr9/Siu9++tx2b2URiheen7n74bl4/GvgLUN1H4gl3v6nWxCKScarnMq3cuI0DWjcLOc0uvYP7+HLHgW+FkEUkUgpyc/j9mb3pWNyMsS8u5ePPNjP27D4U5ScyNIWkirv/xcz+Blzt7mrx0Qg8Nfcjrpo6j66lRUwa0Y/9WkXmf6hI0u3tP0wOUETcldM6mgT8CbhvL+v8x91/WM/9i0iGKC2KVUxXr98amYqpux8TdgaRKGvSxLjquEPp0KY51z21gNPHz+De8/uxbyu1GA2TuiI0Du7OXS8v49Zn3mFAl2ImnFdGq2aaDkay294qpisbcgXT3V82s8713V5EskdpUWyGqagMgFTNzH5ArL/WrjNttdwQ+bIh/TuyX+tmXPLgHE4Z9yoTz+/HYfu1DDtWY6euCFmsaqdz89/eYtL09/nBEftx+xm9yG8amW4wIimztw4j6RjpYJCZzTOzZ8ysxx6DmI0yswozq1i1alUaYolIMlVfMa2MyFymAGY2HjgTuIxgYDegU6ihRCLqm93a8uhFg3CH08fP4OXF+l8cst7EvlS7CfhtcPtNqIkkKbZsr+KyKXOYNP19RhzVhT8OOVKVUmk09lYx/XaK33sO0MndewF/BJ7a04ruPsHdy9y9rG3btimOJSLJVhJcMa3cGJ2KKVDu7ucBa939RmAQ0C3kTCKR1X3/ljx5STnt2zRj+KRZPDLrw7AjNVrufsxubuofn+HWbdrOeRNf5+k3/8v1PziMn5/QnSZNNCK2NB57bMrr7mtS+cbu/nnc46fNbJyZlbr76lS+r4ikX/O8phTkNqEyWk15Nwf3m8xsf6AS2C/EPCKRt1+rZjx28SAueWguVz/+JsvXbObH3+2m6WRCoK4I2eXjzzZz/r2v897qjfxh6JGc2Gv/sCOJpF1oY7+b2b4W/Cczs/5Blsqw8ohIapUU5rMmWldM/2ZmrYHbiLXgeB94KNREIhmgRUEufx5WxtD+HfjTi0u44pE32LqjKuxYjYq6ImSXRf9dz+Bx01n52RYmD++vSqk0Wikb993MpgBHA6VmtgL4BZAL4O7jgdOA0Wa2g9iViyHu7qnKIyLhKinKY3WEKqbufnPw8PFg+oUCd18XZiaRTJGb04RfntKTDsXN+fWzi1i5bgsTzu1L6+Z5YUdrLMrd/Qgzm+/uN5rZb4Fnwg4ldTdzWSUj76ugeV4Oj148SAOLSaOWsoqpuw+t5fU/EZtORkQagZLCPFZFqCmvmRUAY4CvEZu/9BUzu9Pdt4SbTCQzmBljjj6I9m2a85NH5zH4zulMOr8/HUuahx2tMVBXhCzwt/kfc+Uj8+hY0pzJI/pHZjo1kbCE1pRXRBqX4sJ81kRoVF5icyz3IDb42p+A7sD9iWxoZseb2SIzW2Jm1+zm9YvN7E0ze8PMXjGz7klNLhIhJ/banwcuHEDlhm2cMu5V5n64NuxIjUG9uyIkUH7dEZRdb5jZYjP7LO61YWb2bnAblqSfpVGa+Mp7XDZlLr06tGLqxYNUKRUhhVdMRUTilQZNed09KgOlHO7u8RXGF83srdo2MrMcYCxwLLACmGVm09w9ftuHgi4LmNmJwO3A8cmLLhIt/bsU88SYcobfO4shE2by+yFHcvzh+4YdK2vVtytCIuWXu/9P3PqXAUcGj4uJdcsqI9bKZHawrb6JqIOdO51bn32HCS8v4/ge+/K7Ib0pyNV0MCKgK6YikibFhXls27GTjdsiM0jKHDMbWP3EzAYAFQls1x9Y4u7L3H0b8DBwUvwK8aOOA4XETuJEstqBbYt4Ykw53fdvyegHZ/PnV94LO1LWMrMCM7vSzJ4gdqV0RNA9oTa1ll81DAWmBI+PA5539zVBZfR59IVbnWzdUcUVj7zBhJeXMWxQJ8ae3UeVUpE4qpiKSFqUFOUDRGnKmL7AdDN738zeB2YA/YImuPP3st0BwPK45yuCZV9iZpeY2VLg18Dlu9uRmY0yswozq1i1alV9fw6RyCgtymfKyIEc131fbv7bW9wwbSFVO/W9TArUtytCQuUXgJl1AroAL9R1W/mqz7dsZ/i9s5g272Ou+d6h3HBiD3I0R6nIl6gpr4ikRUlhbLTOyo3b6FRSGHIaIMXf9Lv7WGCsmZ0FXA98pT+Wu08AJgCUlZXp7F2yQkFuDmPP7sMtT7/NPa+8x4q1m/nD0N40z9MpRxLVqytCHQ0Bprp7nZq5mNkoYBRAx44dkxwpM33y+RaGTXydJZ9u4PYzejG4T/uwI4lEkq6YikhalBQFFdOIDIDk7h/s7baXTT8COsQ9bx8s25OHgZOTkVkkU+Q0Ma7/YXduPLEHL7zzCUMmzOTT9RrwOonq2xWhLuXXEL5oxpvwtu4+wd3L3L2sbdu2CUTKbks+jc1RunzNJu4d3k+VUpG9UMVURNKiOLhiumZjZJry1tcs4GAz62JmecRO3qbFr2BmB8c9/QHwbhrziUTGsPLO3HVuGe9+soHB46az5NP1YUfKFvXtilBr+QVgZocCbYL9VnsO+K6ZtTGzNsB3g2WyB7PeX8Opd85g646dPHLRIL5+sCrqInujdjUikhYlhbE+pqsjcsW0vtx9h5ldSuyELAeY6O4LzewmoMLdpwGXmtl3gO3AWnbTjFeksTi2+z48ctFARkyqYPC46Yw/ty/lB5aGHSvT1asrQoLlF8QqrA+7u8dtu8bMbiZWuQW4yd3X1P9HyG7PLljJ5Q+/QfvWzZg8oj8dijW/r0htVDEVkbRolpdD87wc1myMTsU0GNzjYHf/p5k1A5q6e62XdNz9aeDpGst+Hvf4R0kPK5LBjmjfmifHlDN80iyGTXydX516hJo0NkAt3Q1q23av5Vfw/IY9bDsRmFjf924s7pvxPr+YtpDeHVrz52H9drUYEpG9U1NeEUmbkqK8yIzKa2YjganAXcGi9sBT4SUSyW4dipvz+OhyyjoVc+Wj8/j9P98l7oKcSMZzd3797Dv8/C8L+fah+/DQhQNVKRWpA1VMRSRtigvzqYzOFdNLgKOAzwHc/V2gXaiJRLJcq2a5TB7Rn8F9DuCOfy7mqqnz2bZjZ9ixRBps246d/PixeYx7aSlD+3dk/Dl9aJanOUpF6kJNeUUkbUoL81i5LjIjc251921msXnkzKwpoMs3IimW17QJvz29Fx3aNOf3/3qX/67bwrhz+tCyIDfsaBmlvl0RJPk2bN3B6Adm8593V3Plsd247FsHUf2/RUQSpyumIpI2xYV5Uepj+m8z+1+gmZkdCzwG/DXkTCKNgpnxP8d24zen92LmskpOu3M6H322OexYGUNdEaLj0/VbOPOuGUxfWsmvTzuCy799sCqlIvWkiqmIpE1JUT6VG7dGpV/ZNcAq4E3gImKDgVwfaiKRRua0vu2ZPKI/K9dt4eSxr7Lgo3VhR8oU6ooQAUtXxaZBWrZqI/cMK+OMsg61byQie6SKqYikTUlhHturnPVbd4QdBeBk4D53P93dT3P3uz0iNWaRxuSog0p5fHQ5eTlNOOOuGbzwzidhR8oEW919V/MTdUVIv9kfrOW0O6ezeVsVD48ayDGH6HsBkYZSxVRE0qZ6dMLKaMxlegKw2MzuN7MfBid2IhKCbvu04Mkx5XRtW8iFkyu4f2a9Z0NpLNQVIUTPv/UJZ98zk1bNcnliTDm9OrQOO5JIVlDFVETSpqQoVjFdszH8KWPcfThwELETuqHAUjO7J9xUIo1Xu5YFPDJqEEcf0o6fPbWAXz79Njt36iLgHqgrQkgefO0DLrq/gkP2acHU0eV0KikMO5JI1tAVAhFJm5LCfABWR+OKKe6+3cyeIdYErhmx5r0XhptKpPEqzG/KhHP7cuNf32LCy8tYsXYTt5/Rm4JcTbtRQ3VXhLvDDtJYuDt3PL+YP7ywhGMOacvYs/vQPE+n0SLJpCumIpI2X1wxDb9iambfM7NJwLvAqcA9wL6hhhIRmuY04aaTenDd9w/j6Tf/y1l3z6RyQ/itLCJGXRHSaHvVTn46dT5/eGEJZ5S15+7zylQpFUkBVUxFJG2+6GMaiZPM84hNr3CIu5/v7k+7eyRGZRJp7MyMkd/oyriz+7Dw48859c7pvLd6Y9ixIkNdEdJn49YdjLyvgsdmr+Dybx/Mr049gqY5On0WSQX9ZYlI2hTk5lCU35TKCFwxdfeh7v6Uu0eiliwiX/X9nvvx0MiBfL5lB6eMe5WK99eEHSky3H078AzwMDCbWPNeSaLVG7Zy1t0zeXnxKn55Sk+uPLab5igVSSFVTEUkrYoL80IdldfMXgnu15vZ53G39Wb2eWjBRGS3+nZqw5NjymnTPI+z7nmNv877OOxIoVNXhNR7f/VGTr1zOos+Wc9d55Zx1oCOYUcSyXpqIC8iaVVSlBdqH1N3/1pw3yK0ECJSJ51KCnlidDmj7q/gsilzWbF2Mxd/s2tjvnp1HvAIcJFafSTfvOWfMWLSLHa68+CFA+nbqU3YkUQahZRdMTWziWb2qZkt2MPrZmZ/MLMlZjbfzPqkKouIREdJYR6rI9DH1MzuT2SZiERDm8I87r9gACf02p9fPfsO1z21gB1VO8OOFQp1RUidF9/5lCETZtIsL4epo8tVKRVJo1Q25Z0EHL+X178HHBzcRgF3pjCLiERESWF+JEblBXrEPwlGtewbUhYRSUBBbg6/P7M3Y44+kIde+5ALJlewYWvjGbNMXRFS69FZy7nwvgq6ti3kiTHlHNi2KOxIIo1Kyiqm7v4ysLdRCk4iNgeXu/tMoLWZ7ZeqPCISDcVBU153D+X9zexaM1sPHBF/Ugd8AvwllFAikrAmTYyfHn8otwzuyStLVnPG+Bn8d92WsGOlRXxXBHdvGXdr4e4tw86XqdydP/zrXX76+HzKDyzhkYsG0a5FQdixRBqdMAc/OgBYHvd8RbDsK8xslJlVmFnFqlWr0hJORFKjpDCPHTudzzeHc5XD3W8J+pfeVuOkrsTdrw0llIjU2dD+HfnzsDI+qNzIKeNe5e2VjeeCoboiJM+Oqp3875MLuP35xQw+8gD+PKwfRfkagkUkDBkxKq+7T3D3Mncva9u2bdhxRKQBSopic5mu3hhu1yh3v9bM2phZfzP7RvUt1FAiUidHH9KOxy4uxx1OHz+Dlxc3mi+v1RUhCTZvq+LiB2Yz5fUPueSYA/ntGb3Ia5oRp8YiWSnMv76PgA5xz9sHy0Qki5UU5gOE3s/UzC4EXgaeA24M7m8IM5OI1F33/Vvy5CXltG/TjOGTZvHorOW1b5ShktEVwcyON7NFweCT1+xhnTPM7C0zW2hmD8UtrzKzN4LbtKT8UCFZs3EbQ++eyb/e+ZSbTurBVccd2phHeRaJhDArptOA84LReQcC69x9ZYh5RCQNigtjV0wrwx+Z90dAP+ADdz8GOBL4LNxIIlIf+7VqxmMXD6L8wBJ++vh8fvPcotD6sadSQ7simFkOMJbYAJTdgaFm1r3GOgcD1wJHuXsP4Iq4lze7e+/gdmLSfrA0+7ByE6feOZ23Vn7OnWf35bxBncOOJCKkcB5TM5sCHA2UmtkK4BdALoC7jweeBr4PLAE2AcNTlUVEoqO0KHbFtDL8kXm3uPsWM8PM8t39HTM7JOxQIlI/LQpymXh+P3721AL+9OISlq/dxK9PO4L8pjlhR0saMzvU3d8BHtvdNHvuPqeWXfQHlrj7smB/DxMbjPKtuHVGAmPdfW2wz0+TEj4iFny0jvPvncX2qp08eOEA+nUuDjuSiARSVjF196G1vO7AJal6fxGJpjaFuQBUbgi9YrrCzFoDTwHPm9la4IPaNjKz44HfAznAPe5+a43XrwQuBHYAq4AR7l7rfkWk4XJzmnDL4J50KG7Obc8tYuW6LUw4ty+tm+eFHS1ZriQ2xd5vd/OaA9+qZfvdDTw5oMY63QDM7FVi5dwN7v5s8FqBmVUQK99udfenar6BmY0KMtKxY8da4qTXy4tXMfqB2bRunsfDowZwULsWYUcSkTgadkxE0iq/aQ4tCpqG3sfU3U8JHt5gZi8CrYBn97JJfDO4Y4md0M0ys2nuHn+1YS5Q5u6bzGw08GvgzKT/ACKyW2bGJcccRPs2zbjqsfmceud0Jg3vT4fi5mFHazB3HxXcH5PCt2lKbI75o4mN//GymfV098+ATu7+kZl1BV4wszfdfWmNjBOACQBlZWWRaU/9+OwVXP34fA5qV8TkEf3Zp6WmgxGJGg09JiJpV1KYF3pTXjMrrr4BbwKvELvisDe7msG5+zaguhncLu7+ortvCp7OJHZiJyJpdlLvA7j/gv6s3rCNU8a9yhvLs6cLuZmdbmYtgsfXm9kTZnZkApsmMvDkCmCau2939/eAxcQqqrj7R8H9MuAlYn3zI83dGfviEn782Dz6dS7m0YsHqVIqElGqmIpI2pUU5Udh8KM5xJraLgbeDR6/b2ZzzGxP0y4kPP9y4ALgmT29qDmaRVJrQNcSnhhTTrO8HIZMmMFzC/8bdqRk+Zm7rzezrwHfAf4MjE9gu1nAwWbWxczygCHEBqOM9xSxq6WYWSmxpr3Lgum18uOWH8WX+6ZGTtVO5xfTFnLbc4s4sdf+TBrRj5YFuWHHEpE9UMVURNKuuDAv9Ka8wPPA99291N1LiI1S+TdgDDCuoTs3s3OAMuC2Pa2jOZpFUu/AtkU8OeYoDt23JRc/MJuJr7wXdqRkqArufwBMcPe/A7V2pHX3HcClxKbHeht41N0XmtlNZlY9yu5zQKWZvQW8CFzl7pXAYUCFmc0Llt9aoxtDpGzZXsUlD87hvhkfMPLrXfjdmb2zaiAskWykPqYiknalRXnM/TD0ZnUD3X1k9RN3/4eZ/cbdL6q+KrAbCc2/bGbfAa4DvunuoV8aFmnsSovymTJyIFc8Mpeb/vYWH67ZxM9+2J2cJhk7b+VHZnYXsf7uvwrKrIQuNrj708RmRohf9vO4x05skKUra6wzHejZwNxp8dmmbYy8r4KKD9bysx9254KvdQk7kogkQFdMRSTtigvzWLtpGzt3hjouxkozu9rMOgW3nwKfBAMc7dzDNrU2gwv6ed0FnJht0yyIZLJmeTmMO7svF3ytC5Omv8/oB2azeVtV7RtG0xnErmweFwxKVAxcFW6kaPjos82cNn4G85av449Dj1SlVCSDqGIqImlXUphP1U5n3ebtYcY4i9gVz6eAJ4ldCT2L2PQIZ+xugwSbwd0GFBGbZ/ANM6vZf0tEQpLTxPjZD7tzwwndef7tTxgyYQar1mdeo4ZggLWlwHFmdinQzt3/EXKs0L298nMGj3uVTz7fwuQR/fnhEfuHHUlE6kBNeUUk7UqKYl2hKjduo01hOPMLuvtq4DIzK3T3jTVeXrKX7WprBvedpAYVkaQ7/6gu7N8qddvbAAARtUlEQVS6GZc/PJdTxr3KpOH9MmpOSzP7ETASeCJY9ICZTXD3P4YYK1QzllYy6r4KCvOb8tjFgzh035ZhRxKROtIVUxFJu5LCWBfOMEfmNbPyYHCPt4PnvcyswYMeiUhm+G6PfXlk1CC2bK9i8LjpzFxWGXakurgAGODuPw++GBtIrKLaKP1t/scMm/g6+7Yq4Ikx5aqUimQoVUxFJO2Kg6ukIY/MewdwHFAJ4O7zgG+EGUhE0qtXh9Y8OeYo2rUs4Nw/v8ZTc78ylllUGV+MzEvwOGNHcmqISa++x2VT5tKrQyumXlzO/q2bhR1JROpJTXlFJO1Kg6a8q0OeMsbdl5t96VwuY0dCEZH66VDcnMcvLueiByq44pE3WL5mE5d+6yBqlA1Rcy/wmpk9GTw/mdhcpo2Gu3Pbc4sY99JSjuuxD78fciQFuZoORiST6YqpiKRddb/SNRtCrZguN7NywM0s18x+QtCsV0Qal1bNc5k8oj+nHHkAv31+MT+dOp/tVXsanDt87n47MBxYE9yGu/vvwk2VPturdvKTx+Yz7qWlnD2gI+PO7qtKqUgW0BVTEUm73JwmtGqWS+XGUEfDvBj4PXAAsblI/wFcEmYgEQlPftMcbj+jFx2Km/OHf73LynVbGHdOH1oW5IYdbRczKyBWdh0EvAmMC0YLbzQ2b6ti9IOzeWnRKn58bLdMuLotIglSxVREQlFSmEdliE15g1F5zw4tgIhEjplx5bHd6NCmGdc+8San3zmDe4f3i1K/xcnAduA/wPeAw4ArQk2URp9v2c6Ie2cx58O13Dq4J0P6dww7kogkkSqmIhKKkqK8UEblNbOf7+Vld/eb0xZGRCLp9LIO7N+6GRffP5uTx77KxPP7cfgBrcKOBdDd3XsCmNmfgddDzpM2qzdsZdjE11n8yXr+dFYfvt9zv7AjiUiSqY+piISiuDAvrFF5N+7mBrHpF64OI5CIRM9RB5UydXQ5uTlNOOOuGbz4zqdhR4LY1VIAGlMT3o8/28wZd81g6aoN3DOsnyqlIllKFVMRCUVJUT6VIQx+5O6/rb4BE4BmxAYReRjomvZAIhJZh+zbgifHlNO1bSEXTJ7FAzM/CDtSLzP7PLitB46ofmxmn4cdLhXeW72R08fPYNXnW7n/ggF8s1vbsCOJSIqoYioioSgpzGPtpm1U7fS0v7eZFZvZ/wPmE+vS0Mfdr3b3SFwSEZHoaNeygEdGDeLoQ9px/VMLuOWZt9kZQrkF4O457t4yuLVw96Zxj1uGEiqF3v1kPaePn8Hm7VVMGTWQfp2Lw44kIimkiqmIhKKkMI+dDp9tSu9VUzO7DZgFrAd6uvsN7r42rSFEJKMU5jdlwrl9OWdgR+769zIumzKXLds17XEqbd1RxSUPzQHg0YsGRaWPr4ikkCqmIhKK4qJ8gDD6mf4Y2B+4Hvg4vllctjaFE5GGa5rThJtPOpz//f6h/P3NlZx9z2th9ZNvFO54/l0Wf7KB204/goPaFYUdR0TSQBVTEQlFSWEeAKvT3M/U3Zu4e7Pqpm81msVlXVM4EUkeM2PUNw5k7Fl9ePOjdQwe9yrvrd5Y+4ZSJ3M+XMuEl5dyZlkHjjmkXdhxRCRNVDEVkVCUFMUqprriICKZ5gdH7MeUkQP4fMsOBo97lYr314QdKWts3lbFTx6dx36tmnH9Dw8LO46IpJEqpiISiuLgimnlxvTPZSoi0lB9OxXzxOhyWjfP46x7XuNv8z8OO1JWuO25RSxbvZFfn3YELQpyw44jImmU0oqpmR1vZovMbImZXbOb1883s1Vm9kZwuzCVeUQkOoqbBxXTEKaMERFJhs6lhTw+upwjDmjFpQ/NZfy/l+Iezoi9iart3CxY5wwze8vMFprZQ3HLh5nZu8FtWLKzvbasknunv8e5Aztx1EGlyd69iERc01Tt2MxygLHAscAKYJaZTXP3t2qs+oi7X5qqHCISTU1zmtC6ea6umIpIRisuzOOBCwfw48fmcesz77B8zSZuPLEHTXOi1ygtkXMzMzsYuBY4yt3Xmlm7YHkx8AugDHBgdrBtUkY137h1Bz+ZOo8ObZpzzfcOTcYuRSTDpLLU7A8scfdl7r6N2OT1J6Xw/UQkw5QU5qmPqYhkvILcHP445Egu/uaBPPjah4y8r4KNW3eEHWt3Ejk3GwmMra5wxs3vfBzwvLuvCV57Hjg+WcFueeZtVqzdzG9O70Vhfsqum4hIhKWyYnoAsDzu+YpgWU2nmtl8M5tqZh1SmEdEIqakMJ/1WyJ58iYiUidNmhjXfO9Q/u+Uw5mxrJJ3/hvJ2acSOTfrBnQzs1fNbKaZHV+HbTGzUWZWYWYVq1atSijU+i3beWnRKi44qgv9uxQn+rOISJYJ+yupvwJT3H2rmV0ETAa+VXMlMxsFjALo2LFjehOKSMo8NHJAJJu7iYjU19kDOvHd7vvStkV+2FHqqylwMHA00B542cx6Jrqxu08AJgCUlZUl1OG2RUEuz/zo6+Tq/4FIo5bKEuAjIP4KaPtg2S7uXunu1R3M7gH67m5H7j7B3cvcvaxt27YpCSsi6adKqYhkowhXSms9NyN2JXSau2939/eAxcQqqolsW28tCnIpyM1J1u5EJAOl8qxwFnCwmXUxszxgCDAtfgUz2y/u6YnA2ynMIyIiItKY1XpuBjxF7GopZlZKrGnvMuA54Ltm1sbM2gDfDZaJiCRFyiqm7r4DuJRYofU28Ki7LzSzm8zsxGC1y4OhyOcBlwPnpyqPiEgyJDAN1jfMbI6Z7TCz08LIKCKyOwmemz0HVJrZW8CLwFVBC7c1wM3EKrezgJuCZSIiSZHSPqbu/jTwdI1lP497fC2xIclFRCIvwWmwPiT2JdtP0p9QRGTvEjg3c+DK4FZz24nAxFRnFJHGKezBj0REMsmuqRYAzKx6qoVdFVN3fz94bWcYAUVEREQykUYeERFJXKLTYCWkPtMqiIiIiGQjVUxFREKiEcdFREREYlQxFRFJXEqnSxARERFprFQxFRFJXCJTLYiIiIhIHVls8LXMYWargA/qsEkpsDpFceoiCjmikAGUo6Yo5IhCBkgsRyd3D63dq5l9H/gdkANMdPf/M7ObgAp3n2Zm/YAngTbAFuC/7t4jgf3WpWzLpM8rHZQjWhlAOWqqLUeo5Vqq6Jwt4zOActQUhRxRyAApOGfLuIppXZlZhbuXKUc0MihHNHNEIUOUckRdVI6TckQvRxQyKEd0c0RdVI5TFHJEIYNyRDNHFDKkKoea8oqIiIiIiEioVDEVERERERGRUDWGiumEsAMEopAjChlAOWqKQo4oZIDo5Ii6qBwn5fiyKOSIQgZQjpqikiPqonKcopAjChlAOWqKQo4oZIAU5Mj6PqYiIiIiIiISbY3hiqmIiIiIiIhEWEZVTM3seDNbZGZLzOya3byeb2aPBK+/Zmad4167Nli+yMyOS3SfycxhZsea2WwzezO4/1bcNi8F+3wjuLVLYY7OZrY57r3Gx23TN8i3xMz+YGaWogxnx73/G2a208x6p/BYfMPM5pjZDjM7rcZrw8zs3eA2rL7HoiE5zKy3mc0ws4VmNt/Mzox7bZKZvRd3PHqn+HhUxb3XtLjlXYLPcEnwmeal6FgcU+N3Y4uZnVzfY5EJ6vt3FLyWlLKtAX/LWVeuNTBH1pVtDfhbzrpyrYHH4xhrRGVbff+Ggtd0zqZzNp2zJXY8suuczd0z4kZszsClQFcgD5gHdK+xzhhgfPB4CPBI8Lh7sH4+0CXYT04i+0xyjiOB/YPHhwMfxW3zElCWpuPRGViwh/2+DgwEDHgG+F4qMtRYpyewNMXHojNwBHAfcFrc8mJgWXDfJnjcpq7HIgk5ugEHB4/3B1YCrYPnk+LXTeXxCF7bsIf9PgoMCR6PB0anKkONz2cN0Lw+xyITbg35OyJJZVsDM2RVudbQHDXWyfiyrYEZsqpcS0aOGp9P1pZtDfkbQudsNXN0Ruds8X83Omf78mtZdc6WSVdM+wNL3H2Zu28DHgZOqrHOScDk4PFU4NvBNyYnAQ+7+1Z3fw9YEuwvkX0mLYe7z3X3j4PlC4FmZpaf8BFIUo497dDM9gNauvtMj/1G3QecnIYMQ4Nt66vWHO7+vrvPB3bW2PY44Hl3X+Pua4HngePrcSwalMPdF7v7u8Hjj4FPgfpOtt6Q47FbwWf2LWKfIcQ+0wb9biSY4TTgGXfflEjODBWFsk3lWmpyZEPZpnItNTmyvWyLQrnWoBxZWLapXEtSjiws2yJTrmVSxfQAYHnc8xXBst2u4+47gHVAyV62TWSfycwR71RgjrtvjVt2b3Cp+2cJNEFoaI4uZjbXzP5tZl+PW39FLftMZoZqZwJTaixL9rGo67Z1PRYNzbGLmfUn9o3V0rjF/xc0F7kjgX+MDc1RYGYVZjazujkGsc/ss+AzTGSfSTkWxL6xrfm7UZdjkQmiULapXEtujmrZULapXEtujmrZXrZFoVxraI542VC2qVxLXo5dsqRsi0y5lkkV06xhZj2AXwEXxS0+2917Al8PbuemMMJKoKO7HwlcCTxkZi1T+H57ZGYDgE3uviBucTqPRaQE3/rdDwx39+pvpa4FDgX6EWsmcXWKY3Ry9zLgLOB3ZnZgit9vt4Jj0RN4Lm5xuo+FJEjl2pepbPuCyrUvU9mWWVS2fUHl2pepbPtCssq1TKqYfgR0iHvePli223XMrCnQCqjcy7aJ7DOZOTCz9sCTwHnuvuvbFXf/KLhfDzxE7LJ6SnIEzWMqg/ebTexbnm7B+u1r2WdSMsS9/pVvV1J0LOq6bV2PRUNzEPyj+TtwnbvPrF7u7is9ZitwL6k9HvHHfxmxviNHEvvMWgefYSL7bFCGwBnAk+6+PS5bXY9FJohC2aZyLUk54l7PlrJN5VoScwQaQ9kWhXKtoTmyrWxTuZa8HNlWtkWnXPM6dEgN8wY0JdbJuQtfdMztUWOdS/hyp+1Hg8c9+HJH+mXEOvrWus8k52gdrD94N/ssDR7nEmsTfnEKc7QFcoLHXYn98hUHz2t2Hv9+KjIEz5sE79011ccibt1JfLUj/XvEOtG3CR7X+VgkIUce8C/git2su19wb8DvgFtTmKMNkB88LgXeJegADzzGlzvSj0lFhrjlM4FjGnIsMuHWkL8jklS2NTBDVpVrDc0RPM+asq2BGbKqXGtojrjlWV+2NeRvCJ2z1cyhc7YvnuucLcvP2UIvvOpyA74PLCb2bdF1wbKbgBODxwXBB7Ek+AWN/+O5LthuEXEjde1un6nKAVwPbATeiLu1AwqB2cB8Yh3sf09QCKUox6nB+7wBzAFOiNtnGbAg2OefAEvhZ3I0MLPG/lJ1LPoRazO/kdg3SQvjth0R5FtCrDlGvY5FQ3IA5wDba/xu9A5eewF4M8jyAFCUwhzlwXvNC+4viNtn1+AzXBJ8pvkp/Ew6E/sH2KTGPut8LDLh1sC/o6SUbfXNQBaWa0n4TI4mi8q2+mYgC8u1JHwmnWkkZVsD/4Z0zqZzNp2zNcJzNgs2FBEREREREQlFJvUxFRERERERkSykiqmIiIiIiIiEShVTERERERERCZUqpiIiIiIiIhIqVUxFREREREQkVKqYioiIiIiISKhUMRUREREREZFQqWIqGcPM2pvZmWHnEBFJJpVtIpJtVK5JfahiKpnk20CfsEOIiCSZyjYRyTYq16TOzN3DziBSKzP7GvAX4DNgPTDY3ZeFm0pEpGFUtolItlG5JvWliqlkDDN7FviJuy8IO4uISLKobBORbKNyTepDTXklkxwCvBN2CBGRJFPZJiLZRuWa1JkqppIRzKwUWOfuO8LOIiKSLCrbRCTbqFyT+lLFVDJFZ+DjsEOIiCRZZ1S2iUh26YzKNakHVUwlU7wDlJrZAjMrDzuMiEiSqGwTkWyjck3qRYMfiYiIiIiISKh0xVRERERERERCpYqpiIiIiIiIhEoVUxEREREREQmVKqYiIiIiIiISKlVMRUREREREJFSqmIqIiIiIiEioVDEVERERERGRUKliKiIiIiIiIqH6/x/TaCqmZ8I6AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -760,12 +768,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "99e13279bde044ea9cea75d2f873e7c6", + "model_id": "0ff3a1563e0f45bdbe67f6838ecaab48", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=0.2, step=0.01), Output()), _dom_classes=('w…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=0.17, step=0.01), Output()), _dom_classes=('…" ] }, "metadata": {}, @@ -790,7 +798,7 @@ " plt.show()\n", " \n", "import ipywidgets as widgets\n", - "widgets.interact(plot_concentrations, t=widgets.FloatSlider(min=0,max=0.2,step=0.01,value=0));\n" + "widgets.interact(plot_concentrations, t=widgets.FloatSlider(min=0,max=0.17,step=0.01,value=0));\n" ] }, { @@ -808,12 +816,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5198757616254d11a031a8deee5a51f7", + "model_id": "ba068df354c2496d95915645646fbb20", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(FloatSlider(value=0.0, description='t', max=0.6863442760242967, step=0.05), Output()), _…" + "interactive(children=(FloatSlider(value=0.0, description='t', max=1.0850295540089985, step=0.05), Output()), _…" ] }, "metadata": {}, diff --git a/examples/notebooks/models/spm1.png b/examples/notebooks/models/spm1.png index b41a99a08c..7344d99b12 100644 Binary files a/examples/notebooks/models/spm1.png and b/examples/notebooks/models/spm1.png differ diff --git a/examples/notebooks/models/spm2.png b/examples/notebooks/models/spm2.png index 172aef3f82..896bc3aca7 100644 Binary files a/examples/notebooks/models/spm2.png and b/examples/notebooks/models/spm2.png differ diff --git a/examples/notebooks/spatial_methods/finite-volumes.ipynb b/examples/notebooks/spatial_methods/finite-volumes.ipynb index ae8b0a5a60..819a778f4d 100644 --- a/examples/notebooks/spatial_methods/finite-volumes.ipynb +++ b/examples/notebooks/spatial_methods/finite-volumes.ipynb @@ -124,9 +124,9 @@ "outputs": [], "source": [ "spatial_methods = {\n", - " \"macroscale\": pybamm.FiniteVolume,\n", - " \"negative particle\": pybamm.FiniteVolume,\n", - " \"positive particle\": pybamm.FiniteVolume,\n", + " \"macroscale\": pybamm.FiniteVolume(),\n", + " \"negative particle\": pybamm.FiniteVolume(),\n", + " \"positive particle\": pybamm.FiniteVolume(),\n", "}\n", "disc = pybamm.Discretisation(mesh, spatial_methods)" ] @@ -1282,7 +1282,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/notebooks/unsteady_heat_equation.ipynb b/examples/notebooks/unsteady_heat_equation.ipynb index e56273fa3c..5582dc8231 100644 --- a/examples/notebooks/unsteady_heat_equation.ipynb +++ b/examples/notebooks/unsteady_heat_equation.ipynb @@ -214,7 +214,7 @@ "submesh_types = {\"rod\": pybamm.Uniform1DSubMesh}\n", "var_pts = {x: 30}\n", "mesh = pybamm.Mesh(geometry, submesh_types, var_pts)\n", - "spatial_methods = {\"rod\": pybamm.FiniteVolume}\n", + "spatial_methods = {\"rod\": pybamm.FiniteVolume()}\n", "disc = pybamm.Discretisation(mesh, spatial_methods)" ] }, @@ -421,7 +421,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/notebooks/using-model-options_thermal-example.ipynb b/examples/notebooks/using-model-options_thermal-example.ipynb index a1d6dee7c1..3039bc97ce 100644 --- a/examples/notebooks/using-model-options_thermal-example.ipynb +++ b/examples/notebooks/using-model-options_thermal-example.ipynb @@ -204,7 +204,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/scripts/compare_extrapolations.py b/examples/scripts/compare_extrapolations.py new file mode 100644 index 0000000000..defcf557f0 --- /dev/null +++ b/examples/scripts/compare_extrapolations.py @@ -0,0 +1,32 @@ +import pybamm + + +x_n = pybamm.standard_spatial_vars.x_n +x_s = pybamm.standard_spatial_vars.x_s +x_p = pybamm.standard_spatial_vars.x_p + +var_pts = {x_n: 10, x_s: 3, x_p: 10} +model_lin = pybamm.lead_acid.Full() +sim_lin = pybamm.Simulation(model_lin, var_pts=var_pts) +sim_lin.solve() + +model_quad = pybamm.lead_acid.Full() +method_options = {"extrapolation": {"order": "quadratic", "use bcs": False}} +spatial_methods = { + "negative particle": pybamm.FiniteVolume(method_options), + "positive particle": pybamm.FiniteVolume(method_options), + "macroscale": pybamm.FiniteVolume(method_options), + "current collector": pybamm.ZeroDimensionalMethod(), +} +sim_quad = pybamm.Simulation( + model_quad, spatial_methods=spatial_methods, var_pts=var_pts +) +sim_quad.solve() + + +# plot the two sols +models = [sim_lin.built_model, sim_quad.built_model] +solutions = [sim_lin.solution, sim_quad.solution] +plot = pybamm.QuickPlot(models, sim_lin.mesh, solutions) +plot.dynamic_plot() + diff --git a/examples/scripts/create-model.py b/examples/scripts/create-model.py index 731d56dcf8..73b7d33e58 100644 --- a/examples/scripts/create-model.py +++ b/examples/scripts/create-model.py @@ -105,7 +105,7 @@ def Diffusivity(cc): var_pts = {x: 50} mesh = pybamm.Mesh(geometry, submesh_types, var_pts) -spatial_methods = {"SEI layer": pybamm.FiniteVolume} +spatial_methods = {"SEI layer": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) diff --git a/examples/scripts/heat_equation.py b/examples/scripts/heat_equation.py index 62eccc3eba..5bccd4fd9d 100644 --- a/examples/scripts/heat_equation.py +++ b/examples/scripts/heat_equation.py @@ -51,7 +51,7 @@ submesh_types = {"rod": pybamm.Uniform1DSubMesh} var_pts = {x: 30} mesh = pybamm.Mesh(geometry, submesh_types, var_pts) -spatial_methods = {"rod": pybamm.FiniteVolume} +spatial_methods = {"rod": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) diff --git a/pybamm/__init__.py b/pybamm/__init__.py index 55ad930ce5..4bddae0546 100644 --- a/pybamm/__init__.py +++ b/pybamm/__init__.py @@ -229,6 +229,7 @@ def version(formatted=False): # Mesh and Discretisation classes # from .discretisations.discretisation import Discretisation +from .discretisations.discretisation import has_bc_of_form from .meshes.meshes import Mesh, SubMesh, MeshGenerator from .meshes.zero_dimensional_submesh import SubMesh0D from .meshes.one_dimensional_submeshes import ( diff --git a/pybamm/discretisations/discretisation.py b/pybamm/discretisations/discretisation.py index 1e1653a8a0..e6e8aefe6f 100644 --- a/pybamm/discretisations/discretisation.py +++ b/pybamm/discretisations/discretisation.py @@ -7,6 +7,18 @@ from scipy.sparse import block_diag, csr_matrix +def has_bc_of_form(symbol, side, bcs, form): + + if symbol.id in bcs: + if bcs[symbol.id][side][1] == form: + return True + else: + return False + + else: + return False + + class Discretisation(object): """The discretisation class, with methods to process a model and replace Spatial Operators with Matrices and Variables with StateVectors @@ -16,8 +28,9 @@ class Discretisation(object): mesh : pybamm.Mesh contains all submeshes to be used on each domain spatial_methods : dict - a dictionary of the spatial method to be used on each - domain. The keys correspond to the keys in a pybamm.Model + a dictionary of the spatial methods to be used on each + domain. The keys correspond to the model domains and the + values to the spatial method. """ def __init__(self, mesh=None, spatial_methods=None): @@ -31,9 +44,11 @@ def __init__(self, mesh=None, spatial_methods=None): spatial_methods["negative electrode"] = method spatial_methods["separator"] = method spatial_methods["positive electrode"] = method - self._spatial_methods = { - dom: method(mesh) for dom, method in spatial_methods.items() - } + + self._spatial_methods = spatial_methods + for method in self._spatial_methods.values(): + method.build(mesh) + self.bcs = {} self.y_slices = {} self._discretised_symbols = {} @@ -714,7 +729,9 @@ def _process_symbol(self, symbol): mesh = self.mesh[symbol.children[0].domain[0]][0] if isinstance(mesh, pybamm.SubMesh1D): symbol.side = mesh.tabs[symbol.side] - return child_spatial_method.boundary_value_or_flux(symbol, disc_child) + return child_spatial_method.boundary_value_or_flux( + symbol, disc_child, self.bcs + ) else: return symbol._unary_new_copy(disc_child) diff --git a/pybamm/models/full_battery_models/base_battery_model.py b/pybamm/models/full_battery_models/base_battery_model.py index a6b0a7779a..a50592bcac 100644 --- a/pybamm/models/full_battery_models/base_battery_model.py +++ b/pybamm/models/full_battery_models/base_battery_model.py @@ -121,17 +121,17 @@ def default_submesh_types(self): @property def default_spatial_methods(self): base_spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "positive particle": pybamm.FiniteVolume, + "macroscale": pybamm.FiniteVolume(), + "negative particle": pybamm.FiniteVolume(), + "positive particle": pybamm.FiniteVolume(), } if self.options["dimensionality"] == 0: # 0D submesh - use base spatial method - base_spatial_methods["current collector"] = pybamm.ZeroDimensionalMethod + base_spatial_methods["current collector"] = pybamm.ZeroDimensionalMethod() elif self.options["dimensionality"] == 1: - base_spatial_methods["current collector"] = pybamm.FiniteVolume + base_spatial_methods["current collector"] = pybamm.FiniteVolume() elif self.options["dimensionality"] == 2: - base_spatial_methods["current collector"] = pybamm.ScikitFiniteElement + base_spatial_methods["current collector"] = pybamm.ScikitFiniteElement() return base_spatial_methods @property diff --git a/pybamm/models/submodels/current_collector/effective_resistance_current_collector.py b/pybamm/models/submodels/current_collector/effective_resistance_current_collector.py index 793adeff00..49df45dc19 100644 --- a/pybamm/models/submodels/current_collector/effective_resistance_current_collector.py +++ b/pybamm/models/submodels/current_collector/effective_resistance_current_collector.py @@ -223,7 +223,7 @@ def default_submesh_types(self): @property def default_spatial_methods(self): - return {"current collector": pybamm.ScikitFiniteElement} + return {"current collector": pybamm.ScikitFiniteElement()} @property def default_solver(self): diff --git a/pybamm/simulation.py b/pybamm/simulation.py index 774a5750b8..cb9b0e4edc 100644 --- a/pybamm/simulation.py +++ b/pybamm/simulation.py @@ -183,6 +183,10 @@ def parameter_values(self): def submesh_types(self): return self._submesh_types + @property + def mesh(self): + return self._mesh + @property def var_pts(self): return self._var_pts diff --git a/pybamm/spatial_methods/finite_volume.py b/pybamm/spatial_methods/finite_volume.py index 9698b4ffd2..916d4517f5 100644 --- a/pybamm/spatial_methods/finite_volume.py +++ b/pybamm/spatial_methods/finite_volume.py @@ -32,8 +32,12 @@ class FiniteVolume(pybamm.SpatialMethod): **Extends:"": :class:`pybamm.SpatialMethod` """ - def __init__(self, mesh): - super().__init__(mesh) + def __init__(self, options=None): + super().__init__(options) + + def build(self, mesh): + super().build(mesh) + # add npts_for_broadcast to mesh domains for this particular discretisation for dom in mesh.keys(): for i in range(len(mesh[dom])): @@ -572,9 +576,9 @@ def add_ghost_nodes(self, symbol, discretised_symbol, bcs): return pybamm.Matrix(matrix) @ discretised_symbol + bcs_vector - def boundary_value_or_flux(self, symbol, discretised_child): + def boundary_value_or_flux(self, symbol, discretised_child, bcs=None): """ - Uses linear extrapolation to get the boundary value or flux of a variable in the + Uses extrapolation to get the boundary value or flux of a variable in the Finite Volume Method. See :meth:`pybamm.SpatialMethod.boundary_value` @@ -586,29 +590,202 @@ def boundary_value_or_flux(self, symbol, discretised_child): prim_pts = submesh_list[0].npts sec_pts = len(submesh_list) + if bcs is None: + bcs = {} + + extrap_order = self.options["extrapolation"]["order"] + use_bcs = self.options["extrapolation"]["use bcs"] + + nodes = submesh_list[0].nodes + edges = submesh_list[0].edges + + dx0 = nodes[0] - edges[0] + dx1 = submesh_list[0].d_nodes[0] + dx2 = submesh_list[0].d_nodes[1] + + dxN = edges[-1] - nodes[-1] + dxNm1 = submesh_list[0].d_nodes[-1] + dxNm2 = submesh_list[0].d_nodes[-2] + + child = symbol.child + # Create submatrix to compute boundary values or fluxes + # Derivation of extrapolation formula can be found at: + # https://github.com/Scottmar93/extrapolation-coefficents/tree/master if isinstance(symbol, pybamm.BoundaryValue): - if symbol.side == "left": - sub_matrix = csr_matrix( - ([1.5, -0.5], ([0, 0], [0, 1])), shape=(1, prim_pts) - ) + + if use_bcs and pybamm.has_bc_of_form( + child, symbol.side, bcs, "Dirichlet" + ): + # just use the value from the bc: f(x*) + sub_matrix = csr_matrix((1, prim_pts)) + additive = bcs[child.id][symbol.side][0] + + elif symbol.side == "left": + + if extrap_order == "linear": + # to find value at x* use formula: + # f(x*) = f_1 - (dx0 / dx1) (f_2 - f_1) + + if use_bcs and pybamm.has_bc_of_form( + child, symbol.side, bcs, "Neumann" + ): + sub_matrix = csr_matrix(([1], ([0], [0])), shape=(1, prim_pts),) + + additive = -dx0 * bcs[child.id][symbol.side][0] + + else: + sub_matrix = csr_matrix( + ([1 + (dx0 / dx1), -(dx0 / dx1)], ([0, 0], [0, 1])), + shape=(1, prim_pts), + ) + additive = pybamm.Scalar(0) + + elif extrap_order == "quadratic": + + if use_bcs and pybamm.has_bc_of_form( + child, symbol.side, bcs, "Neumann" + ): + a = (dx0 + dx1) ** 2 / (dx1 * (2 * dx0 + dx1)) + b = -(dx0 ** 2) / (2 * dx0 * dx1 + dx1 ** 2) + alpha = -(dx0 * (dx0 + dx1)) / (2 * dx0 + dx1) + + sub_matrix = csr_matrix( + ([a, b], ([0, 0], [0, 1])), shape=(1, prim_pts), + ) + additive = alpha * bcs[child.id][symbol.side][0] + + else: + a = (dx0 + dx1) * (dx0 + dx1 + dx2) / (dx1 * (dx1 + dx2)) + b = -dx0 * (dx0 + dx1 + dx2) / (dx1 * dx2) + c = dx0 * (dx0 + dx1) / (dx2 * (dx1 + dx2)) + + sub_matrix = csr_matrix( + ([a, b, c], ([0, 0, 0], [0, 1, 2])), shape=(1, prim_pts), + ) + + additive = pybamm.Scalar(0) + else: + raise NotImplementedError + elif symbol.side == "right": - sub_matrix = csr_matrix( - ([-0.5, 1.5], ([0, 0], [prim_pts - 2, prim_pts - 1])), - shape=(1, prim_pts), - ) + + if extrap_order == "linear": + + if use_bcs and pybamm.has_bc_of_form( + child, symbol.side, bcs, "Neumann" + ): + # use formula: + # f(x*) = fN + dxN * f'(x*) + sub_matrix = csr_matrix( + ([1], ([0], [prim_pts - 1]),), shape=(1, prim_pts), + ) + additive = dxN * bcs[child.id][symbol.side][0] + + else: + # to find value at x* use formula: + # f(x*) = f_N - (dxN / dxNm1) (f_N - f_Nm1) + sub_matrix = csr_matrix( + ( + [-(dxN / dxNm1), 1 + (dxN / dxNm1)], + ([0, 0], [prim_pts - 2, prim_pts - 1]), + ), + shape=(1, prim_pts), + ) + additive = pybamm.Scalar(0) + elif extrap_order == "quadratic": + + if use_bcs and pybamm.has_bc_of_form( + child, symbol.side, bcs, "Neumann" + ): + a = (dxN + dxNm1) ** 2 / (dxNm1 * (2 * dxN + dxNm1)) + b = -(dxN ** 2) / (2 * dxN * dxNm1 + dxNm1 ** 2) + alpha = dxN * (dxN + dxNm1) / (2 * dxN + dxNm1) + sub_matrix = csr_matrix( + ([b, a], ([0, 0], [prim_pts - 2, prim_pts - 1]),), + shape=(1, prim_pts), + ) + + additive = alpha * bcs[child.id][symbol.side][0] + + else: + a = ( + (dxN + dxNm1) + * (dxN + dxNm1 + dxNm2) + / (dxNm1 * (dxNm1 + dxNm2)) + ) + b = -dxN * (dxN + dxNm1 + dxNm2) / (dxNm1 * dxNm2) + c = dxN * (dxN + dxNm1) / (dxNm2 * (dxNm1 + dxNm2)) + + sub_matrix = csr_matrix( + ( + [c, b, a], + ([0, 0, 0], [prim_pts - 3, prim_pts - 2, prim_pts - 1]), + ), + shape=(1, prim_pts), + ) + additive = pybamm.Scalar(0) + else: + raise NotImplementedError + elif isinstance(symbol, pybamm.BoundaryGradient): - if symbol.side == "left": - dx = submesh_list[0].d_nodes[0] - sub_matrix = (1 / dx) * csr_matrix( - ([-1, 1], ([0, 0], [0, 1])), shape=(1, prim_pts) - ) + + if use_bcs and pybamm.has_bc_of_form( + child, symbol.side, bcs, "Neumann" + ): + # just use the value from the bc: f'(x*) + sub_matrix = csr_matrix((1, prim_pts)) + additive = bcs[child.id][symbol.side][0] + + elif symbol.side == "left": + + if extrap_order == "linear": + # f'(x*) = (f_2 - f_1) / dx1 + sub_matrix = (1 / dx1) * csr_matrix( + ([-1, 1], ([0, 0], [0, 1])), shape=(1, prim_pts) + ) + additive = pybamm.Scalar(0) + + elif extrap_order == "quadratic": + + a = -(2 * dx0 + 2 * dx1 + dx2) / (dx1 ** 2 + dx1 * dx2) + b = (2 * dx0 + dx1 + dx2) / (dx1 * dx2) + c = -(2 * dx0 + dx1) / (dx1 * dx2 + dx2 ** 2) + + sub_matrix = csr_matrix( + ([a, b, c], ([0, 0, 0], [0, 1, 2])), shape=(1, prim_pts) + ) + additive = pybamm.Scalar(0) + else: + raise NotImplementedError + elif symbol.side == "right": - dx = submesh_list[0].d_nodes[-1] - sub_matrix = (1 / dx) * csr_matrix( - ([-1, 1], ([0, 0], [prim_pts - 2, prim_pts - 1])), - shape=(1, prim_pts), - ) + + if extrap_order == "linear": + # use formula: + # f'(x*) = (f_N - f_Nm1) / dxNm1 + sub_matrix = (1 / dxNm1) * csr_matrix( + ([-1, 1], ([0, 0], [prim_pts - 2, prim_pts - 1])), + shape=(1, prim_pts), + ) + additive = pybamm.Scalar(0) + + elif extrap_order == "quadratic": + a = (2 * dxN + 2 * dxNm1 + dxNm2) / (dxNm1 ** 2 + dxNm1 * dxNm2) + b = -(2 * dxN + dxNm1 + dxNm2) / (dxNm1 * dxNm2) + c = (2 * dxN + dxNm1) / (dxNm1 * dxNm2 + dxNm2 ** 2) + + sub_matrix = csr_matrix( + ( + [c, b, a], + ([0, 0, 0], [prim_pts - 3, prim_pts - 2, prim_pts - 1]), + ), + shape=(1, prim_pts), + ) + additive = pybamm.Scalar(0) + + else: + raise NotImplementedError # Generate full matrix from the submatrix # Convert to csr_matrix so that we can take the index (row-slicing), which is @@ -622,6 +799,10 @@ def boundary_value_or_flux(self, symbol, discretised_child): boundary_value.domain = symbol.domain boundary_value.auxiliary_domains = symbol.auxiliary_domains + additive.domain = symbol.domain + additive.auxiliary_domains = symbol.auxiliary_domains + boundary_value += additive + return boundary_value def process_binary_operators(self, bin_op, left, right, disc_left, disc_right): diff --git a/pybamm/spatial_methods/scikit_finite_element.py b/pybamm/spatial_methods/scikit_finite_element.py index 464a1d68a7..33b5da03ea 100644 --- a/pybamm/spatial_methods/scikit_finite_element.py +++ b/pybamm/spatial_methods/scikit_finite_element.py @@ -12,7 +12,7 @@ class ScikitFiniteElement(pybamm.SpatialMethod): """ A class which implements the steps specific to the finite element method during discretisation. The class uses scikit-fem to discretise the problem to obtain - the mass and stifnness matrices. At present, this class is only used for + the mass and stiffness matrices. At present, this class is only used for solving the Poisson problem -grad^2 u = f in the y-z plane (i.e. not the through-cell direction). @@ -26,8 +26,11 @@ class ScikitFiniteElement(pybamm.SpatialMethod): **Extends:"": :class:`pybamm.SpatialMethod` """ - def __init__(self, mesh): - super().__init__(mesh) + def __init__(self, options=None): + super().__init__(options) + + def build(self, mesh): + super().build(mesh) # add npts_for_broadcast to mesh domains for this particular discretisation for dom in mesh.keys(): for i in range(len(mesh[dom])): @@ -322,7 +325,7 @@ def integral_form(v, dv, w): return pybamm.Matrix(integration_vector[np.newaxis, :]) - def boundary_value_or_flux(self, symbol, discretised_child): + def boundary_value_or_flux(self, symbol, discretised_child, bcs=None): """ Returns the average value of the symbol over the negative tab ("negative tab") or the positive tab ("positive tab") in the Finite Element Method. diff --git a/pybamm/spatial_methods/spatial_method.py b/pybamm/spatial_methods/spatial_method.py index 1a8fbd7a24..0ed9e70dc4 100644 --- a/pybamm/spatial_methods/spatial_method.py +++ b/pybamm/spatial_methods/spatial_method.py @@ -12,7 +12,7 @@ class SpatialMethod: operations. All spatial methods will follow the general form of SpatialMethod in that they contain a method for broadcasting variables onto a mesh, - a gradient operator, and a diverence operator. + a gradient operator, and a divergence operator. Parameters ---------- @@ -20,7 +20,21 @@ class SpatialMethod: Contains all the submeshes for discretisation """ - def __init__(self, mesh): + def __init__(self, options=None): + + self.options = {"extrapolation": {"order": "linear", "use bcs": False}} + + # update double-layered dict + if options: + for opt, val in options.items(): + if isinstance(val, dict): + self.options[opt].update(val) + else: + self.options[opt] = val + + self._mesh = None + + def build(self, mesh): # add npts_for_broadcast to mesh domains for this particular discretisation for dom in mesh.keys(): for i in range(len(mesh[dom])): @@ -278,7 +292,7 @@ def internal_neumann_condition( raise NotImplementedError - def boundary_value_or_flux(self, symbol, discretised_child): + def boundary_value_or_flux(self, symbol, discretised_child, bcs=None): """ Returns the boundary value or flux using the approriate expression for the spatial method. To do this, we create a sparse vector 'bv_vector' that extracts @@ -291,12 +305,19 @@ def boundary_value_or_flux(self, symbol, discretised_child): The boundary value or flux symbol discretised_child : :class:`pybamm.StateVector` The discretised variable from which to calculate the boundary value + bcs : dict (optional) + The boundary conditions. If these are supplied and "use bcs" is True in + the options, then these will be used to improve the accuracy of the + extrapolation. Returns ------- :class:`pybamm.MatrixMultiplication` The variable representing the surface value. """ + + if bcs is None: + bcs = {} if any(len(self.mesh[dom]) > 1 for dom in discretised_child.domain): raise NotImplementedError("Cannot process 2D symbol in base spatial method") if isinstance(symbol, pybamm.BoundaryGradient): diff --git a/pybamm/spatial_methods/zero_dimensional_method.py b/pybamm/spatial_methods/zero_dimensional_method.py index 2f0318e594..bf8397be44 100644 --- a/pybamm/spatial_methods/zero_dimensional_method.py +++ b/pybamm/spatial_methods/zero_dimensional_method.py @@ -17,7 +17,10 @@ class ZeroDimensionalMethod(pybamm.SpatialMethod): **Extends** : :class:`pybamm.SpatialMethod` """ - def __init__(self, mesh=None): + def __init__(self, options=None): + super().__init__(options) + + def build(self, mesh): self._mesh = mesh def mass_matrix(self, symbol, boundary_conditions): diff --git a/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_asymptotics_convergence.py b/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_asymptotics_convergence.py index 7efc5b9729..0934922960 100644 --- a/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_asymptotics_convergence.py +++ b/tests/integration/test_models/test_full_battery_models/test_lead_acid/test_asymptotics_convergence.py @@ -29,11 +29,17 @@ def test_leading_order_convergence(self): var = pybamm.standard_spatial_vars var_pts = {var.x_n: 3, var.x_s: 3, var.x_p: 3} mesh = pybamm.Mesh(geometry, full_model.default_submesh_types, var_pts) - loqs_disc = pybamm.Discretisation(mesh, full_model.default_spatial_methods) + + method_options = {"extrapolation": {"order": "linear", "use bcs": False}} + spatial_methods = { + "macroscale": pybamm.FiniteVolume(method_options), + "current collector": pybamm.ZeroDimensionalMethod(method_options), + } + loqs_disc = pybamm.Discretisation(mesh, spatial_methods) loqs_disc.process_model(leading_order_model) - comp_disc = pybamm.Discretisation(mesh, full_model.default_spatial_methods) + comp_disc = pybamm.Discretisation(mesh, spatial_methods) comp_disc.process_model(composite_model) - full_disc = pybamm.Discretisation(mesh, full_model.default_spatial_methods) + full_disc = pybamm.Discretisation(mesh, spatial_methods) full_disc.process_model(full_model) def get_max_error(current): @@ -91,6 +97,7 @@ def get_max_error(current): loqs_errs, comp_errs = [np.array(err) for err in zip(*errs)] # Get rates: expect linear convergence for loqs, quadratic for composite loqs_rates = np.log2(loqs_errs[:-1] / loqs_errs[1:]) + np.testing.assert_array_less(0.99 * np.ones_like(loqs_rates), loqs_rates) # Composite not converging as expected comp_rates = np.log2(comp_errs[:-1] / comp_errs[1:]) diff --git a/tests/integration/test_spatial_methods/test_finite_volume.py b/tests/integration/test_spatial_methods/test_finite_volume.py index 6fd39fdb8a..5f46b4d59f 100644 --- a/tests/integration/test_spatial_methods/test_finite_volume.py +++ b/tests/integration/test_spatial_methods/test_finite_volume.py @@ -11,7 +11,7 @@ class TestFiniteVolumeConvergence(unittest.TestCase): def test_cartesian_spherical_grad_convergence(self): # note that grad function is the same for cartesian and spherical - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} whole_cell = ["negative electrode", "separator", "positive electrode"] # Define variable @@ -62,7 +62,7 @@ def get_error(n): def test_cartesian_div_convergence(self): whole_cell = ["negative electrode", "separator", "positive electrode"] - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} # Function for convergence testing def get_error(n): @@ -97,7 +97,7 @@ def get_error(n): def test_spherical_div_convergence_quadratic(self): # test div( r**2 * sin(r) ) == 4*r*sin(r) - r**2*cos(r) - spatial_methods = {"negative particle": pybamm.FiniteVolume} + spatial_methods = {"negative particle": pybamm.FiniteVolume()} # Function for convergence testing def get_error(n): @@ -134,7 +134,7 @@ def get_error(n): def test_spherical_div_convergence_linear(self): # test div( r*sin(r) ) == 3*sin(r) + r*cos(r) - spatial_methods = {"negative particle": pybamm.FiniteVolume} + spatial_methods = {"negative particle": pybamm.FiniteVolume()} # Function for convergence testing def get_error(n): @@ -169,7 +169,7 @@ def get_error(n): def test_p2d_spherical_convergence_quadratic(self): # test div( r**2 * sin(r) ) == 4*r*sin(r) - r**2*cos(r) - spatial_methods = {"negative particle": pybamm.FiniteVolume} + spatial_methods = {"negative particle": pybamm.FiniteVolume()} # Function for convergence testing def get_error(m): @@ -206,7 +206,7 @@ def get_error(m): def test_p2d_with_x_dep_bcs_spherical_convergence(self): # test div_r( (r**2 * sin(r)) * x ) == (4*r*sin(r) - r**2*cos(r)) * x - spatial_methods = {"negative particle": pybamm.FiniteVolume} + spatial_methods = {"negative particle": pybamm.FiniteVolume()} # Function for convergence testing def get_error(m): diff --git a/tests/shared.py b/tests/shared.py index 71b19a01fe..7de38ae22d 100644 --- a/tests/shared.py +++ b/tests/shared.py @@ -8,8 +8,11 @@ class SpatialMethodForTesting(pybamm.SpatialMethod): """Identity operators, no boundary conditions.""" - def __init__(self, mesh): - super().__init__(mesh) + def __init__(self, options=None): + super().__init__(options) + + def build(self, mesh): + super().build(mesh) def gradient(self, symbol, discretised_symbol, boundary_conditions): n = 0 @@ -155,10 +158,10 @@ def get_discretisation_for_testing( if mesh is None: mesh = get_mesh_for_testing(xpts=xpts, rpts=rpts) spatial_methods = { - "macroscale": SpatialMethodForTesting, - "negative particle": SpatialMethodForTesting, - "positive particle": SpatialMethodForTesting, - "current collector": cc_method, + "macroscale": SpatialMethodForTesting(), + "negative particle": SpatialMethodForTesting(), + "positive particle": SpatialMethodForTesting(), + "current collector": cc_method(), } return pybamm.Discretisation(mesh, spatial_methods) diff --git a/tests/unit/test_discretisations/test_discretisation.py b/tests/unit/test_discretisations/test_discretisation.py index 48f5bae365..0a61b05078 100644 --- a/tests/unit/test_discretisations/test_discretisation.py +++ b/tests/unit/test_discretisations/test_discretisation.py @@ -57,7 +57,7 @@ def test_add_internal_boundary_conditions(self): model.boundary_conditions = {c_e: {"left": lbc, "right": rbc}} mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": SpatialMethodForTesting} + spatial_methods = {"macroscale": SpatialMethodForTesting()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.bcs = disc.process_boundary_conditions(model) @@ -69,7 +69,7 @@ def test_add_internal_boundary_conditions(self): def test_discretise_slicing(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) whole_cell = ["negative electrode", "separator", "positive electrode"] @@ -132,10 +132,10 @@ def test_process_symbol_base(self): # create discretisation mesh = get_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.SpatialMethod, - "negative particle": pybamm.SpatialMethod, - "positive particle": pybamm.SpatialMethod, - "current collector": pybamm.SpatialMethod, + "macroscale": pybamm.SpatialMethod(), + "negative particle": pybamm.SpatialMethod(), + "positive particle": pybamm.SpatialMethod(), + "current collector": pybamm.SpatialMethod(), } disc = pybamm.Discretisation(mesh, spatial_methods) diff --git a/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py b/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py index be33fb9688..e1d3cfce91 100644 --- a/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py +++ b/tests/unit/test_models/test_full_battery_models/test_base_battery_model.py @@ -88,20 +88,20 @@ def test_default_submesh_types(self): def test_default_spatial_methods(self): model = pybamm.BaseBatteryModel({"dimensionality": 0}) self.assertTrue( - issubclass( + isinstance( model.default_spatial_methods["current collector"], pybamm.ZeroDimensionalMethod, ) ) model = pybamm.BaseBatteryModel({"dimensionality": 1}) self.assertTrue( - issubclass( + isinstance( model.default_spatial_methods["current collector"], pybamm.FiniteVolume ) ) model = pybamm.BaseBatteryModel({"dimensionality": 2}) self.assertTrue( - issubclass( + isinstance( model.default_spatial_methods["current collector"], pybamm.ScikitFiniteElement, ) diff --git a/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_loqs.py b/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_loqs.py index 89e76f1801..83f3ef8571 100644 --- a/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_loqs.py +++ b/tests/unit/test_models/test_full_battery_models/test_lead_acid/test_loqs.py @@ -50,7 +50,7 @@ def test_defaults_dimensions(self): self.assertIsInstance(model.default_spatial_methods, dict) self.assertNotIn("negative particle", model.default_geometry) self.assertTrue( - issubclass( + isinstance( model.default_spatial_methods["current collector"], pybamm.ZeroDimensionalMethod, ) @@ -69,7 +69,7 @@ def test_defaults_dimensions(self): } ) self.assertTrue( - issubclass( + isinstance( model.default_spatial_methods["current collector"], pybamm.FiniteVolume ) ) @@ -87,7 +87,7 @@ def test_defaults_dimensions(self): } ) self.assertTrue( - issubclass( + isinstance( model.default_spatial_methods["current collector"], pybamm.ScikitFiniteElement, ) diff --git a/tests/unit/test_solvers/test_casadi_solver.py b/tests/unit/test_solvers/test_casadi_solver.py index ca2769bda2..fb0e2938a3 100644 --- a/tests/unit/test_solvers/test_casadi_solver.py +++ b/tests/unit/test_solvers/test_casadi_solver.py @@ -64,7 +64,7 @@ def test_integrate_failure(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) # Solve with failure at t=2 @@ -98,7 +98,7 @@ def test_model_solver(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) # Solve @@ -157,7 +157,7 @@ def test_model_step(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) diff --git a/tests/unit/test_solvers/test_scipy_solver.py b/tests/unit/test_solvers/test_scipy_solver.py index 98f2e70e2c..68ecd1de05 100644 --- a/tests/unit/test_solvers/test_scipy_solver.py +++ b/tests/unit/test_solvers/test_scipy_solver.py @@ -144,7 +144,7 @@ def test_model_solver_python(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) # Solve @@ -172,7 +172,7 @@ def test_model_solver_with_event_python(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) # Solve @@ -196,7 +196,7 @@ def test_model_solver_ode_with_jacobian_python(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) @@ -247,7 +247,7 @@ def test_model_step_python(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) @@ -288,7 +288,7 @@ def test_model_solver_with_event_with_casadi(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) # Solve diff --git a/tests/unit/test_spatial_methods/test_base_spatial_method.py b/tests/unit/test_spatial_methods/test_base_spatial_method.py index 1bd9101e53..708d3c73d2 100644 --- a/tests/unit/test_spatial_methods/test_base_spatial_method.py +++ b/tests/unit/test_spatial_methods/test_base_spatial_method.py @@ -10,7 +10,8 @@ class TestSpatialMethod(unittest.TestCase): def test_basics(self): mesh = get_mesh_for_testing() - spatial_method = pybamm.SpatialMethod(mesh) + spatial_method = pybamm.SpatialMethod() + spatial_method.build(mesh) self.assertEqual(spatial_method.mesh, mesh) with self.assertRaises(NotImplementedError): spatial_method.gradient(None, None, None) @@ -34,7 +35,8 @@ def test_basics(self): def test_discretise_spatial_variable(self): # create discretisation mesh = get_mesh_for_testing() - spatial_method = pybamm.SpatialMethod(mesh) + spatial_method = pybamm.SpatialMethod() + spatial_method.build(mesh) # centre x1 = pybamm.SpatialVariable("x", ["negative electrode"]) @@ -62,12 +64,14 @@ def test_broadcast_checks(self): child = pybamm.Symbol("sym", domain=["negative electrode"]) symbol = pybamm.BoundaryGradient(child, "left") mesh = get_mesh_for_testing() - spatial_method = pybamm.SpatialMethod(mesh) + spatial_method = pybamm.SpatialMethod() + spatial_method.build(mesh) with self.assertRaisesRegex(TypeError, "Cannot process BoundaryGradient"): spatial_method.boundary_value_or_flux(symbol, child) mesh = get_1p1d_mesh_for_testing() - spatial_method = pybamm.SpatialMethod(mesh) + spatial_method = pybamm.SpatialMethod() + spatial_method.build(mesh) with self.assertRaisesRegex(NotImplementedError, "Cannot process 2D symbol"): spatial_method.boundary_value_or_flux(symbol, child) diff --git a/tests/unit/test_spatial_methods/test_finite_volume/__init__.py b/tests/unit/test_spatial_methods/test_finite_volume/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/tests/unit/test_spatial_methods/test_finite_volume/test_extrapolation.py b/tests/unit/test_spatial_methods/test_finite_volume/test_extrapolation.py new file mode 100644 index 0000000000..781c5c083d --- /dev/null +++ b/tests/unit/test_spatial_methods/test_finite_volume/test_extrapolation.py @@ -0,0 +1,518 @@ +# +# Test for the extrapolations in the finite volume class +# +import pybamm +from tests import ( + get_mesh_for_testing, + get_p2d_mesh_for_testing, + get_1p1d_mesh_for_testing, +) +import numpy as np +import unittest + + +def errors(pts, function, method_options, bcs=None): + + domain = "test" + x = pybamm.SpatialVariable("x", domain=domain) + geometry = { + domain: {"primary": {x: {"min": pybamm.Scalar(0), "max": pybamm.Scalar(1)}}} + } + submesh_types = {domain: pybamm.MeshGenerator(pybamm.Uniform1DSubMesh)} + var_pts = {x: pts} + mesh = pybamm.Mesh(geometry, submesh_types, var_pts) + + spatial_methods = {"test": pybamm.FiniteVolume(method_options)} + disc = pybamm.Discretisation(mesh, spatial_methods) + + var = pybamm.Variable("var", domain="test") + left_extrap = pybamm.BoundaryValue(var, "left") + right_extrap = pybamm.BoundaryValue(var, "right") + + if bcs: + model = pybamm.BaseBatteryModel() + bc_dict = {var: bcs} + model.boundary_conditions = bc_dict + disc.bcs = disc.process_boundary_conditions(model) + + submesh = mesh["test"] + y, l_true, r_true = function(submesh[0].nodes) + + disc.set_variable_slices([var]) + left_extrap_processed = disc.process_symbol(left_extrap) + right_extrap_processed = disc.process_symbol(right_extrap) + + l_error = np.abs(l_true - left_extrap_processed.evaluate(None, y)) + r_error = np.abs(r_true - right_extrap_processed.evaluate(None, y)) + + return l_error, r_error + + +def get_errors(function, method_options, pts, bcs=None): + + l_errors = np.zeros(pts.shape) + r_errors = np.zeros(pts.shape) + + for i, pt in enumerate(pts): + l_errors[i], r_errors[i] = errors(pt, function, method_options, bcs) + + return l_errors, r_errors + + +class TestExtrapolation(unittest.TestCase): + def test_convergence_without_bcs(self): + + # all tests are performed on x in [0, 1] + linear = {"extrapolation": {"order": "linear"}} + quad = {"extrapolation": {"order": "quadratic"}} + + def x_squared(x): + y = x ** 2 + l_true = 0 + r_true = 1 + return y, l_true, r_true + + pts = 10 ** np.arange(1, 6, 1) + dx = 1 / pts + + l_errors_lin, r_errors_lin = get_errors(x_squared, linear, pts) + l_errors_quad, r_errors_quad = get_errors(x_squared, quad, pts) + + l_lin_rates = np.log(l_errors_lin[:-1] / l_errors_lin[1:]) / np.log( + dx[:-1] / dx[1:] + ) + + r_lin_rates = np.log(r_errors_lin[:-1] / r_errors_lin[1:]) / np.log( + dx[:-1] / dx[1:] + ) + + np.testing.assert_array_almost_equal(l_lin_rates, 2) + np.testing.assert_array_almost_equal(r_lin_rates, 2) + + # check quadratic is equal up to machine precision + np.testing.assert_array_almost_equal(l_errors_quad, 0, decimal=14) + np.testing.assert_array_almost_equal(r_errors_quad, 0, decimal=14) + + def x_cubed(x): + y = x ** 3 + l_true = 0 + r_true = 1 + return y, l_true, r_true + + l_errors_lin, r_errors_lin = get_errors(x_squared, linear, pts) + + l_lin_rates = np.log(l_errors_lin[:-1] / l_errors_lin[1:]) / np.log( + dx[:-1] / dx[1:] + ) + + r_lin_rates = np.log(r_errors_lin[:-1] / r_errors_lin[1:]) / np.log( + dx[:-1] / dx[1:] + ) + + np.testing.assert_array_almost_equal(l_lin_rates, 2) + np.testing.assert_array_almost_equal(r_lin_rates, 2) + + # quadratic case + pts = 5 ** np.arange(1, 7, 1) + dx = 1 / pts + l_errors_quad, r_errors_quad = get_errors(x_cubed, quad, pts) + + l_quad_rates = np.log(l_errors_quad[:-1] / l_errors_quad[1:]) / np.log( + dx[:-1] / dx[1:] + ) + + r_quad_rates = np.log(r_errors_quad[:-1] / r_errors_quad[1:]) / np.log( + dx[:-1] / dx[1:] + ) + + np.testing.assert_array_almost_equal(l_quad_rates, 3) + np.testing.assert_array_almost_equal(r_quad_rates, 3, decimal=3) + + def test_extrapolation_with_bcs_right_neumann(self): + # simple particle with a flux bc + + pts = 10 ** np.arange(1, 6, 1) + dx = 1 / pts + + left_val = 1 + right_flux = 2 + + def x_cubed(x): + n = 3 + f_x = x ** n + f_l = 0 + fp_r = n + y = f_x + (right_flux - fp_r) * x + (left_val - f_l) + + true_left = left_val + true_right = 1 + (right_flux - fp_r) + (left_val - f_l) + + return y, true_left, true_right + + bcs = {"left": (left_val, "Dirichlet"), "right": (right_flux, "Neumann")} + + linear = {"extrapolation": {"order": "linear", "use bcs": True}} + quad = {"extrapolation": {"order": "quadratic", "use bcs": True}} + l_errors_lin_no_bc, r_errors_lin_no_bc = get_errors(x_cubed, linear, pts,) + l_errors_quad_no_bc, r_errors_quad_no_bc = get_errors(x_cubed, quad, pts,) + + l_errors_lin_with_bc, r_errors_lin_with_bc = get_errors( + x_cubed, linear, pts, bcs + ) + l_errors_quad_with_bc, r_errors_quad_with_bc = get_errors( + x_cubed, quad, pts, bcs + ) + + # test that with bc is better than without + + np.testing.assert_array_less(l_errors_lin_with_bc, l_errors_lin_no_bc) + np.testing.assert_array_less(r_errors_lin_with_bc, r_errors_lin_no_bc) + np.testing.assert_array_less(l_errors_quad_with_bc, l_errors_quad_no_bc) + np.testing.assert_array_less(r_errors_quad_with_bc, r_errors_quad_no_bc) + + # note that with bcs we now obtain the left Dirichlet condition exactly + + r_lin_rates_bc = np.log( + r_errors_lin_with_bc[:-1] / r_errors_lin_with_bc[1:] + ) / np.log(dx[:-1] / dx[1:]) + r_quad_rates_bc = np.log( + r_errors_quad_with_bc[:-1] / r_errors_quad_with_bc[1:] + ) / np.log(dx[:-1] / dx[1:]) + + # check convergence is about the correct order + np.testing.assert_array_almost_equal(r_lin_rates_bc, 2, decimal=2) + np.testing.assert_array_almost_equal(r_quad_rates_bc, 3, decimal=1) + + def test_extrapolation_with_bcs_left_neumann(self): + # simple particle with a flux bc + + pts = 10 ** np.arange(1, 5, 1) + dx = 1 / pts + + left_flux = 2 + right_val = 1 + + def x_cubed(x): + n = 3 + f_x = x ** n + fp_l = 0 + f_r = 1 + y = f_x + (left_flux - fp_l) * x + (right_val - f_r - left_flux + fp_l) + + true_left = right_val - f_r - left_flux + fp_l + true_right = right_val + + return y, true_left, true_right + + bcs = {"left": (left_flux, "Neumann"), "right": (right_val, "Dirichlet")} + + linear = {"extrapolation": {"order": "linear", "use bcs": True}} + quad = {"extrapolation": {"order": "quadratic", "use bcs": True}} + l_errors_lin_no_bc, r_errors_lin_no_bc = get_errors(x_cubed, linear, pts,) + l_errors_quad_no_bc, r_errors_quad_no_bc = get_errors(x_cubed, quad, pts,) + + l_errors_lin_with_bc, r_errors_lin_with_bc = get_errors( + x_cubed, linear, pts, bcs + ) + l_errors_quad_with_bc, r_errors_quad_with_bc = get_errors( + x_cubed, quad, pts, bcs + ) + + # test that with bc is better than without + + np.testing.assert_array_less(l_errors_lin_with_bc, l_errors_lin_no_bc) + np.testing.assert_array_less(r_errors_lin_with_bc, r_errors_lin_no_bc) + np.testing.assert_array_less(l_errors_quad_with_bc, l_errors_quad_no_bc) + np.testing.assert_array_less(r_errors_quad_with_bc, r_errors_quad_no_bc) + + # note that with bcs we now obtain the right Dirichlet condition exactly + + l_lin_rates_bc = np.log( + l_errors_lin_with_bc[:-1] / l_errors_lin_with_bc[1:] + ) / np.log(dx[:-1] / dx[1:]) + l_quad_rates_bc = np.log( + l_errors_quad_with_bc[:-1] / l_errors_quad_with_bc[1:] + ) / np.log(dx[:-1] / dx[1:]) + + # check convergence is about the correct order + np.testing.assert_array_less(2, l_lin_rates_bc) + np.testing.assert_array_almost_equal(l_quad_rates_bc, 3, decimal=1) + + def test_linear_extrapolate_left_right(self): + # create discretisation + mesh = get_mesh_for_testing() + method_options = {"extrapolation": {"order": "linear", "use bcs": True}} + spatial_methods = { + "macroscale": pybamm.FiniteVolume(method_options), + "negative particle": pybamm.FiniteVolume(method_options), + "current collector": pybamm.ZeroDimensionalMethod(method_options), + } + disc = pybamm.Discretisation(mesh, spatial_methods) + + whole_cell = ["negative electrode", "separator", "positive electrode"] + macro_submesh = mesh.combine_submeshes(*whole_cell) + micro_submesh = mesh["negative particle"] + + # Macroscale + # create variable + var = pybamm.Variable("var", domain=whole_cell) + # boundary value should work with something more complicated than a variable + extrap_left = pybamm.BoundaryValue(2 * var, "left") + extrap_right = pybamm.BoundaryValue(4 - var, "right") + disc.set_variable_slices([var]) + extrap_left_disc = disc.process_symbol(extrap_left) + extrap_right_disc = disc.process_symbol(extrap_right) + + # check constant extrapolates to constant + constant_y = np.ones_like(macro_submesh[0].nodes[:, np.newaxis]) + self.assertEqual(extrap_left_disc.evaluate(None, constant_y), 2) + self.assertEqual(extrap_right_disc.evaluate(None, constant_y), 3) + + # check linear variable extrapolates correctly + linear_y = macro_submesh[0].nodes + self.assertEqual(extrap_left_disc.evaluate(None, linear_y), 0) + self.assertEqual(extrap_right_disc.evaluate(None, linear_y), 3) + + # Fluxes + extrap_flux_left = pybamm.BoundaryGradient(2 * var, "left") + extrap_flux_right = pybamm.BoundaryGradient(1 - var, "right") + extrap_flux_left_disc = disc.process_symbol(extrap_flux_left) + extrap_flux_right_disc = disc.process_symbol(extrap_flux_right) + + # check constant extrapolates to constant + self.assertEqual(extrap_flux_left_disc.evaluate(None, constant_y), 0) + self.assertEqual(extrap_flux_right_disc.evaluate(None, constant_y), 0) + + # check linear variable extrapolates correctly + self.assertEqual(extrap_flux_left_disc.evaluate(None, linear_y), 2) + self.assertEqual(extrap_flux_right_disc.evaluate(None, linear_y), -1) + + # Microscale + # create variable + var = pybamm.Variable("var", domain="negative particle") + surf_eqn = pybamm.surf(var) + disc.set_variable_slices([var]) + surf_eqn_disc = disc.process_symbol(surf_eqn) + + # check constant extrapolates to constant + constant_y = np.ones_like(micro_submesh[0].nodes[:, np.newaxis]) + self.assertEqual(surf_eqn_disc.evaluate(None, constant_y), 1.0) + + # check linear variable extrapolates correctly + linear_y = micro_submesh[0].nodes + y_surf = micro_submesh[0].edges[-1] + np.testing.assert_array_almost_equal( + surf_eqn_disc.evaluate(None, linear_y), y_surf + ) + + def test_quadratic_extrapolate_left_right(self): + # create discretisation + mesh = get_mesh_for_testing() + method_options = {"extrapolation": {"order": "quadratic", "use bcs": False}} + spatial_methods = { + "macroscale": pybamm.FiniteVolume(method_options), + "negative particle": pybamm.FiniteVolume(method_options), + "current collector": pybamm.ZeroDimensionalMethod(method_options), + } + disc = pybamm.Discretisation(mesh, spatial_methods) + + whole_cell = ["negative electrode", "separator", "positive electrode"] + macro_submesh = mesh.combine_submeshes(*whole_cell) + micro_submesh = mesh["negative particle"] + + # Macroscale + # create variable + var = pybamm.Variable("var", domain=whole_cell) + # boundary value should work with something more complicated than a variable + extrap_left = pybamm.BoundaryValue(2 * var, "left") + extrap_right = pybamm.BoundaryValue(4 - var, "right") + disc.set_variable_slices([var]) + extrap_left_disc = disc.process_symbol(extrap_left) + extrap_right_disc = disc.process_symbol(extrap_right) + + # check constant extrapolates to constant + constant_y = np.ones_like(macro_submesh[0].nodes[:, np.newaxis]) + np.testing.assert_array_almost_equal( + extrap_left_disc.evaluate(None, constant_y), 2.0 + ) + np.testing.assert_array_almost_equal( + extrap_right_disc.evaluate(None, constant_y), 3.0 + ) + + # check linear variable extrapolates correctly + linear_y = macro_submesh[0].nodes + np.testing.assert_array_almost_equal( + extrap_left_disc.evaluate(None, linear_y), 0 + ) + np.testing.assert_array_almost_equal( + extrap_right_disc.evaluate(None, linear_y), 3 + ) + + # Fluxes + extrap_flux_left = pybamm.BoundaryGradient(2 * var, "left") + extrap_flux_right = pybamm.BoundaryGradient(1 - var, "right") + extrap_flux_left_disc = disc.process_symbol(extrap_flux_left) + extrap_flux_right_disc = disc.process_symbol(extrap_flux_right) + + # check constant extrapolates to constant + np.testing.assert_array_almost_equal( + extrap_flux_left_disc.evaluate(None, constant_y), 0 + ) + self.assertEqual(extrap_flux_right_disc.evaluate(None, constant_y), 0) + + # check linear variable extrapolates correctly + np.testing.assert_array_almost_equal( + extrap_flux_left_disc.evaluate(None, linear_y), 2 + ) + np.testing.assert_array_almost_equal( + extrap_flux_right_disc.evaluate(None, linear_y), -1 + ) + + # Microscale + # create variable + var = pybamm.Variable("var", domain="negative particle") + surf_eqn = pybamm.surf(var) + disc.set_variable_slices([var]) + surf_eqn_disc = disc.process_symbol(surf_eqn) + + # check constant extrapolates to constant + constant_y = np.ones_like(micro_submesh[0].nodes[:, np.newaxis]) + np.testing.assert_array_almost_equal( + surf_eqn_disc.evaluate(None, constant_y), 1 + ) + + # check linear variable extrapolates correctly + linear_y = micro_submesh[0].nodes + y_surf = micro_submesh[0].edges[-1] + np.testing.assert_array_almost_equal( + surf_eqn_disc.evaluate(None, linear_y), y_surf + ) + + def test_extrapolate_on_nonuniform_grid(self): + geometry = pybamm.Geometry("1D micro") + + submesh_types = { + "negative particle": pybamm.MeshGenerator(pybamm.Exponential1DSubMesh), + "positive particle": pybamm.MeshGenerator(pybamm.Exponential1DSubMesh), + } + + var = pybamm.standard_spatial_vars + rpts = 10 + var_pts = { + var.r_n: rpts, + var.r_p: rpts, + } + mesh = pybamm.Mesh(geometry, submesh_types, var_pts) + method_options = {"extrapolation": {"order": "linear", "use bcs": False}} + spatial_methods = { + "negative particle": pybamm.FiniteVolume(method_options), + } + disc = pybamm.Discretisation(mesh, spatial_methods) + + var = pybamm.Variable("var", domain="negative particle") + surf_eqn = pybamm.surf(var) + disc.set_variable_slices([var]) + surf_eqn_disc = disc.process_symbol(surf_eqn) + + micro_submesh = mesh["negative particle"] + + # check constant extrapolates to constant + constant_y = np.ones_like(micro_submesh[0].nodes[:, np.newaxis]) + np.testing.assert_array_almost_equal( + surf_eqn_disc.evaluate(None, constant_y), 1 + ) + + # check linear variable extrapolates correctly + linear_y = micro_submesh[0].nodes + y_surf = micro_submesh[0].edges[-1] + np.testing.assert_array_almost_equal( + surf_eqn_disc.evaluate(None, linear_y), y_surf + ) + + def test_extrapolate_2d_models(self): + # create discretisation + mesh = get_p2d_mesh_for_testing() + method_options = {"extrapolation": {"order": "linear", "use bcs": False}} + spatial_methods = { + "macroscale": pybamm.FiniteVolume(method_options), + "negative particle": pybamm.FiniteVolume(method_options), + "positive particle": pybamm.FiniteVolume(method_options), + "current collector": pybamm.FiniteVolume(method_options), + } + disc = pybamm.Discretisation(mesh, spatial_methods) + + # Microscale + var = pybamm.Variable("var", domain="negative particle") + extrap_right = pybamm.BoundaryValue(var, "right") + disc.set_variable_slices([var]) + extrap_right_disc = disc.process_symbol(extrap_right) + self.assertEqual(extrap_right_disc.domain, []) + # domain for boundary values must now be explicitly set + extrap_right.domain = ["negative electrode"] + disc.set_variable_slices([var]) + extrap_right_disc = disc.process_symbol(extrap_right) + self.assertEqual(extrap_right_disc.domain, ["negative electrode"]) + # evaluate + y_macro = mesh["negative electrode"][0].nodes + y_micro = mesh["negative particle"][0].nodes + y = np.outer(y_macro, y_micro).reshape(-1, 1) + # extrapolate to r=1 --> should evaluate to y_macro + np.testing.assert_array_almost_equal( + extrap_right_disc.evaluate(y=y)[:, 0], y_macro + ) + + var = pybamm.Variable("var", domain="positive particle") + extrap_right = pybamm.BoundaryValue(var, "right") + disc.set_variable_slices([var]) + extrap_right_disc = disc.process_symbol(extrap_right) + self.assertEqual(extrap_right_disc.domain, []) + # domain for boundary values must now be explicitly set + extrap_right.domain = ["positive electrode"] + disc.set_variable_slices([var]) + extrap_right_disc = disc.process_symbol(extrap_right) + self.assertEqual(extrap_right_disc.domain, ["positive electrode"]) + + # 2d macroscale + mesh = get_1p1d_mesh_for_testing() + disc = pybamm.Discretisation(mesh, spatial_methods) + var = pybamm.Variable("var", domain="negative electrode") + extrap_right = pybamm.BoundaryValue(var, "right") + disc.set_variable_slices([var]) + extrap_right_disc = disc.process_symbol(extrap_right) + self.assertEqual(extrap_right_disc.domain, []) + + # test extrapolate to "negative tab" gives same as "left" and + # "positive tab" gives same "right" (see get_mesh_for_testing) + var = pybamm.Variable("var", domain="current collector") + disc.set_variable_slices([var]) + submesh = mesh["current collector"] + constant_y = np.ones_like(submesh[0].nodes[:, np.newaxis]) + + extrap_neg = pybamm.BoundaryValue(var, "negative tab") + extrap_neg_disc = disc.process_symbol(extrap_neg) + extrap_left = pybamm.BoundaryValue(var, "left") + extrap_left_disc = disc.process_symbol(extrap_left) + np.testing.assert_array_equal( + extrap_neg_disc.evaluate(None, constant_y), + extrap_left_disc.evaluate(None, constant_y), + ) + + extrap_pos = pybamm.BoundaryValue(var, "positive tab") + extrap_pos_disc = disc.process_symbol(extrap_pos) + extrap_right = pybamm.BoundaryValue(var, "right") + extrap_right_disc = disc.process_symbol(extrap_right) + np.testing.assert_array_equal( + extrap_pos_disc.evaluate(None, constant_y), + extrap_right_disc.evaluate(None, constant_y), + ) + + +if __name__ == "__main__": + print("Add -v for more debug output") + import sys + + if "-v" in sys.argv: + debug = True + pybamm.settings.debug_mode = True + unittest.main() + diff --git a/tests/unit/test_spatial_methods/test_finite_volume.py b/tests/unit/test_spatial_methods/test_finite_volume/test_finite_volume.py similarity index 74% rename from tests/unit/test_spatial_methods/test_finite_volume.py rename to tests/unit/test_spatial_methods/test_finite_volume/test_finite_volume.py index 99e4cec573..1864d7420a 100644 --- a/tests/unit/test_spatial_methods/test_finite_volume.py +++ b/tests/unit/test_spatial_methods/test_finite_volume/test_finite_volume.py @@ -17,7 +17,8 @@ class TestFiniteVolume(unittest.TestCase): def test_node_to_edge_to_node(self): # create discretisation mesh = get_mesh_for_testing() - fin_vol = pybamm.FiniteVolume(mesh) + fin_vol = pybamm.FiniteVolume() + fin_vol.build(mesh) n = mesh["negative electrode"][0].npts # node to edge @@ -39,7 +40,9 @@ def test_node_to_edge_to_node(self): def test_concatenation(self): mesh = get_mesh_for_testing() - fin_vol = pybamm.FiniteVolume(mesh) + fin_vol = pybamm.FiniteVolume() + fin_vol.build(mesh) + whole_cell = ["negative electrode", "separator", "positive electrode"] edges = [pybamm.Vector(mesh[dom][0].edges, domain=dom) for dom in whole_cell] # Concatenation of edges should get averaged to nodes first, using edge_to_node @@ -56,155 +59,13 @@ def test_concatenation(self): with self.assertRaisesRegex(pybamm.ShapeError, "child must have size n_nodes"): fin_vol.concatenation(edges) - def test_extrapolate_left_right(self): - # create discretisation - mesh = get_mesh_for_testing() - spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "current collector": pybamm.ZeroDimensionalMethod, - } - disc = pybamm.Discretisation(mesh, spatial_methods) - - whole_cell = ["negative electrode", "separator", "positive electrode"] - macro_submesh = mesh.combine_submeshes(*whole_cell) - micro_submesh = mesh["negative particle"] - - # Macroscale - # create variable - var = pybamm.Variable("var", domain=whole_cell) - # boundary value should work with something more complicated than a variable - extrap_left = pybamm.BoundaryValue(2 * var, "left") - extrap_right = pybamm.BoundaryValue(4 - var, "right") - disc.set_variable_slices([var]) - extrap_left_disc = disc.process_symbol(extrap_left) - extrap_right_disc = disc.process_symbol(extrap_right) - - # check constant extrapolates to constant - constant_y = np.ones_like(macro_submesh[0].nodes[:, np.newaxis]) - self.assertEqual(extrap_left_disc.evaluate(None, constant_y), 2) - self.assertEqual(extrap_right_disc.evaluate(None, constant_y), 3) - - # check linear variable extrapolates correctly - linear_y = macro_submesh[0].nodes - self.assertEqual(extrap_left_disc.evaluate(None, linear_y), 0) - self.assertEqual(extrap_right_disc.evaluate(None, linear_y), 3) - - # Fluxes - extrap_flux_left = pybamm.BoundaryGradient(2 * var, "left") - extrap_flux_right = pybamm.BoundaryGradient(1 - var, "right") - extrap_flux_left_disc = disc.process_symbol(extrap_flux_left) - extrap_flux_right_disc = disc.process_symbol(extrap_flux_right) - - # check constant extrapolates to constant - self.assertEqual(extrap_flux_left_disc.evaluate(None, constant_y), 0) - self.assertEqual(extrap_flux_right_disc.evaluate(None, constant_y), 0) - - # check linear variable extrapolates correctly - self.assertEqual(extrap_flux_left_disc.evaluate(None, linear_y), 2) - self.assertEqual(extrap_flux_right_disc.evaluate(None, linear_y), -1) - - # Microscale - # create variable - var = pybamm.Variable("var", domain="negative particle") - surf_eqn = pybamm.surf(var) - disc.set_variable_slices([var]) - surf_eqn_disc = disc.process_symbol(surf_eqn) - - # check constant extrapolates to constant - constant_y = np.ones_like(micro_submesh[0].nodes[:, np.newaxis]) - self.assertEqual(surf_eqn_disc.evaluate(None, constant_y), 1) - - # check linear variable extrapolates correctly - linear_y = micro_submesh[0].nodes - y_surf = micro_submesh[0].nodes[-1] + micro_submesh[0].d_nodes[-1] / 2 - np.testing.assert_array_almost_equal( - surf_eqn_disc.evaluate(None, linear_y), y_surf - ) - - def test_extrapolate_2d_models(self): - # create discretisation - mesh = get_p2d_mesh_for_testing() - spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "positive particle": pybamm.FiniteVolume, - "current collector": pybamm.FiniteVolume, - } - disc = pybamm.Discretisation(mesh, spatial_methods) - - # Microscale - var = pybamm.Variable("var", domain="negative particle") - extrap_right = pybamm.BoundaryValue(var, "right") - disc.set_variable_slices([var]) - extrap_right_disc = disc.process_symbol(extrap_right) - self.assertEqual(extrap_right_disc.domain, []) - # domain for boundary values must now be explicitly set - extrap_right.domain = ["negative electrode"] - disc.set_variable_slices([var]) - extrap_right_disc = disc.process_symbol(extrap_right) - self.assertEqual(extrap_right_disc.domain, ["negative electrode"]) - # evaluate - y_macro = mesh["negative electrode"][0].nodes - y_micro = mesh["negative particle"][0].nodes - y = np.outer(y_macro, y_micro).reshape(-1, 1) - # extrapolate to r=1 --> should evaluate to y_macro - np.testing.assert_array_almost_equal( - extrap_right_disc.evaluate(y=y)[:, 0], y_macro - ) - - var = pybamm.Variable("var", domain="positive particle") - extrap_right = pybamm.BoundaryValue(var, "right") - disc.set_variable_slices([var]) - extrap_right_disc = disc.process_symbol(extrap_right) - self.assertEqual(extrap_right_disc.domain, []) - # domain for boundary values must now be explicitly set - extrap_right.domain = ["positive electrode"] - disc.set_variable_slices([var]) - extrap_right_disc = disc.process_symbol(extrap_right) - self.assertEqual(extrap_right_disc.domain, ["positive electrode"]) - - # 2d macroscale - mesh = get_1p1d_mesh_for_testing() - disc = pybamm.Discretisation(mesh, spatial_methods) - var = pybamm.Variable("var", domain="negative electrode") - extrap_right = pybamm.BoundaryValue(var, "right") - disc.set_variable_slices([var]) - extrap_right_disc = disc.process_symbol(extrap_right) - self.assertEqual(extrap_right_disc.domain, []) - - # test extrapolate to "negative tab" gives same as "left" and - # "positive tab" gives same "right" (see get_mesh_for_testing) - var = pybamm.Variable("var", domain="current collector") - disc.set_variable_slices([var]) - submesh = mesh["current collector"] - constant_y = np.ones_like(submesh[0].nodes[:, np.newaxis]) - - extrap_neg = pybamm.BoundaryValue(var, "negative tab") - extrap_neg_disc = disc.process_symbol(extrap_neg) - extrap_left = pybamm.BoundaryValue(var, "left") - extrap_left_disc = disc.process_symbol(extrap_left) - np.testing.assert_array_equal( - extrap_neg_disc.evaluate(None, constant_y), - extrap_left_disc.evaluate(None, constant_y), - ) - - extrap_pos = pybamm.BoundaryValue(var, "positive tab") - extrap_pos_disc = disc.process_symbol(extrap_pos) - extrap_right = pybamm.BoundaryValue(var, "right") - extrap_right_disc = disc.process_symbol(extrap_right) - np.testing.assert_array_equal( - extrap_pos_disc.evaluate(None, constant_y), - extrap_right_disc.evaluate(None, constant_y), - ) - def test_discretise_diffusivity_times_spatial_operator(self): # Set up whole_cell = ["negative electrode", "separator", "positive electrode"] # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) combined_submesh = mesh.combine_submeshes(*whole_cell) @@ -266,171 +127,6 @@ def test_discretise_diffusivity_times_spatial_operator(self): eqn_disc = disc.process_symbol(eqn) eqn_disc.evaluate(None, y_test) - def test_add_ghost_nodes(self): - # Set up - - # create discretisation - mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} - disc = pybamm.Discretisation(mesh, spatial_methods) - - # Add ghost nodes - whole_cell = ["negative electrode", "separator", "positive electrode"] - var = pybamm.Variable("var", domain=whole_cell) - disc.set_variable_slices([var]) - discretised_symbol = pybamm.StateVector(*disc.y_slices[var.id]) - bcs = { - "left": (pybamm.Scalar(0), "Dirichlet"), - "right": (pybamm.Scalar(3), "Dirichlet"), - } - - # Test - sym_ghost = pybamm.FiniteVolume(mesh).add_ghost_nodes( - var, discretised_symbol, bcs - ) - combined_submesh = mesh.combine_submeshes(*whole_cell) - y_test = np.linspace(0, 1, combined_submesh[0].npts) - np.testing.assert_array_equal( - sym_ghost.evaluate(y=y_test)[1:-1], discretised_symbol.evaluate(y=y_test) - ) - self.assertEqual( - (sym_ghost.evaluate(y=y_test)[0] + sym_ghost.evaluate(y=y_test)[1]) / 2, 0 - ) - self.assertEqual( - (sym_ghost.evaluate(y=y_test)[-2] + sym_ghost.evaluate(y=y_test)[-1]) / 2, 3 - ) - - # test errors - bcs = {"left": (pybamm.Scalar(0), "x"), "right": (pybamm.Scalar(3), "Neumann")} - with self.assertRaisesRegex(ValueError, "boundary condition must be"): - pybamm.FiniteVolume(mesh).add_ghost_nodes(var, discretised_symbol, bcs) - bcs = {"left": (pybamm.Scalar(0), "Neumann"), "right": (pybamm.Scalar(3), "x")} - with self.assertRaisesRegex(ValueError, "boundary condition must be"): - pybamm.FiniteVolume(mesh).add_ghost_nodes(var, discretised_symbol, bcs) - - def test_add_ghost_nodes_concatenation(self): - # Set up - - # create discretisation - mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} - disc = pybamm.Discretisation(mesh, spatial_methods) - - # Add ghost nodes - whole_cell = ["negative electrode", "separator", "positive electrode"] - var_n = pybamm.Variable("var", domain=["negative electrode"]) - var_s = pybamm.Variable("var", domain=["separator"]) - var_p = pybamm.Variable("var", domain=["positive electrode"]) - var = pybamm.Concatenation(var_n, var_s, var_p) - disc.set_variable_slices([var]) - discretised_symbol = disc.process_symbol(var) - bcs = { - "left": (pybamm.Scalar(0), "Dirichlet"), - "right": (pybamm.Scalar(3), "Dirichlet"), - } - - # Test - combined_submesh = mesh.combine_submeshes(*whole_cell) - y_test = np.ones_like(combined_submesh[0].nodes[:, np.newaxis]) - - # both - symbol_plus_ghost_both = pybamm.FiniteVolume(mesh).add_ghost_nodes( - var, discretised_symbol, bcs - ) - np.testing.assert_array_equal( - symbol_plus_ghost_both.evaluate(None, y_test)[1:-1], - discretised_symbol.evaluate(None, y_test), - ) - self.assertEqual( - ( - symbol_plus_ghost_both.evaluate(None, y_test)[0] - + symbol_plus_ghost_both.evaluate(None, y_test)[1] - ) - / 2, - 0, - ) - self.assertEqual( - ( - symbol_plus_ghost_both.evaluate(None, y_test)[-2] - + symbol_plus_ghost_both.evaluate(None, y_test)[-1] - ) - / 2, - 3, - ) - - def test_p2d_add_ghost_nodes(self): - # create discretisation - mesh = get_p2d_mesh_for_testing() - spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "positive particle": pybamm.FiniteVolume, - } - disc = pybamm.Discretisation(mesh, spatial_methods) - - # add ghost nodes - c_s_n = pybamm.Variable("c_s_n", domain=["negative particle"]) - c_s_p = pybamm.Variable("c_s_p", domain=["positive particle"]) - - disc.set_variable_slices([c_s_n]) - disc_c_s_n = pybamm.StateVector(*disc.y_slices[c_s_n.id]) - - disc.set_variable_slices([c_s_p]) - disc_c_s_p = pybamm.StateVector(*disc.y_slices[c_s_p.id]) - bcs = { - "left": (pybamm.Scalar(0), "Dirichlet"), - "right": (pybamm.Scalar(3), "Dirichlet"), - } - c_s_n_plus_ghost = pybamm.FiniteVolume(mesh).add_ghost_nodes( - c_s_n, disc_c_s_n, bcs - ) - c_s_p_plus_ghost = pybamm.FiniteVolume(mesh).add_ghost_nodes( - c_s_p, disc_c_s_p, bcs - ) - - mesh_s_n = mesh["negative particle"] - mesh_s_p = mesh["positive particle"] - - n_prim_pts = mesh_s_n[0].npts - n_sec_pts = len(mesh_s_n) - - p_prim_pts = mesh_s_p[0].npts - p_sec_pts = len(mesh_s_p) - - y_s_n_test = np.kron(np.ones(n_sec_pts), np.ones(n_prim_pts)) - y_s_p_test = np.kron(np.ones(p_sec_pts), np.ones(p_prim_pts)) - - # evaluate with and without ghost points - c_s_n_eval = disc_c_s_n.evaluate(None, y_s_n_test) - c_s_n_ghost_eval = c_s_n_plus_ghost.evaluate(None, y_s_n_test) - - c_s_p_eval = disc_c_s_p.evaluate(None, y_s_p_test) - c_s_p_ghost_eval = c_s_p_plus_ghost.evaluate(None, y_s_p_test) - - # reshape to make easy to deal with - c_s_n_eval = np.reshape(c_s_n_eval, [n_sec_pts, n_prim_pts]) - c_s_n_ghost_eval = np.reshape(c_s_n_ghost_eval, [n_sec_pts, n_prim_pts + 2]) - - c_s_p_eval = np.reshape(c_s_p_eval, [p_sec_pts, p_prim_pts]) - c_s_p_ghost_eval = np.reshape(c_s_p_ghost_eval, [p_sec_pts, p_prim_pts + 2]) - - np.testing.assert_array_equal(c_s_n_ghost_eval[:, 1:-1], c_s_n_eval) - np.testing.assert_array_equal(c_s_p_ghost_eval[:, 1:-1], c_s_p_eval) - - np.testing.assert_array_equal( - (c_s_n_ghost_eval[:, 0] + c_s_n_ghost_eval[:, 1]) / 2, 0 - ) - np.testing.assert_array_equal( - (c_s_p_ghost_eval[:, 0] + c_s_p_ghost_eval[:, 1]) / 2, 0 - ) - - np.testing.assert_array_equal( - (c_s_n_ghost_eval[:, -2] + c_s_n_ghost_eval[:, -1]) / 2, 3 - ) - np.testing.assert_array_equal( - (c_s_p_ghost_eval[:, -2] + c_s_p_ghost_eval[:, -1]) / 2, 3 - ) - def test_grad_div_shapes_Dirichlet_bcs(self): """ Test grad and div with Dirichlet boundary conditions (applied by grad on var) @@ -438,7 +134,7 @@ def test_grad_div_shapes_Dirichlet_bcs(self): whole_cell = ["negative electrode", "separator", "positive electrode"] # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) combined_submesh = mesh.combine_submeshes(*whole_cell) @@ -490,7 +186,7 @@ def test_grad_div_shapes_Dirichlet_bcs(self): def test_grad_1plus1d(self): mesh = get_1p1d_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) a = pybamm.Variable("a", domain=["negative electrode"]) @@ -527,7 +223,7 @@ def test_spherical_grad_div_shapes_Dirichlet_bcs(self): """ # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"negative particle": pybamm.FiniteVolume} + spatial_methods = {"negative particle": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) combined_submesh = mesh.combine_submeshes("negative particle") @@ -595,9 +291,9 @@ def test_p2d_spherical_grad_div_shapes_Dirichlet_bcs(self): mesh = get_p2d_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "positive particle": pybamm.FiniteVolume, + "macroscale": pybamm.FiniteVolume(), + "negative particle": pybamm.FiniteVolume(), + "positive particle": pybamm.FiniteVolume(), } disc = pybamm.Discretisation(mesh, spatial_methods) @@ -654,7 +350,7 @@ def test_grad_div_shapes_Neumann_bcs(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) combined_submesh = mesh.combine_submeshes(*whole_cell) @@ -703,7 +399,7 @@ def test_grad_div_shapes_Dirichlet_and_Neumann_bcs(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) combined_submesh = mesh.combine_submeshes(*whole_cell) @@ -763,7 +459,7 @@ def test_spherical_grad_div_shapes_Neumann_bcs(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"negative particle": pybamm.FiniteVolume} + spatial_methods = {"negative particle": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) combined_submesh = mesh.combine_submeshes("negative particle") @@ -812,7 +508,7 @@ def test_p2d_spherical_grad_div_shapes_Neumann_bcs(self): """ mesh = get_p2d_mesh_for_testing() - spatial_methods = {"negative particle": pybamm.FiniteVolume} + spatial_methods = {"negative particle": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) n_mesh = mesh["negative particle"] @@ -859,7 +555,7 @@ def test_grad_div_shapes_mixed_domain(self): """ # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) # grad @@ -912,10 +608,10 @@ def test_definite_integral(self): # create discretisation mesh = get_mesh_for_testing(xpts=200, rpts=200) spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "positive particle": pybamm.FiniteVolume, - "current collector": pybamm.ZeroDimensionalMethod, + "macroscale": pybamm.FiniteVolume(), + "negative particle": pybamm.FiniteVolume(), + "positive particle": pybamm.FiniteVolume(), + "current collector": pybamm.ZeroDimensionalMethod(), } disc = pybamm.Discretisation(mesh, spatial_methods) # lengths @@ -984,9 +680,9 @@ def test_definite_integral(self): def test_definite_integral_vector(self): mesh = get_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "positive particle": pybamm.FiniteVolume, + "macroscale": pybamm.FiniteVolume(), + "negative particle": pybamm.FiniteVolume(), + "positive particle": pybamm.FiniteVolume(), } disc = pybamm.Discretisation(mesh, spatial_methods) var = pybamm.Variable("var", domain="negative electrode") @@ -1009,10 +705,10 @@ def test_indefinite_integral(self): # create discretisation mesh = get_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "positive particle": pybamm.FiniteVolume, - "current collector": pybamm.ZeroDimensionalMethod, + "macroscale": pybamm.FiniteVolume(), + "negative particle": pybamm.FiniteVolume(), + "positive particle": pybamm.FiniteVolume(), + "current collector": pybamm.ZeroDimensionalMethod(), } disc = pybamm.Discretisation(mesh, spatial_methods) @@ -1087,7 +783,9 @@ def test_indefinite_integral(self): ) phi_approx = int_grad_phi_disc.evaluate(None, phi_exact) np.testing.assert_array_almost_equal(phi_exact, phi_approx) - self.assertEqual(left_boundary_value_disc.evaluate(y=phi_exact), 0) + np.testing.assert_array_almost_equal( + left_boundary_value_disc.evaluate(y=phi_exact), 0 + ) # sine case phi_exact = np.sin( @@ -1095,7 +793,9 @@ def test_indefinite_integral(self): ) phi_approx = int_grad_phi_disc.evaluate(None, phi_exact) np.testing.assert_array_almost_equal(phi_exact, phi_approx) - self.assertEqual(left_boundary_value_disc.evaluate(y=phi_exact), 0) + np.testing.assert_array_almost_equal( + left_boundary_value_disc.evaluate(y=phi_exact), 0 + ) # -------------------------------------------------------------------- # micrsoscale case @@ -1127,17 +827,21 @@ def test_indefinite_integral(self): c_exact = combined_submesh[0].nodes[:, np.newaxis] c_approx = c_integral_disc.evaluate(None, c_exact) np.testing.assert_array_almost_equal(c_exact, c_approx) - self.assertEqual(left_boundary_value_disc.evaluate(y=c_exact), 0) + np.testing.assert_array_almost_equal( + left_boundary_value_disc.evaluate(y=c_exact), 0 + ) # sine case c_exact = np.sin(combined_submesh[0].nodes[:, np.newaxis]) c_approx = c_integral_disc.evaluate(None, c_exact) np.testing.assert_array_almost_equal(c_exact, c_approx, decimal=3) - self.assertEqual(left_boundary_value_disc.evaluate(y=c_exact), 0) + np.testing.assert_array_almost_equal( + left_boundary_value_disc.evaluate(y=c_exact), 0 + ) def test_indefinite_integral_on_nodes(self): mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) # input a phi, take grad, then integrate to recover phi approximation @@ -1173,9 +877,9 @@ def test_discretise_spatial_variable(self): # create discretisation mesh = get_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "positive particle": pybamm.FiniteVolume, + "macroscale": pybamm.FiniteVolume(), + "negative particle": pybamm.FiniteVolume(), + "positive particle": pybamm.FiniteVolume(), } disc = pybamm.Discretisation(mesh, spatial_methods) @@ -1223,7 +927,7 @@ def test_mass_matrix_shape(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) combined_submesh = mesh.combine_submeshes(*whole_cell) @@ -1247,7 +951,7 @@ def test_p2d_mass_matrix_shape(self): } model.variables = {"c": c, "N": N} mesh = get_p2d_mesh_for_testing() - spatial_methods = {"negative particle": pybamm.FiniteVolume} + spatial_methods = {"negative particle": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) @@ -1264,7 +968,7 @@ def test_jacobian(self): # create discretisation mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) combined_submesh = mesh.combine_submeshes(*whole_cell) @@ -1329,9 +1033,9 @@ def test_jacobian(self): def test_boundary_value_domain(self): mesh = get_p2d_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "positive particle": pybamm.FiniteVolume, + "macroscale": pybamm.FiniteVolume(), + "negative particle": pybamm.FiniteVolume(), + "positive particle": pybamm.FiniteVolume(), } disc = pybamm.Discretisation(mesh, spatial_methods) @@ -1358,7 +1062,7 @@ def test_boundary_value_domain(self): def test_delta_function(self): mesh = get_mesh_for_testing() - spatial_methods = {"macroscale": pybamm.FiniteVolume} + spatial_methods = {"macroscale": pybamm.FiniteVolume()} disc = pybamm.Discretisation(mesh, spatial_methods) var = pybamm.Variable("var") @@ -1403,10 +1107,10 @@ def test_grad_div_with_bcs_on_tab(self): # 2d macroscale mesh = get_1p1d_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "positive particle": pybamm.FiniteVolume, - "current collector": pybamm.FiniteVolume, + "macroscale": pybamm.FiniteVolume(), + "negative particle": pybamm.FiniteVolume(), + "positive particle": pybamm.FiniteVolume(), + "current collector": pybamm.FiniteVolume(), } disc = pybamm.Discretisation(mesh, spatial_methods) y_test = np.ones(mesh["current collector"][0].npts) @@ -1463,10 +1167,10 @@ def test_neg_pos_bcs(self): # 2d macroscale mesh = get_1p1d_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "negative particle": pybamm.FiniteVolume, - "positive particle": pybamm.FiniteVolume, - "current collector": pybamm.FiniteVolume, + "macroscale": pybamm.FiniteVolume(), + "negative particle": pybamm.FiniteVolume(), + "positive particle": pybamm.FiniteVolume(), + "current collector": pybamm.FiniteVolume(), } disc = pybamm.Discretisation(mesh, spatial_methods) diff --git a/tests/unit/test_spatial_methods/test_finite_volume/test_ghost_nodes.py b/tests/unit/test_spatial_methods/test_finite_volume/test_ghost_nodes.py new file mode 100644 index 0000000000..4a00656d3b --- /dev/null +++ b/tests/unit/test_spatial_methods/test_finite_volume/test_ghost_nodes.py @@ -0,0 +1,185 @@ +# +# Test for adding ghost nodes in finite volumes class +# +import pybamm +from tests import ( + get_mesh_for_testing, + get_p2d_mesh_for_testing, +) +import numpy as np +import unittest + + +class TestGhostNodes(unittest.TestCase): + def test_add_ghost_nodes(self): + # Set up + + # create discretisation + mesh = get_mesh_for_testing() + spatial_methods = {"macroscale": pybamm.FiniteVolume()} + disc = pybamm.Discretisation(mesh, spatial_methods) + + # Add ghost nodes + whole_cell = ["negative electrode", "separator", "positive electrode"] + var = pybamm.Variable("var", domain=whole_cell) + disc.set_variable_slices([var]) + discretised_symbol = pybamm.StateVector(*disc.y_slices[var.id]) + bcs = { + "left": (pybamm.Scalar(0), "Dirichlet"), + "right": (pybamm.Scalar(3), "Dirichlet"), + } + + # Test + sp_meth = pybamm.FiniteVolume() + sp_meth.build(mesh) + sym_ghost = sp_meth.add_ghost_nodes(var, discretised_symbol, bcs) + combined_submesh = mesh.combine_submeshes(*whole_cell) + y_test = np.linspace(0, 1, combined_submesh[0].npts) + np.testing.assert_array_equal( + sym_ghost.evaluate(y=y_test)[1:-1], discretised_symbol.evaluate(y=y_test) + ) + self.assertEqual( + (sym_ghost.evaluate(y=y_test)[0] + sym_ghost.evaluate(y=y_test)[1]) / 2, 0 + ) + self.assertEqual( + (sym_ghost.evaluate(y=y_test)[-2] + sym_ghost.evaluate(y=y_test)[-1]) / 2, 3 + ) + + # test errors + bcs = {"left": (pybamm.Scalar(0), "x"), "right": (pybamm.Scalar(3), "Neumann")} + with self.assertRaisesRegex(ValueError, "boundary condition must be"): + sp_meth.add_ghost_nodes(var, discretised_symbol, bcs) + bcs = {"left": (pybamm.Scalar(0), "Neumann"), "right": (pybamm.Scalar(3), "x")} + with self.assertRaisesRegex(ValueError, "boundary condition must be"): + sp_meth.add_ghost_nodes(var, discretised_symbol, bcs) + + def test_add_ghost_nodes_concatenation(self): + # Set up + + # create discretisation + mesh = get_mesh_for_testing() + spatial_methods = {"macroscale": pybamm.FiniteVolume()} + disc = pybamm.Discretisation(mesh, spatial_methods) + + # Add ghost nodes + whole_cell = ["negative electrode", "separator", "positive electrode"] + var_n = pybamm.Variable("var", domain=["negative electrode"]) + var_s = pybamm.Variable("var", domain=["separator"]) + var_p = pybamm.Variable("var", domain=["positive electrode"]) + var = pybamm.Concatenation(var_n, var_s, var_p) + disc.set_variable_slices([var]) + discretised_symbol = disc.process_symbol(var) + bcs = { + "left": (pybamm.Scalar(0), "Dirichlet"), + "right": (pybamm.Scalar(3), "Dirichlet"), + } + + # Test + combined_submesh = mesh.combine_submeshes(*whole_cell) + y_test = np.ones_like(combined_submesh[0].nodes[:, np.newaxis]) + + # both + sp_meth = pybamm.FiniteVolume() + sp_meth.build(mesh) + symbol_plus_ghost_both = sp_meth.add_ghost_nodes(var, discretised_symbol, bcs) + np.testing.assert_array_equal( + symbol_plus_ghost_both.evaluate(None, y_test)[1:-1], + discretised_symbol.evaluate(None, y_test), + ) + self.assertEqual( + ( + symbol_plus_ghost_both.evaluate(None, y_test)[0] + + symbol_plus_ghost_both.evaluate(None, y_test)[1] + ) + / 2, + 0, + ) + self.assertEqual( + ( + symbol_plus_ghost_both.evaluate(None, y_test)[-2] + + symbol_plus_ghost_both.evaluate(None, y_test)[-1] + ) + / 2, + 3, + ) + + def test_p2d_add_ghost_nodes(self): + # create discretisation + mesh = get_p2d_mesh_for_testing() + spatial_methods = { + "macroscale": pybamm.FiniteVolume(), + "negative particle": pybamm.FiniteVolume(), + "positive particle": pybamm.FiniteVolume(), + } + disc = pybamm.Discretisation(mesh, spatial_methods) + + # add ghost nodes + c_s_n = pybamm.Variable("c_s_n", domain=["negative particle"]) + c_s_p = pybamm.Variable("c_s_p", domain=["positive particle"]) + + disc.set_variable_slices([c_s_n]) + disc_c_s_n = pybamm.StateVector(*disc.y_slices[c_s_n.id]) + + disc.set_variable_slices([c_s_p]) + disc_c_s_p = pybamm.StateVector(*disc.y_slices[c_s_p.id]) + bcs = { + "left": (pybamm.Scalar(0), "Dirichlet"), + "right": (pybamm.Scalar(3), "Dirichlet"), + } + sp_meth = pybamm.FiniteVolume() + sp_meth.build(mesh) + c_s_n_plus_ghost = sp_meth.add_ghost_nodes(c_s_n, disc_c_s_n, bcs) + c_s_p_plus_ghost = sp_meth.add_ghost_nodes(c_s_p, disc_c_s_p, bcs) + + mesh_s_n = mesh["negative particle"] + mesh_s_p = mesh["positive particle"] + + n_prim_pts = mesh_s_n[0].npts + n_sec_pts = len(mesh_s_n) + + p_prim_pts = mesh_s_p[0].npts + p_sec_pts = len(mesh_s_p) + + y_s_n_test = np.kron(np.ones(n_sec_pts), np.ones(n_prim_pts)) + y_s_p_test = np.kron(np.ones(p_sec_pts), np.ones(p_prim_pts)) + + # evaluate with and without ghost points + c_s_n_eval = disc_c_s_n.evaluate(None, y_s_n_test) + c_s_n_ghost_eval = c_s_n_plus_ghost.evaluate(None, y_s_n_test) + + c_s_p_eval = disc_c_s_p.evaluate(None, y_s_p_test) + c_s_p_ghost_eval = c_s_p_plus_ghost.evaluate(None, y_s_p_test) + + # reshape to make easy to deal with + c_s_n_eval = np.reshape(c_s_n_eval, [n_sec_pts, n_prim_pts]) + c_s_n_ghost_eval = np.reshape(c_s_n_ghost_eval, [n_sec_pts, n_prim_pts + 2]) + + c_s_p_eval = np.reshape(c_s_p_eval, [p_sec_pts, p_prim_pts]) + c_s_p_ghost_eval = np.reshape(c_s_p_ghost_eval, [p_sec_pts, p_prim_pts + 2]) + + np.testing.assert_array_equal(c_s_n_ghost_eval[:, 1:-1], c_s_n_eval) + np.testing.assert_array_equal(c_s_p_ghost_eval[:, 1:-1], c_s_p_eval) + + np.testing.assert_array_equal( + (c_s_n_ghost_eval[:, 0] + c_s_n_ghost_eval[:, 1]) / 2, 0 + ) + np.testing.assert_array_equal( + (c_s_p_ghost_eval[:, 0] + c_s_p_ghost_eval[:, 1]) / 2, 0 + ) + + np.testing.assert_array_equal( + (c_s_n_ghost_eval[:, -2] + c_s_n_ghost_eval[:, -1]) / 2, 3 + ) + np.testing.assert_array_equal( + (c_s_p_ghost_eval[:, -2] + c_s_p_ghost_eval[:, -1]) / 2, 3 + ) + + +if __name__ == "__main__": + print("Add -v for more debug output") + import sys + + if "-v" in sys.argv: + debug = True + pybamm.settings.debug_mode = True + unittest.main() diff --git a/tests/unit/test_spatial_methods/test_scikit_finite_element.py b/tests/unit/test_spatial_methods/test_scikit_finite_element.py index 21bd4b8799..cf1a852387 100644 --- a/tests/unit/test_spatial_methods/test_scikit_finite_element.py +++ b/tests/unit/test_spatial_methods/test_scikit_finite_element.py @@ -10,7 +10,8 @@ class TestScikitFiniteElement(unittest.TestCase): def test_not_implemented(self): mesh = get_2p1d_mesh_for_testing() - spatial_method = pybamm.ScikitFiniteElement(mesh) + spatial_method = pybamm.ScikitFiniteElement() + spatial_method.build(mesh) self.assertEqual(spatial_method.mesh, mesh) with self.assertRaises(NotImplementedError): spatial_method.gradient(None, None, None) @@ -23,8 +24,8 @@ def test_discretise_equations(self): # get mesh mesh = get_2p1d_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "current collector": pybamm.ScikitFiniteElement, + "macroscale": pybamm.FiniteVolume(), + "current collector": pybamm.ScikitFiniteElement(), } disc = pybamm.Discretisation(mesh, spatial_methods) # discretise some equations @@ -127,8 +128,8 @@ def test_discretise_equations(self): def test_manufactured_solution(self): mesh = get_unit_2p1D_mesh_for_testing(ypts=32, zpts=32) spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "current collector": pybamm.ScikitFiniteElement, + "macroscale": pybamm.FiniteVolume(), + "current collector": pybamm.ScikitFiniteElement(), } disc = pybamm.Discretisation(mesh, spatial_methods) @@ -230,8 +231,8 @@ def test_manufactured_solution_cheb_grid(self): mesh = pybamm.Mesh(geometry, submesh_types, var_pts) spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "current collector": pybamm.ScikitFiniteElement, + "macroscale": pybamm.FiniteVolume(), + "current collector": pybamm.ScikitFiniteElement(), } disc = pybamm.Discretisation(mesh, spatial_methods) @@ -292,8 +293,8 @@ def test_manufactured_solution_exponential_grid(self): mesh = pybamm.Mesh(geometry, submesh_types, var_pts) spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "current collector": pybamm.ScikitFiniteElement, + "macroscale": pybamm.FiniteVolume(), + "current collector": pybamm.ScikitFiniteElement(), } disc = pybamm.Discretisation(mesh, spatial_methods) @@ -323,8 +324,8 @@ def test_manufactured_solution_exponential_grid(self): def test_definite_integral(self): mesh = get_2p1d_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "current collector": pybamm.ScikitFiniteElement, + "macroscale": pybamm.FiniteVolume(), + "current collector": pybamm.ScikitFiniteElement(), } disc = pybamm.Discretisation(mesh, spatial_methods) var = pybamm.Variable("var", domain="current collector") @@ -344,8 +345,8 @@ def test_definite_integral(self): def test_definite_integral_vector(self): mesh = get_2p1d_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "current collector": pybamm.ScikitFiniteElement, + "macroscale": pybamm.FiniteVolume(), + "current collector": pybamm.ScikitFiniteElement(), } disc = pybamm.Discretisation(mesh, spatial_methods) var = pybamm.Variable("var", domain="current collector") @@ -366,8 +367,8 @@ def test_definite_integral_vector(self): def test_neg_pos(self): mesh = get_2p1d_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "current collector": pybamm.ScikitFiniteElement, + "macroscale": pybamm.FiniteVolume(), + "current collector": pybamm.ScikitFiniteElement(), } disc = pybamm.Discretisation(mesh, spatial_methods) var = pybamm.Variable("var", domain="current collector") @@ -389,8 +390,8 @@ def test_neg_pos(self): def test_boundary_integral(self): mesh = get_2p1d_mesh_for_testing() spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "current collector": pybamm.ScikitFiniteElement, + "macroscale": pybamm.FiniteVolume(), + "current collector": pybamm.ScikitFiniteElement(), } disc = pybamm.Discretisation(mesh, spatial_methods) var = pybamm.Variable("var", domain="current collector") @@ -447,8 +448,8 @@ def test_pure_neumann_poisson(self): # create discretisation mesh = get_unit_2p1D_mesh_for_testing(ypts=32, zpts=32) spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "current collector": pybamm.ScikitFiniteElement, + "macroscale": pybamm.FiniteVolume(), + "current collector": pybamm.ScikitFiniteElement(), } disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) @@ -483,8 +484,8 @@ def test_dirichlet_bcs(self): # create discretisation mesh = get_unit_2p1D_mesh_for_testing(ypts=8, zpts=32) spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "current collector": pybamm.ScikitFiniteElement, + "macroscale": pybamm.FiniteVolume(), + "current collector": pybamm.ScikitFiniteElement(), } disc = pybamm.Discretisation(mesh, spatial_methods) disc.process_model(model) @@ -501,8 +502,8 @@ def test_dirichlet_bcs(self): def test_disc_spatial_var(self): mesh = get_unit_2p1D_mesh_for_testing(ypts=4, zpts=5) spatial_methods = { - "macroscale": pybamm.FiniteVolume, - "current collector": pybamm.ScikitFiniteElement, + "macroscale": pybamm.FiniteVolume(), + "current collector": pybamm.ScikitFiniteElement(), } disc = pybamm.Discretisation(mesh, spatial_methods)