{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Use examples\n", "This jupyter notebook can be found at:\n", "[https://github.com/environmentalscience/essm/blob/master/docs/examples/api_features.ipynb](https://github.com/environmentalscience/essm/blob/master/docs/examples/api_features.ipynb)\n", "\n", "Below, we will import some generic python packages that are used in this notebook:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'0.4.3.dev21+dirty'" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Checking for essm version installed\n", "import pkg_resources\n", "pkg_resources.get_distribution(\"essm\").version" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from IPython.core.display import display, HTML\n", "display(HTML(\"\"))" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from IPython.display import display\n", "from sympy import init_printing, latex\n", "init_printing() \n", "from sympy.printing import StrPrinter\n", "StrPrinter._print_Quantity = lambda self, expr: str(expr.abbrev) # displays short units (m instead of meter)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "import scipy as sc\n", "# Import various functions from sympy\n", "from sympy import Derivative, Eq, exp, log, solve, Symbol\n", "from essm.equations import Equation\n", "from essm.variables import Variable\n", "from essm.variables.utils import ListTable, generate_metadata_table" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Importing variables and equations from essm" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "from essm.variables.chamber import *\n", "from essm.variables.leaf import *\n", "from essm.variables.physics.thermodynamics import *\n", "from essm.equations.leaf import * \n", "from essm.equations.physics.thermodynamics import *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plotting\n", "Below, we will define a function to make plotting of equations very easy, and then show an example:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "from sympy import latex\n", "from sympy import N\n", "from numpy import arange\n", "from essm.variables.units import derive_unit, SI, Quantity\n", "from essm.variables.utils import markdown\n", "\n", "def plot_expr2(xvar_min_max, yldata, yllabel=None, yrdata=None,\n", " yrlabel='', clf=True, npoints=100, ylmin=None, ylmax=None,\n", " yrmin=None, yrmax=None, xlabel=None,\n", " colors=None,\n", " loc_legend_left='best', loc_legend_right='right',\n", " linestylesl=['-', '--', '-.', ':'], \n", " linestylesr=['-', '--', '-.', ':'],\n", " fontsize=None, fontsize_ticks=None, fontsize_labels=None,\n", " fontsize_legend=None,\n", " fig1=None, **args):\n", " '''\n", " Plot expressions as function of xvar from xmin to xmax.\n", " \n", " **Examples:**\n", " \n", " from essm.variables import Variable\n", " from essm.variables.physics.thermodynamics import T_a\n", " from essm.equations.physics.thermodynamics import eq_nua, eq_ka\n", " vdict = Variable.__defaults__.copy() \n", " expr = eq_nua.subs(vdict)\n", " exprr = eq_ka.subs(vdict)\n", " xvar = T_a\n", " yldata = [(expr.rhs, 'full'), (expr.rhs/2, 'half')]\n", " yrdata = exprr\n", " plot_expr2((T_a, 273, 373), yldata, yllabel = (nu_a), yrdata=yrdata)\n", " plot_expr2((T_a, 273, 373), yldata, yllabel = (nu_a), \n", " yrdata=[(1/exprr.lhs, 1/exprr.rhs)],\n", " loc_legend_right='lower right')\n", " plot_expr2((T_a, 273, 373), expr)\n", " plot_expr2((T_a, 273, 373), yldata, yllabel = (nu_a))\n", " '''\n", " (xvar, xmin, xmax) = xvar_min_max\n", " if not colors:\n", " if yrdata is not None:\n", " colors = ['black', 'blue', 'red', 'green']\n", " else:\n", " colors = ['blue', 'black', 'red', 'green']\n", " if fontsize:\n", " fontsize_labels = fontsize\n", " fontsize_legend = fontsize\n", " fontsize_ticks = fontsize\n", " if not fig1:\n", " plt.close\n", " plt.clf\n", " fig = plt.figure(**args)\n", " else: \n", " fig = fig1\n", " if hasattr(xvar, 'definition'): \n", " unit1 = derive_unit(xvar)\n", " if unit1 != 1:\n", " strunit = ' (' + markdown(unit1) + ')'\n", " else: \n", " strunit = ''\n", " if not xlabel:\n", " xlabel = '$'+latex(xvar)+'$'+ strunit\n", " else: \n", " if not xlabel:\n", " xlabel = xvar\n", " if hasattr(yldata, 'lhs'):\n", " yldata = (yldata.rhs, yldata.lhs)\n", " if not yllabel:\n", " if type(yldata) is tuple:\n", " yllabel = yldata[1]\n", " else:\n", " try: \n", " yllabel = yldata[0][1]\n", " except Exception as e1:\n", " print(e1)\n", " print('yldata must be equation or list of (expr, name) tuples')\n", " \n", " if type(yllabel) is not str: \n", " unit1 = derive_unit(yllabel)\n", " if unit1 != 1:\n", " strunit = ' (' + markdown(unit1) + ')'\n", " else: \n", " strunit = ''\n", " \n", " yllabel = '$'+latex(yllabel)+'$'+ strunit \n", " if type (yldata) is not list and type(yldata) is not tuple:\n", " # If only an expression given\n", " yldata = [(yldata, '')]\n", " if type(yldata[0]) is not tuple:\n", " yldata = [yldata]\n", " if yrdata is not None:\n", " if yrlabel == '':\n", " if hasattr(yrdata, 'lhs'):\n", " yrlabel = yrdata.lhs \n", " if type (yrdata) is not list and type(yrdata) is not tuple:\n", " # If only an expression given\n", " yrdata = [yrdata] \n", " if type(yrlabel) is not str: \n", " yrlabel = '$'+latex(yrlabel)+'$'+ ' (' + markdown(derive_unit(yrlabel)) + ')' \n", " \n", " xstep = (xmax - xmin)/npoints\n", " xvals = arange(xmin, xmax, xstep)\n", " \n", " ax1 = fig.add_subplot(1, 1, 1)\n", " if yrdata is not None:\n", " color = colors[0]\n", " else:\n", " color = 'black'\n", " if ylmin: ax1.set_ylim(ymin=float(ylmin))\n", " if ylmax: ax1.set_ylim(ymax=float(ylmax))\n", " ax1.set_xlabel(xlabel)\n", " ax1.set_ylabel(yllabel, color=color)\n", " ax1.tick_params(axis='y', labelcolor=color)\n", " i = 0\n", " for (expr1, y1var) in yldata:\n", " linestyle = linestylesl[i]\n", " if yrdata is None:\n", " color = colors[i]\n", " i= i + 1\n", " try: \n", " y1vals = [expr1.subs(xvar, dummy).n() for dummy in xvals] \n", " ax1.plot(xvals, y1vals, color=color, linestyle=linestyle, label=y1var)\n", " except Exception as e1:\n", " print([expr1.subs(xvar, dummy) for dummy in xvals])\n", " print(e1)\n", " if i > 1 or yrdata is not None:\n", " plt.legend(loc=loc_legend_left, fontsize=fontsize_legend)\n", " \n", " if yrdata is not None: \n", " ax2 = ax1.twinx() # instantiate a second axes that shares the same x-axis\n", " color = colors[1]\n", " ax2.set_ylabel(yrlabel, color=color)\n", " i = 0\n", "\n", " for item in yrdata:\n", " if type(item) is tuple: # if item is tuple\n", " (expr2, y2var) = item\n", " else:\n", " try: \n", " (y2var, expr2) = (item.lhs, item.rhs)\n", " except Exception as e1:\n", " print(e1)\n", " print('yrdata must be a list of equations or tuples (var, expr)')\n", " return\n", " linestyle = linestylesr[i]\n", " i = i + 1\n", " try:\n", " y2vals = [expr2.subs(xvar, dummy).n() for dummy in xvals]\n", " ax2.plot(xvals, y2vals, color=color, linestyle=linestyle, label=y2var)\n", " except Exception as e1:\n", " print(expr2)\n", " print([expr2.subs(xvar, dummy).n() for dummy in xvals])\n", " print(e1)\n", " \n", " if not yrlabel:\n", " if hasattr(yrdata[0], 'lhs'):\n", " yrlabel = yrdata[0].lhs\n", "\n", " if type(yrlabel) is not str: \n", " yrlabel = '$'+latex(yrlabel)+'$'+ ' (' + markdown(derive_unit(yrlabel)) + ')' \n", " ax2.tick_params(axis='y', labelcolor=color)\n", " if yrmin: ax2.set_ylim(ymin=float(yrmin))\n", " if yrmax: ax2.set_ylim(ymax=float(yrmax))\n", " leg=ax2.legend(loc=loc_legend_right, fontsize=fontsize_legend)\n", " ax2.add_artist(leg);\n", " for item in ([ax2.xaxis.label, ax2.yaxis.label]):\n", " item.set_fontsize(fontsize_labels)\n", " ax2.tick_params(axis='both', which='major', labelsize=fontsize_ticks)\n", "\n", " for item in ([ax1.xaxis.label, ax1.yaxis.label]):\n", " item.set_fontsize(fontsize_labels)\n", " ax1.tick_params(axis='both', which='major', labelsize=fontsize_ticks)\n", " fig.tight_layout() # otherwise the right y-label is slightly clipped\n", " return fig" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl4VdXV+PHvIgmToEBEmQ1KUECFDIKoFcWBQQUHKqhYEBSt2vdVa1/lp1ZFbcV5FplUBA2KRVLHWqXV1gHCZQbBMBpAgTAIAoGQ9ftj7ySXeEMSSO6QrM/z8HjuPvvss08usrL32WcdUVWMMcaYaFMr0h0wxhhjQrEAZYwxJipZgDLGGBOVLEAZY4yJShagjDHGRCULUMYYY6KSBShjjDFRyQKUMcaYqGQByhhjTFSKj3QHqoOjjz5ak5KSIt0NY4yJCXPmzNmsqk3LqmcBqhIkJSWRlZUV6W4YY0xMEJE15alnU3zGGGOikgUoY4wxUckClDHGmKhk96CqyL59+8jJyWHPnj2R7kqlqlu3Lq1atSIhISHSXTHGVHMWoKpITk4ODRs2JCkpCRGJdHcqhaqSm5tLTk4Obdu2jXR3jDHVnE3xVZE9e/aQmJhYbYITgIiQmJhY7UaFxpjoZAGqClWn4FSoOl6TMSY6hT1AiUhvEVkmItkicneI/XVEZKrf/62IJAXtG+nLl4lIr7LaFJG2vo1s32ZtX36HiCwRkQUi8pmIHOfLu4jI1yKy2O8bWJU/C2OMiTV79sCUKfDOO1V/rrAGKBGJA14E+gAdgatEpGOJasOBraraDngaGO2P7QgMAjoBvYGXRCSujDZHA0/7trb6tgHmAumqeiowDXjMl+8Cfqeqhed4RkQaVebPIJyee+45OnTowDXXXFNqnQYNGgCwevVqTj755HB1zRgTYxYuhP/5H2jRAgYPhgkTqv6c4R5BdQWyVXWlqu4FMoD+Jer0B17329OA88TNK/UHMlQ1T1VXAdm+vZBt+mN6+jbwbV4KoKozVXWXL/8GaOXLl6vq9357PbARKDMdR7R66aWX+PTTT5kyZUqku2KMiUE7dsD48dCtG5x6KrzyCvTqBZ99Bh9+WPXnD/cqvpbAD0Gfc4BupdVR1XwR2Q4k+vJvShzb0m+HajMR2Kaq+SHqBxsOfFSyUES6ArWBFWVeVRluuw3mzTvcVg7UpQs880zp+2+66SZWrlxJnz59WLt2Lffddx933nknACeffDLvv/8+lj/QGFOSKsya5QJTRgbs3AkdO8LTT8O110JiYvj6UqOXmYvIYCAd6FGivDnwBjBEVQtKOXYEMAKgTZs2VdzTihszZgwff/wxM2fO5IUXXoh0d4wxUW7LFndvadw4N51Xvz4MHAg33ACnnw6RWB8V7gC1Dmgd9LmVLwtVJ0dE4oGjgNwyjg1Vngs0EpF4P4o64Fwicj5wD9BDVfOCyo8EPgDuUdXgEdsBVHUsMBYgPT1dD3bRBxvpGGNMpKjCF1+4oDRtGuTlQVoajBkDV10FRx4Z2f6F+x7UbCDZr66rjVv0kFmiTiYwxG8PAD5XVfXlg/wqv7ZAMjCrtDb9MTN9G/g2ZwCISArwCtBPVTcWntgfPx2YpKqF965iXnx8PAUFxQNBe47JmJrtp59g9Gg48UQ45xx4/30YPhwCAcjKghtvjHxwgjCPoPw9pVuBT4A4YKKqLhaRUUCWqmYCE4A3RCQb2IILOPh6bwNLgHzgFlXdDxCqTX/Ku4AMEXkYt3KvcN3J40AD4B3/XM9aVe0HXAmcDSSKyFBfd6iqVvIdpPBKSkri/fffByAQCLBq1aoI98gYE27798Mnn7h7S3//O+Tnw9lnw333wRVXuCm9aBP2e1Cq+iHwYYmyPwdt7wF+W8qxjwCPlKdNX74St8qvZPn5pbQ/GZh88CuIPVdccQWTJk2iU6dOdOvWjfbt20e6S8aYMFm7FiZOdH9++AGaNnULt66/3o2golmNXiRR3a1evbpo+x//+EfIOjt37gTcKGvRokXh6JYxport3etGSePHu1ETwIUXwlNPQb9+ULt2ZPtXXhagjDGmmli+3AWl11+HjRuhVSu4914YNgxi8akSC1DGGBPDdu+Gd991K/G++ALi4uCSS9zy8F693OdYZQHKGGNi0IIFLihNngzbtsEJJ8Bf/wpDh0KzZpHuXeWwAGWMMTFixw546y03jTd7truXdMUVbrTUowfUqmbvp7AAZYwxUUwVvv3WjZamToVffoFOnVwCgMGDw5t6KNwsQBljTBTasgXeeMONlhYtgiOOgEGD3PLwbt0ik3oo3KrZgNAEq+grNB544AGeeOIJAL777ju6dOlCSkoKK1Ycdr5cY0w5FBTAzJlw9dXutRa33Qb16rks4uvXu2AVqbx4kWAjKBPSe++9x4ABA7j33nsj3RVjqr0NG+C119w7llasgEaN3H2l66+Hzp0j3bvIsQAVJuecc86vyq688kpuvvlmdu3aRd++fX+1f+jQoQwdOpTNmzczYMCAA/b961//Ktd59+/fzw033MBXX31Fy5YtmTFjBpMnT2bs2LHs3buXdu3a8cYbb1A/KM/Jhx9+yDPPPENcXByfffYZM2fOrNC1GmPKtn8/fPxxceqh/ftd6qEHHnALH+rVi3QPI8+m+Kq577//nltuuYXFixfTqFEj3n33XS6//HJmz57N/Pnz6dChAxNKvBqzb9++3HTTTdx+++0WnIypZGvWwP33uwdnL74YvvoK/vhHWLYM/v1vt/DBgpNjI6gwOdiIp379+gfdf/TRR5d7xFRS27Zt6dKlCwBpaWmsXr2aRYsWce+997Jt2zZ27txJr169DqltY0z57N0LmZlutFSYdaxXL3j2WRekYiX1ULhZgKrm6tSpU7QdFxfH7t27GTp0KO+99x6dO3fmtddeO+TgZ4w5uGXLilMPbdoErVvDn/8M110Hxx0X6d5FPwtQNdCOHTto3rw5+/btY8qUKbRs2TLSXTKm2ti1y6UeGj/epR6Kjy9OPXThhbGdeijcLEDVQA899BDdunWjadOmdOvWjR07dkS6S8bEvHnzXFCaPBm2b4d27apf6qFwE/fiWXM40tPTNSsr64CypUuX0qFDhwj1qGpV52szpiJ+/rk49VBWFtSpc2DqoZryvFJFicgcVU0vq56NoIwxpgJU4ZtvilMP7doFp5wCzz3nVuA1bhzpHlYfFqCMMaYccnNd6qFx42DJEpd66Oqr3WjptNNstFQVwv4clIj0FpFlIpItIneH2F9HRKb6/d+KSFLQvpG+fJmI9CqrTRFp69vI9m3W9uV3iMgSEVkgIp+JyHFBxwwRke/9nyGHc63Vcfq0Ol6TMaUpKIDPPoOrrnKph26/HRo2hLFjXfaHceOga1cLTlUlrAFKROKAF4E+QEfgKhHpWKLacGCrqrYDngZG+2M7AoOATkBv4CURiSujzdHA076trb5tgLlAuqqeCkwDHvPnaALcD3QDugL3i8ghDdjr1q1Lbm5utfoHXVXJzc2lbt26ke6KMVVqwwb4y18gORnOP9+9Nv3GG2H+fDe9d8MNLlCZqhXuKb6uQLaqrgQQkQygP7AkqE5/4AG/PQ14QUTEl2eoah6wSkSyfXuEalNElgI9gat9ndd9uy+ranB6hG+AwX67F/Cpqm7xbX2KC4ZvVfRCW7VqRU5ODps2barooVGtbt26tGrVKtLdMKbS5ee71EPjxsEHH7jUQz16wKhRcPnllt0hEsIdoFoCPwR9zsGNVkLWUdV8EdkOJPryb0ocW/gAT6g2E4Ftqpofon6w4cBHB+lfyIeERGQEMAKgTZs2v9qfkJBA27ZtQx1qjIkiq1e7JK2vvgrr1sGxx8Kdd8Lw4W4EZSKnRi+SEJHBQDrQo6LHqupYYCy4ZeaV3DVjTBXKy3Oph8aNg3/+05X16QPPP+9SDyUkRLZ/xgl3gFoHtA763MqXhaqTIyLxwFFAbhnHhirPBRqJSLwfRR1wLhE5H7gH6OGnDQvPfU6Jtv5VoSs0xkSt774rTj20eTO0aeMStw4b5tIQmegS7lV8s4Fkv7quNm7RQ2aJOplA4eq5AcDn6lYaZAKD/Cq/tkAyMKu0Nv0xM30b+DZnAIhICvAK0E9VNwad+xPgQhFp7BdHXOjLjDExatcuF5B+8xvo0MElaD37bPjoI1i50gUoC07RKawjKH9P6VbcP/pxwERVXSwio4AsVc0EJgBv+EUQW3ABB1/vbdyCinzgFlXdDxCqTX/Ku4AMEXkYt3Kv8L0SjwMNgHfc+gvWqmo/Vd0iIg/hgh7AqMIFE8aY2BIIuNHSlCku40P79vDYYzBkCBxzTKR7Z8rDUh1VglCpjowx4bd9u0s9NG6cC1B168KAAW5Z+G9+Y88rRQtLdWSMqRFU4euvXVB6+203pde5M7zwgsv0YKmHYpcFKGNMTNq8GSZNctN4S5dCgwYuF97110N6uo2WqgMLUMaYmFFQAJ9/7kZL06fDvn1w+ukuSA0c6IKUqT4sQBljot769e5B2gkTYNUqN213883uYdpTTol070xVsQBljIlK+fluKfj48cWph849Fx55BC67zC2AMNWbBShjTFRZtao49dD69S710J/+5EZL7dpFuncmnCxAGWMiLi8PZswoTj1Uq5ZLPfTii3DRRZZ6qKayAGWMiZglS9wU3qRJ7oWAxx3nsodfdx1Y0nxjAcoYE1a//ALvvONGS1995UZH/fu75eHnnw9xcZHuoYkWFqCMMWExZ44bLb35pks9dOKJ8Pjj8LvfWeohE5oFKGNMldm+3QWkceNg7ly38u7KK91o6ayz7GFac3AWoIwxlUoV/vtfF5TeeQd27y5OPXTNNdCoUaR7aGKFBShjTKXYtKk49dB330HDhm767vrrIS3NRkum4ixAGWMOWUGBWxY+fjy8955LPXTGGTBxIvz2t5Z6yBweC1DGmArLySlOPbRmDTRpArfc4kZLnTpFunemurAAZYwpl/x8l3Jo/Hj48EM3ejrvPHj0UZd6qE6dSPfQVDcWoIwxB7VihZuye/VV2LABmjeHu+92qYeOPz7SvTPVmQUoY8yv7Nnj7imNG+deb1GrFvTt695M27cvxNu/HCYMaoX7hCLSW0SWiUi2iNwdYn8dEZnq938rIklB+0b68mUi0qusNkWkrW8j27dZ25efLSIBEckXkQElzv+YiCwWkaUi8pyIrT0yNcfixXD77dCyJVx1FaxcCQ89BGvXwt//Dv36WXAy4RPWACUiccCLQB+gI3CViHQsUW04sFVV2wFPA6P9sR2BQUAnoDfwkojEldHmaOBp39ZW3zbAWmAo8GaJ/p0BnAmcCpwMnAb0qJSLNyZK7dzppvDOOANOPtklaD3/fPjHP9z03r33uoBlTLiFewTVFchW1ZWquhfIAPqXqNMfeN1vTwPO86OY/kCGquap6iog27cXsk1/TE/fBr7NSwFUdbWqLgAKSpxbgbpAbaAOkAD8VDmXbkz0UIWsLLjxRmjRwt1P2roVnnwS1q2DqVPhggvc1J4xkRLuwXpL4IegzzlAt9LqqGq+iGwHEn35NyWOLfy9LlSbicA2Vc0PUT8kVf1aRGYCGwABXlDVpaHqisgIYARAmzZtDtasMVFj2zaYMsWtxJs3D+rVK049dOaZ9jCtiS72+1EQEWkHdABa4YJZTxH5Tai6qjpWVdNVNb1p06bh7KYxFaIKX37psjo0bw633urKX3zRvRDwtdcsL56JTuEeQa0DWgd9buXLQtXJEZF44Cggt4xjQ5XnAo1EJN6PokKdq6TLgG9UdSeAiHwEdAe+LNfVGRNFNm4sTj20bBkceSQMHepW4qWmRrp3xpQt3COo2UCyX11XG7foIbNEnUxgiN8eAHyuqurLB/lVfm2BZGBWaW36Y2b6NvBtziijf2uBHiISLyIJuAUSIaf4jIlGBQXwyScuzVCrVu5V6YmJxa9Pf/llC04mdoR1BOXvKd0KfALEARNVdbGIjAKyVDUTmAC8ISLZwBZcwMHXextYAuQDt6jqfoBQbfpT3gVkiMjDwFzfNiJyGjAdaAxcIiIPqmon3IKKnsBC3IKJj1X171X7UzHm8JVMPZSYCH/4g7u31KFDpHtnzKERN9AwhyM9PV2zsrIi3Q1Tw+zb51IPjRsHH3/sRk/nn++m8Pr3t9RDJnqJyBxVTS+rnj1yZ0yMyc52I6XXXoMff3TLxEeOhGHDLPWQqV4sQBkTA/bsgenT3Whp5kyIi4OLLnLPL1nqIVNd2V9rY6LYokUuKL3xhnuQtm1bePhhuO46N3IypjqzAGVMlNm502VyGDcOvv0WateGSy9195Z69rTsDqbmsABlTBQoTD00bhy89ZYLUh06wFNPwbXXwtFHR7qHxoSfBShjImjr1uLUQ/PnQ/36MHCgWx7evbtldzA1mwUoY8JMFb74wgWladPcAoi0NBgzBgYNgqOOinQPjYkOFqCMCZOffipOPbR8uQtEw4a50VJKSqR7Z0z0sQBlTBXav9+9V2n8eMjMhPx8l5j1nntgwAA3pWeMCc0ClDFV4Icf3EsAJ050b6M9+mj43/91o6WTTop074yJDRagjKkk+/bB++8Xpx4Cl3roiSdc6qHatSPbP2NijQUoYw7T998Xpx766Sf3evR773X3l5KSIt07Y2KXBShjDsGePfDuu2609O9/u9RDF1/spvB697bUQ8ZUBvvfyJgKWLjQBaXJk90zTMcfD4884l4EaKmHjKlcFqCMKcPOnZCR4QLTrFnuXtLll7vUQ+ecY6mHjKkqFqCMCUHVBaPx411w2rkTOnaEp592qYcSEyPdQ2OqPwtQxgTZssVN340f76bzClMP3XADnH66pR4yJpwOKUCJyBHAnsJXrhsTy1TdQodx49zCh7w8SE+HV15xqYeOPDLSPTSmZirX7LmI1BKRq0XkAxHZCHwHbBCRJSLyuIi0K+8JRaS3iCwTkWwRuTvE/joiMtXv/1ZEkoL2jfTly0SkV1ltikhb30a2b7O2Lz9bRAIiki8iA0qcv42I/ENElvrrS8JUSz/+CKNHQ/v2cO657vXp118Pc+fC7NkwYoQFJ2Miqby3d2cCJwAjgWaq2lpVjwHOAr4BRovI4LIaEZE44EWgD9ARuEpEOpaoNhzYqqrtgKeB0f7YjsAgoBPQG3hJROLKaHM08LRva6tvG2AtMBR4M0Q3JwGPq2oHoCuwsazrMrFj/3746CO3yKF1a7j7brf6btIk2LABXngBunSJdC+NMVD+Kb7zVXVfyUJV3QK8C7wrIgnlaKcrkK2qKwFEJAPoDywJqtMfeMBvTwNeEBHx5RmqmgesEpFs3x6h2hSRpUBP4Gpf53Xf7suqutrXLQjunA9s8ar6qb++neW4JhMD1qyBV191qYd++AGaNoXbbnMjphNPjHTvjDGhlGsEFRycROSusuocREvgh6DPOb4sZB1VzQe2A4kHOba08kRgm2+jtHOV1B7YJiJ/E5G5fvoyLlRFERkhIlkikrVp06YymjWRsHevu6fUp497VfqoUe4lgO+8Azk58PjjFpyMiWZljqBE5O3gj0AX/LRbNRQP/AZIwU0DTsVNBU4oWVFVxwJjAdLT0zV8XTRlWb7crcJ7/XXYuBFatYL77oPrrrPUQ8bEkvJM8f2sqtcXfhCRlw/jfOuA1kGfW/myUHVyRCQeOArILePYUOW5QCMRifejqFDnKikHmBc0XfgecDohApSJLrt3F6ce+uILl3rokkvc8vBevdxnY0xsKc8U3yMlPt9zGOebDST71XW1cYseMkvUyQSG+O0BwOeqqr58kF/l1xZIBmaV1qY/ZqZvA9/mjHL0r5GINPWfe3Lg/TETZebPh1tvdQsdrr0W1q2Dv/7VTeFNnw59+1pwMiZWlTmCUtVVACJytKpu9gsjDomq5ovIrcAnQBwwUVUXi8goIEtVM3GjlTf8IogtuICDr/c2LmDkA7cUPocVqk1/yruADBF5GJjr20ZETgOmA42BS0TkQVXtpKr7ReRO4DO/MGMOMO5Qr9dUjR07ilMPzZ4NdeoUpx7q0cNSDxlTXYgbaJSjokimqvar4v7EpPT0dM3Kyop0N6o1Vfj22+LUQ7/8Aief7ILS4MHQpEmke2iMKS8RmaOq6WXVq0gmCUvyYsIuN7c49dCiRXDEES67ww03QNeulnrImOqsIgHKVqqZsCgogH/9ywWld991y8VPOw3GjnXBqWHDSPfQGBMONoIyUWPDBrc0fPx4WLECGjWCG2+E4cOhc+dI984YE24VCVAjq6wXpsbavx8+/tgteHj/ffe5Rw948EG38KFevUj30BgTKeUOUKq6SER+C3ysqjtE5F4gFXhYVQNV1kNTLa1e7dIOTZzoloYfcwzccYdLPdS+faR7Z4yJBhV93cZ9qvqOiJwFnA88DrwMdKv0nplqZ+9eyMx0o6VPP3VlF14Izz7rHqqtXTuy/TPGRJeKBqjC9z9dBIxV1Q/8M0bGlGrZsuLUQ5s2uSzif/4zDBsGbdpEunfGmGhV0QC1TkReAS7AvWKjDuV/ZYepQXbtgmnTXGD68kuIj4d+/dwU3oUXWnYHY0zZKhqgrsS9i+kJVd0mIs2BP1V+t0ysmjfPBaXJk2H7dkhOdi8F/N3voFmzSPfOGBNLKhSgVHUX8LegzxuADZXdKRNbfv4Z3nrL3VuaM8elHhowwD1Me/bZ9jCtMebQVHQEZQzgUg99840LSlOnuim9U05xCx4s9ZAxpjJYgDIVsnlzceqhxYtd6qGrr3ajpdNOs9GSMabyWIAyZSoogJkz3Whp+nS3XLxrV/d54EBLPWSMqRrleaPuBbjFES+q6jwRGeHfJmuqufXr4bXXYMIEWLkSGjeGm25yK/FOOSXSvTPGVHflGUENA34P3CsiTXCvfDfVVH5+ceqhDz5wqYfOOQceegguu8xSDxljwqc8AWqHqm4D7hSRR4HTqrhPJgJWr3YjpVdfdamHjj0W7rzTJWpNTo5074wxNVF5AtQHhRuqereI/KEK+2PCKC8PZsxwCx7++U+3wKFXL3j+ebj4YkhIiHQPjTE1WZlZIFR1RonPzx/OCUWkt4gsE5FsEbk7xP46IjLV7/9WRJKC9o305ctEpFdZbYpIW99Gtm+zti8/W0QCIpIvIgNC9OFIEckRkRcO51qj1dKlbnTUqpVb5LBsGdx/vxtFffihm8qz4GSMibQKreITkXTgHuA4f6wAqqqnlvP4OOBFXKqkHGC2f5X8kqBqw4GtqtpORAYBo4GBItIRGAR0AloA/xSRwrzXpbU5GnhaVTNEZIxv+2VgLTAUuLOUrj4EfFGea4oVu3bBO++4e0v//a9LPdS/v1vwcMEFlnrIGBN9KrrMfAoutdFCoOAQztcVyFbVlQAikgH0B4IDVH/gAb89DXhBRMSXZ6hqHrBKRLJ9e4RqU0SWAj2Bq32d1327L6vqal/3V9cgImnAscDHQPohXGNUCQTcFN6UKS7jQ/v28NhjMGSIe8WFMcZEq4oGqE2qmnkY52sJ/BD0OYdfv6qjqI6q5ovIdiDRl39T4tiWfjtUm4nANlXND1E/JBGpBTwJDMa9TuRgdUcAIwDaRFlK7u3b4c03XWAKBKBuXZd66PrrLfWQMSZ2VDRA3S8i44HPgLzCQlX9W+mHxJSbgQ9VNUfK+FfcPws2FiA9PV3D0LeDUoWvvnJTeG+/Dbt3w6mnugUP11zjnmEyxphYUtEAdR1wEpBA8RSfEpRAtgzrgNZBn1v5slB1ckQkHjgKyC3j2FDluUAjEYn3o6hQ5yqpO/AbEbkZaADUFpGdqvqrxRzRYvNmmDTJjZaWLoUGDeDaa13qobQ0Gy0ZY2JXRQPUaap64mGcbzaQLCJtccFiEMX3iAplAkOAr4EBwOeqqiKSCbwpIk/hFkkkA7NwCzV+1aY/ZqZvI8O3OYODUNVrCrdFZCiQHo3BqaAAPv+8OPXQvn1w+unuOaYrr3RByhhjYl1FA9RXItKxxKq7cvP3lG4FPgHigImqulhERgFZ/v7WBOANvwhiCy7g4Ou9jVtQkQ/coqr7AUK16U95F5Dh3/o717eNiJwGTAcaA5eIyIOq2ulQrimc1q0rTj20apWbtvv9791o6eSTI907Y4ypXKJa/tsnfmXcCcAq3D2oCi0zr67S09M1KyurStrOz3fPJo0b5/5bUAA9e7oFD5dd5hZAGGNMLBGROapa5irpio6geh9if0wFrVxZnHpowwb3Ntq77oJhw6Bdu0j3zhhjql65ApSIiDpryqpTeV2refLy4L33ilMP1aoFffq4Kby+fS27gzGmZinvCGqmiLwLzFDVtYWFPnXQWbgFCDOB1yq9hzXAkiUuKE2aBLm5cNxxMGoUXHedS0dkjDE1UXkDVG/cazfe8qvltgF1cYsS/gE8o6pzq6aL1dekSfDKK+75pYQEl3rohhvg/PPd6MkYY2qycgUoVd0DvAS8JCIJwNHAbv8aDnOIpk51I6bHH4ff/c5SDxljTLAKv/JdVfcBG6qgLzXO5MnQqJE9TGuMMaFUOECZymPph4wxpnR2p8MYY0xUsgBljDEmKh3WFJ+I3AecgcuBN1dVX6yUXhljjKnxDncElYh7R9MjwOEkkTXGGGMOcLgBaivuWaiNuMSuxhhjTKWo0BSfiDQETgV+VNUVqvqgiLQAngMWVUUHjTHG1EwVvQc1E5gPnCQim4DrVHU9MLzSe2aMMaZGq1CACk6PLiIDgI9E5HIfpIwxxphKU+F7UCJSS0RaAmuAj3GjKmOMMaZSVfQe1I9APeBHYD0u5dHfq6BfxhhjariK3oNqr6o/V0lPjDHGmCAVmuKrjOAkIr1FZJmIZIvI3SH21xGRqX7/tyKSFLRvpC9fJiK9ympTRNr6NrJ9m7V9+dkiEhCRfH8vrbB+FxH5WkQWi8gCERl4uNdrjDHm0IQ11ZGIxAEvAn2AjsBVItKxRLXhwFZVbQc8DYz2x3YEBgGdcO+neklE4spoczTwtG9rK8WrDdcCQ4E3S5x7F/A7VS08xzMi0qgyrt0YY0zFhDsXX1cgW1VXqupeIAPoX6JOf+B1vz0NOE9ExJdnqGr6SW3GAAAakUlEQVSeqq4Csn17Idv0x/T0beDbvBRAVVer6gKgIPjEqrpcVb/32+txDyA3rbzLN8YYU17hDlAtgR+CPuf4spB1VDUf2I5LqVTasaWVJwLbfBulnatUItIVqA2sKGX/CBHJEpGsTZs2lbdZY4wx5WTZzEMQkebAG7gHkQtC1VHVsaqarqrpTZvaIMsYYypbuAPUOqB10OdWvixkHRGJB44Ccg9ybGnluUAj30Zp5/oVETkS+AC4R1W/KddVGWOMqXThDlCzgWS/uq42btFDZok6mcAQvz0A+FxV1ZcP8qv82gLJwKzS2vTHzPRt4NuccbDO+eOnA5NUddrB6hpjjKlaYQ1Q/n7QrcAnwFLgbVVdLCKjRKSfrzYBSBSRbOAO4G5/7GLgbWAJLoPFLaq6v7Q2fVt3AXf4thJ924jIaSKSA/wWeEVECutfCZwNDBWRef5Plyr7gRhjjCmVuIGGORzp6emalZUV6W4YY0xMEJE5wbldS2OLJIwxxkQlC1DGGGOikgUoY4wxUckClDHGmKhkAcoYY0xUsgBljDGmXFSVjRs3hu18FX0flDHGmBpi1apVfPXVVwQCAQKBAHPnzqVx48asWrUqLOe3AGWMMTVcfn4+S5cuJRAIMG/ePJ544gni4uJ47LHHGDNmDHXq1KFz585cddVVpKWloaq4F0ZULXtQtxLYg7rGmFiRl5dHrVq1SEhI4MMPP2TUqFHMnz+fPXv2AFC/fn0WL15MUlISy5cvJy8vj5NOOomEhIRK60N5H9S1EZQxxlRTeXl5zJ8/nzlz5hRN0y1cuJCPP/6Ynj17kpCQQL169bj55ptJS0sjNTWV5ORk4uLiAGjfvn1E+28ByhhjqoGdO3cyf/58AoEA6enpdO/enYULF9KtWzcAmjRpQmpqKnfccQctWrQA4IILLuCCCy6IZLcPygKUMcbEmP379xMXF8fu3bu54YYbCAQCfPfddxTesrn33nvp3r07p5xyCu+++y5paWm0adMmLPeNKpMFKGOMiWK5ublF03OBQIA5c+Zw+umnM3nyZOrWrcuSJUtITk5m4MCBRdN0hSOkOnXqcPnll0f4Cg6dBShjjIkSP/30E4FAgM2bN3PttdcC0LNnTxYsWABAUlISqampnHPOOQCICIFAIFLdrXIWoIwxJoKmTJnC1KlTCQQCrFvnXvrduHFjBg8ejIjw17/+ldq1a5OamkqTJk0i3NvwsgBljDFVSFVZs2bNASvp5s+fz/fff88RRxzB0qVLWbFiBeeeey6pqamkpaXRpUuXovtFffv2jfAVRI49B1UJ7DkoYwxAQUEBK1asIBAI0LNnT5o2bcqLL77IrbfeCkB8fDydOnUiJSWFRx99lGOPPTZsD71GE3sOyhhjwmDNmjU8++yzRamAfv75ZwDeffddLr/8ci644ALGjBlDSkoKp556KnXr1j3g+JoWnCoi7MliRaS3iCwTkWwRuTvE/joiMtXv/1ZEkoL2jfTly0SkV1ltikhb30a2b7O2Lz9bRAIiki8iA0qcf4iIfO//DKmKn4ExJrbs27ePBQsW8Oqrr/KHP/yBM888k4kTJxbtGzNmDHl5eQwePJgJEyYwd+5cLr74YsA97HrjjTfStWvXXwUnc3BhHUGJSBzwInABkAPMFpFMVV0SVG04sFVV24nIIGA0MFBEOgKDgE5AC+CfIlL4mHNpbY4GnlbVDBEZ49t+GVgLDAXuLNG/JsD9QDqgwBzf1tbK/lkYY6JTXl4eixYtQlVJT09n9+7dJCYmsnv3bgAaNGhAly5dqFevHgAnnHACP//8M/HxNiFV2cL9E+0KZKvqSgARyQD6A8EBqj/wgN+eBrwgbgzcH8hQ1TxglYhk+/YI1aaILAV6Alf7Oq/7dl9W1dW+bkGJ/vUCPlXVLX7/p0Bv4K3DvnJjTNR67bXX+M9//kMgEGDRokXs27ePvn378sEHH1CvXj3uu+8+jjvuONLS0khOTqZWreLJJxGx4FRFwv1TbQn8EPQ5B+hWWh1VzReR7UCiL/+mxLEt/XaoNhOBbaqaH6J+RfoX8hgRGQGMAGjTpk0ZzRpjIm3Hjh3MmzevaCVdXl4eGRkZALz66qssXryYtLQ07rjjDtLS0khPL76HP3LkyEh1u0azsH+IVHUsMBbcKr4Id8cYE2Tbtm0sWLCAs88+G4DbbruN5557rigVULNmzejevXvRCrq///3vNGzY0BYsRJlwB6h1QOugz618Wag6OSISDxwF5JZxbKjyXKCRiMT7UVSoc4Xq3zkl2vpXGccYYyJs6dKlzJgxo2h0tGLFCgA2bNhAs2bN6NGjB4mJiaSkpJCWlkbz5s0POP7II4+MRLdNGcIdoGYDySLSFhcMBlF8j6hQJjAE+BoYAHyuqioimcCbIvIUbpFEMjALkFBt+mNm+jYyfJszyujfJ8BfRKSx/3whYGN7Y6LEjz/+eMADrw8//DCdOnVi1qxZjBw5kuOPP57U1FSGDRtGWloaRx11FACXXXYZl112WYR7byoqrAHK31O6FRcI4oCJqrpYREYBWaqaCUwA3vCLILbgAg6+3tu4BRX5wC2quh8gVJv+lHcBGSLyMDDXt42InAZMBxoDl4jIg6raSVW3iMhDuEAKMKpwwYQxJnxUlZycHOrUqcMxxxxDIBDg4osvZsOGDYBbmNC+fXs2btxIp06duOKKK+jXrx+NGzcuo2UTSyyTRCWwTBLGHJ69e/eSmZl5QMbuzZs385e//IWRI0eyefNm7rjjDlJTU0lNTSUlJYWGDRtGutvmEJU3k4QFqEpgAcqY8ikoKOD7778vCkRJSUnccsst7Nu3j4YNG7J//35OPvnkokB03nnncdJJJ0W626aSWaojY0xE5efn8+OPP9KqVSsArrzySj766CN27twJuHcVFb5SIiEhgUAgwAknnECdOnUi1mcTXSxAGWMqxbJly/jvf/9bNDqaN28eLVq0IDs7G4C2bdsyZMiQoozdHTt2JCEhoej4jh07RqrrJkpZgDLGVMiePXtYuHAhgUCABQsW8Pzzz1OrVi2eeuopxo4dS8OGDUlJSWHEiBGkp6cXPWs0evToSHfdxBi7B1UJ7B6Uqa527dpFQkICCQkJvPfeezzwwAMsXryY/HyXoKVx48bMnz+f1q1bs2LFCvbv30+7du0OSAVkTEl2D8oYUyG7du0iKyuraIouEAiwdOlSPv/8c3r06EH9+vVp1qwZF110UdEDr0lJSUXZF0444YQIX4GpbixAGVMDbd26lblz5xIIBDjzzDPp3r07CxcupEePHgC0aNGC1NRUrrjiClq2dOkoL7zwQi688MJIdtvUMBagjKnm9u3bR0JCAr/88gtDhgwhEAiwatWqov0PPfQQ3bt3p3PnznzwwQekpqbSrFmzCPbYGMcClDHVyPr16w+YopszZw7nnnsukyZNon79+qxZs4b09HRGjBhR9KzR0UcfDUDdunXp27dvhK/AmGIWoIyJQarK2rVrCQQCbNu2jeuuuw5w03CLFy9GRDjxxBM5++yzOf/88wGXHmj27NkHa9aYqGIBypgoV7hMG2DixIlkZGQQCATIzc0F4JhjjmHo0KGICE899RRHHHEEnTt3pkGDBpHstjGHzQKUMVGkoKCA5cuXHzBNt3DhQtauXUu9evVYtWoVmzdv5tJLLy164PWUU04pCmC2iMFUJ/YcVCWw56DMocjPz2fp0qUEAgH69u1L06ZNeeaZZ7j99tsBlwqoc+fOpKam8tBDDxXdKzIm1tlzUMZEoZUrV/LEE08QCASYP38+e/bsAWD69Olceuml9O3bl0aNGpGSkvKrVEDG1DQWoIypZHv27GHBggUHrKS7+eabGT58OPn5+UyePJnU1FRuvvnmoldHnHjiiQC0b9+e9u3bR/gKjIkOFqCMOQy//PIL8+fPJz4+nq5du7Jz506aNGnCvn37AJcKKC0tjUaNGgGQnJzMtm3bLBWQMeVgAcqYCnr55ZeLsnZ/9913qCqXXHIJmZmZNGjQgEceeYQTTjiB1NRUjjvuuKIFDOCWegd/NsaULuyLJESkN/As7vXs41X10RL76wCTgDQgFxioqqv9vpHAcGA/8D+q+snB2hSRtkAGkAjMAa5V1b2lnUNEEoDxQCoueE9S1b+WdU22SKL6yc3NLUoFFAgE2L9/P++88w4AZ555JqtXryYtLa3oYdf09HRatGgR4V4bExuicpGEiMQBLwIXADnAbBHJVNUlQdWGA1tVtZ2IDAJGAwNFpCMwCOgEtAD+KSKFk/WltTkaeFpVM0RkjG/75dLOAfwWqKOqp4hIfWCJiLxVGCBN9fTTTz+xcOHCogdab7rpJl555ZWi/UlJSZxxxhlFzyN9+umn1K9fP1LdNabGCPcUX1cgW1VXAohIBtAfCA5Q/YEH/PY04AVxcyL9gQxVzQNWiUi2b49QbYrIUqAncLWv87pv9+WDnEOBI0QkHqgH7AV+rqyLN9FhwYIFTJ8+nTlz5hAIBFi3bh0AGzdupGnTpvTu3Zvjjz++aAFDYmLiAcdbcDImPMIdoFoCPwR9zgG6lVZHVfNFZDtuiq4l8E2JY1v67VBtJgLbVDU/RP3SzjENF7w2APWB21V1yyFdqYkoVWXNmjUHrKR76qmn6NChA1lZWTz44IOceOKJnHPOOaSlpZGSksKRRx4JwKWXXhrh3htjwBZJlNQVd3+rBdAY+FJE/lk4OgsmIiOAEQBt2rQJayfNgQoKCli5ciUNGjSgWbNmzJo1iz59+rBli/vdIi4ujk6dOhV9HjhwIFdeeaWlAjImyoU7QK0DWgd9buXLQtXJ8VNtR+EWMhzs2FDluUAjEYn3o6jg+qWd42rgY1XdB2wUkf8C6cCvApSqjgXGglskUd4fgDl8e/bsYdq0aUWjo7lz5/Lzzz/z6KOPctddd5GUlMQVV1xRNEV36qmnUq9evaLjjzjiiAj23hhTXuEOULOBZL+6bh1u0cPVJepkAkOAr4EBwOeqqiKSCbwpIk/hRjjJwCxAQrXpj5np28jwbc4o4xxrcfet3hCRI4DTgWeq4OdgyiE/P58lS5YUBaL27dtz6623UqtWLYYNG0ZcXBydO3dm8ODBpKSkcO655wIueerYsWMj3HtjzOEKa4Dy93tuBT7BLQmfqKqLRWQUkKWqmcAEXIDIBrbgAg6+3tu4BRX5wC2quh8gVJv+lHcBGSLyMDDXt01p58CtBnxVRBbjAt+rqrqgqn4eplheXh4bNmwgKSkJgH79+vHpp58WpQI64ogjil4pUbt2bZYsWUJSUhLx8TZLbUx1ZcliK4E9B1VxCxcu5D//+U/RSrpFixaRlJTE8uXLAbjnnnvIy8sres4oOTmZuLi4CPfaGFMZovI5KFPz7Ny5k3nz5hUFoTFjxlCrVi2effZZJkyYQGJiImlpafzxj38kLS2t6LhHHnkkgr02xkQDG0FVAhtBOdu2baN+/frUrl2bd955hz//+c8sW7aMwr9jxx57LHPnzqV58+asWrWKuLg4Wrdubal/jKlhbARlqtTOnTv5+uuvi6boAoEAK1as4Msvv+Sss87iqKOOon379lx11VVF03TBqYDatm0bwd4bY2KBBShTph9//LEoCPXs2ZMzzjiDhQsXFr29NSkpibS0NIYPH06rVq0A92ZXe7urMeZwWIAyRVSVPXv2UK9ePX7++WeuueYaAoEA69evL6pTu3ZtzjjjDLp06cJnn31GSkoKjRs3jmCvjTHVlQWoGmz16tXMmTPngGm6iy66iFdffZWGDRuyefNmevbsWZS1u0uXLkXpgOrVq0fPnj0jfAXGmOrMAlQNUFBQQHZ2NoFAgB07dnDDDTcA0KdPH7777jvi4+Pp2LEjF198Mb179wbce4u+/vrrSHbbGFPDWYCqZgoKCore1vryyy+TkZHB3Llz2bFjBwCtWrUqClAvvPACRx55JKeccgp169aNWJ+NMSYUC1AxbN++fSxZsuSAKbolS5bw448/UrduXdavX09eXh7XXntt0TRdp06dio4/77zzIth7Y4w5OHsOqhKE4zmovLw8Fi5cSCAQ4PLLL+foo4/mySef5M477wSgQYMGpKSkkJaWxn333UeTJk2qtD/GGHOo7DmoamD58uWMHj26KAtDfr57tVWLFi24+OKL6devHy1atCAtLY127doVTe0ZY0x1YAEqwnbs2MHcuXOLpugCgQB33HEHw4YNIz8/n8zMTFJTU/nTn/5U9MBr4UOuycnJJCcnR/gKjDGmaliAiqBt27bRpEmTolRAzZs3Jy0tjaZNmwLQoUMHNm7caKmAjDE1kgWoCGrUqBFPPvkkJ554IikpKTRv3vyA/RaYjDE1mQWoCLv99tsj3QVjjIlKdlfdGGNMVLIAZYwxJipZgDLGGBOVwh6gRKS3iCwTkWwRuTvE/joiMtXv/1ZEkoL2jfTly0SkV1ltikhb30a2b7N2Oc5xqoh8LSKLRWShiFgOIGOMiYCwBigRiQNeBPoAHYGrRKRjiWrDga2q2g54Ghjtj+0IDAI6Ab2Bl0Qkrow2RwNP+7a2+rYPdo54YDJwk6p2As4B9lXqD8EYY0y5hHsE1RXIVtWVqroXyAD6l6jTH3jdb08DzhO33ro/kKGqeaq6Csj27YVs0x/T07eBb/PSMs5xIbBAVecDqGququ6vxOs3xhhTTuEOUC2BH4I+5/iykHVUNR/YDiQe5NjSyhOBbb6Nkucq7RztARWRT0QkICL/V9qFiMgIEckSkaxNmzaV49KNMcZUhC2SOFA8cBZwjf/vZSISMuW3qo5V1XRVTS/M/GCMMabyhPtB3XVA66DPrXxZqDo5/p7QUUBuGceGKs8FGolIvB8lBdcv7Rw5wBequhlARD4EUoHPDnZRc+bM2Swiaw5+6WF1NLA50p2IgJp43XbNNUN1u+bjylMp3AFqNpAsIm1xQWIQcHWJOpnAEOBrYADwuaqqiGQCb4rIU0ALIBmYBUioNv0xM30bGb7NGWWc4xPg/0SkPrAX6IFbRHFQqhpVQygRySpPKvvqpiZet11zzVATrxnCHKBUNV9EbgU+AeKAiaq6WERGAVmqmglMAN4QkWxgCy7g4Ou9DSwB8oFbChcwhGrTn/IuIENEHgbm+rY5yDm2+gA4G1DgQ1X9oAp/JMYYY0phLyyshmrqb1s18brtmmuGmnjNYIskqquxke5AhNTE67Zrrhlq4jXbCMoYY0x0shGUMcaYqGQByhhjTFSyABWDRKS1iMwUkSU+qe3/+vIuIvKNiMzzWS66+nIRked8ctwFIpIa2SuoOBGpKyKzRGS+v+YHfXmFEwLHioNc8xSfHHmRiEwUkQRfXm2/56D9z4nIzqDPMf89w0G/axGRR0RkuYgsFZH/CSqP6e+6XFTV/sTYH6A5kOq3GwLLcYly/wH08eV9gX8FbX+Ee2bsdODbSF/DIVyzAA38dgLwrb+Wt4FBvnwM8Hu/fTMwxm8PAqZG+hoq8Zr7+n0CvBV0zdX2e/af04E3gJ1B9WP+ey7ju74OmATU8vuOqS7fdXn+2AgqBqnqBlUN+O0dwFJcfkEFjvTVjgLW++3+wCR1vsFl2Gge5m4fFt/3wt+cE/wfpeIJgWNGadesqh/6fYp7WL2Vr1Ntv2dxby14HCiZHzPmv2c46N/v3wOjVLXA19vo68T8d10eFqBinJ/SSMH9xnUb8LiI/AA8AYz01cqTpDfqiXu9yjxgI/ApsIKKJwSOKSWvWVW/DdqXAFwLfOyLquX37K/5ViBTVTeUqF4tvmco9bpPAAb6KfuPRCTZV68W33VZLEDFMBFpALwL3KaqP+N+27pdVVsDt1OcOaNaUNX9qtoFN2LoCpwU4S5VuZLXLCInB+1+CZc78svI9K5qhLjms4HfAs9HtmdVq5Tvug6wR91DuuOAiZHsY7hZgIpR/rfnd4Epqvo3XzwEKNx+B/ePOJQvSW/MUNVtwEygOz4hsN8VKiFw4YsoCxMCx6Sga+4NICL3A02BO4KqVdfv+VygHZAtIquB+j5NGVSz7xl+9V3nUPz/9HTgVL9drb7r0liAikF+jn0CsFRVnwratR6X4BbcvZnv/XYm8Du/8ud0YHuIqZKoJiJNRaSR364HXIC791aYEBhCJwSGoITA4evx4Svlmr8TkeuBXsBVhfcmvOr6Pc9R1WaqmqSqScAudW/DhmrwPUPp3zXwHi5Ag/t/e7nfjvnvujzCnc3cVI4zcfceFvo5a4D/B9wAPOt/k9wDjPD7PsSt+skGduFWBsWa5sDr/mZ5LeBtVX1fRJZQgYTAMaa0a84H1gBf+/UAf1PVUVTj7/kg9avD9wylf9f/AaaIyO3ATuB6X786fNdlslRHxhhjopJN8RljjIlKFqCMMcZEJQtQxhhjopIFKGOMMVHJApQxxpioZAHKGGNMVLIAZYwxJipZgDImBojI9eLe8zVPRAqCtp8u47h6IvJv/wAoJd6l1Ne/Z+g4EaktIl8EpY0yJuLsQV1jYoiItAS+UtXjyln/FiBeVZ/1n3eqagMROQ94Beilqiv8vvuBbFWdUkXdN6ZCbARlTGw5GVhYgfrXUJyfEACfHXwccHFhcPLe8/WNiQo2nDcmtpwCLCpPRRGpDRyvqquDiuvgAtE5qvpdiUMWAadVRieNqQw2gjImtlRkBHU0sK1E2T7gK2B4ycqquh/YKyIND6uHxlQSC1DGxJZfjaBE5AEReVZE/lyi7m6gbomyAuBK3Avx/l+I9uvgMuEbE3EWoIyJESJSC0jGvQersKwlbqp+G+41LEVUdSsQJyJ1S5TvAi4CrhGR4UFtJQKbVXVflV2EMRVg96CMiR3tgBxV3RtU9hDwv7i367YOccw/gLOAfwYXquoWEekNfCEim1Q1E/divA+qpOfGHAJbZm5MDBORPwJHAonAMlV9vsT+VOB2Vb22HG39DbhbVZeXVdeYcLARlDExTFWfLGN/QERmikicXwQRkl/x954FJxNNbARljDEmKtkiCWOMMVHJApQxxpioZAHKGGNMVLIAZYwxJipZgDLGGBOVLEAZY4yJShagjDHGRKX/DyaAEn5k0VXsAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "vdict = Variable.__defaults__.copy() \n", "expr = eq_nua.subs(vdict)\n", "exprr = eq_ka.subs(vdict)\n", "xvar = T_a\n", "yldata = [(expr.rhs, 'full'), (expr.rhs/2, 'half')]\n", "yrdata = exprr\n", "fig=plot_expr2((T_a, 273, 373), yldata=expr, yrdata=exprr, yrmin=-0.0001, fontsize=14) # note that yrmin=0 would have no effect\n", "fig=plot_expr2((T_a, 273, 373), yldata=expr, yrdata=exprr, colors=['red', 'blue'], linestylesr=['--'])\n", "fig=plot_expr2((T_a, 273, 373), yldata, yllabel = (nu_a), yrdata=yrdata)\n", "fig=plot_expr2((T_a, 273, 373), yldata, yllabel = (nu_a), yrdata=[(1/exprr.rhs, 1/exprr.lhs)],\n", " loc_legend_right='lower right')\n", "fig=plot_expr2((T_a, 273, 373), expr)\n", "fig=plot_expr2((T_a, 273, 373), yldata, yllabel = (nu_a))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also manipulate the figure later, e.g. change the width:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%matplotlib inline\n", "fig.set_figwidth(8)\n", "fig" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Creating new variables\n", "To create custom variables, first import `Variable`:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "from essm.variables import Variable" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To define units, you can either import these units from the library,\n", "e.g.\n", "\n", "`from essm.variables.units import joule, kelvin, meter`\n", "\n", "or import the appropriate units from sympy, e.g.\n", "\n", "`from sympy.physics.units import joule, kelvin, meter`" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "from sympy.physics.units import joule, kelvin, meter, mole, pascal, second" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then you can define a custom variable with its name, description, domain,\n", "latex_name, unit, and an optional default value, e.g.:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:R_mol\" will be overridden by \"__main__:\"\n", " instance[expr] = instance\n" ] } ], "source": [ "class R_mol(Variable):\n", " \"\"\"Molar gas constant.\"\"\"\n", " unit = joule/(kelvin*mole)\n", " latex_name = 'R_{mol}'\n", " default = 8.314472" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The variables defined above hold information about their docstring, units, latex representations and default values if any. Each can be accessed by e.g.:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Molar gas constant.\n", "J/(K*mol)\n", "R_{mol}\n", "8.314472\n" ] } ], "source": [ "print(R_mol.__doc__)\n", "print(R_mol.definition.unit)\n", "print(R_mol.definition.latex_name)\n", "print(R_mol.definition.default)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will now define a few additional variables. " ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:P_wa\" will be overridden by \"__main__:\"\n", " instance[expr] = instance\n" ] } ], "source": [ "class P_g(Variable):\n", " \"\"\"Pressure of gas.\"\"\"\n", " unit = pascal\n", "\n", "class V_g(Variable):\n", " \"\"\"Volume of gas.\"\"\"\n", " unit = meter**3\n", " \n", "class n_g(Variable):\n", " \"\"\"Amount of gas.\"\"\"\n", " unit = mole\n", " \n", "class n_w(Variable):\n", " \"\"\"Amount of water.\"\"\"\n", " unit = mole\n", "\n", "class T_g(Variable):\n", " \"\"\"Temperature of gas.\"\"\"\n", " unit = kelvin\n", " \n", "class P_wa(Variable):\n", " \"\"\"Partial pressure of water vapour in air.\"\"\"\n", " unit = pascal\n", " latex_name = 'P_{wa}'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Variables with expressions as definitions" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "class Delta_Pwa(Variable):\n", " \"\"\"Slope of saturated vapour pressure, $\\partial P_{wa} / \\partial T_g$\"\"\"\n", " expr = Derivative(P_wa,T_g)\n", " latex_name = r'\\Delta'" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAqBAMAAABSACYXAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZqu7zZkQ7zKJVHZEIt2ubTYdAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABDUlEQVQoFWNgYBD6b6TkmsAAB18YGJjL4DyOnwwMXL/hXO4/DAzcQCEoYP7AwMAEFIICfgcGhvsBDLyR0WAD+icwcL1kYDh+gQWojIFhv+bM6AQGtkIGVgMQ1z4BRLJ+Y+DbAGL8AxEM7AYM+Q1AmuMriMeQP4FhPYgGWQsE+QsYVLguMDCwfANzmTcwPuIEGuH/CWwCm/aOS3vAEgNC/EcB1HbCpv9ODAz6Xxpg5gJjiWExMCgggAcYJYwLYDwGzj8MbHPhPAZg8HcieAz8DowBSNzzE/Y/QOLO3836C4nrL8ALsgoGPgPjrQHGYeABJozzCnAu5w8GBj5I1IDE+D4gp5VUUCzt+28LkgEAHQpRBYpNYdsAAAAASUVORK5CYII=\n", "text/latex": [ "$$\\frac{Pa}{K}$$" ], "text/plain": [ "Pa\n", "──\n", "K " ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Delta_Pwa.definition.unit" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEUAAAAxBAMAAAB+EHnNAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAMrvvmVREEIndzSJ2Zqtw62vAAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAB60lEQVQ4EYWUP0gjQRTGv90kbiSJW2ifA/sTrxCuONhOORC2FeQMWFmIKeyzhYU2oo12EkGuE7c7sDBR/HNwh7E4/FPd1iEkIkrEwtxsMjve7JuJr9n3/b43s5s3kwfwMEadKNU/bVfvRc5SMcr0zzW9JZw9kWmSzNTxk8YSeN4320KoE+sLkmW1JWiyjUFPKHWS+IBSQW0JWvIwJ4QmKbmop3yNybFZze2k+5fAahwfnb9TI9u51kOzPikzouwyMPrOEec9YK5KlkqgVgBqnoSIGGOkVSBYAi9A5lEiRBjPwIxHsASyr6srFxKhglylTizuAXuDrouTvMPIwCUOrW0sX+7G7a4O24O0XTzBd2vTUN/hg/AYfiyggV9Jx1C++GunEW43hQl4CTcbhEITW1Yb1ZJv3oS7go2Dyqdm52Od9e4tdlP3OT/h5xd7yHZXgc/A9FsFMHL25wwDjVkOl4pB94Cu/6+J5WvGFXLsv9zvAPYMYIj1oRBbKyQfBwllH3gVHwcVR6wiSTQO/rrEEiAaB61uqwSWkmgcsPZog4+D3v29/R2oCvk4CNuDbGA67EGCj4Pu/az4pvLLe+Ng/eCFXYg72H2+vLf9OobJe+LgG5pxRHTy5z5hFIxTJJNMkCrLhKrM/qnyZ/0Dg7KNiZG4tPAAAAAASUVORK5CYII=\n", "text/latex": [ "$$\\frac{d}{d T_g} P_{wa}$$" ], "text/plain": [ " d \n", "────(P_wa)\n", "dT_g " ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Delta_Pwa.definition.expr" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
SymbolNameDescriptionDefinitionDefault valueUnits
$\\Delta$Delta_PwaSlope of saturated vapour pressure, $\\partial P_{wa} / \\partial T_g$$\\frac{d}{d T_g} P_{wa}$-Pa K$^{-1}$
" ], "text/plain": [ "[('Symbol', 'Name', 'Description', 'Definition', 'Default value', 'Units'),\n", " ('$\\\\Delta$',\n", " 'Delta_Pwa',\n", " 'Slope of saturated vapour pressure, $\\\\partial P_{wa} / \\\\partial T_g$',\n", " '$\\\\frac{d}{d T_g} P_{wa}$',\n", " '-',\n", " 'Pa K$^{-1}$')]" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "generate_metadata_table([Delta_Pwa])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Linking assumptions to variables\n", "We can specify if a given variable is a complex, real, integer etc. by using the `assumptions` property during variable definition:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1]\n" ] } ], "source": [ "class x(Variable):\n", " \"\"\"Positive real variable.\"\"\" \n", " assumptions = {'positive': True, 'real': True}\n", "\n", "print(solve(x**2 - 1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Creating new equations\n", "Equations have a left hand side and a right hand side and if they contain variables with units, the units of each addend must be the same.\n", "\n", "### Custom equation\n", "To create custom equations, first import `Equation`:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "from essm.equations import Equation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will now define an equation representing the ideal gas law, based on the variables defined above:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "class eq_ideal_gas_law(Equation):\n", " \"\"\"Ideal gas law.\"\"\"\n", " \n", " expr = Eq(P_g*V_g, n_g*R_mol*T_g)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that whenever an equation is defined, its units are checked for consistency in the background and if they are not consistent, an error message will be printed. To illustrate this, we will try to define the above equation again, but omit temperature on the right hand side:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dimension of \"R_mol*n_g\" is Dimension(length**2*mass/(temperature*time**2)), but it should be the same as P_g*V_g, i.e. Dimension(length**2*mass/time**2)\n" ] } ], "source": [ "try:\n", " class eq_ideal_gas_law(Equation):\n", " \"\"\"Ideal gas law.\"\"\"\n", "\n", " expr = Eq(P_g*V_g, n_g*R_mol)\n", "except Exception as exc1:\n", " print(exc1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The equation can be displayed in typesetted form, and the documentation string can be accessed in a similar way as for Variable:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJ8AAAAUBAMAAABhQvLIAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZqu7zZkQ7zKJVHZEIt2ubTYdAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACm0lEQVQ4EXWTzWsTQRjGn2Tzsdl0u0v1ohS7BhFKkdb2INiDqVjwIkm9iZfFf6CioKEHya0HwSylCMFDg/9Al9aIRbB7Ey8SclDQQ3Lw4m3tl1+t8Z2d3c1kk7yQnd887/POzsy+ATDWmc0tmqB41bkKPPtZZNwbY53c3OVeCWg9zHVmL/yOysABID1icooIisEwGvvAZyMiVoEnwFJEBWR6h/LXkx/TM95nIEGmfPxXJGNAPQTGIyqQPaYf33iBkm/6DCRkT4BR+okh64j9AV6LmseSS2+nRSmmG1AtjyIP6T6wOdMrylR2BDi9Ks20PN1v0ZM3nMEnhmZAedBXiXTb1z5c+lq3fUbFgvKdTyZs4cTrN1gsepnK+a3DclDgjfdcGvx9ANacnQpvZHeyetfk5kpx8Imxa+K07+FOjLQJJmp8Jte+QQ2/2TWTq/Rcnhn4jYErdDNWaGOQYZc0bTKkfksdI8a27MW/AKioPd6diLRHxzNEAZJOU2pDHoqLeJ4jZOolijNvDeqMI7YNDwF+h9dZUv5BH7mI2NLTenarDLyoQmvAa0NuT+ah6SavZG1IjWZIRfrD7JsBMjGMLN3Php2KvdfTF7MGEk5cX6Uka0NembawaVp8kQT1Eh2oIdWAJFucIxPDSLi0Q/vLp3fQnKSF28gY25SUWKlnbzlYj5U9TBb2bJLPQTPplQYCJAiDPDoy8zamsIrRGlYgWfPAWuFgyrd/BJpn/UV42RpZ/RAwkIKxhG20ZJxguVwq99vFypfIBVUCBpI/qi7t8VQGNzEJl52LhWAXEMmdBZ6ni+xiIPnjiIFbaD5Hc6eGO44vCnYBKVnyDb3YFYfToErVUPJ+hYDD1+hmBLuAUBfqZrBgF7tlwyla+R/4trDIL59RwAAAAABJRU5ErkJggg==\n", "text/latex": [ "$$P_g V_g = R_{mol} T_g n_g$$" ], "text/plain": [ "P_g⋅V_g = Rₘₒₗ⋅T_g⋅n_g" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Ideal gas law.\n" ] } ], "source": [ "display(eq_ideal_gas_law)\n", "print(eq_ideal_gas_law.__doc__)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### New equation based on manipulation of previous equations\n", "We can use the above equation just as any Sympy expression, and e.g. solve it for pressure:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[{P_g: R_mol*T_g*n_g/V_g}]\n" ] } ], "source": [ "soln = solve(eq_ideal_gas_law, P_g, dict=True); print(soln)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we want to define a new equation based on a manipulation of eq_ideal_gas_law we can specify that the parent of the new equation is `eq_ideal_gas_law.definition`:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAI8AAAAwBAMAAADa0TQAAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZqu7zZkQ7zKJVHZEIt2ubTYdAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADEUlEQVRIDb1W30sUURT+dsfVmVlnZ7EeiiSviwTig2ZEkA9pJPQSrhFB+DL0D6wklPUQ+yYU5CISiA8u0bvLmpEIuW+9ikRBELuvva0/+6Vt587M/pjVubOj0QF3zjnfd87eO/d+ZwVE1laKXbpYT8hPxEr9XT/r0+J4G/jM6ihzwFNgtC4rDuXfQPBHHYdB2wXa67LiMHwAROiv1uQoAr+At7U5T18aBxb7nDSZFrkH5JxZj0hnUB8c5rQUrFzrzNfVscPwEZnpzuxu0pG/X6QwH7dyijSAxLoDdwnWDJw2HFhrgcKOtJV7FhlEPmn54s8rgJ5yUBS+mF7DyhmJHDocsFuwRdtgDlCKUkjXyLJFoKvsi57yJh1aHIHR58vhbBKYn4NOr4RfI+DsKsMdYLMZgfmsqAthYbqLC5nmwIdoy4UwQ1MuGJ2iNL9GCDMpjsdQ9xRkcdmjUVORVpT58uk99FwohdtQ2BKVSHSNkF+X0to+lMEz2gGuihuFRraiUAYy6MEUImk8gZQaAGZGdnqA89ANOkKtMx0ogHcG2kr9sWHDdF0+JrGEvIwDJJKTSZszQ80tU5g8bnk7tNqHdvaoh1akNZ1ScBPdKGZsxivEbE9lQWa6Mo0WlWTuaq0Mt7DxEhsradzL2bTQylC5YGw2arrhfToDn3OKF06WG6ElaboSnU2QmvkyjamDdsEGXlueTpmyDG3M+6ENLRs26+O5u5Y3nYL6rVw6e4PbcDn09VzrnhszfFW4kK+5dSn5MHrP+OPyBX7TsqllU8xUar2j636bcD6/RraYuXN8azIVx8V8/B68kiTO5cPFzMMTW1XMglZvSjR4XnyPCyioilnAaqY5AZUJGLTDqpgFvEeEBQW4CVXF7M4cIeidO0xIjZhFvN51aCkRATViFvEWct47E9VXsI6Mx84qTA9nOu6xM4/6Cpzo8zyzClfo6IV2Id4wGNnjZ8Z/9U9o0rbxTwYFQnzknHxQ0P8hjBr930FBX+hpDQ0Kzy5EaGxQNNKp5le/IboLqcFB4VJdk3YZFH8BPKzacURMNHkAAAAASUVORK5CYII=\n", "text/latex": [ "$$P_g = \\frac{R_{mol} T_g n_g}{V_g}$$" ], "text/plain": [ " Rₘₒₗ⋅T_g⋅n_g\n", "P_g = ────────────\n", " V_g " ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class eq_Pg(eq_ideal_gas_law.definition):\n", " \"\"\"Calculate pressure of ideal gas.\"\"\"\n", " \n", " expr = Eq(P_g, soln[0][P_g])\n", "eq_Pg" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also have nested inheritance, if we now define another equation based on eq_Pg:" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJ8AAAAwBAMAAAD9f7XoAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZqu7zZkQ7zKJVHZEIt2ubTYdAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADMUlEQVRIDa1WTWjTYBh+0vQnada1TBH8/ywijCHODRXcYR0o7CLrPAjSg0HwIIgdijI8SG87iCyMIYwdrMObh5aOCUNw8SQiSCmiqIf24EFPm/tD3WZ902SypDZNtryQ5Huf93mffL9vAjS3tmq8+6SVVr4dr3Yd/WWFnflLwEdmoU4A94FBC+rMFdYA308LlyGyAhywoM5caQNopWurCTFwv4HnWzHHbX4IyHWa6QJ1ehVQzahDL8oQvlXPDVUM7M3xLzP5+nhjZPRIYSVjCl9dILecNDClOx+0zIiJXefMydgtm9CWCrmHszomZL8iYl0zPdTgfgaIKqaYqHXuhKxjweA6OK3Ljm2RhsdMbD5GLm1D3cIL8CX0pqO78IMWOQlu8MGMVMgAkxOIFlHbhsDeFwyBBKIx+S2LJG7KThQlmp/H+SD3OhY6JjH4VV9shPK0bQiJ8UmEFORkRVmVOv2qE0E/zU8u//nDS0TVgIKLENk05fG0DVEu8lmUVYxzD29UfHmJet7UAgOLMYg9eXRgBK1Z3AOv9ABjA8sdwCFEZbwDSvsQUEKqWFNrq3bFz8tNhTGMaZQFbCCdGc4Y9DF6iWGtalqW9PYy9f/uJt7wGVmgPu4S0Y92LOQN2hTimwn+TA4Ha45ARS1MBaWJtTBcQOkRSrNZXFYNcmC2bzNNSD1JZWuOtE6rtc1KCZqIOuNpFX0kug2LsHCiPi1K2L+DXh+2QyJ9M3J9fFRB+LsZFs/VLGlGnXpz7RMp2SnZCa/XXq3qymg98MfJW11wBPp4AUatuFbo1zxjDpnWdm3aNgT0WhH8JmhHfmfm1yQieq0IJIXKztQAKibawdRrRShLBc8b02tFusjvkZsKSgNLWQjzd2yJeq0IFUdf2dL0YDpBzyl7ol4rWjqeOfn9CQ2RGLMXdBXVPgpSxlWKPdlH/wmf7CnuoiJtXeYuxZ7NrXk7YtBp9XTECC55O2IqUJxqPyluo/PXKYObLLjNa8jvPU2hAk41JLgNXFGpQG3grNu8hvw2inAV7Lx2bn2DyATtSHtnYeZj3qlpSqnxmLeCCGU8FSzhqad6eL//0v8E/wKw2fO+j5j4zwAAAABJRU5ErkJggg==\n", "text/latex": [ "$$P_{wa} = \\frac{R_{mol} T_g n_w}{V_g}$$" ], "text/plain": [ " Rₘₒₗ⋅T_g⋅n_w\n", "P_wa = ────────────\n", " V_g " ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class eq_Pwa_nw(eq_Pg.definition):\n", " \"\"\"Calculate vapour pressure from amount of water in gas.\"\"\"\n", " \n", " expr = Eq(P_wa, eq_Pg.rhs.subs(n_g, n_w))\n", "eq_Pwa_nw" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Show inheritance of equations\n", "To see the inheritance (what other equations it depends on) of the newly created equation:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(__main__.eq_Pg,)" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eq_Pwa_nw.definition.__bases__" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['eq_Pg']" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[parent.name for parent in eq_Pwa_nw.definition.__bases__]" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJ0AAAAyBAMAAAC0QsTeAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMA74lUIhAyZqu7zZl2RN1RZXl/AAAACXBIWXMAAA7EAAAOxAGVKw4bAAADgUlEQVRIDa2Xz2sTQRTHv90km2yTNtVi0YuGglCk0BzFSyNtoXhJjt6S4lVs8CBVrF0K0lAKrXiwYsEexIo9NAhSkR5CQUltsfE/CP4FUVv7yxrf7O5sshun2V36YDNv3nvz2Zmd3W92can6E6dkUrXagc7BoVPCITA40IGuJrSxau75M3tN8kKuOj/duDC5OQ8HwHXVBuwGLgKrtijggCf/AUK/bSNV+I+AcVvUES+yA7TTUW9yFsFfwKf6mOY7mJ/SAfTPWUfKNOVdoGSNUs8BL6rCd75hIFrKeqytZ3BrzUw74I1OFY8y5gDm3KzQTzKvxyRlAemE7jua33YKD1K8XmvbytRMxPXYrfZFJDO674j3BIjGeL3WSmxqs8Y5UukSJsy0g/Xu09pUcwBzlCz90O2nWz8wzX0H+yHv0fbmEVy9vRkpZoDebkQT0G4/4O6Wio/AXgDB3iKDNp9fhG7lvkIg+C3b8jiiorUUyo7QQHb7IaIqeZyFb1dCES+c8VorNL/CwNBXREvhGD5AUjdopEK3H5IJJe4/hrR4z7+Dp4544ZX9LKSFAmYwgvY4OqHEFoCelcMZ4BGiKdps/1Q8WAY7gbnesep8btnYMRZvtC5sICljB+lMV8ZI99A5dJNUunJk5vU7pCWcM5L/a/wVmuF9Ca8xiUrBqLiKnOH51JDKXM6TScp8JCRCa1PxCsOXMbwex7uSURZeX+ID1q5kmct5kWParUZ55NXCtibGLRlWxHlKhRSDmK7Mr/oWjQHDuKZ5nBelBH/CjZLmjX9pM2VU3Xj4XvM4bzQG33dOuPKW2TLvumk5b3uye42fy814ey3nvRTBqi6M9oDz/tpP5LFv8GT6syJjckGmX783zHVrBo/dfoZcuCVY6w1eq/YwM7mwpl33dB6JSIGGMrlwTbAOMOanB2tyYS2y9L5USeju/MhbgmbHwqvJhZlvdAKkRPCpjQktYuHVyYWgnIXP0BES5S08NH13Y5gVOj474dXJhaicxWcT8MdEBfXzq5MLUTmL95XEyzWft5MAttxEQbxcL7zRvHi5XnjpOeHu1vTFtqaTutHyuDhdvx/iKkumfTdGfUOKLBnqeOApB/SQa28udpg3Xphpm0iKPMwvqBJPJEUeeESj9yHzzUXrmj9eeSIp8soTSZFXnkiKiOfle1UgRdr3qpfvaYEUse/pf1is+IJ7vGmCAAAAAElFTkSuQmCC\n", "text/latex": [ "$$\\left [ P_g = \\frac{R_{mol} T_g n_g}{V_g}\\right ]$$" ], "text/plain": [ "⎡ Rₘₒₗ⋅T_g⋅n_g⎤\n", "⎢P_g = ────────────⎥\n", "⎣ V_g ⎦" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[parent.expr for parent in eq_Pwa_nw.definition.__bases__]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also use a pre-defined function to extract the set of parents:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'eq_Pg'}" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from essm.variables.utils import get_parents\n", "get_parents(eq_Pwa_nw)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can use another function to get all parents recursively:" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'eq_Pg', 'eq_ideal_gas_law'}" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from essm.variables.utils import get_allparents\n", "get_allparents(eq_Pwa_nw)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Computational burden of deriving equations within class definition\n", "If we solve for a variable to derive a new equation, is the solve() command performed every time this equation is used?" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[{P_g: R_mol*T_g*n_g/V_g}]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/stan/Programs/essm/essm/equations/_core.py:107: UserWarning: \"__main__:eq_Pg\" will be overridden by \"__main__:\"\n", " instance[expr] = instance\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAI8AAAAwBAMAAADa0TQAAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZqu7zZkQ7zKJVHZEIt2ubTYdAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADEUlEQVRIDb1W30sUURT+dsfVmVlnZ7EeiiSviwTig2ZEkA9pJPQSrhFB+DL0D6wklPUQ+yYU5CISiA8u0bvLmpEIuW+9ikRBELuvva0/+6Vt587M/pjVubOj0QF3zjnfd87eO/d+ZwVE1laKXbpYT8hPxEr9XT/r0+J4G/jM6ihzwFNgtC4rDuXfQPBHHYdB2wXa67LiMHwAROiv1uQoAr+At7U5T18aBxb7nDSZFrkH5JxZj0hnUB8c5rQUrFzrzNfVscPwEZnpzuxu0pG/X6QwH7dyijSAxLoDdwnWDJw2HFhrgcKOtJV7FhlEPmn54s8rgJ5yUBS+mF7DyhmJHDocsFuwRdtgDlCKUkjXyLJFoKvsi57yJh1aHIHR58vhbBKYn4NOr4RfI+DsKsMdYLMZgfmsqAthYbqLC5nmwIdoy4UwQ1MuGJ2iNL9GCDMpjsdQ9xRkcdmjUVORVpT58uk99FwohdtQ2BKVSHSNkF+X0to+lMEz2gGuihuFRraiUAYy6MEUImk8gZQaAGZGdnqA89ANOkKtMx0ogHcG2kr9sWHDdF0+JrGEvIwDJJKTSZszQ80tU5g8bnk7tNqHdvaoh1akNZ1ScBPdKGZsxivEbE9lQWa6Mo0WlWTuaq0Mt7DxEhsradzL2bTQylC5YGw2arrhfToDn3OKF06WG6ElaboSnU2QmvkyjamDdsEGXlueTpmyDG3M+6ENLRs26+O5u5Y3nYL6rVw6e4PbcDn09VzrnhszfFW4kK+5dSn5MHrP+OPyBX7TsqllU8xUar2j636bcD6/RraYuXN8azIVx8V8/B68kiTO5cPFzMMTW1XMglZvSjR4XnyPCyioilnAaqY5AZUJGLTDqpgFvEeEBQW4CVXF7M4cIeidO0xIjZhFvN51aCkRATViFvEWct47E9VXsI6Mx84qTA9nOu6xM4/6Cpzo8zyzClfo6IV2Id4wGNnjZ8Z/9U9o0rbxTwYFQnzknHxQ0P8hjBr930FBX+hpDQ0Kzy5EaGxQNNKp5le/IboLqcFB4VJdk3YZFH8BPKzacURMNHkAAAAASUVORK5CYII=\n", "text/latex": [ "$$P_g = \\frac{R_{mol} T_g n_g}{V_g}$$" ], "text/plain": [ " Rₘₒₗ⋅T_g⋅n_g\n", "P_g = ────────────\n", " V_g " ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class eq_Pg1(eq_ideal_gas_law.definition):\n", " \"\"\"Calculate pressure of ideal gas.\"\"\"\n", " from sympy import solve\n", " soln = solve(eq_ideal_gas_law, P_g, dict=True); print(soln)\n", " expr = Eq(P_g, soln[0][P_g])\n", "eq_Pg1" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 3 µs, sys: 2 µs, total: 5 µs\n", "Wall time: 8.34 µs\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGoAAAAUBAMAAACXJ7UVAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZqu7zZkQ7zKJVHZEIt2ubTYdAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABpElEQVQ4EZ2Svy9DURzFT99ri/dCE5tIpGwGiZgkBm2DVUM6Wd7SQQyqksZoEenUhqkTsdksBhHhP1CTSTTdbAj123O+997kSWtoneG+ez7f873v3vsegH5/YmTWQ4uyi5PCtoBsZcxUxWiMJ8AutDRF49i7IK0juoZrT9dpDO5+A5wPTX+NEQ9dOcDNw8rBSqsKjcFwP1ljZ5O6arC+gKsUYgn03KsqjcGwSSx2NincgPUKlFNYHYfLforGYFkKt3oHqhQMfQ2Eqlye71KriqGIgVIZzp2J9swomTUuy1hBSrYXfpCAGIoYOB+tLHniWlTnniQ4hcN3KSojt0pNezL+oUgazqZ0OYNFntAYEFPffzQodAwsQ2/KkqMYQwx0P6vIwGmcT3MumcJJ4+Ygk3lZ4jwsRBvB/FTqety43XyNReCM2TxCBZSqnCkDjfkBqNuqvS/PQL13lYUa7TrcuWgSUf53YjSOzD8e0Q4h5gkOFPZ9vwbs+sOoZC70zdEYrHM72A4a2p4dYKTtbBCMnCQD08Fso4OsifbGncQ/upLHXgddP35BeqiFu0v3AAAAAElFTkSuQmCC\n", "text/latex": [ "$$P_g = 249.42$$" ], "text/plain": [ "P_g = 249.42" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%time\n", "eq_Pg.subs({R_mol: 8.314, T_g: 300, n_g: 0.1, V_g: 1})" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 3 µs, sys: 1 µs, total: 4 µs\n", "Wall time: 7.87 µs\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGoAAAAUBAMAAACXJ7UVAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZqu7zZkQ7zKJVHZEIt2ubTYdAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABpElEQVQ4EZ2Svy9DURzFT99ri/dCE5tIpGwGiZgkBm2DVUM6Wd7SQQyqksZoEenUhqkTsdksBhHhP1CTSTTdbAj123O+997kSWtoneG+ez7f873v3vsegH5/YmTWQ4uyi5PCtoBsZcxUxWiMJ8AutDRF49i7IK0juoZrT9dpDO5+A5wPTX+NEQ9dOcDNw8rBSqsKjcFwP1ljZ5O6arC+gKsUYgn03KsqjcGwSSx2NincgPUKlFNYHYfLforGYFkKt3oHqhQMfQ2Eqlye71KriqGIgVIZzp2J9swomTUuy1hBSrYXfpCAGIoYOB+tLHniWlTnniQ4hcN3KSojt0pNezL+oUgazqZ0OYNFntAYEFPffzQodAwsQ2/KkqMYQwx0P6vIwGmcT3MumcJJ4+Ygk3lZ4jwsRBvB/FTqety43XyNReCM2TxCBZSqnCkDjfkBqNuqvS/PQL13lYUa7TrcuWgSUf53YjSOzD8e0Q4h5gkOFPZ9vwbs+sOoZC70zdEYrHM72A4a2p4dYKTtbBCMnCQD08Fso4OsifbGncQ/upLHXgddP35BeqiFu0v3AAAAAElFTkSuQmCC\n", "text/latex": [ "$$P_g = 249.42$$" ], "text/plain": [ "P_g = 249.42" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%time\n", "eq_Pg1.subs({R_mol: 8.314, T_g: 300, n_g: 0.1, V_g: 1})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is actually no difference!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Empirical equations with internal variables\n", "Empirical equations not only contain variables but also numbers. As an example, we will try to define the Clausius-Clapeyron equation for saturation vapour pressure in the following example, after defining a few additional variables used in this equation.\n", "$$ P_{wa} = 611 e^\\frac{-M_w \\lambda_E (1/T_g - 1/273)}{R_{mol}}$$\n" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:lambda_E\" will be overridden by \"__main__:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:M_w\" will be overridden by \"__main__:\"\n", " instance[expr] = instance\n" ] } ], "source": [ "from sympy.physics.units import joule, kilogram\n", "class lambda_E(Variable):\n", " \"\"\"Latent heat of evaporation.\"\"\"\n", " unit = joule/kilogram\n", " latex_name = '\\\\lambda_E'\n", " default = 2.45e6 \n", "\n", "class M_w(Variable):\n", " \"\"\"Molar mass of water.\"\"\"\n", " unit = kilogram/mole\n", " default = 0.018" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dimension of \"1/T_g\" is Dimension(1/temperature), but it should be the same as -0.00366300366300366, i.e. Dimension(1)\n" ] } ], "source": [ "from sympy import exp\n", "try:\n", " class eq_Pwa_CC(Equation):\n", " \"\"\"Clausius-Clapeyron P_wa as function of T_g.\n", "\n", " \\cite[Eq. B3]{hartmann_global_1994}\n", " \"\"\"\n", "\n", " expr = Eq(P_wa, 611.*exp(-M_w*lambda_E*(1/T_g - 1/273.)/R_mol))\n", "except Exception as exc1:\n", " print(exc1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The unit mismatch reported in the error message stems from the fact that the numbers in the empirical equation actually need units. Since the term in the exponent has to be non-dimensional, the units of `611` must be the same as those of `P_wa`, i.e. pascal. The units of the subtraction term in the exponent must match, meaning that `273` needs units of kelvin. To avoid the error message, we can define the empirical numbers as internal variables to the equation we want to define:" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "class eq_Pwa_CC(Equation):\n", " \"\"\"Clausius-Clapeyron P_wa as function of T_g.\n", "\n", " Eq. B3 in :cite{hartmann_global_1994}\n", " \"\"\"\n", " \n", " class p_CC1(Variable):\n", " \"\"\"Internal parameter of eq_Pwl.\"\"\"\n", " unit = pascal\n", " latex_name = '611'\n", " default = 611. \n", " \n", " \n", " \n", " class p_CC2(Variable):\n", " \"\"\"Internal parameter of eq_Pwl.\"\"\"\n", " unit = kelvin\n", " latex_name = '273'\n", " default = 273. \n", " \n", " expr = Eq(P_wa, p_CC1*exp(-M_w*lambda_E*(1/T_g - 1/p_CC2)/R_mol))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the above, we defined the latex representation of the empirical constants as their actual values, so the equation displays in the familiar way:" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAAsBAMAAAC3ThhGAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZqu7zZkQ7zKJVHZEIt2ubTYdAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEg0lEQVRYCc1XXYgbVRT+ksn8ZfKnsNVaxeCDuLTiouiT0BG2UBA1LaZQd5Vr7VJE2cSXPvTFgSpSBZsVRddYmIoiZUVDoQ/rD5tSEaUgAZXqgzYvlvogrGILi7XruTOZycwkk0z+wAO593zf/c45c2bm5ibARCzV6J82Xe+vGVZxPkrgzVFEQ2nShShhKouiGkYjRAqSZiLJhhBt88Xc6UME4sxm3gsujAv7Gjt2OJBWeZvZzDOBhXFBJe/LdMmHCGSYzcQNex73qOZ8GUPrx2o+3eBA/RO4cLcdpzzixicarssdt77aop3+Fd9z8sVEA+kicJMjPe04kF3Pctz6Yot36qPsFw6MYi8hec6JkpnjLTqOPU+uvibjp1WnmFoAxI3lncAPDmXNr10xW7jVv7L2RItwr6yFB500wTB3OEEq7bNUE3HgqEP5ZrX4VNEp3FpovzI+ZWTwtHorO4xTtR9VE5jfD2j5tGb3v1AsFk1sto2S8v6zDrNOYNT636QelJr4uLAtlYNQvwAIteckoP38BbyOJ38pCPUPqJpVHwWlLNU4Ihvx/id/k/JHj0A0d9B5+y7EGuTpy5S2/f4nUIKhMgnLvJz1/M1YXjI4IuP3YHRLsD/oplt2EWaKvt88OT8BzgLHZjhlv39xp3tIukc4vJtcWv2yFU23mVyx7iaT6BHrhL7ijMIHZAxroiFZcLwxzcnZ5TfzQKzi5jvAQG+IhmzDpUrk/byV3wTRpGESpjtJpX3PIqXjEF5xGPtWXOIbBok2OV7PPdgzm9eRKiBWvcstoD5aQTIvMCK+pc9ErN/BnqxYW/SBiRSnpLF6n8x79pIgafZRDb98ondoEp+R4OXeolFWRdYzWriFdojU3iU9xf+/xdR9ZPTyOEfJCDM1d+PmvXfsYuFdVleN8MXuK+rGW/u6r3Rj/6Zzi87uEDtYF3XgI0bL1hAi89GKjjd8RC+gbNBW+CdUcT+EGWn6Hvoe5UM00yp4OJqSVNo1+tA1dLfUvxZ/O6PJGrrL/Gx86XHTz/RAwjr9I6Jr6G5C2eIHqy8zgVlh9vBrzgM63KwOXCx00C0iu7s6T65bX6qeaYRpXX4RCdMF9HYZHtDhHqfz4Hc/q85axi+q9BAypqf+d410xS/ugt6H/DVr83Lb7eKtTS/PecQBRWkdIm0Op3/pCBaMgKQDJmfr6hymTk69+g6wMoXvOxReYifzoqCfbSJ2rV0//sLnW4KSELyiy+Yp+o2j5baGKGz6es/VjI4Y/ctz+s/me6q9i3FjEfNIGGpu3ksHfeUKZ87n0/oiw8Lp3Ry1nn+e3HjZ13+2/8PnCbhl8CGaZoIdZE3TIroPfPsDlavaTKIuXVauBlREiOV2/xmqXwtIQuABfIHtDWXpBKqNEAmnE7xi+vlmvKY1xILS5JzXpnHIBNYYcTRoOhZ6ZfNGRvLFx/7i/YgVua5CNrV8MErdT7/d9r64K2cPZ27IBRXjwJl6iWkoNYQtbBzpBs6RMD7FbZAbx88OHDqWAGXu5JyJ1PaVPWNJFznJfzN3Py+JqTMaAAAAAElFTkSuQmCC\n", "text/latex": [ "$$P_{wa} = 611 e^{- \\frac{M_w \\lambda_E \\left(- \\frac{1}{273} + \\frac{1}{T_g}\\right)}{R_{mol}}}$$" ], "text/plain": [ " ⎛ 1 1 ⎞ \n", " -M_w⋅λ_E⋅⎜- ───── + ───⎟ \n", " ⎝ p_CC2 T_g⎠ \n", " ─────────────────────────\n", " Rₘₒₗ \n", "P_wa = p_CC1⋅ℯ " ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eq_Pwa_CC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "All default values of variables defined along with the variable definitions are stored in a dictionary that can be accessed as `Variable.__defaults__`. We can substitute the values from this dictionary into our empirical equation to plot saturation vapour pressure as a function of temperature:" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Eq(P_wa, 167405731976.232*exp(-5304.00487246815/T_g))\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "expr = eq_Pwa_CC.subs(Variable.__defaults__)\n", "print(expr)\n", "xvar = T_g\n", "p = plot_expr2((xvar, 273, 373), expr)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Piecewise defined equations" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/latex": [ "$$P_{wa} = \\begin{cases} 0 & \\text{for}\\: T_a < 0 \\\\611 e^{- \\frac{M_w \\lambda_E \\left(- \\frac{1}{273} + \\frac{1}{T_g}\\right)}{R_{mol}}} & \\text{otherwise} \\end{cases}$$" ], "text/plain": [ " ⎧ 0 for Tₐ < 0\n", " ⎪ \n", " ⎪ ⎛ 1 1 ⎞ \n", " ⎪ -M_w⋅λ_E⋅⎜- ───── + ───⎟ \n", "P_wa = ⎨ ⎝ p_CC2 T_g⎠ \n", " ⎪ ───────────────────────── \n", " ⎪ Rₘₒₗ \n", " ⎪p_CC1⋅ℯ otherwise \n", " ⎩ " ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sympy import Piecewise\n", "expr = Eq(P_wa, Piecewise((0, T_a < 0), (eq_Pwa_CC.rhs, T_a >= 0)))\n", "expr" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/latex": [ "$$P_{wa} = \\begin{cases} 0 & \\text{for}\\: T_a < 0 \\\\611 e^{- \\frac{M_w \\lambda_E \\left(- \\frac{1}{273} + \\frac{1}{T_g}\\right)}{R_{mol}}} & \\text{otherwise} \\end{cases}$$" ], "text/plain": [ " ⎧ 0 for Tₐ < 0\n", " ⎪ \n", " ⎪ ⎛ 1 1 ⎞ \n", " ⎪ -M_w⋅λ_E⋅⎜- ───── + ───⎟ \n", "P_wa = ⎨ ⎝ p_CC2 T_g⎠ \n", " ⎪ ───────────────────────── \n", " ⎪ Rₘₒₗ \n", " ⎪p_CC1⋅ℯ otherwise \n", " ⎩ " ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "try:\n", " class eq1(Equation):\n", " \"\"\"Test\"\"\"\n", " expr = Eq(P_wa, Piecewise((0, T_a < 0), (eq_Pwa_CC.rhs, T_a >= 0)))\n", " display(eq1)\n", "except Exception as e1:\n", " print(e1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**If the above returns a dimension error, then unit checking for `Piecewise` has not been implemented yet.**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Substituting into integrals and derivatives and evaluating\n", "Above, we defined `Delta_Pwa` as a variable that represents the partial derivative of `P_wa` with respect to `T_g`:\n", "```\n", "class Delta_Pwa(Variable):\n", " \"\"\"Slope of saturated vapour pressure, $\\partial P_{ws} / \\partial T_g\"\"\"\n", " expr = P_wa(T_g).diff(T_g)\n", " #unit = pascal/kelvin\n", " latex_name = r'\\Delta'\n", "```\n", "This definition can be accessed by typing `Delta_Pwa.definition.expr`. Example:" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Derivative(P_wa, T_g)\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHUAAAAxBAMAAAAW4/v1AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZjJ2me8QRFSJqyLN3buI9fnTAAAACXBIWXMAAA7EAAAOxAGVKw4bAAACeklEQVRIDZ2VT2jTUBzHv/nbJP0LggdFVs+CLfMg9GKkIgiKCuJF1BwUQZBGRPC2iBdBYYGdhAmBnhyD9eBpCBbpaQgr3vQ0UEF2caDWzqn1vXZuSdP3XrLfIfx+38/3l+SX914LCEL+bAscHFz0OFCAZhyBgYOfc5gIdUQGFs+eme6zmEi/3yr0RB4G1y9CbTOYSFZ7yPsiE4Nra2i4DCaSGz5mRR4Wb3hYNFosytcLVemDybeUWFhvTi8fZ8GhLn/j4h14YLC+0HF2ymGiXh8Toni3+g0ULu+WNHswlWwN5U3AGHtHW0u275SfgEL6Q5HxpKgQYpG0sAFYpD8UKpBs4GIbeG2HOsm4wPbA829pMA9sxYfxPtKKAEg28IkXz+pOpNfwAOl7RGIUX51xYFEhNnBxMBbE9Ge8FY+pMmXT62jeFZpOCHn4cveCbPuOgxu1N8QSUJu2Ra/8oMsL+D1lLefq72SyJ4zOKRLnEgycozsoe6trVZWWastdIL89l0Nvygt19VeVcNXXXBOapwQ882SWdxuOgkarsN+ZbBipRy9lf6wv/V1YDR+VXHkWB6G1Knd5rUDf9KF1oZZCNrn+sO4h03x0MiTG00yPrD3ZwJIbZyLF7B4mK+9BcUTOOM/ZZWDJQSaOBMrLuYpHLFcFtkk4cwV072cTbJpY+80SzhJR2stf6HkH9JxbyX7Koo++Bp3ufbK8qUPfhLFBusjykhefq6W5gd6H1X4yXF6ghk9pevERhwIfo2+9hS+pem8fO9J0zcXBShVSF3v5YsPHmYF8IdVzQ2YjsIJQmS6tz5fSNYTdWjlcpcmX8TSNPeJ9te90pP5f/AMhLaevBQv/TQAAAABJRU5ErkJggg==\n", "text/latex": [ "$$\\Delta = \\frac{d}{d T_g} P_{wa}$$" ], "text/plain": [ " d \n", "Δ_Pwa = ────(P_wa)\n", " dT_g " ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "print(Delta_Pwa.definition.expr)\n", "display(Eq(Delta_Pwa, Delta_Pwa.definition.expr))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We also defined the Clausius-Clapeyron approximation to $P_{wa}(T_g)$ as `eq_Pwa_CC`. " ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAAsBAMAAAC3ThhGAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZqu7zZkQ7zKJVHZEIt2ubTYdAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEg0lEQVRYCc1XXYgbVRT+ksn8ZfKnsNVaxeCDuLTiouiT0BG2UBA1LaZQd5Vr7VJE2cSXPvTFgSpSBZsVRddYmIoiZUVDoQ/rD5tSEaUgAZXqgzYvlvogrGILi7XruTOZycwkk0z+wAO593zf/c45c2bm5ibARCzV6J82Xe+vGVZxPkrgzVFEQ2nShShhKouiGkYjRAqSZiLJhhBt88Xc6UME4sxm3gsujAv7Gjt2OJBWeZvZzDOBhXFBJe/LdMmHCGSYzcQNex73qOZ8GUPrx2o+3eBA/RO4cLcdpzzixicarssdt77aop3+Fd9z8sVEA+kicJMjPe04kF3Pctz6Yot36qPsFw6MYi8hec6JkpnjLTqOPU+uvibjp1WnmFoAxI3lncAPDmXNr10xW7jVv7L2RItwr6yFB500wTB3OEEq7bNUE3HgqEP5ZrX4VNEp3FpovzI+ZWTwtHorO4xTtR9VE5jfD2j5tGb3v1AsFk1sto2S8v6zDrNOYNT636QelJr4uLAtlYNQvwAIteckoP38BbyOJ38pCPUPqJpVHwWlLNU4Ihvx/id/k/JHj0A0d9B5+y7EGuTpy5S2/f4nUIKhMgnLvJz1/M1YXjI4IuP3YHRLsD/oplt2EWaKvt88OT8BzgLHZjhlv39xp3tIukc4vJtcWv2yFU23mVyx7iaT6BHrhL7ijMIHZAxroiFZcLwxzcnZ5TfzQKzi5jvAQG+IhmzDpUrk/byV3wTRpGESpjtJpX3PIqXjEF5xGPtWXOIbBok2OV7PPdgzm9eRKiBWvcstoD5aQTIvMCK+pc9ErN/BnqxYW/SBiRSnpLF6n8x79pIgafZRDb98ondoEp+R4OXeolFWRdYzWriFdojU3iU9xf+/xdR9ZPTyOEfJCDM1d+PmvXfsYuFdVleN8MXuK+rGW/u6r3Rj/6Zzi87uEDtYF3XgI0bL1hAi89GKjjd8RC+gbNBW+CdUcT+EGWn6Hvoe5UM00yp4OJqSVNo1+tA1dLfUvxZ/O6PJGrrL/Gx86XHTz/RAwjr9I6Jr6G5C2eIHqy8zgVlh9vBrzgM63KwOXCx00C0iu7s6T65bX6qeaYRpXX4RCdMF9HYZHtDhHqfz4Hc/q85axi+q9BAypqf+d410xS/ugt6H/DVr83Lb7eKtTS/PecQBRWkdIm0Op3/pCBaMgKQDJmfr6hymTk69+g6wMoXvOxReYifzoqCfbSJ2rV0//sLnW4KSELyiy+Yp+o2j5baGKGz6es/VjI4Y/ctz+s/me6q9i3FjEfNIGGpu3ksHfeUKZ87n0/oiw8Lp3Ry1nn+e3HjZ13+2/8PnCbhl8CGaZoIdZE3TIroPfPsDlavaTKIuXVauBlREiOV2/xmqXwtIQuABfIHtDWXpBKqNEAmnE7xi+vlmvKY1xILS5JzXpnHIBNYYcTRoOhZ6ZfNGRvLFx/7i/YgVua5CNrV8MErdT7/d9r64K2cPZ27IBRXjwJl6iWkoNYQtbBzpBs6RMD7FbZAbx88OHDqWAGXu5JyJ1PaVPWNJFznJfzN3Py+JqTMaAAAAAElFTkSuQmCC\n", "text/latex": [ "$$P_{wa} = 611 e^{- \\frac{M_w \\lambda_E \\left(- \\frac{1}{273} + \\frac{1}{T_g}\\right)}{R_{mol}}}$$" ], "text/plain": [ " ⎛ 1 1 ⎞ \n", " -M_w⋅λ_E⋅⎜- ───── + ───⎟ \n", " ⎝ p_CC2 T_g⎠ \n", " ─────────────────────────\n", " Rₘₒₗ \n", "P_wa = p_CC1⋅ℯ " ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Clausius-Clapeyron P_wa as function of T_g.\n", "\n", " Eq. B3 in :cite{hartmann_global_1994}\n", " \n" ] } ], "source": [ "display(eq_Pwa_CC)\n", "print(eq_Pwa_CC.__doc__)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we want to substitute this approximation into `Delta_Pwa.definition.expr`, we need to use `replace` instead of `subs` and evaluate the derivative using `doit()`:" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS4AAABOBAMAAABs7eaeAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZjJ2me8QRFSJqyLN3buI9fnTAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAHFklEQVRoBd1aa4wTVRT+Om2nM33MVsEgKNIESIQo1ECURYWuFpBX3BCDxEQYQkgERSoGA1FhDCQCQSmCj10hjhIgIAnVAAoqW5AEoygbNfjAmDX4ij9wheWxPFzPnXZmOrNtdxq27caT7L3ndc/59s6ZO3fuFKggPesgVyDhwKl7XXxRJ/Gud+LUrT57HEUTZUdu3ejU4igW78zNUSxHTi7rZdxmH+SXM5rX7YYyy5Il/pDpFhHgXpUzmidthnKLQ60JTlhFICRnNP6I3VJeeb01fEFctuttHXUtkvgPsPfdTATuCyOSyWkqA5eY9dDni2sxhnQvE4gDN+ghR+sM6g1OYwxcnqxex2V3tA67Bsl1G4Rl+nivnOX4Zl2V6SuPy+3F+7U6CDEGeNob/kYgrau0fmCbkpWz88WNfSCrMBBn5e7q3FJE2a4HE6cDvmb4UaBsxPjUuA4oO8ZWiHqka+5ni33k6Vgd3SMqwISJgFsNuLX54uNxBqLDJErG5qtG17SSUC5ci3x/UDG9GOvlC0NK7AWk6BweOfUl4XZM/igmJdYSCg0XYlw9H2USUZmuo/Atrw6bAY+y3ZfCG/BE4d3xNaWrZzk1CmIhIqLMo4GJWn0pLpWPaEaAzVn5KCifdGejN0HxAc05uV4CngKGtDBVpu79+myBT5OyfCSsr707G50uF7ETzFw8lVCaxOeYimMNQhGto0aI6VyZe+FYwyYV6GummS+zcnOjJmXoFhK3vy+bNI9CTQUpaOTix8+DL425GGyotKk7wW5gmH6mtZycmNCjhzquwheDa8M7ugbil0kIqiSTYqmhrAzT5UZUSC5gSH6vDBwzSx+Tzc/VTSK9oOQ3lk8rmlWeN4mAUaQflNdWVuX44tGlG5MAT3//D5rdxWVYdppItjyV9adxqX3RCevXoZDdfe7PrJdwIcddHPFKjuSMFds3dnElncV5MEp+Q000P5vD+KOYQrcO7a0yjWkpwnFpNBYxOzUF+qvk2q/V8B8rG6wUw2nMbzyPTGPoizLuJD4t6uDM6DqYBlxzWwzvJjZ/GVqu1ZqLcEFrdH3R3r9+ilLUwZnR46kHPsgBE2w2Bv6mcSXi8srac0YP8klY50rrPe5WIDogYoxyXTbYK0NGJrJTpYGbN2KyYSvILEBQyTFKkRyhBPY94QwEebc5gm8nfu2l+K7L/JUwvs/B5TuJ/aZfIW4NvM/IptFrsiVxNwUu4jHMNMdw54h319OTle8AxsmZ0mLzNVfh7zP9CnDCsYR4P3q/0PtWWmJW9MbBAn5dqWM4i2jgrOk2bABdO38LkMRVgASjvrb2ukM2/YpyK9JeZTXtSd3hnH1i0RF2YwwPCSnXGUPNnfCqgDfJyWH8RLjCJq5LhlOXjD+ygHbUwYgYztlXdzkqxyEQxlez4a+HbzQ+5k8Ai1MeuhEWJiRy2mqdL1Z4DimElWhWgvITcrPicIjVzZXCOHrFaoFYI4/BUfgugLsIrIuzZX+4jHE5df8D1Z11dEFpPu7ClhS3/k1sSBV0KmYIAWMjGB7Fvuexhd5nlocBgrQZc2iUP8nPICxsXWXNPeAdrBPFsuW1UcZO5J/1DZ7Gy7N+lDERD1OpnyKXdSkcweM8+W9sjMCz9UpdpnHXXdcpwLUruJx7Ll+07/jziOoGupSVOsn2zJL1rHn7w0IrFVuGOFrzV+b16n7lkgHJokEHjeo9SnfY3BbfZS4durY8fczL6rfHkU9xlbD+VA4+nad0UWCVw5KbaQmt3ZkC23SM0ZFcYxV5lR56PbDA2Hu3q62K81IgtZ/pOxdYqa983ewPrGK4BsRYm6mvzxlbfVIZBK+5da8+Ig2BcITO1ONTy1tgG3+VS/13Q9nCKHlgCYnElD9dgnvFXEMp9rivDvXr2Hn6F3vqppk7O/7a1R5KBMxTDrtPueV/6WOoakvSADwK1NHhStUWbra59Nt3QCoCdEPRuWooakNcMdFNFRSyVRFHr3K0v72Ttt0Vw2FPJNXT9r/FquVoCukC0gtwzGqooFSjQnikcz5vM9MtxaLOpspohr89ui1iSTW/lcSmGDXcZ6sq/rFAhzJWxs2yLmg9fT2mB69Cjbejg2GsCtFJXU3SklmMkbhbtugqL9DRSZNqSSuFSaTlq6rE0W9M1sXgqhs40j06Amxo0D4usuWrquSmJfWtKO9aHPZuc6sIJvzhwQSILV9VpSAV9rroh/vuRU3Ck8QkiOoYAiRpz5++I9QqgfMcvxSGeCpKJz+DEVIwA1KSDloaj1/ZQic+qhSrEi4j7TSMQROHy1gYmRbJaptSkmI4VIcJtNKM3SLiMHagNZrF0B81cnXgGFl9Kv2K5cBrOFCrYGIiq27M/b5uuFafWYOd1QeRB4Gn9lAebU9QTesJIOwYAqqQtut6ghw4NFIuGcd/Q89nCfrnonYAAAAASUVORK5CYII=\n", "text/latex": [ "$$\\Delta = \\frac{M_w \\lambda_E 611 e^{- \\frac{M_w \\lambda_E \\left(- \\frac{1}{273} + \\frac{1}{T_g}\\right)}{R_{mol}}}}{R_{mol} T_g^{2}}$$" ], "text/plain": [ " ⎛ 1 1 ⎞ \n", " -M_w⋅λ_E⋅⎜- ───── + ───⎟ \n", " ⎝ p_CC2 T_g⎠ \n", " ─────────────────────────\n", " Rₘₒₗ \n", " M_w⋅λ_E⋅p_CC1⋅ℯ \n", "Δ_Pwa = ────────────────────────────────────────\n", " 2 \n", " Rₘₒₗ⋅T_g " ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "expr = Eq(Delta_Pwa, Delta_Pwa.definition.expr.replace(P_wa, eq_Pwa_CC.rhs).doit())\n", "display(expr)\n", "p = plot_expr2((T_g, 273, 373), expr.subs(Variable.__defaults__))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we only had the slope of the curve, we could take the integral to get the absolute value:" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAANYAAABOBAMAAACu+PUzAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAZqu7zZkQ7zKJVHZEIt2ubTYdAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAEvElEQVRoBe1YXYgbVRT+8jeZZCY/COrDqhnqtlD2YeOCCgomlCz0Qd3UdgsaWIdi2welu/j3IK6NioIPmhErshRqBF9UdENKfdhVNhV8sIINpQo+7TwVC8LGrW7tumu8dyYzk0lmM+sycynoecg995xzv+/ec+6dmRvAC7l9d273aNoLJHeMPcgg0HCP8yCCq+Eg4k0PkNwheBlXIbrHeRPBbXiDsx0UcU2Peus9/zMZU3WuLN9R9K4vvyFJh81zLV/wu0FT5HAFFu8D4mq32Re9UgY+wQzwlO/1+nZlL/AIL4Hb48tS+kCvCF/h6DGlz+6H4buhA1hpq35A/3cwI3Mys8XWj0usuLiNZI0Vl9BixQQks+y4lpllEFhqsFtXTmbHdZ0dFb/Kjkv4ix1XiOGnVKrzKcVidRXVYklbql27pT22a1y227p6gdFru4YPdxm2UDOS6eCt0r3+QuL6GEGYUHTv70DoRTOwT0nlgfvlPnOvYdR6bEROWuHrMQVRFRF9qfwN8qllzaQXAxUypXkLyPLHbcaVhum5kCFDdBHXgsBy0bjFCGQDCYRvK6HPniVzcFeUjYtry6arGDX3SUx9FchUIejeUAsIDtiwOYIx2jCBLMXGJVqPDbEaMKceLpbJaNm4xdB6kFVuKaSciT+cvDau2DUzJAJ0Cvbj6UqVmF8xXaQe8atmT1NOFaiMazot5xdOKYSNK2wuBRdI1rQB4ixysm2mS3vnSsSylQirc+9/2e3ks52ejSu1bsZIgF6w42kcItaA5aLUAyRk1lkP4idVqsQKhUefLxQkqlNZ3tRbsqerBF5L+pP0vkk2g4XwtxHk3KbUHrtoGGzrmm8ZYWSTdwr2HLT7ZlSlFiq8Q931eu3T/JWi1lg/zlwf5o2IT6mSIaO4G4jTGVgbjx4v4HspkT8h42h9P+11Cz1eEOu4zF0BVxouw5krpxiDJKpESUq5dQTzn2vHi2T1dB0Ia9lU1oRsuMH9wlu5pUOITMjkJ5aSz+JhnChXyFFRiYGKLYcnq5qNWMcniUzRbD2IuyQyBW1D1HEvIhOrNbItn1GDNaEZKfbddw+1R8ion37ACL7GJN4ha1QNVDLQEOuxkWzrIgNHFt8eacSG2/tqSGziASM2okQbMUSrgmRY7O3jeBkKXgJJhCNX12PDPrDTC6gwM5ZsTMsCppuh22TH2F+5NdS4TdxzzOLiukIFl6+NmMTPGMDh8jzuRLRZOW9Y7O3+eCvQxCy/kXa+fgd/s8f39uJSUDJsfOmjUhXiyGcHDIu9fWPh1gXgm4Vz6cQULXCvJP/stfT0S6fSPZYdd1Mtt6HRslvEdv2V7ODIS/h4cMC/8FpvYudBl4cOOzt2YHV8me4AZztDVrYT5FEMeXmzEvryZiUBt+Pl4USCMx6CuUClFJcAD90Xmx6CDYQ6g7sH+r10PsTPegk3EOvnenmg/3/nzZOBwLMHVx9z+QDwarZBOdDCHV6hDcZ5GpEsyMctC3kTSQUNFkyUY5oZE3BRpozkmiVrja8/Z3R0/gMGXGOdlSQZcNHDNXRWBgMunrz+40qU/I/t+7rEqVUF4eZrLLi0YiXlxQaDdWlc4rvn0vzSE5p+c/z8A8zdJ0OF5rA2AAAAAElFTkSuQmCC\n", "text/latex": [ "$$P_{wa} = P_{wa1} + \\int_{T_{a1}}^{T_{a2}} \\Delta\\, dT_g$$" ], "text/plain": [ " Tₐ₂ \n", " ⌠ \n", "P_wa = P_wa1 + ⎮ Δ_Pwa d(T_g)\n", " ⌡ \n", " Tₐ₁ " ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from sympy import Integral\n", "class T_a1(Variable):\n", " \"\"\"Air temperature\"\"\"\n", " unit = kelvin\n", " latex_name = r'T_{a1}'\n", " \n", "class T_a2(Variable):\n", " \"\"\"Air temperature\"\"\"\n", " unit = kelvin\n", " latex_name = r'T_{a2}'\n", " \n", "class P_wa1(Variable):\n", " \"\"\"P_wa at T1\"\"\"\n", " unit = pascal\n", " latex_name = r'P_{wa1}'\n", " \n", "class eq_Pwa_Delta(Equation):\n", " \"\"\"P_wa deduced from the integral of Delta\"\"\"\n", " expr = Eq(P_wa, P_wa1 + Integral(Delta_Pwa, (T_g, T_a1, T_a2)))\n", "display(eq_Pwa_Delta)" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/latex": [ "$$P_{wa} = 167405731976.232 e^{- \\frac{5304.00487246815}{T_{a2}}}$$" ], "text/plain": [ " -5304.00487246815 \n", " ──────────────────\n", " Tₐ₂ \n", "P_wa = 167405731976.232⋅ℯ " ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "expr_Delta = eq_Pwa_CC.rhs.diff(T_g)\n", "expr = Eq(P_wa, eq_Pwa_Delta.rhs.replace(Delta_Pwa, expr_Delta).doit())\n", "vdict = Variable.__defaults__.copy()\n", "vdict[T_a1] = 273.\n", "vdict[P_wa1] = eq_Pwa_CC.rhs.subs(T_g, T_a1).subs(vdict)\n", "display(expr.subs(vdict))\n", "p = plot_expr2((T_a2, 273, 373), expr.subs(vdict))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Unit conversions\n", "Values for variables are often given in obscure units, but to convert to our standard units, we can use the dictionary `SI_EXTENDED_DIMENSIONS`:" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.3*inch/hour\n", "2.11666666666667e-6*m/s\n" ] } ], "source": [ "from sympy.physics.units import convert_to, kilo, mega, joule, kilogram, meter, second, inch, hour\n", "from essm.variables.units import SI_EXTENDED_DIMENSIONS, SI_EXTENDED_UNITS\n", "value1 = 0.3\n", "unit1 = inch/hour\n", "print(value1*unit1)\n", "unit2 = Variable.get_dimensional_expr(unit1).subs(SI_EXTENDED_DIMENSIONS)\n", "print(convert_to(value1*unit1, unit2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exporting definitions\n", "The below example creates a file called `test_variable-definitions.py` with all the variable definitions and \n", "relevant imports used in this notebook. \n", "Then, we re-import all the variables from the newly created file and create another file called\n", "`test_equation-definitions.py` with all the equation definitions and relevant imports.\n", "To re-use the equations in another notebook, just execute `from test_equation-definitions.py import *`" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [], "source": [ "from essm._generator import EquationWriter, VariableWriter" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [], "source": [ "StrPrinter._print_Quantity = lambda self, expr: str(expr.name) # displays long units (meter instead of m)\n", "writer = VariableWriter(docstring='Variables defined in api_features.ipynb and dependencies.')\n", "for variable in Variable.__registry__.keys():\n", " writer.var(variable)\n", "writer.write('test_variable_definitions.py')\n", "StrPrinter._print_Quantity = lambda self, expr: str(expr.abbrev) # displays short units (m instead of meter)" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:alpha_a\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:c_pa\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:c_pamol\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:c_pv\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:C_wa\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:D_va\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:g\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:Gr\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:h_c\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:k_a\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:lambda_E\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:Le\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:M_air\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:M_N2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:M_O2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:M_w\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:nu_a\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:Nu\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:P_a\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:Pr\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:P_N2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:P_O2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:P_wa\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:P_was\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:R_d\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:Re_c\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:Re\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:rho_a\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:R_u\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:R_mol\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:R_s\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:sigm\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:T0\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:T_a\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:v_w\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:x_N2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.variables.physics.thermodynamics:x_O2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.equations.physics.thermodynamics:p_Dva1\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.equations.physics.thermodynamics:p_Dva2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.equations.physics.thermodynamics:p_alpha1\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.equations.physics.thermodynamics:p_alpha2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.equations.physics.thermodynamics:p_ka1\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.equations.physics.thermodynamics:p_ka2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.equations.physics.thermodynamics:p_nua1\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"essm.equations.physics.thermodynamics:p_nua2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:P_g\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:V_g\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:n_g\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:n_w\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:T_g\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:Delta_Pwa\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:x\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:p_CC1\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:p_CC2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:T_a1\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:T_a2\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n", "/home/stan/Programs/essm/essm/variables/_core.py:89: UserWarning: \"__main__:P_wa1\" will be overridden by \"test_variable_definitions:\"\n", " instance[expr] = instance\n" ] } ], "source": [ "from test_variable_definitions import *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Since we re-imported names that already had definitions associated with them, we got a warning for each of them before it was overwritten. This tells us that the same variable used before may now have a different meaning, which could introduce inconsistency in the notebook. Here, however, we know that they are all the same. Now that we have re-imported all variables, we can use the `EquationWriter` to generate\n", "another python file with all the equations and variables they depend on, as shown below. The re-import was necessary so that the import statements do not point to `__main__`\n", "for locally defined variables." ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [], "source": [ "StrPrinter._print_Quantity = lambda self, expr: str(expr.name) # displays long units (meter instead of m)\n", "writer = EquationWriter(docstring='Equations defined in api_features.ipynb and dependencies.')\n", "eqs_with_deps = []\n", "for eq in Equation.__registry__.keys():\n", " parents = tuple(get_parents(eq))\n", " if parents == ():\n", " writer.eq(eq)\n", " else:\n", " eqs_with_deps.append(eq) # Equations with dependencies must be at the end\n", "for eq in eqs_with_deps:\n", " writer.eq(eq)\n", "writer.write('test_equation_definitions.py') \n", " \n", "StrPrinter._print_Quantity = lambda self, expr: str(expr.abbrev) # displays short units (m instead of meter)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "These definitions are re-imported in `examples_numerics.ipynb`, where you can also find examples for numerical computations using essm equations and variables." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.4" }, "nav_menu": {}, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": { "height": "calc(100% - 180px)", "left": "10px", "top": "150px", "width": "253.977px" }, "toc_section_display": "block", "toc_window_display": true }, "toc_position": { "height": "991px", "left": "0px", "right": "888.92px", "top": "105px", "width": "212px" } }, "nbformat": 4, "nbformat_minor": 4 }