From aa56a74f63f6ebc54053495371a2355cf66f9150 Mon Sep 17 00:00:00 2001 From: Philipp Rehner Date: Mon, 21 Mar 2022 14:46:34 +0100 Subject: [PATCH 1/4] New struct `StateVec` and simpler interfaces for phase equilibria --- build_wheel/src/cubic.rs | 6 +- build_wheel/src/user_defined.rs | 9 +- example/user_defined_eos.ipynb | 255 ++++--- src/errors.rs | 4 +- src/lib.rs | 5 +- src/phase_equilibria/bubble_dew.rs | 73 +- src/phase_equilibria/mod.rs | 4 +- src/phase_equilibria/phase_diagram_binary.rs | 335 +++----- src/phase_equilibria/phase_diagram_pure.rs | 131 ++-- src/phase_equilibria/tp_flash.rs | 8 +- src/phase_equilibria/vle_pure.rs | 93 ++- src/python/phase_equilibria.rs | 765 ++++--------------- src/python/state.rs | 77 ++ src/state/critical_point.rs | 7 +- src/state/mod.rs | 22 +- 15 files changed, 659 insertions(+), 1135 deletions(-) diff --git a/build_wheel/src/cubic.rs b/build_wheel/src/cubic.rs index 2a17594..cffec8b 100644 --- a/build_wheel/src/cubic.rs +++ b/build_wheel/src/cubic.rs @@ -38,16 +38,14 @@ impl_virial_coefficients!(PyPengRobinson); impl_state!(PengRobinson, PyPengRobinson); impl_state_molarweight!(PengRobinson, PyPengRobinson); -impl_vle_state!(PengRobinson, PyPengRobinson); +impl_phase_equilibrium!(PengRobinson, PyPengRobinson); #[pymodule] pub fn cubic(_py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_class::()?; m.add_class::()?; m.add_class::()?; - m.add_class::()?; - m.add_class::()?; - m.add_class::()?; + m.add_class::()?; m.add_class::()?; Ok(()) } diff --git a/build_wheel/src/user_defined.rs b/build_wheel/src/user_defined.rs index 8ab1999..566829b 100644 --- a/build_wheel/src/user_defined.rs +++ b/build_wheel/src/user_defined.rs @@ -1,5 +1,5 @@ -use feos_core::python::user_defined::*; use feos_core::python::statehd::*; +use feos_core::python::user_defined::*; use feos_core::*; use numpy::convert::ToPyArray; use numpy::{PyArray1, PyArray2}; @@ -10,7 +10,6 @@ use quantity::si::*; use std::collections::HashMap; use std::rc::Rc; - /// Equation of state implemented as python class. /// /// Parameters @@ -43,7 +42,7 @@ impl_equation_of_state!(PyUserDefinedEos); impl_virial_coefficients!(PyUserDefinedEos); impl_state!(PyEoSObj, PyUserDefinedEos); impl_state_molarweight!(PyEoSObj, PyUserDefinedEos); -impl_vle_state!(PyEoSObj, PyUserDefinedEos); +impl_phase_equilibrium!(PyEoSObj, PyUserDefinedEos); #[pymodule] pub fn user_defined(_py: Python, m: &PyModule) -> PyResult<()> { @@ -61,9 +60,7 @@ pub fn user_defined(_py: Python, m: &PyModule) -> PyResult<()> { m.add_class::()?; m.add_class::()?; m.add_class::()?; - m.add_class::()?; - m.add_class::()?; - m.add_class::()?; + m.add_class::()?; m.add_class::()?; Ok(()) } diff --git a/example/user_defined_eos.ipynb b/example/user_defined_eos.ipynb index 0f467a8..085561e 100644 --- a/example/user_defined_eos.ipynb +++ b/example/user_defined_eos.ipynb @@ -446,7 +446,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_81996/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_7165/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", " return n * (np.log(v / (v - b * n)) - ak_mix / (b * SQRT2 * 2.0 * state.temperature)\n" ] }, @@ -469,7 +469,7 @@ } ], "source": [ - "vle = PhaseEquilibrium.pure_t(eos, temperature=350*KELVIN)\n", + "vle = PhaseEquilibrium.pure(eos, temperature_or_pressure=350*KELVIN)\n", "vle" ] }, @@ -576,9 +576,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_81996/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_7165/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", " return n * (np.log(v / (v - b * n)) - ak_mix / (b * SQRT2 * 2.0 * state.temperature)\n", - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_81996/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_7165/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", " * np.log((v * (SQRT2 - 1.0) + b * n) / (v * (SQRT2 + 1.0) - b * n)))\n" ] } @@ -611,15 +611,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_81996/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_7165/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", " return n * (np.log(v / (v - b * n)) - ak_mix / (b * SQRT2 * 2.0 * state.temperature)\n", - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_81996/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_7165/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", " * np.log((v * (SQRT2 - 1.0) + b * n) / (v * (SQRT2 + 1.0) - b * n)))\n" ] } ], "source": [ - "dia = PhaseDiagramPure(eos, 250.0 * KELVIN, 500)" + "dia = PhaseDiagram.pure(eos, 250.0 * KELVIN, 500)" ] }, { @@ -633,9 +633,28 @@ "cell_type": "code", "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[17885.65767341655, 17874.1788893546, 17862.675545128997, 17851.147539437217, 17839.59477063816, ..., 1950.036863971225, 1689.5006399946997, 1380.0591082552019, 976.2649461965975, 0] J/mol" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "enthalpy_of_vaporization = [(vle.vapor.molar_enthalpy() - vle.liquid.molar_enthalpy()) / (KILO * JOULE) * MOL for vle in dia.states]" + "enthalpy_of_vaporization = dia.vapor.molar_enthalpy - dia.liquid.molar_enthalpy\n", + "enthalpy_of_vaporization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The full information about the states is also available from the `states` field" ] }, { @@ -645,7 +664,28 @@ "outputs": [ { "data": { - "image/png": "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\n", + "text/plain": [ + "[17885.65767341655, 17874.1788893546, 17862.675545128997, 17851.147539437217, 17839.59477063816, ..., 1950.036863971225, 1689.5006399946997, 1380.0591082552019, 976.2649461965975, 0] J/mol" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "enthalpy_of_vaporization = SIArray1([(vle.vapor.molar_enthalpy() - vle.liquid.molar_enthalpy()) for vle in dia.states])\n", + "enthalpy_of_vaporization" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -656,7 +696,7 @@ ], "source": [ "fig, ax = plt.subplots(figsize=(7, 4))\n", - "sns.lineplot(x=dia.temperature / KELVIN, y=enthalpy_of_vaporization, ax=ax);\n", + "sns.lineplot(x=dia.vapor.temperature / KELVIN, y=enthalpy_of_vaporization / (KILO*JOULE/MOL), ax=ax);\n", "ax.set_ylabel(r\"$\\Delta^{LV}h$ / kJ / mol\")\n", "ax.set_xlabel(r\"$T$ / K\");" ] @@ -671,7 +711,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -705,7 +745,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -729,100 +769,100 @@ " \n", " \n", " \n", - " molar enthalpy vapor\n", + " molar enthalpy liquid\n", + " molar entropy liquid\n", " temperature\n", " molar entropy vapor\n", - " molar entropy liquid\n", - " density vapor\n", - " molar enthalpy liquid\n", - " pressure\n", " density liquid\n", + " molar enthalpy vapor\n", + " pressure\n", + " density vapor\n", " \n", " \n", " \n", " \n", " 0\n", - " 21.774512\n", + " 3.888854\n", + " 0.041205\n", " 250.000000\n", " 0.112747\n", - " 0.041205\n", - " 110.874504\n", - " 3.888854\n", - " 216751.867612\n", " 13517.744128\n", + " 21.774512\n", + " 216751.867612\n", + " 110.874504\n", " \n", " \n", " 1\n", - " 21.769636\n", + " 3.895457\n", + " 0.041231\n", " 250.240382\n", " 0.112659\n", - " 0.041231\n", - " 111.801129\n", - " 3.895457\n", - " 218680.955365\n", " 13509.916346\n", + " 21.769636\n", + " 218680.955365\n", + " 111.801129\n", " \n", " \n", " 2\n", - " 21.764747\n", + " 3.902072\n", + " 0.041256\n", " 250.480764\n", " 0.112570\n", - " 0.041256\n", - " 112.733771\n", - " 3.902072\n", - " 220623.177946\n", " 13502.075331\n", + " 21.764747\n", + " 220623.177946\n", + " 112.733771\n", " \n", " \n", " 3\n", - " 21.759845\n", + " 3.908698\n", + " 0.041282\n", " 250.721146\n", " 0.112481\n", - " 0.041282\n", - " 113.672458\n", - " 3.908698\n", - " 222578.594255\n", " 13494.221046\n", + " 21.759845\n", + " 222578.594255\n", + " 113.672458\n", " \n", " \n", " 4\n", - " 21.754930\n", + " 3.915336\n", + " 0.041308\n", " 250.961528\n", " 0.112393\n", - " 0.041308\n", - " 114.617219\n", - " 3.915336\n", - " 224547.263292\n", " 13486.353455\n", + " 21.754930\n", + " 224547.263292\n", + " 114.617219\n", " \n", " \n", "\n", "" ], "text/plain": [ - " molar enthalpy vapor temperature molar entropy vapor \\\n", - "0 21.774512 250.000000 0.112747 \n", - "1 21.769636 250.240382 0.112659 \n", - "2 21.764747 250.480764 0.112570 \n", - "3 21.759845 250.721146 0.112481 \n", - "4 21.754930 250.961528 0.112393 \n", + " molar enthalpy liquid molar entropy liquid temperature \\\n", + "0 3.888854 0.041205 250.000000 \n", + "1 3.895457 0.041231 250.240382 \n", + "2 3.902072 0.041256 250.480764 \n", + "3 3.908698 0.041282 250.721146 \n", + "4 3.915336 0.041308 250.961528 \n", "\n", - " molar entropy liquid density vapor molar enthalpy liquid pressure \\\n", - "0 0.041205 110.874504 3.888854 216751.867612 \n", - "1 0.041231 111.801129 3.895457 218680.955365 \n", - "2 0.041256 112.733771 3.902072 220623.177946 \n", - "3 0.041282 113.672458 3.908698 222578.594255 \n", - "4 0.041308 114.617219 3.915336 224547.263292 \n", + " molar entropy vapor density liquid molar enthalpy vapor pressure \\\n", + "0 0.112747 13517.744128 21.774512 216751.867612 \n", + "1 0.112659 13509.916346 21.769636 218680.955365 \n", + "2 0.112570 13502.075331 21.764747 220623.177946 \n", + "3 0.112481 13494.221046 21.759845 222578.594255 \n", + "4 0.112393 13486.353455 21.754930 224547.263292 \n", "\n", - " density liquid \n", - "0 13517.744128 \n", - "1 13509.916346 \n", - "2 13502.075331 \n", - "3 13494.221046 \n", - "4 13486.353455 " + " density vapor \n", + "0 110.874504 \n", + "1 111.801129 \n", + "2 112.733771 \n", + "3 113.672458 \n", + "4 114.617219 " ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -841,7 +881,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -869,12 +909,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -889,12 +929,12 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAukAAAGGCAYAAADGjh8ZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAB8DklEQVR4nO3dd1xV9ePH8de9lwvIUMCBe6emuPceuXfmTnOkppZWNmxou/xmZaVpDnKHmWZZ7q25Q82RZuXAhQsEWbLu+f1h8osciYLnAu/n48HjK+eee3if80V78+FzPsdiGIaBiIiIiIg4DavZAUREREREJDWVdBERERERJ6OSLiIiIiLiZFTSRUREREScjEq6iIiIiIiTUUn/l6ZNm9K0aVOzY4iIiIhINuZidgBnExUVZXYEEREREcnmNJIuIiIiIuJkVNJFRERERJyMSrqIiIiIiJNRSRcRERERcTIq6SIiIiIiTkYlXURERETEyaiki4iIiIg4GZV0EREREREno5IuIiIiIuJkVNJFRERERJyMSrqIiIiIiJNRSRcRERERcTIuZgcQEXnQDMPAiI/BEXeVK7GRxOfMj5erG152N1ysNrPjiYiIqKSLSOaXHHeVpEsnSLzxEXYKR1wkjrirOK5dxREXff1/r0X9vS0KDCPl/d8Vqs7k0s0AcLfZ8bK74Wl3w/vG/7pe/18vFzfy5PCisJcvhb18KOzlSyFPH1xt+qdURETSl/7LIiKZhpGcRPyZg1w7EUzC2d+IP/MbCWd/I/nqhfs6brSLa8qfryUnci05kcvXou/qvRYsFPX2pZxv/lQfJXLm1qi8iIjcM4th/GM4SahRowYAwcHBJicRkaSI88T9tZ1rx3Zx7fhurp0IxkiIve3+FlcP7PlKYs9dFKunH9YcObG6e2PLkROre06sObz+/t/r2605chLn6sEVuwcxifFEJV4jJjGB6JQ/xxP9z4+EeC7GRXEm+gqhsZE47vDPp6vVxkM++aiSpwjV8xWlRr5ilMiZB4vFkhGXSkREshiV9H9RSRcxjyM+hrijW4j5bR2xv60j4cyhW+5n8ymAW5FKuBUKwLVwBVzzl8WeryQ277wPrAQnOpIJjYnkVFQ4f0Rc4PcrF/j9ynmOXjlPTFLCLd/j6+ZBjXzFqJO/BI0KlqGcr79Ku4iI3JJK+r+opIs8WEkR54n+9Uei9y4l7vAGjH8VXIvdHbfi1clRqjbupWrjXrI2Ln6FnbbcOgwHZ6Mj+P3KeX4LD2XvpVPsuXiKyIS4m/bNl8ObRgUfolGhh2hYsDR5c3ibkFhExLm9+uqrbN26lc2bN2O1/v/ChK+99ho7d+5k/fr1fPvttyxcuJDjx4/jcDgoVaoUQ4cOpVWrVgAsWbKEMWPGMG/ePN566y1CQkIoXbo0L7zwAvXr10855vnz55kwYQI7duzg6tWrBAQE8Oyzz1KrVi0Azpw5wyOPPMKrr77KggULiIiI4M0336Rt27bpft4q6f+iki6S8ZKjw4ja9S1Xdy7g2l/bU93EicWKe4maeFRojkdAc3KUqoPlH3PGMyOH4eBY5GWCL4YQfPEkP5/7i3MxkTftV8GvAK2KVqBNsQCNsotIukl0JHP+Fv/mPGj5PXNhv4d7dXbu3Em/fv2YN29eSllOSEigQYMG9OrVi9y5c/O///2PkSNHUrVqVSIjI5kxYwZHjhxh/fr1+Pv7s2TJEl577TV8fHwYOHAgZcuWZc6cOezevZtvvvmGgIAALl68SJcuXfD09OSZZ57B09OTr7/+mp07dxIYGEjdunVTSrq7uztvvvkmOXLkoGbNmuTJkye9L5duHBWRB8ORcI2Y/cu4un0+MQdWQnJSymvWHDnxrNwWr6od8Qhoic3T18Sk6c9qsfKQTz4e8slHrzI1MQyDY5GX2HzuT7ac/ZMd548Tm5TAb+Gh/BYeyoRf11HcOzdtigXQpngFquQpjNWix1qISNolOpJpsmQCIVFhZkehmHduNnUZleaiXrt2bQoUKMDy5ctTSvrWrVuJjIykY8eOLFy4kEGDBjF06NCU9xQqVIguXbqwd+9e2rRpA1xffnfgwIEMGTIEgLp169K8eXOmT5/OxIkTmTVrFlevXmXRokUUKFAAgCZNmtCpUyc+/vhjvvvuu5Tjt2nThi5dutzX9fgvKukikqESQo8SsXEaV7fOwREbkbLd6u6NV83H8K7VHY+Hm2b60fK0sFgslPbJR2mffDxZvj4JyUnsuXSKdaeOsDLkN05Fh3MyKowvD23my0ObKeTpw2OlqvJY6WqUypXX7PgiIg+UxWKhQ4cOLF68mLFjx+Li4sLy5cupUKECpUqV4rXXXgPg6tWrHD9+nJCQEHbt2gVAYmJiqmN16NAh5c+urq40adKE9evXA9dnUVSvXj2loANYrVbatm3L559/TnT0/6/6VaZMmQw73xtU0kUk3RnJSUTv+5HIDVOJPbz+/1+wueAZ0Iqc9R7Hs0oHrG4e5oV0Iq42F+rmL0nd/CUZU7Mth8NDWRFyiFUhv3E04gJnYyKYeGAjEw9spGreIjxWqhqdSlTC193T7Ogi4uTsVhubuozK1NNdADp16sT06dPZsWMHNWvWZMOGDTz33HMAnDp1ijfeeIMdO3Zgt9spWbIk5cqVA66Pnv9T3rypBzr8/PyIjLx+bSIjIylevPhNXztPnjwYhkFMTEzKtty5c9/TeaSFSrqIpBtHQhxXf57NlVWfkHjpRMp2e94S5Gr6FDkb9MMlZz4TEzo/i8VChdwFqZC7IC9Va8lfERdZcmwf3x3bx9mYCPZdOs2+S6d5e/cymhUuS+8ytWhSqAw2q6bDiMit2a02inj7mR3jvpQuXZoKFSqwatUqoqOjiY+Pp127djgcDoYMGYKbmxuLFy/m4YcfxsXFhb/++oulS5fedJzIyMhUBTssLCzl85w5c3L58uWb3nPx4kUAfH19U/78IKiki8h9S465QsT6KUSsnURy1KXrGy0WPCu1JVezoXhWbIVFD/a5J6V98vFy9Va8WK0Fuy6cZPFfe1l+8iDRifGsPnWY1acOU9TLj8fL1qJnmRrkdvcyO7KISIbo2LEjgYGBREVFUb9+ffLkyUNYWBgnTpzgjTfeoGLFiin7btmyBbh5JH3jxo107doVgPj4eDZu3JiyukvNmjX5+uuvOX/+PPnz5wfA4XCwatUqKlasiKvrg52WqZIuIvcsOTqc8JUfE7F+MsbfT+i0uLjiXa8vfm1ewLVAWZMTZh1WizVlSsx7dTqy+tRhFvzxC9tCj3EqOpxxe1bxyb61tC1ekX7l6lAjXzGtDiMiWUr79u0ZP34869at48MPPwSuTzspVKgQc+fOJV++fHh5efHzzz8zd+5cAGJjUz8A78MPPyQ+Pp7ChQsza9YsYmJiUm44HTBgAEuXLqVfv36MGDECT09PgoKCOHbsGDNmzHiwJ4tKuojcA0dcFFfWTuTKyo9xxF0Frt8ImqvZUHxbjMTFt6DJCbO2HC6udC5Zhc4lq3As8hLzft/Jor/2EJlwjR+O/8oPx3+lSp4iDA1oSJtiAZoKIyJZQp48eahfvz7BwcE0b948ZfuUKVN4//33efnll3F1daV06dJ8+eWXfPDBB+zZs4fevXun7Dt27FimTJlCaGgolSpVYv78+ZQoUQKAfPnysWDBAj7++GPefPNNHA4HAQEBzJo1i9q1az/w89U66f+iddJFbs9ISiBi/RTCl40jOer6vD1rjpz4th6FT/MR2Dx9zA2YjcUlJfDjiQPM/X0n+y+fSdle1MuPwRUa0OOhGnjYs88KOiIi/7RkyRJeffVVNm/enDKVxdlpJF1E/pNhGMTs+5FLC18m8cJfAFhcc+DT/Bn82r6EzSvj73KXO8vh4kqPh2rQvXR1frkYwrRDW1hz6ginosMZu+tHPt63ln7l6jCgfD092VREJBNQSReRO4o/fZBLC174/6UUrTZyNRlM7o5jcPEpcOc3ywNnsVio5V+cWv7FORZ5iRm/bf17KkwcEw9sZPpvW+lbrjbDAhqTz0NlXUTEWWm6y79ouovIdY5r0Vz+/k0i1kwEwwGAR0BL8vb6BLdC5U1OJ2lxOS6aOb/vYPaRHVyJv34TlZvNhT5lazO8YmP8PXKanFBERP5NJf1fVNJFIHrfj1ycN5Kk8NMA2POXJW+vj/Gq3NbkZHI/YhLjmX1kB9MO/Ux4/PWHcrjZXOhdphZPV2pCfpV1ERGnoZL+Lyrpkp0lhp/h0tfPEr3nBwAsdndydxqLb+tRWFx002FWEZMYz9zfdzL10BbCrl0v6+42O0+Wr8/wio3J5ZbD5IQiIqKS/i8q6ZIdGYbB1Z9ncSloFI5rUQB4BLQg3xOTcc1XyuR0klFiExOYd3QnUw5uTinruVxz8EylJvR/uB45XOwmJxQRyb5MLemGYTBnzhwWLFhAaGgoxYsXZ/DgwXTo0CFln6NHjzJ+/Hj27t2Lu7s7DRo0YPTo0eTJkydln4MHDzJ+/HgOHTqEp6cnXbp0YcSIEdjtaf8PjEq6ZDdJEaFcmDWEmP0rALDlzEfe3hPwrt1TD8PJJqIT45nx289MPbiFmKQEAAp45OKFqs3pWroaLnparIjIA2dqSZ86dSoTJ05kxIgRVKlShS1btjBz5kw+/fRT2rZty+nTp3n00Ud5+OGHGTRoEBEREXzyyScUKFCAhQsXAhASEkKXLl2oWrUqffv25dixY3z66ad069aNN954I82ZVNIluzAMg6hdC7k47xkcMVcA8KrVDf8nJmtJxWzqclw0E/dvYN7RXSQ6kgF4KFc+xtRsyyNFypmcTkQkezGtpCcmJlK/fn06dOjA2LFjU7b37duX5ORkgoKCGD16NPv27eOnn37Czc0NgA0bNvD2228zf/58ihQpwuuvv862bdtYs2YNrq7X58wGBQXx3nvvsXHjRvz9/dOUSyVdsgNHXBQX5j5N1I6vAbB6+uH/xBd41+5hcjJxBqeiwvl431q+P/YrBtf/E9GkUBnerNWeh3zymZxORCR7MO1Z0TabjXnz5jFkyJBU2+12O/Hx8RiGwbp16+jatWtKQQdo1qwZmzdvpkiRIgBs27aNpk2bphR0gNatW5OcnMzWrVsfzMmIZCLXTu4l5K0aKQXds3Jbir9/QAVdUhT19mNiox6s7jSCBgVKA7Dp7B+0+OEz3tz1ExF/L+MoIiIZx7SSbrVaKVu2LP7+/hiGweXLl5k+fTrbt2+nR48enDlzhujoaPLnz88bb7xBjRo1qFy5MqNGjeLKleu/mo+LiyM0NJQSJUqkOrafnx9eXl6cOHHCjFMTcUqGYXBl7SROv1efxAt/YXFxJW+fiRR87kc9lEhuqbxfQRa0epKvmvWlmHdukgwHXx3eRoPvPmb2kR0k/T0lRkQkI5UtW5YpU6YAsGvXLsqWLZvuMx7OnDlD2bJlWbp06R33a9asGa+//nq6fu3bcYonjq5Zs4aRI0cC0KRJEzp27Mgff/wBwPjx46levTqff/45586d4+OPP2bkyJHMmzePqKjrq1B4eXnddExPT0+io6Nv2n5jOsvtREVF4e2tp/BJ1pIcc4XzgQOI2fcTAHb/hygwfAHuxaqanEycncVioVWxCjQpXJavDm9j4v4NRMTHMmbnUoL+2M24up2pnq+Y2TFFJJuoUKECCxcupHTp0ul63Hz58rFw4UKKFi2arse9H05R0suXL8/8+fM5evQon3/+OUOGDEkp7f7+/nz22Wcpq0zkypWLESNGsHPnzpQR9FutQGEYBlarab8oEHEa8WcOcW5iFxIvHgPAu14f/Pt+gTWHfhiVu+dmc2F4xcZ0LVWN8XtXs/DPPRwOD6XT8i/pXaYWr9Zoja+bh9kxRSSL8/LyokqVKul+XFdX1ww57v1wihZbpEgRatasSZ8+fXj99dfZtWsXDsf1x5A3atQoVQmvX78+cH1pxhsj6LcaMY+Njb3liHhwcPAdPzSKLllJ1O5vOfVOXRIvHsNid8f/ya8oMGSOCrrcs3we3nzcoCtL2w+jgt/1aVJBf+ym8Xef8O2fwejRGyKSkW413WXnzp10796dypUr06ZNG9avX0+LFi1SpsgsWbKEsmXLcv78+VTH+ufUlVtNd/n9998ZMGAAVatWpWnTpvz4448P4Az/n2kj6REREWzatIm6deumWoGlfPnyAISGhmKxWEhISEj1vuTk63MgLRYLnp6e+Pv7ExISkmqfsLAwoqOjb5qrLpJdGMlJXP5uDFdWfASAS+6iFBzxHe7Fq5mcTLKKanmLsrzDM8z5fScf7V1DeHwMo7Yu5ps/g/mgbmfK+eY3O6KI/M1ISiTpylmzY+DiWwhLOj8k7bfffmPQoEHUrl2biRMnEhISwquvvkpiYuJ9HffChQv06dOH4sWL89FHHxEdHc3HH39MWFhYOiX/b6aVdIfDwSuvvMLw4cNTprbA9dVaACpWrEj16tVZu3Ytzz33XMqDiTZs2AD8/9zy+vXrs3HjRl5++eWUFV5Wr16NzWajVq1aD/KURJxCcmwkoVN6EHtoLQAe5R+hwLAgbN55/uOdImnjYrXxZPn6tCtekXd2L+PHEwfYfeEkrZdOZFjFxjxbuRnuemqpiKmMpEROvlYhZcqjmez5SlH8g9/StahPmzaNPHnyMHXq1JSumDNnTkaPHn1fx509ezbJycnMmDEDX19fAEqUKEH37t3vO/PdMm26i5+fH71792b69OlMnz6dHTt28MUXXzBhwgS6detGyZIlef755zl37hxDhw7l559/ZsGCBbz77ru0aNEiZcR90KBBXLp0iSFDhrBx40ZmzZrFuHHj6N69OwULFjTr9ERMkXjpJKffb5hS0H1bv0ChF1aooEuGyu+RkylNehPU8klK5MxDkuFg0oGNtP5xInsuhvz3AURE7lFwcDCNGjVK9ZT59u3b4+Jyf+PQe/bsoVq1aikFHaBy5coPtFuaeuPoq6++SoECBVi8eDGTJk0if/78jBgxgkGDBgHXR8tnz57NhAkTePrpp/H29qZr166MGjUq5RilSpVi5syZjB8/npEjR+Lr68uAAQMYMWKEWaclYoq4Y7s493lnkq9eBJud/AOnk7P+E2bHkmykUaGHWNvpWT7fv4EpBzfzV+QlOi+fysDy9RhdrRUedtf/PoiIpCuLi53iH/yWZae7REZG4ufnl/rruLiQO/f9PTk7MjKSYsVuXrkqb96893XctDC1pNvtdgYPHszgwYNvu0+NGjUICgq643Fq1KjBt99+m97xRDKNqN2LOD+jP0biNayevhQc8R0e5RqbHUuyIXcXO6Ort6Jd8QBe2LqY38JD+erwNtaeOsL4+l1oUDB9l00Tkf9mcbFjz1vc7BgZwtfXl8uXL9+0PTIyMuXPNxYguXFf4w0xMTF3PO6t5p9HRETcY9K0c4rVXUTk3hiGQfiKjwmd0hMj8Rp2/9IUHbtdBV1MF5C7EMs6PMMr1VvhZnPhVHQ4PVcH8tK274iMjzM7nohkEXXr1mXTpk3Exf3/vyvbt2/n2rVrKZ/fWA0wNDQ0Zdvx48fvWLjr1KnDnj17uHTpUsq2v/76i9OnT6dj+jtTSRfJpAyHg8sLX+byt9dvjslRpiFFx2zDNX8Zk5OJXGe32nimUlNWdxxJjb8feLTgj19o/sNnbD33l8npRCQrePrpp4mLi+PJJ59kw4YNLFmyhJdffjnVPnXq1CFHjhx88MEHbNmyhRUrVjB8+HB8fHxue9x+/frh7e3NwIEDWbNmDStWrGDYsGGp5r5nNJV0kUzISErkwlcDubJqAgBeNR6j0EurdYOoOKXSPvn4rs1TvFO7Azlc7ITGRtJzdSBv7PyRuKSE/z6AiMhtFC9enK+//hq73c5zzz3H5MmTb1rZxdvbm4kTJ5KcnMzw4cP5/PPPefrppwkICLjtcX19fVmwYAGFChVi9OjRfPDBBzz++OOUK1cuo08phcXQkydSubG04z8XyRdxJo74WEKn9CBm/woAcjV9inx9J2Gx2kxOJvLfjkde5rmfv2XvpVMAlMqVl88bdqdK3iImJxORrKRs2bI8++yzDB8+3Owo90wj6SKZSHJMBGc+apVS0P06vUG+JyaroEumUTJXHpa0fYrR1VrhYrFyLPISnZZ/ySf71pLoSP7vA4iIZBMq6SKZRHJ0OGc+asm1v7aDxULePhPJ8+ibKXeti2QWLlYbIyo3ZVmHpynr40+y4eDTX9fTefmX/BVx0ex4IiJOQdNd/kXTXcQZJV29xNmPWhF/ej9YbeQfNIuc9R43O5bIfbuWlMhH+9Yy/dDPGBi42VwYW7Md/crV0Q+gIpKtaSRdxMklRV7gzIePXC/oNhcKDAtSQZcsw93Fztiabfm2zWAKe/kQn5zEmJ1LGbRhHleu3X4NYxGRrE4lXcSJJV05x5n/NSPh7G9gs1Pw6W/xrtnV7Fgi6a5u/pKs7fQcj5asAsDqU4dpsfRztoceMzeYiIhJVNJFnFTSlXOc/l8zEkJ/x+LiRsGRS/Cq1snsWCIZxtvVnUmNe/JZw+54urhyPvYqPVYF8tHeNSTpplIRyWZU0kWcUNLVS5z5qCWJF/7E4pqDgs8txatyW7NjiTwQXUtXY2XHkVTKXQgDg8/3b+CxFdM4HRVudjQRkQdGJV3EySTHXOHsR61IOHcEi4srBUd+j2dAC7NjiTxQJXPl4Yd2w3gqoBEAey6dotWPE1l24oDJyUREHgyVdBEnkhx3lbOftP3/m0Sf/lYFXbItV5sLY2u2ZX7LgeTN4cXVhGsM3RTEmJ1LiU9OMjueiEiGUkkXcRKO+BjOfdqBa8d3g8VKgafm4VW1g9mxREzXpFAZ1nR6lsYFHwJg9pEddFkxlVOa/iIiWZhKuogTcCRc49zER4n7YysA+Qd9hXet7ianEnEeeXN4M7fFAF6s2gILFvZfPkObHyey5tRhs6OJiGQIlXQRkxmOZM5P70vsb+sByPfEZHLWf8LkVCLOx2a18lyVR1jQ6knyuHsRmXCNgevn8u4vK0jU6i8iksWopIuYyDAMLs5/lujgJQDk6f4/fJoNNTmViHNrULA0qzqNpLZ/CQCmHdpCt5XTORcTaXIyEZH0o5IuYqLwnz4gcsOXAPi2eh7fNi+anEgkc8jvkZOFrQfxTKUmAARfDKH10olsPvuHucFERNKJSrqISSI3BxK25A0AvOv2Jk+P8VgsFpNTiWQeLlYbr1RvzZzm/cnlmoPw+Bj6rJnFFwc2YhiG2fFERO6LSrqICaL3/ciF2cMA8AhoQf4nv8Ji1V9HkXvxSJFyrO40ksp5CmNg8L89qxmycT7RifFmRxMRuWdqBSIPWNzx3YRO6QWGA7fi1Sn49CIsLq5mxxLJ1Ap7+fJdm6fo8VANAFaG/Eb7n77gWOQlk5OJiNwblXSRByjxcgjnPuuMkXgNe75SFBq1DGsOb7NjiWQJ7i52Pq7/GP+r+yh2q42/Ii/R7qcvWBXym9nRRETSTCVd5AFJjrvK2c86knz1AlYPHwo9/xMuOfOZHUskS7FYLPQpV5vFbYbg75GT6MR4Bm2Yx/g9q0l2OMyOJyJy11TSRR4AIzmJ0Ck9SThzCGwuFByxGNcCZc2OJZJlVc9XjJUdRlDbvzgAEw9spN+62VyJjzU3mIjIXVJJF8lghmFw8etniT24GgD//lPxeLipyalEsr58Ht5803owAx+uB8Cms3/Q/qcv+CPigsnJRET+m0q6SAaLWDuJyA1TAfBr/wq5Gg4wOZFI9mG32ninTkc+b9QDN5sLIVHhdFw2hXWnj5gdTUTkjlTSRTJQzIFVXFrwAgBeNbuSu8u7JicSyZ4eK1WV79sOJf/f89QHrJvL5AObtJ66iDgtlXSRDJJw4S9Cpz5+fanFEjXJP3i21kIXMVGlPIVZ3uEZquYtgoHBuD2rePbnb7mWlGh2NBGRm6gxiGQAR1wU5yZ2wREbgS2nPwVHLMbqmsPsWCLZnr9HTha1HsJjpaoCsOTYPrqunM6F2KsmJxMRSU0lXSSdGYbB+cABJJz97fpKLs98i92vsNmxRORv7i52PmvYnddrtMGChV8vn6btT1+w//IZs6OJiKRQSRdJZ+E/jSN6z/cA5Hv8c3KUaWByIhH5N4vFwrCKjZndvB9edjcuxF6ly4qp/HD8V7OjiYgAKuki6Sr612WEff8GALkaDyJX06dMTiQid/JIkXL82H44xbxzE5+cxDObv+HDPatxGHrwkYiYSyVdJJ0knP+D89P6gmHgXroueftMxGKxmB1LRP5DGR9/lrUfTv0CpQCYdGAjQzcGEZeUYHIyEcnOVNJF0oEjPpZzX3THEXcVm08BCj6zCKvdzexYInKXfN09md9yIP3K1QFgRcghuq6czsXYKJOTiUh2pZIukg4uzh9BwpmDYLVRcPg3uPgUMDuSiKSR3Wrj/bqdebt2B6wWC/svn6HDssn8fuW82dFEJBtSSRe5T5E/z+Lqz7MByNNtnG4UFcnknixfn5mPPIGHiytnYyLovPxLNp39w+xYIpLNmFrSDcNg9uzZtGrVikqVKtGxY0d++umn2+7/wQcfUL58+Zu2Hzx4kL59+1K1alUaNGjAhAkTSEzUwykk48WfPsDFuc8A4Fm1I76tR5mcSETSQ/MiD7Ok7VMpTyjtt3Y2837faXYsEclGTC3p06ZNY/z48XTu3Jlp06ZRv359XnzxRVasWHHTvr/88gvz5s27aXtISAj9+/fHzc2Nzz77jIEDBzJr1izGjRv3IE5BsrHkuKuc+6I7RuI17HlLkH/QLN0oKpKFBOQuxE/tnybAryDJhoNXd/zA27uXkezQyi8ikvEshmEYZnzhxMRE6tevT4cOHRg7dmzK9r59+5KcnExQUFDKttjYWDp27EhiYiKXLl3i8OHDKa+9/vrrbNu2jTVr1uDq6gpAUFAQ7733Hhs3bsTf3z9NuWrUqAFAcHDw/ZyeZHGGYRA6pSfRvyzG4uJKkTFbcS9e3exYIpIBYhLjeWbzN6w9fQSAlkUe5ovGvfCwu5qcTESyMtNG0m02G/PmzWPIkCGpttvtduLj41Nt+/DDD8mTJw9dunS56Tjbtm2jadOmKQUdoHXr1iQnJ7N169aMCS/ZXuTGqUT/shiAvL0/VUEXycI87W4ENuvL4ArX7zdZc/oIj62cxvnYqyYnE5GszLSSbrVaKVu2LP7+/hiGweXLl5k+fTrbt2+nR48eKftt27aNpUuXMm7cOKzW1HHj4uIIDQ2lRIkSqbb7+fnh5eXFiRMnHsi5SPYSf+YQlxa8CIB37R56YJFINmCzWnmzVns+qNsZq8XCwbCzdPhpMkfCtfKLiGQMF7MDAKxZs4aRI0cC0KRJEzp27AhAVFQUr7/+OiNHjrypiN94HcDLy+um1zw9PYmOjr5p+43pLLcTFRWFt7d3ms9BsgdHQhyhUx/HSLyGS57i5Ov3peahi2QjT5SrQxEvX4ZtCiI0NpLHVk5lRrO+KQ9CEhFJL06xBGP58uWZP38+Y8eOZe/evSlTYD744APy589P//79b/m+G9Ppb1WSDMO4aeRd5H5dWvgyCWcOgdVGgaFfY/PIZXYkEXnAmhYuy5K2T+HvkZOrCdfos2Ym3x/71exYIpLFOMVIepEiRShSpAg1a9bEy8uL0aNHM3nyZJYvX853332Hw+FI+QBISkrCarWmjKDfasQ8Njb2liPi/3VD6H+NtEv2Fb3vRyLXTwEgd+e3yFG6jsmJRMQs5f0K8mO74fRdO5M/Ii4yYss3hMZGMiygkX67JiLpwrSh5oiICH744QcuXLiQavuNddADAwOJj4+nffv2VKhQgQoVKjBlyhSSk5OpUKECkydPxtPTE39/f0JCQlIdIywsjOjo6FtOkRG5F4lXznL+q0EA5CjXBL/2o01OJCJmK+Tlw5K2Q6ntf/2/NR8Er2TMzh+1RKOIpAvTSrrD4eCVV15h4cKFqbZv27YNgO+++47Fixen+ujevTs2my3lzwD169dn48aNJCQkpBxj9erV2Gw2atWq9eBOSLIsw5HM+en9cUSHYfX0I/+QOVisNrNjiYgT8HHzIKjVk3QsUQmAOb/vYMjG+cQlJfzHO0VE7sy06S5+fn707t2b6dOn4+7uTsWKFdmzZw/Tpk2jW7dulCxZ8qb3bNq0CYCKFSumbBs0aBDLly9nyJAh9OvXj5MnTzJhwgS6d+9OwYIFH9TpSBZ2ZdUE4o5sACD/wBnY/QqbnEhEnImbzYUvGvekgKcP0w5tYfWpw/RYFcjs5v3wc/c0O56IZFKmPcwIrj/QaPbs2SxevJhz586RP39+unXrxqBBg2550+ekSZP48ssvUz3MCK7PMx8/fjxHjhzB19eXzp07M2LECOx2e5oz6WFG8k/xpw9w6u3aGEkJ5GoyBP/+X5odSUSc2FeHt/HWrmUYGJTImYf5LQdQzDu32bFEJBMytaQ7I5V0ucGRGM+pd+qQcPoAdv/SFHtnL1Y3jYqJyJ0tP3mQkVsWEp+cRB53L2Y370eVvEXMjiUimYzWKBS5jfCl75Bw+gBYrOQfPFsFXUTuSrviFfmm1SB83Dy4fC2abqums/7072bHEpFMRiVd5Bbi/tpB+PLxAPi1e5kcpeuanEhEMpOa/sX5oe1Qinj5EpeUyMD1c/n2T/2GVkTunkq6yL844mM4P6M/GA7cilQmd+c3zY4kIplQaZ98LG03nAC/giQbDkZtXcyXBzebHUtEMgmVdJF/ubRwNIkX/sLi4kr+IbOxuLiaHUlEMql8Ht4sajOEevmvr1j2fvBK3t29HIehtdRF5M5U0kX+IebQGiI3XF/BJfejb+NWpJLJiUQks/N2dWduiwG0K359+eBpv/3M8z8vItGRbHIyEXFmKukif0uOu8qFmYMBcC9dD982L5icSESyCncXO1Ma9+KJcnUA+O7YPgaum0tsoh56JCK3ppIu8rfLC0eTFH4Gi2sO8g+epaeKiki6slmtvF+nE6OqNAdg49mj9FwdyJVrMSYnExFnpJIuAsQe2UTkpukA5OnyLq7+pU1OJCJZkcViYVTV5oyr2xkLFvZeOkWXFdM4Fx1hdjQRcTIq6ZLtOeJjuTBrCADuJWvj03KkyYlEJKvrW64OXzbtjavVxp+RF+m0/Ev+iLhgdiwRcSIq6ZLthS15g8SLx8Bmx//JGZrmIiIPRPviFZnXciBedjdCYyPpsmIaey6GmB1LRJyESrpka3F/7eTKms8AyN1pLG6FKpgbSESylfoFSrG4zRDyuHsRER9Lj1WBejqpiAAq6ZKNORLjuTBzEBgGbkUq49f2ZbMjiUg2FJC7EN+3G0oxbz+uJV9/Oul3x/aZHUtETKaSLtlW+I/vk3DuCFht+D8ZiMXFbnYkEcmmSuTMw/dth1HBrwDJhoNntyxk1uHtZscSEROppEu2FH/6AOErPgTAt82LuBevZnIiEcnurj+d9Clq+xcHYOyuH/n81/UYhmFuMBExhUq6ZDuGw8GF2cMgOQl7/jLk7vSG2ZFERADI6erO/JYDaVa4LAAf7VvLu78sV1EXyYZU0iXbidw0nWvHdgLg328KVld3kxOJiPy/HC6uBDbrS6cSlQGY/ttWXty2mCRHssnJRORBUkmXbCUp4jyXF70GQM76ffF4uKnJiUREbuZqc2Fiox70LVsbgIV/7mHYpiDik5NMTiYiD4pKumQrl755AUdcJFZPP/L0+MjsOCIit2WzWvmgbmeeqdQEgJUhvzFg3RxiExPMDSYiD4RKumQbMYfWELXzGwDy9vgQl5x5TU4kInJnFouFV6q35rUabQDYcu5Peq0OJCI+1uRkIpLRVNIlW3AkxHFxztMA5CjTkJwNB5icSETk7g2v2Jj/1XsUCxb2XDpF15XTuRgbZXYsEclAKumSLYT/9AGJl46DzU6+flOwWCxmRxIRSZM+ZWszuXFPXCxWfr9ynkdXTOV0VLjZsUQkg9xTSU9KSmLfvn2sWLGCy5cvEx0dTWRkZHpnE0kX8eeOEL7i+vxzvzYv4laovMmJRETuTceSlZnZvB/uNjshUWF0XjGVPyIumB1LRDJAmkv6ypUradKkCb179+aFF17gzz//ZM+ePTRu3JjAwMCMyChyzwzDuD7NJTkRe96S+HV83exIIiL3pVnhsnzdciDedjcuxF7lsRXT+PXSabNjiUg6S1NJ37p1Ky+88ALFixdn9OjRKQ9XKFy4MGXKlOGTTz5h6dKlGRJU5F5E7VpI3NHNAOTrOwmraw6TE4mI3L/a+Uvwbesh5Hb35Ep8LD1WzWBb6DGzY4lIOkpTSZ88eTIBAQHMnTuXTp06pWwvVaoUQUFBVK1alTlz5qR7SJF74bgWzaVvXgLAq3pnPCu1NjmRiEj6qZinEEvaDqWgZy5ikhJ4Yu0s1p/+3exYIpJO0lTSjxw5Qrt27bBab36bi4sL7du358SJE+kWTuR+hP34PskR57DY3cnb8xOz44iIpLtSufLyfdthlMiZh/jkJAZtmMeykwfNjiUi6SBNJd1ut5OUdPunnUVERGC32+87lMj9Sjj/B1dWfwqAX7vR2PMWNzeQiEgGKeTlw3dtnqKsjz+JjmSGbwpi8V97zI4lIvcpTSW9Vq1aLF68mPj4+Jteu3jxIkFBQVSvXj3dwoncC8MwuDj/WUhOxCVPcXzbvmR2JBGRDJXPw5vFbYZQOU9hHIbBcz8vYu7vO82OJSL3IU0l/fnnn+fSpUt07NiRKVOurzW9fv16xo0bR/v27YmOjmbkyJEZlVXkrsTs+5HYQ2sAyNd7gm4WFZFswdfdkwWtBlHLvzgAr+34gWmHtpgbSkTumcW4sUTLXTp69Cjvvfcev/zyS6rtAQEBjBkzhipVqqRnvgeuRo0aAAQHB5ucRO6FIyGOkNcrknjpBB4VW1Fo1HI9uEhEspXYxAQGbZjHlnN/AjCqSnOer/KI/i0UyWTSVNL//PNPSpcujcViISIiglOnTuFwOChUqBB58+bNyJwPjEp65ha29F3Cvn8LbHaKv38A1/xlzI4kIvLAXUtKZPimINacPgLAUwGNGFOjjYq6SCaSpuku/fv355NPrq+S4ePjQ6VKlahSpUqWKeiSuSVeOkn4sv8B4NvqeRV0Ecm23F3sTGvWh44lKgEw7dAWXtvxAw7DYXIyEblbaSrpsbGxFC5cOKOyiNyXS9+Oxki8hs2nILn1ZFERyebsVhuTGvWkx0PXf0M87+gunv95EUmOZJOTicjdSFNJ79evHzNnztRUEHE6cX9sJfqXxQDk7T4Oq7uXyYlERMxns1r5qH4XBjxcD4Dvju3j6c3fkJB8++WURcQ5uKRl50OHDnHp0iX69u2Lu7s7Pj4+Nz3YyGKxsG7dunQNKXInhsPBxQUvAOBWoibedXqbnEhExHlYLVbeqd0BT7srXxzYxPKTB4lLSmBa0z7kcNGzTUScVZpKenx8PAEBARmVReSeRO34mvgT13+7k6/3J1hu8URcEZHszGKx8Er11ni6uPHh3tVsOHOUfmtnMat5PzztbmbHE5FbSPMSjOnJMAzmzJnDggULCA0NpXjx4gwePJgOHTqk7LNy5UoCAwM5fvw4OXPmpF69erz44ovkzp07ZZ+DBw8yfvx4Dh06hKenJ126dGHEiBH39PRTre6SuTjiYzj5ysMkXTmLV61uFBz+jdmRREScWuBvW3lr9zIAquctytwWA8jlpudJiDgbU4ccp02bxvjx4+ncuTPTpk2jfv36vPjii6xYsQKAFStW8Nxzz1GhQgUmTZrEc889x86dO+nfvz8JCQkAhISE0L9/f9zc3Pjss88YOHAgs2bNYty4cWaemjwgV1ZNIOnKWSwubuTt9j+z44iIOL1BFRowvn4XLFjYc+kUPVbNIOxatNmxRORf0jSS/sgjj9zVfuvXr//PfRITE6lfvz4dOnRg7NixKdv79u1LcnIyQUFBdOrUCX9/f6ZPn57y+v79++nevTuTJ0+mefPmvP7662zbto01a9bg6uoKQFBQEO+99x4bN27E39//bk8P0Eh6ZpJ45SwnR5fDSIjFt91o8nb7wOxIIiKZxvfHfuW5n78l2XDwUK58LGg9iPweOc2OJSJ/S9NIesGCBW/6yJ8/Py4uLpw9exa73U6TJk3u6lg2m4158+YxZMiQVNvtdjvx8fEYhkG9evXo3r17qtdLliwJwKlTpwDYtm0bTZs2TSnoAK1btyY5OZmtW7em5fQkkwlbPAYjIRZbznz4tX/F7DgiIpnKo6WqMK3p47habfwZeZGuK6ZxNjrC7Fgi8rc03Tg6b96827526NAhBg0aRK1ate7qWFarlbJlywLX56aHhYWxZMkStm/fzjvvvIPFYmH06NE3ve/GyjGlS5cmLi6O0NBQSpQokWofPz8/vLy8OHHixN2emmQy107u4eq2uQDk7vI2thwa/RERSavWxSows3k/nlw/l5NRYXRdOY2FrQdT1NvP7Ggi2V6aSvqdBAQE0KdPHyZPnkyrVq3S9N41a9YwcuRIAJo0aULHjh1vud+pU6f48MMPqVChAg0aNODy5csAeHndvCa2p6cn0dE3z7G7MZ3ldqKiovD29k5TfnmwDMPgUtD1JRddC1ckV6MnTU4kIpJ5NSlUhrktBjBg3RxOR1/hsRXTWNh6ECVz6WniImZK1xtH8+TJw8mTJ9P8vvLlyzN//nzGjh3L3r17b5oCA3Ds2DGeeOIJXFxc+Oyzz7BardyYTm+xWG7a3zCMm9Zwl6whZu9S4v74GYC8vT7GYrWZnEhEJHOrX6AUX7cciJfdjdDYSLqunM4fERfMjiWSraXbSPqlS5dYsGABBQsWTPN7ixQpQpEiRahZsyZeXl6MHj2affv2UbVqVQB27drFiBEj8PDwYM6cORQtWhT4/xH0W42Yx8bG3nJE/L9uCP2vkXYxl5GcxOXFrwPgUak1nhWam5xIRCRrqOlfnAWtBtFnzVdcjIui64rpfNP6Scr7pf2/6yJy/9JU0m+3uktCQgLh4eEkJyfz5ptv3tWxIiIi2LRpE3Xr1k21Akv58uUBuHDh+k/wK1as4OWXX6ZEiRIEBgam2tfT0xN/f39CQkJSHTssLIzo6Oib5qpL5hf58ywSQn8Hi4W83bTMpohIeqqatwgLWw+m1+qvCI+PodvKGQS1epLKeQqbHU0k27nv1V0KFixIqVKlaNOmDVOnTqVXr153dSyHw8Err7zCwoULU23ftm0bAGXKlOHnn3/mpZdeomrVqixYsOCWyynWr1+fjRs3pqybDrB69WpsNttd38QqmYMjPpawH94GIGe9vrgVqWRyIhGRrCcgdyEWtRlCHncvIhPi6LlqBnsuhvz3G0UkXaXb6i5p5efnR+/evZk+fTru7u5UrFiRPXv2MG3aNLp160bhwoXp378/Hh4eDB06lL/++ivV+wsUKIC/vz+DBg1i+fLlDBkyhH79+nHy5EkmTJhA9+7d72nqjTivK2s+JzkiFIuLG7m7vG12HBGRLKucb34WtxlCj9WBXIi9Sq/VXzGnRX/q5i9pdjSRbCNNDzN64oknGDZsGHXr1r3l6xs2bOCTTz5h+fLld3W8xMREZs+ezeLFizl37hz58+enW7duDBo0iD179tCnT5/bvvfZZ59l+PDhwPV55uPHj+fIkSP4+vrSuXNnRowYgd1uv9tTS6GHGTmn5KjLnHj5IRxxV/Ft/QJ5e443O5KISJZ38moYPVbN4GxMBO42O7OaP0HDgg+ZHUskW7hjSY+Li+PKlSspnzdr1ozXX3/9lnPTHQ4HgYGBfP/99+zfvz9j0j4AKunO6WLQKCLWfI7Vw4cS4//E5qU1fEVEHoQz0VfosWoGIVHhuNlcmN60D48UKWd2LJEs744lPTw8nNatWxMVFXVXBzMMg/r16/PVV1+lW8AHTSXd+SReOsGJVx6G5ETydP8ffm1fMjuSiEi2EhoTSY9VMzh+9TJ2q40vm/SmdbEKZscSydL+c7rL5s2bOXjwIIZhMHnyZFq0aJHypNB/slqt+Pn50a5du0z9MCCVdOcTOq0vUTuCcPErTPH//Y7VNYfZkUREsp2LsVH0Wh3I0YgL2CxWJjXqQceSlc2OJZJl/eeNo40bN6Zx48YAnDt3jp49e1K5sv5SyoNxLWQfUTuCAMj96Fsq6CIiJsnn4c2iNkPotTqQ38JDeWbLNyQ4kuhaurrZ0USypDQtwThu3Lj/LOjh4eH3FUjkny4veg0A10IVyFn/CZPTiIhkb37unixsPZjKeQrjMAye/3kxXx/dbXYskSwpzU8c/eGHH1izZg2xsbE4HI6U7cnJycTExPDXX39x6NChdA0p2VPs75uJPbQGgDzdPsBitZmcSEREfNw8+KbVIJ5YO4tfLoYwevsSEpKTGFC+ntnRRLKUNJX0GTNmMGHCBOx2O15eXly5coX8+fMTERFBXFwc7u7u9O3bN6OySjZiGAaXvxsLgHvpenhWbmdyIhERucHb1Z35LQfSf90cdpw/zthdP5LgSOKpgEZmRxPJMtI03WXJkiWUK1eO7du3s3DhQgzDYO7cuQQHB/PGG28QHx+v+eqSLmIPruLan9efPpvnsXewWCwmJxIRkX/ytLsxt0V/Gv+9bvq7v6xg4v4NJqcSyTrSVNLPnj1Lp06d8PLyokiRIuTKlYvg4GBsNhu9e/embdu2zJkzJ6OySjZxfRT9DQA8yj+Cx8NNTU4kIiK3ksPFla8eeYLmf6+bPn7vGj7au4Y0PCdRRG4jTSXdxcUFT0/PlM+LFSvG0aNHUz6vXbs2J0+eTLdwkj1FBy8hPmQvALkfe9fkNCIicifuLnamN+1Dm7/XTf98/wbeC16poi5yn9JU0kuVKsW+fftSPi9RokSqm0SvXr1KQkJC+qWTbMdwJBP2/ZsAeFZpT45StU1OJCIi/8XV5sKXTXrT6e9106cd2sLYXT/iMBz/8U4RuZ00lfQuXbqwZMkSXnzxRWJjY2nWrBnBwcF88cUXrFixgtmzZ1OunB4VLPcuaucCEs4dASD3o2+bnEZERO6Wi9XGxIY96P73uumzj+zgle0/qKiL3KM0re7Sq1cvzp8/z9dff42LiwstW7akXbt2fPHFFwB4eXnx4osvZkhQyfqMpETCvr9ezL1qdcO9WBVzA4mISJrYrFY+bvAYrjYX5h/dRdAfu0lITuKTBl2xWdM0LiiS7VmMNEwau3LlCr6+viQlJeHi8v/9Pjg4mIiICKpWrUru3LkzJOiDUqNGDeD6OcmDFbFpOhdnDwOLleLvH8S1oH4rIyKSGRmGwVu7l/HV4eurdHUqUZnPGnXHruddiNy1NP1Y++ijjzJ58uRUBR2uF9vmzZtn+oIu5nEkXCP8x/cByFm/rwq6iEgmZrFYeKtWe4YFNAZg6Yn9DNsYREJyksnJRDKPNJX08PBw8ubNm1FZJBuL3DiNpPAzYLOTu9MbZscREZH7ZLFYeK1Ga56r8ggAq079xuAN87mWlGhyMpHMIU0lvUOHDixcuJAzZ85kVB7JhhzxsYQv/xCAXI2fxJ63uLmBREQkXVgsFl6s2oLR1VoBsP7M7zy5fi5xSVoJTuS/pOnGUavVyvHjx2nVqhVFixYld+7cWP91I4jFYtEDjSRNIjdNJ/nqBSwurvh1eM3sOCIiks5GVG6Km82Fd35ZzuZzf/LE2tnMbt4PT7ub2dFEnFaaSvq2bdvw9fUFID4+nnPnzmVIKMk+ro+ijwcgZ+NB2H0LmZxIREQywpCAhrjaXBizcyk7zh/n8TUzmdtiADld3c2OJuKU0lTSN2zYkFE5JJuK3DTj/0fR2402O46IiGSg/g/XxW618cr27wm+GEKv1YF83XIgPm4eZkcTcTr3vGjphQsX2L9/P1FRUSQkJOBw6GEFkjaOhDjCV/w9it7oSex+hU1OJCIiGe3xsrX4tGFXrBYL+y+foeeqQMKvxZgdS8TppLmk79mzhy5dutCkSRN69uzJoUOH2L17N02aNGHFihUZkVGyqMhNM0iOPA82u0bRRUSyka6lq/NFo57YLFYOhZ+j28rpXIqLMjuWiFNJU0k/cOAAAwYMICYmhn79+qVsz5UrFy4uLrz44ots3rw53UNK1uNIuJYyip6r8ZPYcxcxOZGIiDxIHUtWZmrT3titNo5GXKDryumExkSaHUvEaaSppH/++ecULlyYpUuXMmTIEG48rLRixYr8+OOPlCpVimnTpmVIUMlaIjcHkhwRqlF0EZFsrE2xAAKb9cXN5sKxyEt0XTmds9ERZscScQppKun79u2jS5cuuLu7Y7FYUr3m5eVF9+7d+fPPP9M1oGQ9joRr/78uesMB2HMXNTmRiIiY5ZEi5Zj5yBO42+yERIXRdeU0TkWFmx1LxHRpnpPu6up629fi4+N1A6n8p8gtX5Ecce76KHr7V8yOIyIiJmtcqAxzW/THw8WV09FXeGzFNI5HXjI7loip0lTSK1euzLJly275WmxsLIsWLaJixYrpEkyyJkfCNa6kjKL3x56nmMmJRETEGdQrUIqvWw7Ey+5GaGwkXVdO54+IC2bHEjFNmkr6yJEjOXz4MH369OGHH37AYrFw4MAB5s6dS6dOnThz5gxDhw7NqKySBVzdMpOkK2fB5oJfO42ii4jI/6vpX5wFrQaRy9Wdi3FRdFs5ncPhoWbHEjGFxbhx9+dd2rZtG2+++SZnzpxJtT1v3ryMHTuWli1bpmvAB61GjRoABAcHm5wk63EkxnNydBmSws+Qq/Eg/AfoJmMREbnZobCz9Fr9FVfiY/Fx8yCo5UAq5dGzNCR7SXNJBzAMg8OHD3Pq1CkcDgeFChUiICAAF5c0PcDUKamkZ5zIzYFcmPUUWG2U+PAo9rwlzI4kIiJO6vcr5+m5KpDL16LJ6erOvBYDqZ5PCw1I9nFPTxy1WCwUKFCAIkWKULJkSUqVKpUlCrpkHCM5ifDlfz9dtO7jKugiInJH5Xzzs7jNEPw9cnI14Rq9Vwey6/wJs2OJPDBpLunBwcH07NmTBg0a0K1bN7p06ULdunUZNGgQf/zxR0ZklCwg6pfFJF48BhYLvu1eNjuOiIhkAqV98rG4zRAKeuYiJimBPmtnsvXcX2bHEnkg0jTdZdeuXTz55JN4eHjQsWNHihcvTnJyMidPnuSnn37CMAwWLFhAmTJlMjJzhtJ0l/RnGAYhY6uScOYgXjW6UPCZRWZHEhGRTOR0VDg9VgVyKjocN5sLgc360rRwWbNjiWSoNJX0Xr16ER4ezoIFC/Dz80v12uXLl+nevTtlypRh6tSp6R70QVFJT3/R+37i3OedASj61m7ci1c3N5CIiGQ652Ii6bFqBieuXsbVamNq08dpWbS82bFEMkyaprv8/vvv9OrV66aCDpAnTx569+7NL7/8km7hJPMzDIPwn8YB4FGxlQq6iIjck4KeuVjcZghlfPKR4EhmyIb5LDt50OxYIhkmTSU9d+7chIWF3fb1+Ph4vLy87juUZB1xv2/i2vFdAPi1f9XkNCIikpn5e+RkUZshlPcrQJLhYPimIJYc22d2LJEMkaaSPnToUObOncuGDRtuem3//v3MnTuXp59+Ot3CSeYXvuz6KHqOMg3wKNvQ5DQiIpLZ5Xb3YmHrwVTKXQiHYfDslm9Z+KemqErWk6Z1E3/99Vdy587N008/nbL0ot1u5/Tp0xw8eBBXV1eWLVvGsmXLUt5jsViYM2dOugcX5xd3fDexv60HwK+9ni4qIiLpw9fNgwWtBtF37Sz2XjrFC1sXk5icTJ9ytc2OJpJu0jSSvn37dgAKFChAXFwchw4dYt++fVy+fJkCBQqQO3duzpw5k+rj9OnTtz2eYRjMnj2bVq1aUalSJTp27MhPP/2Uap+tW7fy2GOPUblyZZo1a8bMmTNvOs7Bgwfp27cvVatWpUGDBkyYMIHExMS0nJpkgPBl/wPArVhVPCq2NjmNiIhkJbncchDU6klq+xcH4JUd3xP421ZzQ4mkozSNpN9qmsv9mDZtGhMnTmTEiBFUqVKFLVu28OKLL2Kz2Wjbti179+5l6NChtGnThmeffZY9e/Ywfvx4DMPgySefBCAkJIT+/ftTtWpVPvvsM44dO8ann35KdHQ0b7zxRrrmlbsXf/Y3YvYuBa6PolssFpMTiYhIVuNld2Nei4EMXD+XraF/8dbuZSQ4khlesbHZ0UTuW5qWYExPiYmJ1K9fnw4dOjB27NiU7X379iU5OZmgoCD69+9PbGws3377bcrrH330Ed9++y3btm3D1dWV119/nW3btrFmzRpcXV0BCAoK4r333mPjxo34+/unKZeWYEwfodP6ErUjCHv+shT/4CAWq83sSCIikkXFJSUyZMN8Np49CsCLVVvwXJVHTE4lcn/SNJKekJDAjBkz2LZtG5cuXcLhcNy0j8ViYd26df95LJvNxrx58/Dx8Um13W63ExsbS3x8PMHBwTz33HOpXm/VqhWBgYHs3buXOnXqsG3bNpo2bZpS0AFat27N22+/nTJVRh6shIvHidr5DQB+7V5WQRcRkQyVw8VO4CN9Gb4piNWnDvPxvrUkJCfxUrWW+k2uZFppKunvv/8+CxcuJH/+/BQqVAirNU1T2lOxWq2ULXv9aWGGYRAWFsaSJUvYvn0777zzDqdPnyYxMZESJUqkel+xYsUAOHHiBJUrVyY0NPSmffz8/PDy8uLEiRP3nE/u3ZXVn4LhwMWvCDnrPm52HBERyQbcbC5Mbfo4IzZ/w7KTB5l4YCPxyUmMqdlWRV0ypTSV9LVr19K+fXs+/vjjdA2xZs0aRo4cCUCTJk3o2LEjR44cAbhp3XVPT08AoqOjiYqKuuU+N/aLjo6+afuN6Sy3ExUVhbe3d9pPQgBIjrrM1Z9nAeDb6nksLnaTE4mISHZht9r4onFP7FYb3x//lWm//cy15CTerdMBq+XeBxZFzJCm79jk5GRq1qyZ7iHKly/P/PnzGTt2LHv37mXIkCHcmCp/u59+rVbrHfcxDOO+Rvrl3kSsn4KREIfVw4dcjZ80O46IiGQzLlYbnzXsTo+Hrg/Kzfl9B6O3f4/DuHmKrogzS9NIeqtWrVi7di09evRI1xBFihShSJEi1KxZEy8vL0aPHp1SwP89Gn7jc29v75QR9FuNmMfGxt5yRPy/bgj9r5F2uT1HfCxX1n0BgE+zYVjd9fRZERF58GxWKx/V74KbzYW5v+9kwR+/kJiczCcNumLTAJ5kEmkq6aNHj2bIkCH07NmT5s2bkzt37luOYnfu3Pk/jxUREcGmTZuoW7duqhVYypcvD8CZM2ew2WycOnUq1ftufF6iRAk8PT3x9/cnJCQk1T5hYWFER0ffNFddMtbVrXNwRIdhcXHFp/kzZscREZFszGqx8n6dTtitNr46vI3Fx/aS6Ejms0bdsWtBA8kE0lTS9+zZw+HDh4mLi+PXX3+95T4Wi+WuSrrD4eCVV15h+PDhKfPRAbZt2wZAxYoVqVGjBmvWrKFfv34pPwysXr0ab29vAgICAKhfvz4bN27k5ZdfTlnhZfXq1dhsNmrVqpWW05P7YDiSubJqAgA56z+Bi09+kxOJiEh2Z7FYeKtWe9xsLkw5uJmlJ/YTn5zElCa9cLWlqQKJPHBp+g4dP348Hh4evPTSS5QoUQKb7d5/EvXz86N3795Mnz4dd3d3KlasyJ49e5g2bRrdunWjZMmSDBs2jAEDBvD888/z6KOPsm/fPr766iteeOEFcuTIAcCgQYNYvnw5Q4YMoV+/fpw8eZIJEybQvXt3ChYseM/5JG2ig5eQeOk4WCz4th5ldhwRERHgelF/tXpr3GwufPrrelad+o3BG+YzrenjuGtxA3FiaXqYUaVKlXjppZfo27dvunzxxMREZs+ezeLFizl37hz58+enW7duDBo0KOWmz7Vr1zJx4kROnDiBv78/jz/+OAMHDkx1nODgYMaPH8+RI0fw9fWlc+fOjBgxArs97X/59DCjtDMMg1Nv1yb+5B48q3Wi0MglZkcSERG5yRcHNvK/PasBaFTwIb56pC85XFz/410i5khTSe/UqROtWrVi+PDhGZnJVCrpaRd7ZCNnPmwOQJHXfybHQ/VMTiQiInJrM377mbd3Lwegbv6SzG7eD0+7m8mpRG6WplucR44cyZw5c9i8efMtnzYq2VP4yuvr5ruXrqeCLiIiTm1whYa8V6cTADvOH+fxNTO5mnDN5FQiN0vTnPRFixbh6urK0KFDcXNzw8fH56Z56RaLhXXr1qVrSHFe8acPEntgFQB+bV80OY2IiMh/6/9wXVxtNkZv+57giyH0Wh3I1y0H4uPmYXY0kRRpKukxMTEUL16c4sWLZ1AcyWyurPoEAHv+snhW6WByGhERkbvTu0wtXK0ujNq6iP2Xz9Bj1QwWtBqEn7un2dFEgDTOSc8ONCf97iWGnebEy6UhOQn/AdPI1XiQ2ZFERETS5KcTB3hm8zckGw7K+vjzTetB5M1x88MQRR60e3rsVlJSEvv27WPFihVcvnyZ6OhoIiMj0zubOLmItRMhOQlbTn+86/YxO46IiEiadShRiWlNH8dutXE04gJdV04nNEadRsyX5pK+cuVKmjRpQu/evXnhhRf4888/2bNnD40bNyYwMDAjMooTSo67SuSmGQD4tBiB1dXd5EQiIiL3pnWxCgQ264ubzYVjkZd4bMU0TkWFmx1Lsrk0lfStW7fywgsvULx4cUaPHs2NmTKFCxemTJkyfPLJJyxdujRDgopzubplFo5rUVhcPfBp+pTZcURERO7LI0XKMbt5P3K42DkVHU6XFVP5K+Ki2bEkG0tTSZ88eTIBAQHMnTuXTp06pWwvVaoUQUFBVK1alTlz5qR7SHEuhiOZK2snApCzwRPYvPxMTiQiInL/GhZ8iKCWT+Jtd+N87FUeWzmNw+HnzI4l2VSaSvqRI0do165dytNA/8nFxYX27dtz4sSJdAsnzil6zw8kXT4JgG+LkeaGERERSUc1/YuzsPVgfN08CLsWQ7eV09l76ZTZsSQbSlNJt9vtJCUl3fb1iIgI7Hb7fYcS53ZlzecAeFZui2uBsianERERSV+V8hRmcZunyJfDm8iEa/RaFcj20GNmx5JsJk0lvVatWixevJj4+PibXrt48SJBQUFUr1493cKJ87l2/Beu/bkNAN9Wz5ucRkREJGOU9fXnu7ZPUcjTh5ikBPquncWGM0fNjiXZSJpK+vPPP8+lS5fo2LEjU6ZMwWKxsH79esaNG0f79u2Jiopi5EhNf8jKrqz5DADXIpXI8XBTc8OIiIhkoBI587Ck7VBK5MxDfHIST66fy/KTB82OJdlEmkp66dKlCQoKIl++fMybNw/DMJg/fz5z5syhaNGizJ07l4cffjijsorJEsPPEPXLYgB8Wz6LxWIxOZGIiEjGKuTlw3dtnqKsjz+JjmSGbQpi8V97zY4l2UCaSvoTTzxBWFgY8+bNY+fOnXz77bd88803/PzzzyxevJiwsDDatWuXUVnFZBHrJv//w4vq9DI7joiIyAORz8ObxW2GUCl3IRyGwXM/f8u833eaHUuyuDuW9Li4OM6dO5fysXv3bv766y/OnTtHbGwsefLkIV++fCQmJnLmzBm2bNnCmTNnHlR2eYAc8TFEbv774UWPDMNqdzM5kYiIyIPj6+7JN60HU8u/OACv7viBqQe3mBtKsjSLceOJRLcQHh5O69atiYqKuquDGYZB/fr1+eqrr9It4INWo0YNAIKDg01O4lwi1n/JxXnPYHFxo8SEk7jkzGd2JBERkQcuNjGBQRvmseXcnwA8X+URRlVprimgku5c7vSin58fH330EQcPHsQwDCZPnkyLFi0oW/bmZfesVit+fn6a7pIFGQ5HyrKL3vUeV0EXEZFsy8PuysxHnmD4piDWnD7Cp7+uJyYxnrE126moS7q6Y0kHaNy4MY0bNwbg3Llz9OzZk8qVK2d4MHEeMQdWkHjh+oiBb6vnzA0jIiJiMncXO9Oa9eG5n79l6fH9TP9tK7FJiXxQtxNWS5pu9xO5rf8s6f80bty4jMohTuzK6uuj6B4BLXArVMHkNCIiIuazW21MbNgDDxdXFvzxC/OP7iI2KYEJDbriYrWZHU+yAP24J3cUf/oAcUc2AODb8jlzw4iIiDgRm9XK+HpdeLJ8fQCWHNvH0I1BxCff/unsIndLJV3u6MraSQC4FnwYj4qtTE4jIiLiXCwWC2/Vas+zlZsBsOrUbwxcP5e4pASTk0lmp5Iut5UcHUbUjiAAfJo/rRtiREREbsFisfBStZa8Wr01AJvP/kGfNbOISrhmcjLJzFTS5bYit8zESLyGNUcuctbra3YcERERp/Z0pSa8V6cTALsunKDn6kCuXIsxOZVkVirpcktGchIR66cAkLNhf6zuXiYnEhERcX79H67LhAZdsVos7L98hq4rp3M+9qrZsSQTUkmXW4r+9SeSwk6BxYLPI8PNjiMiIpJpdH+oBlOa9MZutXE04gJdlk8lJCrM7FiSyaikyy1FrJsMgGfF1rj6lzY5jYiISObSvnhFZjXvRw4XO6eiw+myfCq/XzlvdizJRFTS5SbxZw4Rd2QjAD7NnzE5jYiISObUpFAZFrQcRE5Xdy7ERfHYimnsvXTK7FiSSaiky01ujKLb/R/CI6ClyWlEREQyrxr+xVjcZgh53L2ITIij56pAtp77y+xYkgmopEsqyTFXuLp9PvD3sotWfYuIiIjcj/J+BVnSdiiFvXyITUrgibWzWBlyyOxY4uTUwCSVyC2zMBJisbh7kbNBP7PjiIiIZAklc+VhSdthlM6VlwRHMk9t/JpFf+4xO5Y4MZV0SWE4konccH3ZxVz1+2HLkdPkRCIiIllHQc9cfNf2KSrlLoTDMHh+6yICf9tqdixxUirpkiJm/woSL50Ark91ERERkfSV292Lha0HU9u/BABv7V7GJ/vWYhiGycnE2aikS4qIdV8A4BHQAtcCZU1OIyIikjV5u7ozv+VAmhcpB8Cnv67nzV0/4TAcJicTZ6KSLgDEnztC7G/rAC27KCIiktFyuNiZ0awvnUtWAWDmke28sHUxSY5kc4OJ01BJF+Afyy7mLYlnpTYmpxEREcn67FYbExt1p1+5OgAs+msvT238mmtJiSYnE2egki4kx0ZyddtcAHweGY7FajM5kYiISPZgtVh5r04nRlRqCsDqU4fpv24O0YnxJicTs5la0h0OBwsWLKBDhw5UrVqV5s2bM27cOKKjo1P2Wb16NZ07d6ZKlSq0atWK2bNn43CknrN18OBB+vbtS9WqVWnQoAETJkwgMVE/hd6tq9vnY8THYHH1IGfD/mbHERERyVYsFgujq7diTI22AGwN/YueqwK5Eh9rcjIxk6klPTAwkHfffZcmTZowefJkBgwYwA8//MCzzz4LwNatWxk5ciRly5ZlypQpdO7cmQ8//JCZM2emHCMkJIT+/fvj5ubGZ599xsCBA5k1axbjxo0z67QyFcMwiNzwJQA56/bG5ulrciIREZHsaWjFRnxU/zGsFgu/Xj5N1xXTOB971exYYhIXs76wYRgEBgbSo0cPXnjhBQDq1auHr68vzz//PEeOHOH777+naNGijBs3DqvVSr169Thx4gRBQUEMGjQIgOnTp+Pt7c2UKVNwdXWlcePGuLu789577/HUU0/h7+9v1ilmCnFHt5Bw7ggAuZoNNTmNiIhI9tarTE28Xd0ZsfkbjkZc4NHlX/J1yycpmSuP2dHkATNtJD0mJoaOHTvSvn37VNtLliwJwKlTp4iPjydHjhxY//Foeh8fHyIiIlI+37ZtG02bNsXV1TVlW+vWrUlOTmbrVj0g4L9E/D2K7l6yNu7FqpqcRkRERNoXr8is5v3I4WLndPQVuqyYysHLZ82OJQ+YaSXdy8uLMWPGUL169VTb1627vgxg6dKlefzxxzl+/Djz5s0jKiqKHTt2sGTJEjp16gRAXFwcoaGhlChRItUx/Pz88PLy4sSJEw/mZDKppIjzRO/5HgCfRzSKLiIi4iyaFCrDwtaD8XHz4PK1aLqtms620GNmx5IHyLTpLreyf/9+pk+fTvPmzSlVqhQlS5Zk4MCBvPfee7z33nsA1K9fn1dffRWAqKgo4Hrh/zdPT89UN6DeUKNGjTtmiIqKwtvb+35PJVOI3PIVJCdh9fTDq2Z3s+OIiIjIP1TLW5Tv2w6l9+qvCI2NpO+amXzRuBdtiweYHU0eAKdZgnHPnj0MGjSIwoULpxTyN998k5kzZ/LMM88wb9483nzzTQ4fPsyzzz6LYRgpj9C1WCw3Hc8wjFTTZCQ1w5FM5KYZAORqOACrq7vJiUREROTfHvLJx9J2wyidKy8JjmSGbvqa+Ud3mR1LHgCnGElfsWIFr7zyCsWLFycwMBBfX18uXLjAt99+y9NPP82IESMAqFWrFkWLFuXJJ59k06ZN1KpVC+CWI+axsbG3HBEPDg6+Y5b/GmnPKmL2Lycp/DQAuZoOMTmNiIiI3E5BLx++bzuUJ9bNZt+l07yy/XvC4qIZWbnZLQcqJWswfah51qxZjBo1iipVqvD111+TL18+AM6dO4dhGFSrVi3V/jVr1gTgzz//xNPTE39/f0JCQlLtExYWRnR09E1z1eX/Ray/fsOoR0BLXP1Lm5xGRERE7sTX3ZNvWg2icaEyAHy0by1v7PoJh+H4j3dKZmVqSV+0aBH/+9//aNOmDYGBgalGvosVK4bNZuOXX35J9Z59+/YBULhwYeD6HPWNGzeSkJCQss/q1aux2WwpI+2SWsLFY8QeWgOAj5ZdFBERyRQ87W7MeuQJOpWsDMCsI9sZsWUhCclJJieTjGDadJewsDDef/99ChUqxOOPP87hw4dTvV60aFH69OlDYGAgVquV2rVrc+LECSZNmkS5cuVo3rw5AIMGDWL58uUMGTKEfv36cfLkSSZMmED37t0pWLCgGafm9CI3TAPAxa8InpXbmZxGRERE7parzYVJjXrg5+bJrCPbWXp8PxHXYpnerA+edjez40k6shg37r58wH744QdGjx5929fHjx9Phw4dmD17NgsXLuTs2bPkz5+fZs2aMXLkyFQrugQHBzN+/HiOHDmCr68vnTt3ZsSIEdjt9jTnujEn/b/mrmdWjoRrHB9VFEd0GLm7vEPujq+bHUlERETSyDAMJh3YyPi9138zXiVPEea26I+fu6fJySS9mFbSnVVWL+lXt83j/Iz+YHOh5CchuPjkNzuSiIiI3KP5R3fx2o4fcBgGpXPl5euWT1LIy8fsWJIOTL9xVB6siA1TAfCq/qgKuoiISCbXp2xtvmzSG1erjb8iL9F5+Zf8GXHR7FiSDlTSs5FrIfu4dmwnAD7NhpmcRkRERNJDu+IVmddyIF52N0JjI3l0xVT2Xjpldiy5Tyrp2Ujk36PorgXLk6NsI5PTiIiISHqpX6AUi1oPIbe7JxHxsfRYNYMNZ46aHUvug0p6NpEcG8nVHUEA5Go2VA8/EBERyWIq5inE922HUcTLl7ikRAasm8O3f2bNe+yyA5X0bCJq+9cYCbFYXD3IWa+P2XFEREQkA5TMlYcf2g2jvF8Bkg0Ho7YuZtL+jWidkMxHJT0bMAyDiE3TAfCu0wubRy6TE4mIiEhG8ffIyXdtnqJBgetPFP9w72rG7FxKskNPJ81MVNKzgWvHd5Nw5iAAPk0Gm5xGREREMpq3qztzW/RPeTrpnN93MnTT18QlJZqcTO6WSno2ELlpBgBuRavgVqKGyWlERETkQbjxdNKnKjQEYGXIbzy+5iuuxMeanEzuhkp6FpccG0nUroUA5GoySDeMioiIZCNWi5WxtdrxZq12AOy+cJIuy6dyNjrC3GDyn1TSs7ionUEpN4x61+ltdhwRERExweAKDZnSuBeuVht/Rl6k0/IpHAk/b3YsuQOV9CzMMAwiNwUC4F27h24YFRERycY6lqzMvJYD8ba7cT72Ko+tnMr20GNmx5LbUEnPwuJP7iH+1K8A5NINoyIiItle/QKl+K7tUPxzeHM14Rp91sxk2YkDZseSW1BJz8Ju3DDqWrgi7iVrmZxGREREnEF5vwIsbT+ch3LlI8GRzLBNC/jq8DazY8m/qKRnUY64KK7uXABcH0XXDaMiIiJyQ2EvX5a0G0qNfMUwMHhz10+898sKHIbWUncWKulZ1NVdCzDiY7DY3clZ93Gz44iIiIiT8XXzYEGrQbQqWh6AqYe28OyWb0lITjI5mYBKepaVcsNore7YPH3MDSMiIiJOKYeLnelN+/BEuToAfH/8V/qvm0NUwjWTk4lKehZ07eQe4k/uAXTDqIiIiNyZzWrl/TqdeLlaSwC2nPuTLiumci4m0uRk2ZtKehZ0YxTdtVAF3EvXNTmNiIiIODuLxcLIys34tEE3XCxWjlw5T8dlkzkcfs7saNmWSnoW47gWzdWdQYBuGBUREZG06fZQdea1HJCylnqXFdPYfPYPs2NlSyrpWUzUrm8wrkXrhlERERG5Jw0LPsSStsMo4JGL6MR4+q2dzTd//GJ2rGxHJT2Lifh7qotXza7YvPxMTiMiIiKZ0cN++fmx/XDK+xUgyXDw4rbv+GjvGgzDMDtatqGSnoVcC9lH/InrP+n66IZRERERuQ8FPHOxpO1QGhcqA8Dn+zfw3M9aovFBUUnPQiI3/33DaMGHcX+ovslpREREJLPzsrsxu3k/epWpCcB3x/bRZ81MIuPjTE6W9amkZxGO+Fiidvx9w2jjQbphVERERNKF3WpjfL0ujK7WCoDt54/TZcVUzkRfMTlZ1qaSnkVEBy/GEXcVi4srOev3NTuOiIiIZCEWi4URlZsysVEP7FYbRyMu0HHZFA5ePmt2tCxLJT2LiNwyCwDPap2weeU2OY2IiIhkRV1KVeXrlgPJ5erOxbgoHls5jfWnfzc7Vpakkp4FJJz/k7ijWwDI1WigyWlEREQkK6tXoBTftxtGYS8fYpMSGLB+DvN/32V2rCxHJT0LuLp1NgAufkXwKP+IuWFEREQkyyvj48+P7Z6mUu5COAyDV3Z8zwfBK3EYDrOjZRkq6ZmckZxE5NY5AORs2B+L1WZyIhEREckO8nl4s6jNEJoXKQfAlIObGb5pAXFJiSYnyxpU0jO5mIOrSI4IBYuFXA36mx1HREREshFPuxuBzfryRLk6ACw7eZDuq6ZzKS7K5GSZn0p6Jhe5ZSYAHuWbYc9b3NwwIiIiku24WG28X6cTb9VqjwUL+y6dpsOyyfx+5bzZ0TI1lfRMLCnyAjH7lwOQs6FuGBURERFzWCwWBlVowMxH+uLh4sqZ6Ag6L/+SjWeOmh0t01JJz8Subp8PyUlYPX3xqtbZ7DgiIiKSzbUoWp7v2w4lv0dOohPj6bduNnOO7DA7Vqakkp5JGYbB1b+nuuSs0xurq7vJiURERESgQu6CLOvwDBX/Xvnl9Z1LeXPXTyQ7tPJLWqikZ1LX/tpBQuj1hwfk1NroIiIi4kTye+TkuzZP0apoeQC+OryNgevnEp0Yb3KyzEMlPZO6ccOoW7FquBerYm4YERERkX/xsLsyo1kfhgY0AmD9md95dPmXnIuOMDdYJqGSngk54qKI2v0toCeMioiIiPOyWqyMqdmWD+t1wcVi5ciV87RfNpn9l8+YHc3pmVrSHQ4HCxYsoEOHDlStWpXmzZszbtw4oqOjU/Y5evQoTz75JFWrVqVu3bq89NJLXL58OdVxDh48SN++falatSoNGjRgwoQJJCZm3YX0o35ZhBEfg8XujnedXmbHEREREbmjx8vWYn7LgeR0dediXBSPrZjGipOHzI7l1Ewt6YGBgbz77rs0adKEyZMnM2DAAH744QeeffZZAE6fPs3jjz9OQkICn332Ga+88gq7du3i6aefTjlGSEgI/fv3x83Njc8++4yBAwcya9Ysxo0bZ9ZpZbjILbMA8Kr+KDZPH3PDiIiIiNyFBgVLs7TdcIp5+3EtOZEhG+cz5eBmDMMwO5pTcjHrCxuGQWBgID169OCFF14AoF69evj6+vL8889z5MgRZs+ejZ+fH4GBgbi5uQHg7e3N22+/zenTpylSpAjTp0/H29ubKVOm4OrqSuPGjXF3d+e9997jqaeewt/f36xTzBDx545w7a/tgKa6iIiISObykE8+fmw/nEHr5/HLxRA+CF7JschLjKvbGVebabXUKZk2kh4TE0PHjh1p3759qu0lS5YE4NSpU6xbt46uXbumFHSAZs2asXnzZooUKQLAtm3baNq0Ka6urin7tG7dmuTkZLZu3foAzuTBuvr3KLo9bwlylGtibhgRERGRNMrt7sWCVoPoXLIKAAv/DKb3mq8IvxZjbjAnY1pJ9/LyYsyYMVSvXj3V9nXr1gFQunRpoqOjyZ8/P2+88QY1atSgcuXKjBo1iitXrgAQFxdHaGgoJUqUSHUMPz8/vLy8OHHixIM5mQfESErk6vZ5AORsOACLVff9ioiISObj7mJnUqMevFC1OQA7z5+g/U+TOXrlgsnJnIdT/V5h//79TJ8+nebNmxMTc/2nqfHjx1O9enU+//xzzp07x8cff8zIkSOZN28eUVFRwPXC/2+enp6pbkC9oUaNGnfMEBUVhbe3dzqcTfqL2b+c5KsXwWIlZ4N+ZscRERERuWcWi4XnqzTnoVz5eO7nRZyKDqfT8il80bgnzYs8bHY80zlNSd+zZw9Dhw6lcOHCvPfeexw7dgwAf39/PvvsMywWCwC5cuVixIgR7Ny5M2UE/cZr/2QYBtYsNtJ8Y210j4otsfsVNjmNiIiIyP1rX6ISxbxzM2D9HM7HXmXAurm8VqM1QwMa3bLjZRdOUdJXrFjBK6+8QvHixQkMDMTX1zdldLxRo9T/B9WvXx+4vjRjxYoVAW45Yh4bG3vLEfHg4OA7ZvmvkXazJEWEEnNwFQC5Gg4wOY2IiIhI+qmYpxDLOzzDoA3z2HfpNO8Hr+SPiAv8r14X3LLpDaWmDzXPmjWLUaNGUaVKFb7++mvy5csHQJEiRbBYLCQkJKTaPzk5Gbg+eu7p6Ym/vz8hISGp9gkLCyM6OvqmueqZ2dUdQeBIxurph2eVDmbHEREREUlX/h45WdR6CI/+fUPpor/20n3ldC7FRZkbzCSmlvRFixbxv//9jzZt2hAYGJhq5NvT05Pq1auzdu3aVA8m2rBhA/D/I97169dn48aNqcr86tWrsdls1KpV6wGdScYyDIOrW+cAkLNOL6x2t/94h4iIiEjm4+5iZ2KjHrxSvTUWLOy5dIp2P33Bb2HnzI72wFkMk1aQDwsL45FHHsHPz4/x48fj4pL6VxlFixbl+PHj9O/fn9q1a9O/f3/OnDnDxx9/TN26dfniiy8AOHbsGI8++ijVqlWjX79+nDx5kgkTJvDYY4/x1ltvpTnXjfL/X9NiHqRrJ4I59XZtAIq+tRv34tX/4x0iIiIimdvqkN8YsWUhsUkJ5HCx83nDHrQtHmB2rAfGtJL+ww8/MHr06Nu+Pn78eDp16kRwcDATJkzg0KFDeHt70759e0aNGpVq7fTg4GDGjx/PkSNH8PX1pXPnzowYMQK73Z7mXM5Y0i/MG0Hk+im4Fg6g2Lu/ZuubKERERCT7OBweysD1czgTHQHAS1VbMLJys2zRhUwr6c7K2Uq6IzGe488VwhFzhTw9PsKvzSizI4mIiIg8MGHXohm8YT67L5wEoFOJynzcoCs5XNI+GJuZmH7jqNxZzK8/4Yi5AlYbOev2NjuOiIiIyAOV292Lb1oNosdD1wdSl57YT9eV0wiNiTQ5WcZSSXdyN24Y9azYGhef/CanEREREXnwXG0ufFz/Md6q1R6rxcL+y2do/9MX7Ll4yuxoGUYl3YldXxt9NYCeMCoiIiLZmsViYVCFBsxp3h9vuxsX4qLotnIa3/zxi9nRMoRKuhNLvTZ6e7PjiIiIiJiuaeGyLOvwDKVy5SXBkcyL277j9R1LSXQkmx0tXamkOymtjS4iIiJya6Vy5eWn9k/TvEg5AOb8voNeqwMJu3bzU+gzK5V0JxV/cg8JZ38DIGdDTXURERER+aecru7MfOQJnq3cDICd50/Q9scvOHj5rMnJ0odKupOK/HsU3bVwAG7FqpmcRkRERMT5WC1WXqrWkmlNH8fDxZWzMRE8umIqPxz/1exo900l3Qk5EuOJ2rkAgJz1+2WLBftFRERE7lW74hVZ2m44xbz9uJacyDObv+G9X1aQ7HCYHe2eqaQ7Ia2NLiIiIpI2D/vlZ1mHZ2hU8CEAph7awhNrZ3ElPtbkZPdGJd0J/f/a6K20NrqIiIjIXfJ182Bui/48VaEhAJvP/Un7nybz+5XzJidLO5V0J6O10UVERETunYvVxtha7ZjYqAduNhdCosLouGwKK0MOmR0tTVTSncz/r43ui2eVDmbHEREREcmUupSqyvdth1LQMxexSQkM3jCfj/etxWFkjnnqKulO5J9ro3trbXQRERGR+1IpT2FWdBhBbf8SAHz263oGrp9LZHycycn+m0q6E/nn2ui5NNVFRERE5L7lyeHFN60H0a9cXQDWnf6ddj994fTz1FXSnUjK2uiFKuBWvLrJaURERESyBrvVxvt1OzGhQVfcbC6cjAqjw7LJ/HTigNnRbksl3UmkWhu9gdZGFxEREUlv3R+qwfdth1LI04e4pESGbQri3V9WkORINjvaTVTSnYTWRhcRERHJeJXyFGZlxxE0KFAagGmHtvD4mpnEJyeZnCw1lXQnce3kXuDG2ugFTE4jIiIiknX5uXsyv+UAhgU0BmBb6DF+uXDS3FD/4mJ2ALnOt8UILFYXcjV7yuwoIiIiIlmei9XG6zXbUL9gKX4LO0eNfMXMjpSKxTAMw+wQzqRGjRoABAcHm5xERERERLIrTXcREREREXEyKukiIiIiIk5GJV1ERERExMmopIuIiIiIOBmVdBERERERJ6OSLiIiIiLiZFTSRUREREScjEq6iIiIiIiTUUkXEREREXEyKukiIiIiIk5GJV1ERERExMlYDMMwzA7hTMqVK4dhGHh7e5sdRURERESyOG9vbzZu3HjTdo2k/4vVasVisaTb8aKiooiKikq344muaUbQNc0Yuq7pT9c0/emapj9d0/SXHa+pRtIzWI0aNQAIDg42OUnWoWua/nRNM4aua/rTNU1/uqbpT9c0/WXHa6qRdBERERERJ6OSLiIiIiLiZFTSRUREREScjEq6iIiIiIiTUUkXEREREXEyKukiIiIiIk5GJV1ERERExMlonXQRERERESejkXQRERERESejki4iIiIi4mRU0kVEREREnIxKehotW7aMdu3aUalSJdq0acMPP/xwx/1jYmJ4++23qV+/PlWrVmXw4MGcPHnytvtHR0fTtGlTXn/99fQN7sQy4poGBwdTtmzZmz6eeuqpjDsRJ5JR36fffPMNbdq0oWLFirRq1Yq5c+dmzAk4ofS+ppMmTbrl9+iNj7Nnz2bsCTmBjPg+jYmJ4YMPPqBp06ZUq1aNvn37cuDAgYw7CSeTEdf07NmzjBw5kho1alCjRg2GDx/OsWPHMu4knExar+k/ffjhh/Tv3/+m7UlJSXz22Wc0btyYypUr07t372z1fQoZc11vGDlyZNboUYbctRUrVhhly5Y13n//fWPLli3GG2+8YZQpU8ZYuXLlbd8zePBgo06dOsaSJUuM1atXGx06dDAaNmxoXL169Zb7v/baa0aZMmWM1157LaNOw6lk1DWdP3++UaVKFWPfvn2pPo4dO/YgTstUGXVNZ86caZQrV8749NNPje3btxuffPKJUaZMGSMoKOhBnJapMuKahoaG3vT9uXHjRqNSpUrG4MGDjeTk5Ad1eqbIqO/TUaNGGVWqVDHmz59v/Pzzz8bAgQONKlWqGKdOnXoQp2WqjLimERERRqNGjYz69esbCxcuNLZs2WKMGjXKqFmzpq7pf5g3b55RpkwZo1+/fje99tZbbxmVK1c25s2bZ6xfv97o06ePUbVq1WxxTQ0j466rw+EwPvzwwyzTo1TS06B58+bGc889l2rbs88+a7Ru3fqW+//yyy9GmTJljM2bN6dsCwsLM6pUqWJMmzbtpv03bdpkVK1a1ahevXqW+Oa6Gxl1TceMGWN069YtY0I7uYy4ptHR0UaVKlWMTz/9NNV7R40aZTz99NPpewJOKKP/7t8wfPhwo1GjRkZkZGT6BHdiGXFN4+LijIcfftiYNGlSyj7R0dFGpUqVUm3LqjLims6cOdMoU6aMsX///pR9HA6H0a1bN2PUqFEZcBbOJa3X1DAM4/z588aoUaOMcuXKGdWrV7+pTJ4+fdp4+OGHUw1wxMfHG02aNDHeeOONdM3vrDLiuh47dswYOHCgUbFiRaNSpUpZokdpustdOn36NKdOnaJly5aptrdq1Yrjx49z+vTpm96zbds2PD09qV+/fso2Pz8/atasyZYtW1LtGxkZyZgxY3jppZfImTNnxpyEk8nIa3rkyBHKli2bceGdVEZd061btxIbG0vv3r1TvfeTTz7hiy++yIAzcR4Z/Xf/hk2bNrFu3TpeffXVLP9vQEZd08TERBwOB15eXin7eHh44ObmRkRERMacjJPIqGt64sQJcufOTaVKlVL2sVgsVK9enc2bN2fQ2TiHe7mmAJ9++imHDx9m1qxZPPzwwze9vnPnTpKTk2nVqlXKNldXV5o0aXLbfx+ykoy6rm+++SZRUVEsXLiQ3LlzZ0j2B00l/S4dP34cgBIlSqTaXqxYMeD6P2S3ek+xYsWw2WypthctWvSm/d99911KlSpFz5490zO2U8uoa+pwOPjzzz85f/48jz76KAEBATRp0oSZM2diZPHHAmTUNT169Cg+Pj6EhobSs2dPAgICaNy4cbaYk57Rf/cBDMNg/Pjx1KpVi9atW6dXdKeVUdfU29ubRx99lDlz5nDgwAEiIyP55JNPiImJoW3bthlxKk4jo65pgQIFuHr1KtHR0an2OXPmDFFRUVn6h597uaYAgwYNYvny5dSpU+e2x82VKxd+fn43HffcuXNcu3btfqM7tYy6rmPGjOHbb7+9ZYHPrFTS71JUVBRAqhEaAE9PT4Cb/gG7se3f+994zz/3X7t2LevXr+e9997DYrGkZ2ynllHX9MSJE1y7do0TJ04wePBgZsyYQfPmzRk/fjyTJk1K79NwKhl1TcPDw0lMTGTYsGG0bNmSGTNm8Mgjj/D++++zZMmS9D4Np5KRf/dv2LBhA8eOHWP48OHpEdnpZeQ1ff7558mVKxfdunWjVq1aBAYG8vbbb1OtWrX0PAWnk1HXtE2bNthsNp577jmOHz9OREQE8+fPTxnxjYuLS9fzcCb3ck0BSpcujdV6+3p1p+sO12/mzcoy6rpmxd+eu5gdILO4MQL77xJ9Y/utvnHuNGp7Y//w8HDefPNNXn75ZQoXLpxecTOFjLqm/v7+zJgxg4cffpi8efMCULduXa5du8aMGTMYOHDgLf+BzAoy6pomJiYSExPDqFGj6NOnD3D9mp47d45JkybRpUuXdMnvjDLqmv7T119/Tfny5albt+79RM00MuqahoWF0b17d1xdXfnkk0/InTs3q1ev5s0338TDwyNLj6Zn1DUtXrw4EydOZOzYsbRp0waAWrVq8dRTT/H555/j7u6eLvmd0b1c07Qc926/XlaTUdc1K9KVuEve3t7AzT/h3fiJ98br/+Tl5XXLn4hjYmJSSuJbb71FqVKl6Nq1K0lJSSQlJQHXv1lv/Dmryqhr6uXlRaNGjVIK+g1NmjQhISHhtr9Kywoy6preGOFo3Lhxqn0aNmzIuXPnUkZGsqKMuqY3REREsGvXLjp16pRekZ1eRl3TRYsWcf78eb766ivat29P3bp1eeutt2jdujXvvvsuDocjvU/FaWTk92njxo3ZvHkz69atY9OmTcybNw+Hw4HVas3S90/cyzW9G3e67jdez8oy6rpmRSrpd+nG3KlTp06l2h4SEpLq9X+/5/Tp0zf91BwSEpKy/+rVq9m9ezcBAQFUqFCBChUqcPbsWb777jsqVKjAmTNnMuJ0nEJGXdOjR48SFBREYmJiqn1uzPPz9fVNnxNwQhl1TW/MFUxISEi1z41rnJVHfjLqmt7w888/k5SUlDJKmR1k1DU9d+4cefPmpUiRIqn2qVGjBuHh4YSHh6fbOTibjLymixYtIjk5mSJFilCgQAEADh8+TNmyZW+az56V3Ms1vRslS5YkIiKCyMjIm45buHBhXF1d7+m4mUVGXdesSCX9LhUrVozChQuzatWqVNvXrFlD8eLFKViw4E3vadCgAVevXmX79u0p28LDwwkODqZevXoALF68+KaPvHnz8sgjj7B48WLy5cuXsSdmooy6piEhIbz99ts33SW/YsUKChcuTKFChTLgbJxDRl3Thg0bArB8+fJU7924cSNly5bN0iM/GXVNb9i/fz+FChXC398/Y07ACWXUNS1RogSXL1++6WE8v/76K15eXuTKlSv9T8ZJZNQ1vXz5MmPGjCE4ODhln+PHj7NlyxaaN2+eQWfjHO7lmt6NG9d29erVKdsSEhLYvHnzTf8+ZEUZdV2zIs1JT4Onn36aV199lVy5ctGkSRM2bNjAypUr+fTTT4Hr/7idOnWK0qVL4+XlRc2aNalVqxajRo3ixRdfxMfHh0mTJuHt7U2vXr0AqFix4k1fx9XVFV9f31u+ltVkxDVt0qQJAQEBjB07lvDwcPLnz89PP/3Ehg0bmDRpUpYe9YWMuaZFixalV69eTJs2DRcXF6pUqcLy5cvZuXMnU6ZMMfN0H4iMuKY3HD16lNKlS5txWqbKiGvatWtX5s2bx5AhQxgxYgS5c+dmw4YN/PDDD7z44ovY7XYzTznDZcQ1DQgIoEqVKrz55pu89NJLJCUlMX78eAoUKEC/fv3MPN0HIq3X9G4UKlSIRx99lPfee4/Y2FiKFSvGrFmziIyMZNCgQRl5Ok4jI65rlpThK7FnMQsWLDBatGhhBAQEGG3atDG+//77lNe+++47o0yZMsbOnTtTtkVERBivvPKKUaNGDaNatWrG4MGD//Opl02bNs0Si/DfrYy4pmFhYcbYsWONRo0aGQEBAcajjz5qrF279kGdkuky4pomJycbU6dONZo1a2YEBAQYHTp0MFavXv2gTsl0GfV3v02bNsYLL7zwIE7B6WTENT1//rzxwgsvGLVq1TKqVKlidOnSxVi2bNmDOiXTZcQ1vXDhgjFy5EijZs2aRu3atY0XX3zROH/+/IM6JdOl9Zr+U58+fW75ZMz4+Hjj/fffN+rWrWtUrlzZ6N27t/Hrr79m0Bk4p4y4rjdklR5lMYwsvnC0iIiIiEgmoznpIiIiIiJORiVdRERERMTJqKSLiIiIiDgZlXQRERERESejki4iIiIi4mRU0kVEREREnIxKuohIFlS2bFleeeUVs2Ok2enTp82OICLiFFTSRUTEKXz33Xe0a9fO7BgiIk5BJV1ERJzCL7/8Qnx8vNkxREScgkq6iIiIiIiTUUkXEXnAmjVrxjvvvMOiRYto1aoVlSpV4rHHHuPAgQNcunSJZ599lqpVq9KwYUM+/fRTHA5HqvevW7eOnj17UqlSJWrUqMHQoUP5/fff7/g1ExMTmTZtGh07dqRKlSpUqlSJjh07snjx4lT7lS1bls8++4yhQ4cSEBBA27ZtSUpKuu1xN27cSM+ePalcuTI1a9ZkxIgRnDhx4qZjTp8+nVmzZtG8eXMCAgLo0KEDK1euTNmnb9++fP/99yn735hP36xZM8aMGcNrr71GxYoVadSoEeHh4QAEBwfTv39/qlatStWqVXniiSf45ZdfbrrWr7/+OosWLeKRRx6hSpUq9OzZk507d6bs88knn1C2bFn++uuvVO91OBw0aNCAZ5999o7XVkQkI6iki4iYYP369Xz++ed07dqVZ555huPHjzNixAgGDBiA1WrllVdeoUyZMkydOpWlS5emvO/rr7/m6aefJjExkVGjRtG/f38OHDhAr169OHDgwG2/3quvvsrEiROpVasWr7/+Os888wyxsbG8/vrr7N69O9W+c+bM4dq1a4wZM4bu3bvj4uJyy2MuWbKEYcOGkSNHDl566SX69+/Pvn376N69+01FfcGCBcyePZvu3bvz8ssvExsby/PPP88ff/wBwNChQ6lRowYA48ePp0ePHinvXb58Ob///juvv/463bt3x8/Pj/Xr19O3b19CQ0MZNmwYw4YNIzQ0lP79+7N+/fpUX3v79u288847tGrVimeffZbw8HAGDRqUct4dOnQASPVDA8Du3bu5dOkS7du3v+11FRHJMIaIiDxQTZs2NcqWLWv8/vvvKds+/PBDo0yZMsZzzz2Xsi0mJsaoUKGCMWrUKMMwDCM8PNyoXLmy0bVrVyM+Pj5lv9OnT6dsv6FMmTLG6NGjDcMwjIsXLxply5Y1Pv7441Q5jh07ZpQpU8Z49913U72vevXqRmRk5B3PISoqyqhWrZrx/PPPp9p+8eJFo2bNmsbw4cNTHbNKlSrGxYsXU7b9+uuvRpkyZYwJEyakbBs9erRRpkyZm65VuXLljJCQkJRtiYmJRqNGjYzGjRsbUVFRKdsjIyONhg0bGg0bNjQSEhJS3l+mTBlj7dq1KfuFhYUZNWrUMLp3756yrX379kabNm1Sfe2xY8ca1atXT3WtRUQeFI2ki4iYoGjRopQtWzbl8xIlSgDQokWLlG0eHh7kzp2bS5cuAbBjxw7i4uIYMGAArq6uKfsVLlyYjh07cuDAAS5evHjT18qbNy979uxh+PDhKdsMw0iZxhITE5Nq/8qVK5MzZ8475t+2bRvR0dE0b96c8PDwlA+bzUadOnXYunVrqmky1atXJ2/evCmfP/zwwwAp53YnRYsWpWjRoimfHz58mPPnz/P444/j5eWVsj1nzpz06dOHCxcucOjQoZTtJUuWpHnz5imf+/n50alTJ/bv309YWBhwfTT92LFjKSP7SUlJrFmzhhYtWqS61iIiD8qtf4cpIiIZKnfu3Kk+t9lswPUC+e/thmEAcObMGeB66fy3UqVKAXDu3Dny5ct30+uurq78+OOPbN26lZMnTxISEpJSzm8c/4Z/Z7iVU6dOAfD888/fdp/w8PCULP8+5o3i++/59rfy72t14zrc+MHmn25cm3PnzlG1alUASpcufdN+xYoVwzAMzp49S+7cuWnfvj0TJkxg1apVlClThm3btnHlypWUqTAiIg+aSrqIiAluN8/bYrHc0/FuFG273X7TawkJCTz55JPs2bOH2rVrU7duXfr370+tWrVo0qTJTfvf+IHhTm6U63fffZfChQvfcp9cuXKl/Nlqvfdf3P47z79/qLjVa/+8Dre6JsnJyamOXbBgQapVq8bKlSsZOXIkK1euJE+ePNSuXfuec4uI3A+VdBGRTKJQoUIAHD9+nHLlyqV67fjx4wDkz5//pvetWLGC3bt38/7779O1a9eU7RcuXLjvLH5+ftSrVy/Va7t27cLhcGTYNJF/Xod/u3HD6j+vw41R/38KCQnBZrOl+gGjffv2vP322xw/fpyNGzfSoUOHu/qBRUQkI2hOuohIJlGvXj3c3NyYNWsWCQkJKdvPnz/PTz/9RKVKlW6aGgIQEREB3DztY+7cuQB3XGLxv7IEBgaSmJiYsv3ChQsMHz6cjz/+OM2/Fbgx2v5fU2AqVKhA3rx5WbBgAdHR0Snbo6OjCQoKIm/evAQEBKRsP3jwIL/++mvK55cvX+bHH3+kTp06qUb727Rpg91uZ9KkSURERGhVFxExlUbSRUQyCV9fX0aNGsW4cePo1asXHTp0ICYmhgULFuBwOBgzZswt31evXj1cXFx4+eWXefzxx3FxcWHjxo1s3boVu91+042jd8PPzy8lS48ePejYsSNJSUkEBQURHx/P6NGj7+mYABMnTkyZlnMrdrudsWPH8txzz/HYY4+l/HZg8eLFXLx4kYkTJ6aaXuPq6srgwYPp168f7u7uBAUF4XA4ePnll1Md19fXl/r167NixQoKFy5MlSpV0nwOIiLpRSVdRCQT6d+/P/ny5WPmzJlMmDCBHDlyUKtWLZ555plUq8X8U5kyZZg4cSJffPEFEyZMwNPTk4ceeohZs2YRFBTE7t27SUxMvOXc7f/K4u/vz6xZs/j0009xd3enQoUKfPTRR1SvXj3N59arVy927txJYGAgBw8evG1JB2jVqhUzZ85kypQpTJ48GRcXFypXrsz777+fst76DVWqVKFdu3ZMmTKFqKgoatSowQsvvHDTlCG4vsrLpk2bNIouIqazGHe6A0dERCQTa9asGYUKFWLevHl3tf+KFSt4/vnnWbFiRcqKOSIiZtCcdBEREa6vDPPNN99QuXJlFXQRMZ2mu4iISLaWlJTEqFGjCA0N5cCBA0yaNMnsSCIiKukiIpK9ubi4EBISwpkzZ3jmmWdo2bKl2ZFERDQnXURERETE2WhOuoiIiIiIk1FJFxERERFxMirpIiIiIiJORiVdRERERMTJqKSLiIiIiDgZlXQRERERESfzf1/g76avuYQ4AAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -919,7 +959,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -934,7 +974,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -948,7 +988,7 @@ "T = 300.00000 K, ρ = 40.96869 mol/m³, x = [0.50000, 0.50000]" ] }, - "execution_count": 24, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -967,7 +1007,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -976,7 +1016,7 @@ "[-15625.347451682397, -12435.866602695123] J/mol" ] }, - "execution_count": 25, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -987,7 +1027,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -997,7 +1037,7 @@ " [-0.10593968, 4.85467746]])" ] }, - "execution_count": 26, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1015,7 +1055,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -1029,7 +1069,7 @@ "T = 401.65486 K, ρ = 3.99952 kmol/m³, x = [0.50000, 0.50000]" ] }, - "execution_count": 27, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -1041,7 +1081,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -1057,44 +1097,44 @@ "phase 1: T = 350.00000 K, ρ = 8.96382 kmol/m³, x = [0.50000, 0.50000]" ] }, - "execution_count": 28, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "vle = PhaseEquilibrium.bubble_point_tx(eos, 350*KELVIN, liquid_molefracs=np.array([0.5, 0.5]))\n", + "vle = PhaseEquilibrium.bubble_point(eos, 350*KELVIN, liquid_molefracs=np.array([0.5, 0.5]))\n", "vle" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_81996/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_7165/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", " return n * (np.log(v / (v - b * n)) - ak_mix / (b * SQRT2 * 2.0 * state.temperature)\n", - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_81996/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_7165/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", " * np.log((v * (SQRT2 - 1.0) + b * n) / (v * (SQRT2 + 1.0) - b * n)))\n" ] } ], "source": [ - "vle = PhaseDiagramBinary.new_pxy(eos, temperature=350*KELVIN, npoints=50)" + "vle = PhaseDiagram.binary_vle(eos, temperature_or_pressure=350*KELVIN, npoints=50)" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1106,15 +1146,15 @@ "source": [ "fig, ax = plt.subplots(1, 2, figsize=(18, 6))\n", "# fig.title(\"T = 350 K, Propane (1), Butane (2)\")\n", - "sns.lineplot(x=vle.liquid_molefracs, y=vle.pressure / BAR, ax=ax[0])\n", - "sns.lineplot(x=vle.vapor_molefracs, y=vle.pressure / BAR, ax=ax[0])\n", + "sns.lineplot(x=vle.liquid.molefracs[:,0], y=vle.liquid.pressure / BAR, ax=ax[0])\n", + "sns.lineplot(x=vle.vapor.molefracs[:,0], y=vle.liquid.pressure / BAR, ax=ax[0])\n", "ax[0].set_xlabel(r\"$x_1$, $y_1$\")\n", "ax[0].set_ylabel(r\"$p$ / bar\")\n", "ax[0].set_xlim(0, 1)\n", "ax[0].set_ylim(5, 35)\n", "# ax[0].legend(frameon=False);\n", "\n", - "sns.lineplot(x=vle.liquid_molefracs, y=vle.vapor_molefracs, ax=ax[1])\n", + "sns.lineplot(x=vle.liquid.molefracs[:,0], y=vle.vapor.molefracs[:,0], ax=ax[1])\n", "sns.lineplot(x=np.linspace(0, 1, 10), y=np.linspace(0, 1, 10), color=\"black\", alpha=0.3, ax=ax[1])\n", "ax[1].set_xlabel(r\"$x_1$\")\n", "ax[1].set_ylabel(r\"$y_1$\")\n", @@ -1137,12 +1177,12 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "# rust\n", - "from feos_core.cubic import PengRobinson, State as StateR, PengRobinsonParameters, PhaseDiagramPure as PhaseDiagramPureR\n", + "from feos_core.cubic import PengRobinson, State as StateR, PengRobinsonParameters, PhaseDiagram as PhaseDiagramR\n", "eos_rust = PengRobinson(PengRobinsonParameters.from_json([\"propane\"], \"peng-robinson.json\"))\n", "\n", "# python\n", @@ -1155,7 +1195,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -1166,7 +1206,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -1178,7 +1218,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -1186,7 +1226,7 @@ "output_type": "stream", "text": [ "Critical point for pure substance\n", - "Python implementation is slower by a factor of 34.\n" + "Python implementation is slower by a factor of 40.\n" ] } ], @@ -1198,28 +1238,28 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_81996/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_7165/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", " return n * (np.log(v / (v - b * n)) - ak_mix / (b * SQRT2 * 2.0 * state.temperature)\n", - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_81996/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_7165/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", " * np.log((v * (SQRT2 - 1.0) + b * n) / (v * (SQRT2 + 1.0) - b * n)))\n" ] } ], "source": [ - "time_python = timeit.timeit(lambda: PhaseDiagramPure(eos_python, 250*KELVIN, 100), number=100) * MILLI * SECOND\n", - "time_rust = timeit.timeit(lambda: PhaseDiagramPureR(eos_rust, 250*KELVIN, 100), number=100) * MILLI * SECOND" + "time_python = timeit.timeit(lambda: PhaseDiagram.pure(eos_python, 250*KELVIN, 100), number=100) * MILLI * SECOND\n", + "time_rust = timeit.timeit(lambda: PhaseDiagramR.pure(eos_rust, 250*KELVIN, 100), number=100) * MILLI * SECOND" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -1227,7 +1267,7 @@ "output_type": "stream", "text": [ "Phase diagram for pure substance\n", - "Python implementation is slower by a factor of 16.\n" + "Python implementation is slower by a factor of 21.\n" ] } ], @@ -1236,13 +1276,20 @@ "print(f\"Phase diagram for pure substance\")\n", "print(f\"Python implementation is {'slower' if rel_dev < 0 else 'faster'} by a factor of {abs(time_python / time_rust):.0f}.\")" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "feos", "language": "python", - "name": "python3" + "name": "feos" }, "language_info": { "codemirror_mode": { @@ -1254,7 +1301,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.9.10" } }, "nbformat": 4, diff --git a/src/errors.rs b/src/errors.rs index d087ae3..c8542c9 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -19,9 +19,11 @@ pub enum EosError { #[error("Undetermined state: {0}.")] UndeterminedState(String), #[error("System is supercritical.")] - SuperCritical(), + SuperCritical, #[error("No phase split according to stability analysis.")] NoPhaseSplit, + #[error("Wrong input units. Expected: {0}, got {1}")] + WrongUnits(String, String), #[error(transparent)] QuantityError(#[from] QuantityError), #[error(transparent)] diff --git a/src/lib.rs b/src/lib.rs index b898b46..d66bf43 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,6 +6,7 @@ use quantity::si::*; use quantity::*; +/// Print messages with level `Verbosity::Iter` or higher. #[macro_export] macro_rules! log_iter { ($verbosity:expr, $($arg:tt)*) => { @@ -15,6 +16,7 @@ macro_rules! log_iter { } } +/// Print messages with level `Verbosity::Result` or higher. #[macro_export] macro_rules! log_result { ($verbosity:expr, $($arg:tt)*) => { @@ -38,8 +40,7 @@ pub use equation_of_state::{ }; pub use errors::{EosError, EosResult}; pub use phase_equilibria::{ - PhaseDiagramBinary, PhaseDiagramHetero, PhaseDiagramPure, PhaseEquilibrium, SolverOptions, - Verbosity, + PhaseDiagram, PhaseDiagramHetero, PhaseEquilibrium, SolverOptions, StateVec, Verbosity, }; pub use state::{Contributions, DensityInitialization, State, StateBuilder, StateHD}; diff --git a/src/phase_equilibria/bubble_dew.rs b/src/phase_equilibria/bubble_dew.rs index 645a474..d699d51 100644 --- a/src/phase_equilibria/bubble_dew.rs +++ b/src/phase_equilibria/bubble_dew.rs @@ -9,6 +9,7 @@ use crate::{equation_of_state::EquationOfState, EosUnit}; use ndarray::*; use num_dual::linalg::{norm, LU}; use quantity::{QuantityArray1, QuantityScalar}; +use std::convert::TryFrom; use std::rc::Rc; const MAX_ITER_INNER: usize = 5; @@ -68,36 +69,12 @@ where /// # Bubble and dew point calculations impl PhaseEquilibrium { /// Calculate a phase equilibrium for a given temperature - /// and composition of the liquid phase. - pub fn bubble_point_tx( + /// or pressure and composition of the liquid phase. + pub fn bubble_point( eos: &Rc, - temperature: QuantityScalar, - pressure: Option>, - liquid_molefracs: &Array1, - vapor_molefracs: Option<&Array1>, - options: (SolverOptions, SolverOptions), - ) -> EosResult - where - QuantityScalar: std::fmt::Display, - { - Self::bubble_dew_point_with_options( - eos, - TPSpec::Temperature(temperature), - pressure, - liquid_molefracs, - vapor_molefracs, - true, - options, - ) - } - - /// Calculate a phase equilibrium for a given pressure - /// and composition of the liquid phase. - pub fn bubble_point_px( - eos: &Rc, - pressure: QuantityScalar, - temperature: Option>, + temperature_or_pressure: QuantityScalar, liquid_molefracs: &Array1, + tp_init: Option>, vapor_molefracs: Option<&Array1>, options: (SolverOptions, SolverOptions), ) -> EosResult @@ -106,8 +83,8 @@ impl PhaseEquilibrium { { Self::bubble_dew_point_with_options( eos, - TPSpec::Pressure(pressure), - temperature, + TPSpec::try_from(temperature_or_pressure)?, + tp_init, liquid_molefracs, vapor_molefracs, true, @@ -116,36 +93,12 @@ impl PhaseEquilibrium { } /// Calculate a phase equilibrium for a given temperature - /// and composition of the vapor phase. - pub fn dew_point_tx( + /// or pressure and composition of the vapor phase. + pub fn dew_point( eos: &Rc, - temperature: QuantityScalar, - pressure: Option>, - vapor_molefracs: &Array1, - liquid_molefracs: Option<&Array1>, - options: (SolverOptions, SolverOptions), - ) -> EosResult - where - QuantityScalar: std::fmt::Display, - { - Self::bubble_dew_point_with_options( - eos, - TPSpec::Temperature(temperature), - pressure, - vapor_molefracs, - liquid_molefracs, - false, - options, - ) - } - - /// Calculate a phase equilibrium for a given pressure - /// and composition of the vapor phase. - pub fn dew_point_px( - eos: &Rc, - pressure: QuantityScalar, - temperature: Option>, + temperature_or_pressure: QuantityScalar, vapor_molefracs: &Array1, + tp_init: Option>, liquid_molefracs: Option<&Array1>, options: (SolverOptions, SolverOptions), ) -> EosResult @@ -154,8 +107,8 @@ impl PhaseEquilibrium { { Self::bubble_dew_point_with_options( eos, - TPSpec::Pressure(pressure), - temperature, + TPSpec::try_from(temperature_or_pressure)?, + tp_init, vapor_molefracs, liquid_molefracs, false, diff --git a/src/phase_equilibria/mod.rs b/src/phase_equilibria/mod.rs index 400eb42..ff67f48 100644 --- a/src/phase_equilibria/mod.rs +++ b/src/phase_equilibria/mod.rs @@ -13,8 +13,8 @@ mod phase_diagram_pure; mod stability_analysis; mod tp_flash; mod vle_pure; -pub use phase_diagram_binary::{PhaseDiagramBinary, PhaseDiagramHetero}; -pub use phase_diagram_pure::PhaseDiagramPure; +pub use phase_diagram_binary::PhaseDiagramHetero; +pub use phase_diagram_pure::{PhaseDiagram, StateVec}; /// Level of detail in the iteration output. #[derive(Copy, Clone, PartialOrd, PartialEq)] diff --git a/src/phase_equilibria/phase_diagram_binary.rs b/src/phase_equilibria/phase_diagram_binary.rs index bd7d280..8cc2462 100644 --- a/src/phase_equilibria/phase_diagram_binary.rs +++ b/src/phase_equilibria/phase_diagram_binary.rs @@ -1,4 +1,4 @@ -use super::{PhaseEquilibrium, SolverOptions}; +use super::{PhaseDiagram, PhaseEquilibrium, SolverOptions}; use crate::equation_of_state::EquationOfState; use crate::errors::{EosError, EosResult}; use crate::state::{Contributions, DensityInitialization, State, StateBuilder, TPSpec}; @@ -6,75 +6,21 @@ use crate::EosUnit; use ndarray::{arr1, arr2, concatenate, s, Array1, Array2, Axis}; use num_dual::linalg::{norm, LU}; use quantity::{QuantityArray1, QuantityScalar}; +use std::convert::{TryFrom, TryInto}; use std::rc::Rc; const DEFAULT_POINTS: usize = 51; -/// Phase diagram (Txy or pxy) for a binary mixture. -pub struct PhaseDiagramBinary { - pub states: Vec>, -} - -impl Clone for PhaseDiagramBinary { - fn clone(&self) -> Self { - Self { - states: self.states.clone(), - } - } -} - -impl PhaseDiagramBinary { - /// Create a new Txy phase diagram for a given pressure. +impl PhaseDiagram { + /// Create a new binary phase diagram exhibiting a + /// vapor/liquid equilibrium. /// /// If a heteroazeotrope occurs and the composition of the liquid /// phases are known, they can be passed as `x_lle` to avoid - /// the calculation of instable branches. - pub fn new_txy( - eos: &Rc, - pressure: QuantityScalar, - npoints: Option, - x_lle: Option<(f64, f64)>, - bubble_dew_options: (SolverOptions, SolverOptions), - ) -> EosResult - where - QuantityScalar: std::fmt::Display + std::fmt::LowerExp, - { - Self::new_vle( - eos, - TPSpec::Pressure(pressure), - npoints, - x_lle, - bubble_dew_options, - ) - } - - /// Create a new pxy phase diagram for a given temperature. - /// - /// If a heteroazeotrope occurs and the composition of the liquid - /// phases are known, they can be passed as `x_lle` to avoid - /// the calculation of instable branches. - pub fn new_pxy( - eos: &Rc, - temperature: QuantityScalar, - npoints: Option, - x_lle: Option<(f64, f64)>, - bubble_dew_options: (SolverOptions, SolverOptions), - ) -> EosResult - where - QuantityScalar: std::fmt::Display + std::fmt::LowerExp, - { - Self::new_vle( - eos, - TPSpec::Temperature(temperature), - npoints, - x_lle, - bubble_dew_options, - ) - } - - fn new_vle( + /// the calculation of unstable branches. + pub fn binary_vle( eos: &Rc, - tp: TPSpec, + temperature_or_pressure: QuantityScalar, npoints: Option, x_lle: Option<(f64, f64)>, bubble_dew_options: (SolverOptions, SolverOptions), @@ -83,15 +29,16 @@ impl PhaseDiagramBinary { QuantityScalar: std::fmt::Display + std::fmt::LowerExp, { let npoints = npoints.unwrap_or(DEFAULT_POINTS); + let tp = temperature_or_pressure.try_into()?; // calculate boiling temperature/vapor pressure of pure components - let vle_sat = PhaseEquilibrium::vle_pure_comps(eos, tp); + let vle_sat = PhaseEquilibrium::vle_pure_comps(eos, temperature_or_pressure); let vle_sat = [vle_sat[1].clone(), vle_sat[0].clone()]; // Only calculate up to specified compositions if let Some(x_lle) = x_lle { let (states1, states2) = - Self::new_vlle(eos, tp, npoints, x_lle, vle_sat, bubble_dew_options)?; + Self::calculate_vlle(eos, tp, npoints, x_lle, vle_sat, bubble_dew_options)?; let states = states1 .into_iter() @@ -108,16 +55,26 @@ impl PhaseDiagramBinary { // look for supercritical components let (x_lim, vle_lim, bubble) = match vle_sat { - [None, None] => return Err(EosError::SuperCritical()), + [None, None] => return Err(EosError::SuperCritical), [Some(vle2), None] => { - let cp = - State::critical_point_binary(eos, tp, None, None, SolverOptions::default())?; + let cp = State::critical_point_binary( + eos, + temperature_or_pressure, + None, + None, + SolverOptions::default(), + )?; let cp_vle = PhaseEquilibrium::from_states(cp.clone(), cp.clone()); ([0.0, cp.molefracs[0]], (vle2, cp_vle), bubble) } [None, Some(vle1)] => { - let cp = - State::critical_point_binary(eos, tp, None, None, SolverOptions::default())?; + let cp = State::critical_point_binary( + eos, + temperature_or_pressure, + None, + None, + SolverOptions::default(), + )?; let cp_vle = PhaseEquilibrium::from_states(cp.clone(), cp.clone()); ([1.0, cp.molefracs[0]], (vle1, cp_vle), bubble) } @@ -141,7 +98,7 @@ impl PhaseDiagramBinary { } #[allow(clippy::type_complexity)] - fn new_vlle( + fn calculate_vlle( eos: &Rc, tp: TPSpec, npoints: usize, @@ -179,70 +136,20 @@ impl PhaseDiagramBinary { ); Ok((states1, states2)) } - _ => Err(EosError::SuperCritical()), + _ => Err(EosError::SuperCritical), } } - /// Create a new Txy phase diagram for a given pressure using - /// Tp flash calculation. + /// Create a new phase diagram using Tp flash calculations. /// /// The usual use case for this function is the calculation of /// liquid-liquid phase diagrams, but it can be used for vapor- /// liquid diagrams as well, as long as the feed composition is /// in a two phase region. - pub fn new_txy_lle( - eos: &Rc, - pressure: QuantityScalar, - x_feed: f64, - min_temperature: QuantityScalar, - max_temperature: QuantityScalar, - npoints: Option, - ) -> EosResult - where - QuantityScalar: std::fmt::Display + std::fmt::LowerExp, - { - Self::new_lle( - eos, - TPSpec::Pressure(pressure), - x_feed, - min_temperature, - max_temperature, - npoints, - ) - } - - /// Create a new pxy phase diagram for a given temperature using - /// Tp flash calculation. - /// - /// The usual use case for this function is the calculation of - /// liquid-liquid phase diagrams, but it can be used for vapor- - /// liquid diagrams as well, as long as the feed composition is - /// in a two phase region. - pub fn new_pxy_lle( - eos: &Rc, - temperature: QuantityScalar, - x_feed: f64, - min_pressure: QuantityScalar, - max_pressure: QuantityScalar, - npoints: Option, - ) -> EosResult - where - QuantityScalar: std::fmt::Display + std::fmt::LowerExp, - { - Self::new_lle( - eos, - TPSpec::Temperature(temperature), - x_feed, - max_pressure, - min_pressure, - npoints, - ) - } - - fn new_lle( + pub fn lle( eos: &Rc, - tp: TPSpec, - x_feed: f64, + temperature_or_pressure: QuantityScalar, + feed: &QuantityArray1, min_tp: QuantityScalar, max_tp: QuantityScalar, npoints: Option, @@ -252,8 +159,9 @@ impl PhaseDiagramBinary { { let npoints = npoints.unwrap_or(DEFAULT_POINTS); let mut states = Vec::with_capacity(npoints); + let tp: TPSpec = temperature_or_pressure.try_into()?; - let feed = arr1(&[x_feed, 1.0 - x_feed]) * U::reference_moles(); + // let feed = arr1(&[x_feed, 1.0 - x_feed]) * U::reference_moles(); let tp_vec = QuantityArray1::linspace(min_tp, max_tp, npoints)?; let mut vle = None; @@ -263,7 +171,7 @@ impl PhaseDiagramBinary { eos, t, p, - &feed, + feed, vle.as_ref(), SolverOptions::default(), None, @@ -275,36 +183,6 @@ impl PhaseDiagramBinary { } Ok(Self { states }) } - - pub fn temperature(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].vapor().temperature) - } - - pub fn pressure(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| { - self.states[i].vapor().pressure(Contributions::Total) - }) - } - - pub fn vapor_molefracs(&self) -> Array1 { - let mut x: Array1 = self.states.iter().map(|v| v.vapor().molefracs[0]).collect(); - if self.states[0].vapor().eos.components() == 1 { - x[0] = 0.0; - } - x - } - - pub fn liquid_molefracs(&self) -> Array1 { - let mut x: Array1 = self - .states - .iter() - .map(|v| v.liquid().molefracs[0]) - .collect(); - if self.states[0].liquid().eos.components() == 1 { - x[0] = 0.0; - } - x - } } fn iterate_vle( @@ -376,85 +254,35 @@ impl State { } /// Phase diagram (Txy or pxy) for a system with heteroazeotropic phase behavior. -pub struct PhaseDiagramHetero { - pub vle1: PhaseDiagramBinary, - pub vle2: PhaseDiagramBinary, - pub lle: Option>, +pub struct PhaseDiagramHetero { + pub vle1: PhaseDiagram, + pub vle2: PhaseDiagram, + pub lle: Option>, } -impl PhaseDiagramHetero { - /// Create a new Txy phase diagram exhibiting a heteroazeotrope for - /// a given pressure. +impl PhaseDiagram { + /// Create a new binary phase diagram exhibiting a + /// vapor/liquid/liquid equilibrium. /// /// The `x_lle` parameter is used as initial values for the calculation /// of the heteroazeotrope. - pub fn new_txy( - eos: &Rc, - pressure: QuantityScalar, - x_lle: (f64, f64), - min_temperature_lle: Option>, - npoints_vle: Option, - npoints_lle: Option, - bubble_dew_options: (SolverOptions, SolverOptions), - ) -> EosResult - where - QuantityScalar: std::fmt::Display + std::fmt::LowerExp, - { - Self::new( - eos, - TPSpec::Pressure(pressure), - x_lle, - min_temperature_lle, - npoints_vle, - npoints_lle, - bubble_dew_options, - ) - } - - /// Create a new pxy phase diagram exhibiting a heteroazeotrope for - /// a given temperature. - /// - /// The `x_lle` parameter is used as initial values for the calculation - /// of the heteroazeotrope. - pub fn new_pxy( - eos: &Rc, - temperature: QuantityScalar, - x_lle: (f64, f64), - max_pressure_lle: Option>, - npoints_vle: Option, - npoints_lle: Option, - bubble_dew_options: (SolverOptions, SolverOptions), - ) -> EosResult - where - QuantityScalar: std::fmt::Display + std::fmt::LowerExp, - { - Self::new( - eos, - TPSpec::Temperature(temperature), - x_lle, - max_pressure_lle, - npoints_vle, - npoints_lle, - bubble_dew_options, - ) - } - - fn new( + pub fn binary_vlle( eos: &Rc, - tp: TPSpec, + temperature_or_pressure: QuantityScalar, x_lle: (f64, f64), tp_lim_lle: Option>, npoints_vle: Option, npoints_lle: Option, bubble_dew_options: (SolverOptions, SolverOptions), - ) -> EosResult + ) -> EosResult> where QuantityScalar: std::fmt::Display + std::fmt::LowerExp, { let npoints_vle = npoints_vle.unwrap_or(DEFAULT_POINTS); + let tp = temperature_or_pressure.try_into()?; // calculate pure components - let vle_sat = PhaseEquilibrium::vle_pure_comps(eos, tp); + let vle_sat = PhaseEquilibrium::vle_pure_comps(eos, temperature_or_pressure); let vle_sat = [vle_sat[1].clone(), vle_sat[0].clone()]; // calculate heteroazeotrope @@ -477,7 +305,7 @@ impl PhaseDiagramHetero { let x_hetero = (vlle.liquid1().molefracs[0], vlle.liquid2().molefracs[0]); // calculate vapor liquid equilibria - let (dia1, dia2) = PhaseDiagramBinary::new_vlle( + let (dia1, dia2) = PhaseDiagram::calculate_vlle( eos, tp, npoints_vle, @@ -493,10 +321,12 @@ impl PhaseDiagramHetero { TPSpec::Pressure(_) => vlle.vapor().temperature, TPSpec::Temperature(_) => vlle.vapor().pressure(Contributions::Total), }; - PhaseDiagramBinary::new_lle( + let x_feed = 0.5 * (x_hetero.0 + x_hetero.1); + let feed = arr1(&[x_feed, 1.0 - x_feed]) * U::reference_moles(); + PhaseDiagram::lle( eos, - tp, - 0.5 * (x_hetero.0 + x_hetero.1), + temperature_or_pressure, + &feed, tp_lim, tp_hetero, npoints_lle, @@ -504,15 +334,17 @@ impl PhaseDiagramHetero { }) .transpose()?; - Ok(Self { - vle1: PhaseDiagramBinary { states: dia1 }, - vle2: PhaseDiagramBinary { states: dia2 }, + Ok(PhaseDiagramHetero { + vle1: PhaseDiagram { states: dia1 }, + vle2: PhaseDiagram { states: dia2 }, lle, }) } +} - pub fn vle(&self) -> PhaseDiagramBinary { - PhaseDiagramBinary { +impl PhaseDiagramHetero { + pub fn vle(&self) -> PhaseDiagram { + PhaseDiagram { states: self .vle1 .states @@ -532,9 +364,28 @@ impl PhaseEquilibrium where QuantityScalar: std::fmt::Display + std::fmt::LowerExp, { + /// Calculate a heteroazeotrope (three phase equilbrium) for a binary + /// system and given pressure. + pub fn heteroazeotrope( + eos: &Rc, + temperature_or_pressure: QuantityScalar, + x_init: (f64, f64), + options: SolverOptions, + bubble_dew_options: (SolverOptions, SolverOptions), + ) -> EosResult { + match TPSpec::try_from(temperature_or_pressure)? { + TPSpec::Temperature(t) => { + Self::heteroazeotrope_t(eos, t, x_init, options, bubble_dew_options) + } + TPSpec::Pressure(p) => { + Self::heteroazeotrope_p(eos, p, x_init, options, bubble_dew_options) + } + } + } + /// Calculate a heteroazeotrope (three phase equilbrium) for a binary /// system and given temperature. - pub fn heteroazeotrope_t( + fn heteroazeotrope_t( eos: &Rc, temperature: QuantityScalar, x_init: (f64, f64), @@ -544,22 +395,10 @@ where // calculate initial values using bubble point let x1 = arr1(&[x_init.0, 1.0 - x_init.0]); let x2 = arr1(&[x_init.1, 1.0 - x_init.1]); - let vle1 = PhaseEquilibrium::bubble_point_tx( - eos, - temperature, - None, - &x1, - None, - bubble_dew_options, - )?; - let vle2 = PhaseEquilibrium::bubble_point_tx( - eos, - temperature, - None, - &x2, - None, - bubble_dew_options, - )?; + let vle1 = + PhaseEquilibrium::bubble_point(eos, temperature, &x1, None, None, bubble_dew_options)?; + let vle2 = + PhaseEquilibrium::bubble_point(eos, temperature, &x2, None, None, bubble_dew_options)?; let mut l1 = vle1.liquid().clone(); let mut l2 = vle2.liquid().clone(); let p0 = (vle1.vapor().pressure(Contributions::Total) @@ -685,7 +524,7 @@ where /// Calculate a heteroazeotrope (three phase equilbrium) for a binary /// system and given pressure. - pub fn heteroazeotrope_p( + fn heteroazeotrope_p( eos: &Rc, pressure: QuantityScalar, x_init: (f64, f64), @@ -698,9 +537,9 @@ where let x1 = arr1(&[x_init.0, 1.0 - x_init.0]); let x2 = arr1(&[x_init.1, 1.0 - x_init.1]); let vle1 = - PhaseEquilibrium::bubble_point_px(eos, pressure, None, &x1, None, bubble_dew_options)?; + PhaseEquilibrium::bubble_point(eos, pressure, &x1, None, None, bubble_dew_options)?; let vle2 = - PhaseEquilibrium::bubble_point_px(eos, pressure, None, &x2, None, bubble_dew_options)?; + PhaseEquilibrium::bubble_point(eos, pressure, &x2, None, None, bubble_dew_options)?; let mut l1 = vle1.liquid().clone(); let mut l2 = vle2.liquid().clone(); let t0 = (vle1.vapor().temperature + vle2.vapor().temperature) * 0.5; diff --git a/src/phase_equilibria/phase_diagram_pure.rs b/src/phase_equilibria/phase_diagram_pure.rs index ca535c9..9197ec6 100644 --- a/src/phase_equilibria/phase_diagram_pure.rs +++ b/src/phase_equilibria/phase_diagram_pure.rs @@ -1,21 +1,28 @@ use super::{PhaseEquilibrium, SolverOptions}; -use crate::equation_of_state::EquationOfState; +use crate::equation_of_state::{EquationOfState, MolarWeight}; use crate::errors::EosResult; use crate::state::{Contributions, State}; use crate::EosUnit; use ndarray::prelude::*; use quantity::{QuantityArray1, QuantityScalar}; -use std::fmt; use std::rc::Rc; -/// Pure component phase diagram. -#[derive(Debug)] -pub struct PhaseDiagramPure { +/// Pure component and binary mixture phase diagrams. +pub struct PhaseDiagram { pub states: Vec>, } -impl PhaseDiagramPure { - pub fn new( +impl Clone for PhaseDiagram { + fn clone(&self) -> Self { + Self { + states: self.states.clone(), + } + } +} + +impl PhaseDiagram { + /// Calculate a phase diagram for a pure component. + pub fn pure( eos: &Rc, min_temperature: QuantityScalar, npoints: usize, @@ -36,89 +43,99 @@ impl PhaseDiagramPure { let mut vle = None; for &ti in temperatures.iter() { - vle = PhaseEquilibrium::pure_t(eos, ti, vle.as_ref(), options).ok(); + vle = PhaseEquilibrium::pure(eos, ti, vle.as_ref(), options).ok(); if let Some(vle) = vle.as_ref() { states.push(vle.clone()); } } states.push(PhaseEquilibrium::from_states(sc.clone(), sc)); - Ok(PhaseDiagramPure { states }) + Ok(PhaseDiagram { states }) + } + + /// Return the vapor states of the diagram. + pub fn vapor(&self) -> StateVec<'_, U, E> { + StateVec { + states: self.states.iter().map(|s| s.vapor()).collect(), + } } + /// Return the liquid states of the diagram. + pub fn liquid(&self) -> StateVec<'_, U, E> { + StateVec { + states: self.states.iter().map(|s| s.liquid()).collect(), + } + } +} + +/// A list of states for a simple access to properties +/// of multiple states. +pub struct StateVec<'a, U, E> { + pub states: Vec<&'a State>, +} + +impl<'a, U: EosUnit, E: EquationOfState> StateVec<'a, U, E> { pub fn temperature(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].vapor().temperature) + QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].temperature) } pub fn pressure(&self) -> QuantityArray1 { QuantityArray1::from_shape_fn(self.states.len(), |i| { - self.states[i].vapor().pressure(Contributions::Total) + self.states[i].pressure(Contributions::Total) }) } - pub fn density_vapor(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].vapor().density) + pub fn compressibility(&self) -> Array1 { + Array1::from_shape_fn(self.states.len(), |i| { + self.states[i].compressibility(Contributions::Total) + }) } - pub fn density_liquid(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].liquid().density) + pub fn density(&self) -> QuantityArray1 { + QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].density) } - pub fn molar_enthalpy_vapor(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| { - self.states[i].vapor().molar_enthalpy(Contributions::Total) - }) + pub fn molefracs(&self) -> Array2 { + Array2::from_shape_fn( + (self.states.len(), self.states[0].eos.components()), + |(i, j)| self.states[i].molefracs[j], + ) } - pub fn molar_enthalpy_liquid(&self) -> QuantityArray1 { + pub fn molar_enthalpy(&self) -> QuantityArray1 { QuantityArray1::from_shape_fn(self.states.len(), |i| { - self.states[i].liquid().molar_enthalpy(Contributions::Total) + self.states[i].molar_enthalpy(Contributions::Total) }) } - pub fn molar_entropy_vapor(&self) -> QuantityArray1 { + pub fn molar_entropy(&self) -> QuantityArray1 { QuantityArray1::from_shape_fn(self.states.len(), |i| { - self.states[i].vapor().molar_entropy(Contributions::Total) + self.states[i].molar_entropy(Contributions::Total) }) } +} + +impl<'a, U: EosUnit, E: EquationOfState + MolarWeight> StateVec<'a, U, E> { + pub fn mass_density(&self) -> QuantityArray1 { + QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].mass_density()) + } - pub fn molar_entropy_liquid(&self) -> QuantityArray1 { + pub fn massfracs(&self) -> Array2 { + Array2::from_shape_fn( + (self.states.len(), self.states[0].eos.components()), + |(i, j)| self.states[i].massfracs()[j], + ) + } + + pub fn specific_enthalpy(&self) -> QuantityArray1 { QuantityArray1::from_shape_fn(self.states.len(), |i| { - self.states[i].liquid().molar_entropy(Contributions::Total) + self.states[i].specific_enthalpy(Contributions::Total) }) } -} -impl fmt::Display for PhaseDiagramPure -where - U: EosUnit, - QuantityScalar: fmt::Display, - E: EquationOfState, -{ - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let temperature = self.temperature(); - let pressure = self.pressure(); - let density_vapor = self.density_vapor(); - let density_liquid = self.density_liquid(); - let molar_enthalpy_vapor = self.molar_enthalpy_vapor(); - let molar_enthalpy_liquid = self.molar_enthalpy_liquid(); - let molar_entropy_vapor = self.molar_entropy_vapor(); - let molar_entropy_liquid = self.molar_entropy_liquid(); - - for i in 0..temperature.len() { - writeln!( - f, - "{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}", - temperature.get(i), - pressure.get(i), - density_vapor.get(i), - density_liquid.get(i), - molar_enthalpy_vapor.get(i), - molar_enthalpy_liquid.get(i), - molar_entropy_vapor.get(i), - molar_entropy_liquid.get(i) - )?; - } - Ok(()) + pub fn specific_entropy(&self) -> QuantityArray1 { + QuantityArray1::from_shape_fn(self.states.len(), |i| { + self.states[i].specific_entropy(Contributions::Total) + }) } } diff --git a/src/phase_equilibria/tp_flash.rs b/src/phase_equilibria/tp_flash.rs index 8d188b7..05546e2 100644 --- a/src/phase_equilibria/tp_flash.rs +++ b/src/phase_equilibria/tp_flash.rs @@ -23,7 +23,7 @@ impl PhaseEquilibrium { temperature: QuantityScalar, pressure: QuantityScalar, feed: &QuantityArray1, - init_vle_state: Option<&PhaseEquilibrium>, + initial_state: Option<&PhaseEquilibrium>, options: SolverOptions, non_volatile_components: Option>, ) -> EosResult { @@ -34,7 +34,7 @@ impl PhaseEquilibrium { feed, DensityInitialization::None, )? - .tp_flash(init_vle_state, options, non_volatile_components) + .tp_flash(initial_state, options, non_volatile_components) } } @@ -48,7 +48,7 @@ impl State { /// containing non-volatile components (e.g. ions). pub fn tp_flash( &self, - init_vle_state: Option<&PhaseEquilibrium>, + initial_state: Option<&PhaseEquilibrium>, options: SolverOptions, non_volatile_components: Option>, ) -> EosResult> { @@ -56,7 +56,7 @@ impl State { let (max_iter, tol, verbosity) = options.unwrap_or(MAX_ITER_TP, TOL_TP); // initialization - let mut new_vle_state = match init_vle_state { + let mut new_vle_state = match initial_state { Some(init) => init .clone() .update_pressure(self.temperature, self.pressure(Contributions::Total))?, diff --git a/src/phase_equilibria/vle_pure.rs b/src/phase_equilibria/vle_pure.rs index ec886a3..c675a0c 100644 --- a/src/phase_equilibria/vle_pure.rs +++ b/src/phase_equilibria/vle_pure.rs @@ -4,8 +4,9 @@ use crate::equation_of_state::EquationOfState; use crate::errors::{EosError, EosResult}; use crate::state::{Contributions, DensityInitialization, State, TPSpec}; use crate::EosUnit; -use ndarray::arr1; +use ndarray::{arr1, Array1}; use quantity::{QuantityArray1, QuantityScalar}; +use std::convert::TryFrom; use std::rc::Rc; const SCALE_T_NEW: f64 = 0.7; @@ -15,9 +16,25 @@ const TOL_PURE: f64 = 1e-12; /// # Pure component phase equilibria impl PhaseEquilibrium { + /// Calculate a phase equilibrium for a pure component. + pub fn pure( + eos: &Rc, + temperature_or_pressure: QuantityScalar, + initial_state: Option<&PhaseEquilibrium>, + options: SolverOptions, + ) -> EosResult + where + QuantityScalar: std::fmt::Display + std::fmt::LowerExp, + { + match TPSpec::try_from(temperature_or_pressure)? { + TPSpec::Temperature(t) => Self::pure_t(eos, t, initial_state, options), + TPSpec::Pressure(p) => Self::pure_p(eos, p, initial_state, options), + } + } + /// Calculate a phase equilibrium for a pure component /// and given temperature. - pub fn pure_t( + fn pure_t( eos: &Rc, temperature: QuantityScalar, initial_state: Option<&PhaseEquilibrium>, @@ -151,7 +168,7 @@ impl PhaseEquilibrium { /// Calculate a phase equilibrium for a pure component /// and given pressure. - pub fn pure_p( + fn pure_p( eos: &Rc, pressure: QuantityScalar, initial_state: Option<&Self>, @@ -314,7 +331,7 @@ impl PhaseEquilibrium { let cp = State::critical_point(eos, None, None, SolverOptions::default())?; if pressure > cp.pressure(Contributions::Total) { - return Err(EosError::SuperCritical()); + return Err(EosError::SuperCritical); }; if let Some(mut e) = vle { if e.vapor().density < cp.density { @@ -402,24 +419,11 @@ impl PhaseEquilibrium { .collect() } - pub(super) fn vle_pure_comps( - eos: &Rc, - tp: TPSpec, - ) -> Vec>> - where - QuantityScalar: std::fmt::Display + std::fmt::LowerExp, - { - match tp { - TPSpec::Temperature(t) => Self::vle_pure_comps_t(eos, t), - TPSpec::Pressure(p) => Self::vle_pure_comps_p(eos, p), - } - } - /// Calculate the pure component phase equilibria of all /// components in the system for the given temperature. - pub fn vle_pure_comps_t( + pub fn vle_pure_comps( eos: &Rc, - temperature: QuantityScalar, + temperature_or_pressure: QuantityScalar, ) -> Vec>> where QuantityScalar: std::fmt::Display + std::fmt::LowerExp, @@ -427,25 +431,38 @@ impl PhaseEquilibrium { (0..eos.components()) .map(|i| { let pure_eos = Rc::new(eos.subset(&[i])); - PhaseEquilibrium::pure_t(&pure_eos, temperature, None, SolverOptions::default()) - .ok() - }) - .collect() - } - - /// Calculate the pure component phase equilibria of all - /// components in the system for the given pressure. - pub fn vle_pure_comps_p( - eos: &Rc, - pressure: QuantityScalar, - ) -> Vec>> - where - QuantityScalar: std::fmt::Display + std::fmt::LowerExp, - { - (0..eos.components()) - .map(|i| { - let pure_eos = Rc::new(eos.subset(&[i])); - PhaseEquilibrium::pure_p(&pure_eos, pressure, None, SolverOptions::default()).ok() + PhaseEquilibrium::pure( + &pure_eos, + temperature_or_pressure, + None, + SolverOptions::default(), + ) + .ok() + .map(|vle_pure| { + let mut moles_vapor = Array1::zeros(eos.components()) * U::reference_moles(); + let mut moles_liquid = moles_vapor.clone(); + moles_vapor + .try_set(i, vle_pure.vapor().total_moles) + .unwrap(); + moles_liquid + .try_set(i, vle_pure.liquid().total_moles) + .unwrap(); + let vapor = State::new_nvt( + eos, + vle_pure.vapor().temperature, + vle_pure.vapor().volume, + &moles_vapor, + ) + .unwrap(); + let liquid = State::new_nvt( + eos, + vle_pure.liquid().temperature, + vle_pure.liquid().volume, + &moles_liquid, + ) + .unwrap(); + PhaseEquilibrium::from_states(vapor, liquid) + }) }) .collect() } diff --git a/src/python/phase_equilibria.rs b/src/python/phase_equilibria.rs index 1081273..11e2b9b 100644 --- a/src/python/phase_equilibria.rs +++ b/src/python/phase_equilibria.rs @@ -1,5 +1,5 @@ #[macro_export] -macro_rules! impl_vle_state { +macro_rules! impl_phase_equilibrium { ($eos:ty, $py_eos:ty) => { /// A thermodynamic two phase equilibrium state. #[pyclass(name = "PhaseEquilibrium", unsendable)] @@ -9,59 +9,14 @@ macro_rules! impl_vle_state { #[pymethods] impl PyPhaseEquilibrium { /// Create a liquid and vapor state in equilibrium - /// for a pure substance given temperature. + /// for a pure substance. /// /// Parameters /// ---------- /// eos : Saft /// The SAFT equation of state. - /// temperature : SINumber - /// The system temperature. - /// initial_state : PhaseEquilibrium, optional - /// A phase equilibrium used as initial guess. - /// Can speed up convergence. - /// max_iter : int, optional - /// The maximum number of iterations. - /// tol: float, optional - /// The solution tolerance. - /// verbosity : Verbosity, optional - /// The verbosity. - /// - /// Returns - /// ------- - /// PhaseEquilibrium - /// - /// Raises - /// ------ - /// RuntimeError - /// When pressure iteration fails or no phase equilibrium is found. - #[staticmethod] - #[pyo3(text_signature = "(eos, temperature, initial_state=None, max_iter=None, tol=None, verbosity=None)")] - pub fn pure_t( - eos: $py_eos, - temperature: PySINumber, - initial_state: Option<&PyPhaseEquilibrium>, - max_iter: Option, - tol: Option, - verbosity: Option, - ) -> PyResult { - Ok(Self(PhaseEquilibrium::pure_t( - &eos.0, - temperature.into(), - initial_state.and_then(|s| Some(&s.0)), - (max_iter, tol, verbosity).into(), - )?)) - } - - /// Create a liquid and vapor state in equilibrium - /// for a pure substance given pressure. - /// - /// Parameters - /// ---------- - /// eos : Saft - /// The SAFT equation of state. - /// pressure : SINumber - /// The system pressure. + /// temperature_or_pressure : SINumber + /// The system temperature or pressure. /// initial_state : PhaseEquilibrium, optional /// A phase equilibrium used as initial guess. /// Can speed up convergence. @@ -81,18 +36,18 @@ macro_rules! impl_vle_state { /// RuntimeError /// When pressure iteration fails or no phase equilibrium is found. #[staticmethod] - #[pyo3(text_signature = "(eos, pressure, initial_state=None, max_iter=None, tol=None, verbosity=None)")] - pub fn pure_p( + #[pyo3(text_signature = "(eos, temperature_or_pressure, initial_state=None, max_iter=None, tol=None, verbosity=None)")] + pub fn pure( eos: $py_eos, - pressure: PySINumber, + temperature_or_pressure: PySINumber, initial_state: Option<&PyPhaseEquilibrium>, max_iter: Option, tol: Option, verbosity: Option, ) -> PyResult { - Ok(Self(PhaseEquilibrium::pure_p( + Ok(Self(PhaseEquilibrium::pure( &eos.0, - pressure.into(), + temperature_or_pressure.into(), initial_state.and_then(|s| Some(&s.0)), (max_iter, tol, verbosity).into(), )?)) @@ -113,7 +68,7 @@ macro_rules! impl_vle_state { /// The system pressure. /// feed : SIArray1 /// Feed composition (units of amount of substance). - /// init_vle_state : PhaseEquilibrium, optional + /// initial_state : PhaseEquilibrium, optional /// A phase equilibrium used as initial guess. /// Can speed up convergence. /// max_iter : int, optional @@ -132,13 +87,13 @@ macro_rules! impl_vle_state { /// RuntimeError /// When pressure iteration fails or no phase equilibrium is found. #[staticmethod] - #[pyo3(text_signature = "(eos, temperature, pressure, feed, init_vle_state=None, max_iter=None, tol=None, verbosity=None, non_volatile_components=None)")] + #[pyo3(text_signature = "(eos, temperature, pressure, feed, initial_state=None, max_iter=None, tol=None, verbosity=None, non_volatile_components=None)")] pub fn tp_flash( eos: $py_eos, temperature: PySINumber, pressure: PySINumber, feed: &PySIArray1, - init_vle_state: Option<&PyPhaseEquilibrium>, + initial_state: Option<&PyPhaseEquilibrium>, max_iter: Option, tol: Option, verbosity: Option, @@ -149,23 +104,25 @@ macro_rules! impl_vle_state { temperature.into(), pressure.into(), feed, - init_vle_state.and_then(|s| Some(&s.0)), + initial_state.and_then(|s| Some(&s.0)), (max_iter, tol, verbosity).into(), non_volatile_components )?)) } - /// Compute a VLE given temperature and liquid mole fraction. + /// Compute a phase equilibrium for given temperature + /// or pressure and liquid mole fractions. /// /// Parameters /// ---------- /// eos : Saft /// The SAFT equation of state. - /// temperature : SINumber - /// The system temperature. + /// temperature_or_pressure : SINumber + /// The system temperature_or_pressure. /// liquid_molefracs : numpy.ndarray /// The mole fraction of the liquid phase. - /// pressure : SINumber, optional - /// The system pressure used as starting condition for iteration. + /// tp_init : SINumber, optional + /// The system pressure/temperature used as starting + /// condition for the iteration. /// vapor_molefracs : numpy.ndarray, optional /// The mole fraction of the vapor phase used as /// starting condition for iteration. @@ -184,12 +141,12 @@ macro_rules! impl_vle_state { /// ------- /// PhaseEquilibrium #[staticmethod] - #[pyo3(text_signature = "(eos, temperature, liquid_molefracs, pressure=None, vapor_molefracs=None, max_iter_inner=None, max_iter_outer=None, tol_inner=None, tol_outer=None, verbosity=None)")] - pub fn bubble_point_tx( + #[pyo3(text_signature = "(eos, temperature_or_pressure, liquid_molefracs, tp_init=None, vapor_molefracs=None, max_iter_inner=None, max_iter_outer=None, tol_inner=None, tol_outer=None, verbosity=None)")] + pub fn bubble_point( eos: $py_eos, - temperature: PySINumber, + temperature_or_pressure: PySINumber, liquid_molefracs: &PyArray1, - pressure: Option, + tp_init: Option, vapor_molefracs: Option<&PyArray1>, max_iter_inner: Option, max_iter_outer: Option, @@ -198,11 +155,11 @@ macro_rules! impl_vle_state { verbosity: Option, ) -> PyResult { let x = vapor_molefracs.and_then(|m| Some(m.to_owned_array())); - Ok(Self(PhaseEquilibrium::bubble_point_tx( + Ok(Self(PhaseEquilibrium::bubble_point( &eos.0, - temperature.into(), - pressure.map(|p| p.into()), + temperature_or_pressure.into(), &liquid_molefracs.to_owned_array(), + tp_init.map(|p| p.into()), x.as_ref(), ( (max_iter_inner, tol_inner, verbosity).into(), @@ -211,75 +168,20 @@ macro_rules! impl_vle_state { )?)) } - /// Compute a VLE given pressure and liquid mole fraction. + /// Compute a phase equilibrium for given temperature + /// or pressure and vapor mole fractions. /// /// Parameters /// ---------- /// eos : Saft /// The SAFT equation of state. - /// pressure : SINumber - /// The system pressure. - /// liquid_molefracs : numpy.ndarray - /// The mole fraction of the liquid phase. - /// temperature : SINumber, optional - /// The system temperature used as starting condition for iteration. - /// vapor_molefracs : numpy.ndarray, optional - /// The mole fraction of the vapor phase used as - /// starting condition for iteration. - /// max_iter_inner : int, optional - /// The maximum number of inner iterations. - /// max_iter_outer : int, optional - /// The maximum number of outer iterations. - /// tol_inner : float, optional - /// The solution tolerance in the inner loop. - /// tol_outer : float, optional - /// The solution tolerance in the outer loop. - /// verbosity : Verbosity, optional - /// The verbosity. - /// - /// Returns - /// ------- - /// PhaseEquilibrium - #[staticmethod] - #[pyo3(text_signature = "(eos, pressure, liquid_molefracs, temperature=None, vapor_molefracs=None, max_iter_inner=None, max_iter_outer=None, tol_inner=None, tol_outer=None, verbosity=None)")] - pub fn bubble_point_px( - eos: $py_eos, - pressure: PySINumber, - liquid_molefracs: &PyArray1, - temperature: Option, - vapor_molefracs: Option<&PyArray1>, - max_iter_inner: Option, - max_iter_outer: Option, - tol_inner: Option, - tol_outer: Option, - verbosity: Option, - ) -> PyResult { - let x = vapor_molefracs.and_then(|m| Some(m.to_owned_array())); - Ok(Self(PhaseEquilibrium::bubble_point_px( - &eos.0, - pressure.into(), - temperature.map(|t| t.into()), - &liquid_molefracs.to_owned_array(), - x.as_ref(), - ( - (max_iter_inner, tol_inner, verbosity).into(), - (max_iter_outer, tol_outer, verbosity).into() - ) - )?)) - } - - /// Compute a VLE given temperature and vapor mole fraction. - /// - /// Parameters - /// ---------- - /// eos : Saft - /// The SAFT equation of state. - /// temperature : SINumber - /// The system temperature. + /// temperature_or_pressure : SINumber + /// The system temperature or pressure. /// vapor_molefracs : numpy.ndarray /// The mole fraction of the vapor phase. - /// pressure : SINumber, optional - /// The system pressure used as starting condition for iteration. + /// tp_init : SINumber, optional + /// The system pressure/temperature used as starting + /// condition for the iteration. /// liquid_molefracs : numpy.ndarray, optional /// The mole fraction of the liquid phase used as /// starting condition for iteration. @@ -298,69 +200,12 @@ macro_rules! impl_vle_state { /// ------- /// PhaseEquilibrium #[staticmethod] - #[pyo3(text_signature = "(eos, temperature, vapor_molefracs, pressure=None, liquid_molefracs=None, max_iter_inner=None, max_iter_outer=None, tol_inner=None, tol_outer=None, verbosity=None)")] - pub fn dew_point_tx( - eos: $py_eos, - temperature: PySINumber, - vapor_molefracs: &PyArray1, - pressure: Option, - liquid_molefracs: Option<&PyArray1>, - max_iter_inner: Option, - max_iter_outer: Option, - tol_inner: Option, - tol_outer: Option, - verbosity: Option, - ) -> PyResult { - let x = liquid_molefracs.and_then(|m| Some(m.to_owned_array())); - Ok(Self(PhaseEquilibrium::dew_point_tx( - &eos.0, - temperature.into(), - pressure.map(|p| p.into()), - &vapor_molefracs.to_owned_array(), - x.as_ref(), - ( - (max_iter_inner, tol_inner, verbosity).into(), - (max_iter_outer, tol_outer, verbosity).into() - ) - )?)) - } - - /// Compute a VLE given pressure and vapor mole fraction. - /// - /// Parameters - /// ---------- - /// eos : Saft - /// The SAFT equation of state. - /// pressure : SINumber - /// The system pressure. - /// liquid_molefracs : numpy.ndarray - /// The mole fraction of the liquid phase. - /// temperature : SINumber, optional - /// The system temperature used as starting condition for iteration. - /// vapor_molefracs : numpy.ndarray, optional - /// The mole fraction of the vapor phase used as - /// starting condition for iteration. - /// max_iter_inner : int, optional - /// The maximum number of inner iterations. - /// max_iter_outer : int, optional - /// The maximum number of outer iterations. - /// tol_inner : float, optional - /// The solution tolerance in the inner loop. - /// tol_outer : float, optional - /// The solution tolerance in the outer loop. - /// verbosity : Verbosity, optional - /// The verbosity. - /// - /// Returns - /// ------- - /// PhaseEquilibrium - #[staticmethod] - #[pyo3(text_signature = "(eos, pressure, vapor_molefracs, temperature=None, liquid_molefracs=None, max_iter_inner=None, max_iter_outer=None, tol_inner=None, tol_outer=None, verbosity=None)")] - pub fn dew_point_px( + #[pyo3(text_signature = "(eos, temperature_or_pressure, vapor_molefracs, tp_init=None, liquid_molefracs=None, max_iter_inner=None, max_iter_outer=None, tol_inner=None, tol_outer=None, verbosity=None)")] + pub fn dew_point( eos: $py_eos, - pressure: PySINumber, + temperature_or_pressure: PySINumber, vapor_molefracs: &PyArray1, - temperature: Option, + tp_init: Option, liquid_molefracs: Option<&PyArray1>, max_iter_inner: Option, max_iter_outer: Option, @@ -369,11 +214,11 @@ macro_rules! impl_vle_state { verbosity: Option, ) -> PyResult { let x = liquid_molefracs.and_then(|m| Some(m.to_owned_array())); - Ok(Self(PhaseEquilibrium::dew_point_px( + Ok(Self(PhaseEquilibrium::dew_point( &eos.0, - pressure.into(), - temperature.map(|t| t.into()), + temperature_or_pressure.into(), &vapor_molefracs.to_owned_array(), + tp_init.map(|p| p.into()), x.as_ref(), ( (max_iter_inner, tol_inner, verbosity).into(), @@ -414,38 +259,16 @@ macro_rules! impl_vle_state { /// ---------- /// eos : Saft /// The SAFT equation of state. - /// temperature : SINumber - /// The system temperature. + /// temperature_or_pressure : SINumber + /// The system temperature or pressure. /// /// Returns /// ------- /// list[PhaseEquilibrium] #[staticmethod] - #[pyo3(text_signature = "(eos, temperature)")] - fn vle_pure_comps_t(eos: $py_eos, temperature: PySINumber) -> Vec> { - PhaseEquilibrium::vle_pure_comps_t(&eos.0, temperature.into()) - .into_iter() - .map(|o| o.map(Self)) - .collect() - } - - /// Calculate the pure component vapor-liquid equilibria for all - /// components in the system. - /// - /// Parameters - /// ---------- - /// eos : Saft - /// The SAFT equation of state. - /// pressure : SINumber - /// The system pressure. - /// - /// Returns - /// ------- - /// list[PhaseEquilibrium] - #[staticmethod] - #[pyo3(text_signature = "(eos, pressure)")] - fn vle_pure_comps_p(eos: $py_eos, pressure: PySINumber) -> Vec> { - PhaseEquilibrium::vle_pure_comps_p(&eos.0, pressure.into()) + #[pyo3(text_signature = "(eos, temperature_or_pressure)")] + fn vle_pure_comps(eos: $py_eos, temperature_or_pressure: PySINumber) -> Vec> { + PhaseEquilibrium::vle_pure_comps(&eos.0, temperature_or_pressure.into()) .into_iter() .map(|o| o.map(Self)) .collect() @@ -511,68 +334,15 @@ macro_rules! impl_vle_state { #[pymethods] impl PyPhaseEquilibrium { - /// Calculate a heteroazeotrope in a binary mixture for a given temperature. - /// - /// Parameters - /// ---------- - /// eos : Saft - /// The SAFT equation of state. - /// temperature : SINumber - /// The system temperature. - /// x_init : list[float] - /// Initial guesses for the liquid molefracs of component 1 - /// at the heteroazeotropic point. - /// max_iter : int, optional - /// The maximum number of iterations. - /// tol: float, optional - /// The solution tolerance. - /// verbosity : Verbosity, optional - /// The verbosity. - /// max_iter_bd_inner : int, optional - /// The maximum number of inner iterations in the bubble/dew point iteration. - /// max_iter_bd_outer : int, optional - /// The maximum number of outer iterations in the bubble/dew point iteration. - /// tol_bd_inner : float, optional - /// The solution tolerance in the inner loop of the bubble/dew point iteration. - /// tol_bd_outer : float, optional - /// The solution tolerance in the outer loop of the bubble/dew point iteration. - /// verbosity_bd : Verbosity, optional - /// The verbosity of the bubble/dew point iteration. - #[staticmethod] - #[pyo3(text_signature = "(eos, temperature, x_init, max_iter=None, tol=None, verbosity=None, max_iter_bd_inner=None, max_iter_bd_outer=None, tol_bd_inner=None, tol_bd_outer=None, verbosity_bd=None)")] - fn heteroazeotrope_t( - eos: $py_eos, - temperature: PySINumber, - x_init: (f64, f64), - max_iter: Option, - tol: Option, - verbosity: Option, - max_iter_bd_inner: Option, - max_iter_bd_outer: Option, - tol_bd_inner: Option, - tol_bd_outer: Option, - verbosity_bd: Option, - ) -> PyResult { - Ok(PyThreePhaseEquilibrium(PhaseEquilibrium::heteroazeotrope_t( - &eos.0, - temperature.into(), - x_init, - (max_iter, tol, verbosity).into(), - ( - (max_iter_bd_inner, tol_bd_inner, verbosity_bd).into(), - (max_iter_bd_outer, tol_bd_outer, verbosity_bd).into(), - ) - )?)) - } - - /// Calculate a heteroazeotrope in a binary mixture for a given pressure. + /// Calculate a heteroazeotrope in a binary mixture for a given temperature + /// or pressure. /// /// Parameters /// ---------- /// eos : Saft /// The SAFT equation of state. - /// pressure : SINumber - /// The system pressure. + /// temperature_or_pressure : SINumber + /// The system temperature or pressure. /// x_init : list[float] /// Initial guesses for the liquid molefracs of component 1 /// at the heteroazeotropic point. @@ -593,10 +363,10 @@ macro_rules! impl_vle_state { /// verbosity_bd : Verbosity, optional /// The verbosity of the bubble/dew point iteration. #[staticmethod] - #[pyo3(text_signature = "(eos, pressure, x_init, max_iter=None, tol=None, verbosity=None, max_iter_bd_inner=None, max_iter_bd_outer=None, tol_bd_inner=None, tol_bd_outer=None, verbosity_bd=None)")] - fn heteroazeotrope_p( + #[pyo3(text_signature = "(eos, temperature_or_pressure, x_init, max_iter=None, tol=None, verbosity=None, max_iter_bd_inner=None, max_iter_bd_outer=None, tol_bd_inner=None, tol_bd_outer=None, verbosity_bd=None)")] + fn heteroazeotrope( eos: $py_eos, - pressure: PySINumber, + temperature_or_pressure: PySINumber, x_init: (f64, f64), max_iter: Option, tol: Option, @@ -607,9 +377,9 @@ macro_rules! impl_vle_state { tol_bd_outer: Option, verbosity_bd: Option, ) -> PyResult { - Ok(PyThreePhaseEquilibrium(PhaseEquilibrium::heteroazeotrope_p( + Ok(PyThreePhaseEquilibrium(PhaseEquilibrium::heteroazeotrope( &eos.0, - pressure.into(), + temperature_or_pressure.into(), x_init, (max_iter, tol, verbosity).into(), ( @@ -652,7 +422,7 @@ macro_rules! impl_vle_state { /// /// Parameters /// ---------- - /// init_vle_state : PhaseEquilibrium, optional + /// initial_state : PhaseEquilibrium, optional /// A phase equilibrium used as initial guess. /// Can speed up convergence. /// max_iter : int, optional @@ -670,55 +440,56 @@ macro_rules! impl_vle_state { /// ------ /// RuntimeError /// When pressure iteration fails or no phase equilibrium is found. - #[pyo3(text_signature = "($self, init_vle_state=None, max_iter=None, tol=None, verbosity=None, non_volatile_components=None)")] + #[pyo3(text_signature = "($self, initial_state=None, max_iter=None, tol=None, verbosity=None, non_volatile_components=None)")] pub fn tp_flash( &self, - init_vle_state: Option<&PyPhaseEquilibrium>, + initial_state: Option<&PyPhaseEquilibrium>, max_iter: Option, tol: Option, verbosity: Option, non_volatile_components: Option>, ) -> PyResult { Ok(PyPhaseEquilibrium(self.0.tp_flash( - init_vle_state.and_then(|s| Some(&s.0)), + initial_state.and_then(|s| Some(&s.0)), (max_iter, tol, verbosity).into(), non_volatile_components )?)) } } - /// Phase diagram for a pure component. - /// - /// Parameters - /// ---------- - /// eos: Eos - /// The equation of state. - /// min_temperature: SINumber - /// The lower limit for the temperature. - /// npoints: int - /// The number of points. - /// critical_temperature: SINumber, optional - /// An estimate for the critical temperature to initialize - /// the calculation if necessary. For most components not necessary. - /// Defaults to `None`. - /// max_iter : int, optional - /// The maximum number of iterations. - /// tol: float, optional - /// The solution tolerance. - /// verbosity : Verbosity, optional - /// The verbosity. - /// - /// Returns - /// ------- - /// PhaseDiagramPure - #[pyclass(name = "PhaseDiagramPure", unsendable)] - #[pyo3(text_signature = "(eos, min_temperature, npoints, critical_temperature=None, max_iter=None, tol=None, verbosity=None)")] - pub struct PyPhaseDiagramPure(PhaseDiagramPure); + /// Phase diagram for a pure component or a binary mixture. + #[pyclass(name = "PhaseDiagram", unsendable)] + pub struct PyPhaseDiagram(PhaseDiagram); #[pymethods] - impl PyPhaseDiagramPure { - #[new] - pub fn new( + impl PyPhaseDiagram { + /// Calculate a pure component phase diagram. + /// + /// Parameters + /// ---------- + /// eos: Eos + /// The equation of state. + /// min_temperature: SINumber + /// The lower limit for the temperature. + /// npoints: int + /// The number of points. + /// critical_temperature: SINumber, optional + /// An estimate for the critical temperature to initialize + /// the calculation if necessary. For most components not necessary. + /// Defaults to `None`. + /// max_iter : int, optional + /// The maximum number of iterations. + /// tol: float, optional + /// The solution tolerance. + /// verbosity : Verbosity, optional + /// The verbosity. + /// + /// Returns + /// ------- + /// PhaseDiagram + #[staticmethod] + #[pyo3(text_signature = "(eos, min_temperature, npoints, critical_temperature=None, max_iter=None, tol=None, verbosity=None)")] + pub fn pure( eos: &$py_eos, min_temperature: PySINumber, npoints: usize, @@ -727,7 +498,7 @@ macro_rules! impl_vle_state { tol: Option, verbosity: Option, ) -> PyResult { - let dia = PhaseDiagramPure::new( + let dia = PhaseDiagram::pure( &eos.0, min_temperature.into(), npoints, @@ -747,43 +518,13 @@ macro_rules! impl_vle_state { } #[getter] - pub fn get_temperature(&self) -> PySIArray1 { - self.0.temperature().into() - } - - #[getter] - pub fn get_pressure(&self) -> PySIArray1 { - self.0.pressure().into() + pub fn get_vapor(&self) -> PyStateVec { + self.0.vapor().into() } #[getter] - pub fn get_density_vapor(&self) -> PySIArray1 { - self.0.density_vapor().into() - } - - #[getter] - pub fn get_density_liquid(&self) -> PySIArray1 { - self.0.density_liquid().into() - } - - #[getter] - pub fn get_molar_enthalpy_vapor(&self) -> PySIArray1 { - self.0.molar_enthalpy_vapor().into() - } - - #[getter] - pub fn get_molar_enthalpy_liquid(&self) -> PySIArray1 { - self.0.molar_enthalpy_liquid().into() - } - - #[getter] - pub fn get_molar_entropy_vapor(&self) -> PySIArray1 { - self.0.molar_entropy_vapor().into() - } - - #[getter] - pub fn get_molar_entropy_liquid(&self) -> PySIArray1 { - self.0.molar_entropy_liquid().into() + pub fn get_liquid(&self) -> PyStateVec { + self.0.liquid().into() } /// Returns the phase diagram as dictionary. @@ -802,37 +543,28 @@ macro_rules! impl_vle_state { /// Keys: property names. Values: property for each state. pub fn to_dict(&self) -> PyResult>> { let mut result = HashMap::with_capacity(8); - result.insert(String::from("temperature"), (self.0.temperature() / KELVIN).into_value()?.into_raw_vec()); - result.insert(String::from("pressure"), (self.0.pressure() / PASCAL).into_value()?.into_raw_vec()); - result.insert(String::from("density liquid"), (self.0.density_liquid() / (MOL / METER.powi(3))).into_value()?.into_raw_vec()); - result.insert(String::from("density vapor"), (self.0.density_vapor() / (MOL / METER.powi(3))).into_value()?.into_raw_vec()); - result.insert(String::from("molar enthalpy liquid"), (self.0.molar_enthalpy_liquid() / (KILO*JOULE / MOL)).into_value()?.into_raw_vec()); - result.insert(String::from("molar enthalpy vapor"), (self.0.molar_enthalpy_vapor() / (KILO*JOULE / MOL)).into_value()?.into_raw_vec()); - result.insert(String::from("molar entropy liquid"), (self.0.molar_entropy_liquid() / (KILO*JOULE / KELVIN / MOL)).into_value()?.into_raw_vec()); - result.insert(String::from("molar entropy vapor"), (self.0.molar_entropy_vapor() / (KILO*JOULE / KELVIN / MOL)).into_value()?.into_raw_vec()); + result.insert(String::from("temperature"), (self.0.vapor().temperature() / KELVIN).into_value()?.into_raw_vec()); + result.insert(String::from("pressure"), (self.0.vapor().pressure() / PASCAL).into_value()?.into_raw_vec()); + result.insert(String::from("density liquid"), (self.0.liquid().density() / (MOL / METER.powi(3))).into_value()?.into_raw_vec()); + result.insert(String::from("density vapor"), (self.0.vapor().density() / (MOL / METER.powi(3))).into_value()?.into_raw_vec()); + result.insert(String::from("molar enthalpy liquid"), (self.0.liquid().molar_enthalpy() / (KILO*JOULE / MOL)).into_value()?.into_raw_vec()); + result.insert(String::from("molar enthalpy vapor"), (self.0.vapor().molar_enthalpy() / (KILO*JOULE / MOL)).into_value()?.into_raw_vec()); + result.insert(String::from("molar entropy liquid"), (self.0.liquid().molar_entropy() / (KILO*JOULE / KELVIN / MOL)).into_value()?.into_raw_vec()); + result.insert(String::from("molar entropy vapor"), (self.0.vapor().molar_entropy() / (KILO*JOULE / KELVIN / MOL)).into_value()?.into_raw_vec()); Ok(result) } - } - - - /// Phase diagram for a binary mixture. - #[pyclass(name = "PhaseDiagramBinary", unsendable)] - pub struct PyPhaseDiagramBinary(PhaseDiagramBinary); - - #[pymethods] - impl PyPhaseDiagramBinary { - /// Txy phase diagram for a binary mixture. + /// Binary phase diagram calculated using bubble/dew point iterations. /// /// Parameters /// ---------- - /// eos: SaftFunctional - /// The SAFT Helmholtz energy functional. - /// pressure: SINumber - /// The pressure. + /// eos: $eos + /// The equation of state. + /// temperature_or_pressure: SINumber + /// The constant temperature or pressure. /// npoints: int, optional /// The number of points (default 51). - /// x_lle: SINumber, optional + /// x_lle: (float, float), optional /// An estimate for the molefractions of component 1 /// at the heteroazeotrop /// max_iter_inner : int, optional @@ -848,12 +580,12 @@ macro_rules! impl_vle_state { /// /// Returns /// ------- - /// PhaseDiagramBinary + /// PhaseDiagram #[staticmethod] - #[pyo3(text_signature = "(eos, pressure, npoints=None, x_lle=None, max_iter_bd_inner=None, max_iter_bd_outer=None, tol_bd_inner=None, tol_bd_outer=None, verbosity_bd=None)")] - pub fn new_txy( + #[pyo3(text_signature = "(eos, temperature_or_pressure, npoints=None, x_lle=None, max_iter_inner=None, max_iter_outer=None, tol_inner=None, tol_outer=None, verbosity=None)")] + pub fn binary_vle( eos: $py_eos, - pressure: PySINumber, + temperature_or_pressure: PySINumber, npoints: Option, x_lle: Option<(f64, f64)>, max_iter_inner: Option, @@ -862,62 +594,9 @@ macro_rules! impl_vle_state { tol_outer: Option, verbosity: Option, ) -> PyResult { - let dia = PhaseDiagramBinary::new_txy( + let dia = PhaseDiagram::binary_vle( &eos.0, - pressure.into(), - npoints, - x_lle, - ( - (max_iter_inner, tol_inner, verbosity).into(), - (max_iter_outer, tol_outer, verbosity).into(), - ) - )?; - Ok(Self(dia)) - } - - /// pxy phase diagram for a binary mixture. - /// - /// Parameters - /// ---------- - /// eos: SaftFunctional - /// The SAFT Helmholtz energy functional. - /// temperature: SINumber - /// The temperature. - /// npoints: int, optional - /// The number of points (default 51). - /// x_lle: SINumber, optional - /// An estimate for the molefractions of component 1 - /// at the heteroazeotrop - /// max_iter_inner : int, optional - /// The maximum number of inner iterations in the bubble/dew point iteration. - /// max_iter_outer : int, optional - /// The maximum number of outer iterations in the bubble/dew point iteration. - /// tol_inner : float, optional - /// The solution tolerance in the inner loop of the bubble/dew point iteration. - /// tol_outer : float, optional - /// The solution tolerance in the outer loop of the bubble/dew point iteration. - /// verbosity : Verbosity, optional - /// The verbosity of the bubble/dew point iteration. - /// - /// Returns - /// ------- - /// PhaseDiagramBinary - #[staticmethod] - #[pyo3(text_signature = "(eos, temperature, npoints=None, x_lle=None, max_iter_bd_inner=None, max_iter_bd_outer=None, tol_bd_inner=None, tol_bd_outer=None, verbosity_bd=None)")] - pub fn new_pxy( - eos: $py_eos, - temperature: PySINumber, - npoints: Option, - x_lle: Option<(f64, f64)>, - max_iter_inner: Option, - max_iter_outer: Option, - tol_inner: Option, - tol_outer: Option, - verbosity: Option, - ) -> PyResult { - let dia = PhaseDiagramBinary::new_pxy( - &eos.0, - temperature.into(), + temperature_or_pressure.into(), npoints, x_lle, ( @@ -928,116 +607,51 @@ macro_rules! impl_vle_state { Ok(Self(dia)) } - /// Txy phase diagram for a liquid-liquid equilibrium of a binary mixture. + /// Create a new phase diagram using Tp flash calculations. /// - /// Parameters - /// ---------- - /// eos: SaftFunctional - /// The SAFT Helmholtz energy functional. - /// pressure: SINumber - /// The pressure. - /// x_feed: float - /// Molefraction of component 1 in the (unstable) feed state. - /// min_temperature: - /// The lower limit of the temperature range. - /// max_temperature: - /// The upper limit of the temperature range. - /// npoints: int, optional - /// The number of points (default 51). - /// - /// Returns - /// ------- - /// PhaseDiagramBinary - #[staticmethod] - #[pyo3(text_signature = "(eos, pressure, min_temperature, max_temperature, npoints=None)")] - pub fn new_txy_lle( - eos: $py_eos, - pressure: PySINumber, - x_feed: f64, - min_temperature: PySINumber, - max_temperature: PySINumber, - npoints: Option, - ) -> PyResult { - let dia = PhaseDiagramBinary::new_txy_lle( - &eos.0, - pressure.into(), - x_feed, - min_temperature.into(), - max_temperature.into(), - npoints, - )?; - Ok(Self(dia)) - } - - /// pxy phase diagram for a liquid-liquid equilibrium of a binary mixture. + /// The usual use case for this function is the calculation of + /// liquid-liquid phase diagrams, but it can be used for vapor- + /// liquid diagrams as well, as long as the feed composition is + /// in a two phase region. /// /// Parameters /// ---------- - /// eos: SaftFunctional - /// The SAFT Helmholtz energy functional. - /// temperature: SINumber - /// The temperature. - /// x_feed: float - /// Molefraction of component 1 in the (unstable) feed state. - /// min_pressure: - /// The lower limit of the pressure range. - /// max_pressure: - /// The upper limit of the pressure range. + /// eos: $eos + /// The equation of state. + /// temperature_or_pressure: SINumber + /// The consant temperature or pressure. + /// feed: SIArray1 + /// Mole numbers in the (unstable) feed state. + /// min_tp: + /// The lower limit of the temperature/pressure range. + /// max_tp: + /// The upper limit of the temperature/pressure range. /// npoints: int, optional /// The number of points (default 51). /// /// Returns /// ------- - /// PhaseDiagramBinary + /// PhaseDiagram #[staticmethod] - #[pyo3(text_signature = "(eos, temperature, min_pressure, max_pressure, npoints=None)")] - pub fn new_pxy_lle( + #[pyo3(text_signature = "(eos, temperature_or_pressure, feed, min_tp, max_tp, npoints=None)")] + pub fn lle( eos: $py_eos, - temperature: PySINumber, - x_feed: f64, - min_pressure: PySINumber, - max_pressure: PySINumber, + temperature_or_pressure: PySINumber, + feed: PySIArray1, + min_tp: PySINumber, + max_tp: PySINumber, npoints: Option, ) -> PyResult { - let dia = PhaseDiagramBinary::new_pxy_lle( + let dia = PhaseDiagram::lle( &eos.0, - temperature.into(), - x_feed, - min_pressure.into(), - max_pressure.into(), + temperature_or_pressure.into(), + &feed, + min_tp.into(), + max_tp.into(), npoints, )?; Ok(Self(dia)) } - - #[getter] - pub fn get_states(&self) -> Vec { - self.0 - .states - .iter() - .map(|vle| PyPhaseEquilibrium(vle.clone())) - .collect() - } - - #[getter] - pub fn get_temperature(&self) -> PySIArray1 { - self.0.temperature().into() - } - - #[getter] - pub fn get_pressure(&self) -> PySIArray1 { - self.0.pressure().into() - } - - #[getter] - fn get_vapor_molefracs<'py>(&self, py: Python<'py>) -> &'py PyArray1 { - self.0.vapor_molefracs().view().to_pyarray(py) - } - - #[getter] - fn get_liquid_molefracs<'py>(&self, py: Python<'py>) -> &'py PyArray1 { - self.0.liquid_molefracs().view().to_pyarray(py) - } } /// Phase diagram for a binary mixture exhibiting a heteroazeotrope. @@ -1045,8 +659,8 @@ macro_rules! impl_vle_state { pub struct PyPhaseDiagramHetero(PhaseDiagramHetero); #[pymethods] - impl PyPhaseDiagramHetero { - /// Txy phase diagram for a binary mixture exhibiting a heteroazeotrope. + impl PyPhaseDiagram { + /// Phase diagram for a binary mixture exhibiting a heteroazeotrope. /// /// Parameters /// ---------- @@ -1077,10 +691,10 @@ macro_rules! impl_vle_state { /// /// Returns /// ------- - /// PhaseDiagramBinary + /// PhaseDiagramHetero #[staticmethod] #[pyo3(text_signature = "(eos, pressure, x_lle, min_temperature_lle=None, npoints_vle=None, npoints_lle=None, max_iter_bd_inner=None, max_iter_bd_outer=None, tol_bd_inner=None, tol_bd_outer=None, verbosity_bd=None)")] - pub fn new_txy( + pub fn binary_vlle( eos: $py_eos, pressure: PySINumber, x_lle: (f64, f64), @@ -1092,8 +706,8 @@ macro_rules! impl_vle_state { tol_inner: Option, tol_outer: Option, verbosity: Option, - ) -> PyResult { - let dia = PhaseDiagramHetero::new_txy( + ) -> PyResult { + let dia = PhaseDiagram::binary_vlle( &eos.0, pressure.into(), x_lle, @@ -1105,92 +719,33 @@ macro_rules! impl_vle_state { (max_iter_outer, tol_outer, verbosity).into(), ) )?; - Ok(Self(dia)) - } - - /// pxy phase diagram for a binary mixture exhibiting a heteroazeotrope. - /// - /// Parameters - /// ---------- - /// eos: SaftFunctional - /// The SAFT Helmholtz energy functional. - /// temperature: SINumber - /// The temperature. - /// x_lle: SINumber - /// Initial values for the molefractions of component 1 - /// at the heteroazeotrop. - /// max_pressure: SINumber, optional - /// The maximum pressure up to which the LLE is calculated. - /// If it is not provided, no LLE is calcualted. - /// npoints_vle: int, optional - /// The number of points for the VLE (default 51). - /// npoints_lle: int, optional - /// The number of points for the LLE (default 51). - /// max_iter_inner : int, optional - /// The maximum number of inner iterations in the bubble/dew point iteration. - /// max_iter_outer : int, optional - /// The maximum number of outer iterations in the bubble/dew point iteration. - /// tol_inner : float, optional - /// The solution tolerance in the inner loop of the bubble/dew point iteration. - /// tol_outer : float, optional - /// The solution tolerance in the outer loop of the bubble/dew point iteration. - /// verbosity : Verbosity, optional - /// The verbosity of the bubble/dew point iteration. - /// - /// Returns - /// ------- - /// PhaseDiagramBinary - #[staticmethod] - #[pyo3(text_signature = "(eos, temperature, x_lle, max_pressure_lle=None, npoints_vle=None, npoints_lle=None, max_iter_bd_inner=None, max_iter_bd_outer=None, tol_bd_inner=None, tol_bd_outer=None, verbosity_bd=None)")] - pub fn new_pxy( - eos: $py_eos, - temperature: PySINumber, - x_lle: (f64, f64), - max_pressure_lle: Option, - npoints_vle: Option, - npoints_lle: Option, - max_iter_inner: Option, - max_iter_outer: Option, - tol_inner: Option, - tol_outer: Option, - verbosity: Option, - ) -> PyResult { - let dia = PhaseDiagramHetero::new_pxy( - &eos.0, - temperature.into(), - x_lle, - max_pressure_lle.map(|t| t.into()), - npoints_vle, - npoints_lle, - ( - (max_iter_inner, tol_inner, verbosity).into(), - (max_iter_outer, tol_outer, verbosity).into(), - ) - )?; - Ok(Self(dia)) + Ok(PyPhaseDiagramHetero(dia)) } + } + #[pymethods] + impl PyPhaseDiagramHetero { #[getter] - pub fn get_vle(&self) -> PyPhaseDiagramBinary { - PyPhaseDiagramBinary(self.0.vle().clone()) + pub fn get_vle(&self) -> PyPhaseDiagram { + PyPhaseDiagram(self.0.vle().clone()) } #[getter] - pub fn get_vle1(&self) -> PyPhaseDiagramBinary { - PyPhaseDiagramBinary(self.0.vle1.clone()) + pub fn get_vle1(&self) -> PyPhaseDiagram { + PyPhaseDiagram(self.0.vle1.clone()) } #[getter] - pub fn get_vle2(&self) -> PyPhaseDiagramBinary { - PyPhaseDiagramBinary(self.0.vle2.clone()) + pub fn get_vle2(&self) -> PyPhaseDiagram { + PyPhaseDiagram(self.0.vle2.clone()) } #[getter] - pub fn get_lle(&self) -> Option { + pub fn get_lle(&self) -> Option { self.0 .lle .as_ref() - .map(|d| PyPhaseDiagramBinary(d.clone())) + .map(|d| PyPhaseDiagram(d.clone())) } } } diff --git a/src/python/state.rs b/src/python/state.rs index 5028d37..d4aa5e3 100644 --- a/src/python/state.rs +++ b/src/python/state.rs @@ -987,6 +987,60 @@ macro_rules! impl_state { Ok(self.0.to_string()) } } + + + #[pyclass(name = "StateVec", unsendable)] + pub struct PyStateVec(Vec>); + + impl From> for PyStateVec { + fn from(vec: StateVec) -> Self { + Self(vec.states.iter().map(|&s| s.clone()).collect()) + } + } + + impl<'a> From<&'a PyStateVec> for StateVec<'a, SIUnit, $eos> { + fn from(vec: &'a PyStateVec) -> Self { + Self { states: vec.0.iter().collect() } + } + } + + #[pymethods] + impl PyStateVec { + #[getter] + fn get_temperature(&self) -> PySIArray1{ + StateVec::from(self).temperature().into() + } + + #[getter] + fn get_pressure(&self) -> PySIArray1 { + StateVec::from(self).pressure().into() + } + + #[getter] + fn get_compressibility<'py>(&self, py: Python<'py>) -> &'py PyArray1 { + StateVec::from(self).compressibility().view().to_pyarray(py) + } + + #[getter] + fn get_density(&self) -> PySIArray1 { + StateVec::from(self).density().into() + } + + #[getter] + fn get_molefracs<'py>(&self, py: Python<'py>) -> &'py PyArray2 { + StateVec::from(self).molefracs().view().to_pyarray(py) + } + + #[getter] + fn get_molar_enthalpy(&self) -> PySIArray1 { + StateVec::from(self).molar_enthalpy().into() + } + + #[getter] + fn get_molar_entropy(&self) -> PySIArray1 { + StateVec::from(self).molar_entropy().into() + } + } }; } @@ -1140,6 +1194,29 @@ macro_rules! impl_state_molarweight { PySINumber::from(self.0.specific_enthalpy(contributions)) } } + + #[pymethods] + impl PyStateVec { + #[getter] + fn get_mass_density(&self) -> PySIArray1 { + StateVec::from(self).mass_density().into() + } + + #[getter] + fn get_massfracs<'py>(&self, py: Python<'py>) -> &'py PyArray2 { + StateVec::from(self).massfracs().view().to_pyarray(py) + } + + #[getter] + fn get_specific_enthalpy(&self) -> PySIArray1 { + StateVec::from(self).specific_enthalpy().into() + } + + #[getter] + fn get_specific_entropy(&self) -> PySIArray1 { + StateVec::from(self).specific_entropy().into() + } + } }; } diff --git a/src/state/critical_point.rs b/src/state/critical_point.rs index 347d4e3..6690c56 100644 --- a/src/state/critical_point.rs +++ b/src/state/critical_point.rs @@ -8,6 +8,7 @@ use num_dual::linalg::{norm, smallest_ev, LU}; use num_dual::{Dual, Dual3, Dual64, DualNum, DualVec64, HyperDual, StaticVec}; use num_traits::{One, Zero}; use quantity::{QuantityArray1, QuantityScalar}; +use std::convert::TryFrom; use std::rc::Rc; const MAX_ITER_CRIT_POINT: usize = 50; @@ -36,9 +37,9 @@ impl State { .collect() } - pub(crate) fn critical_point_binary( + pub fn critical_point_binary( eos: &Rc, - tp: TPSpec, + temperature_or_pressure: QuantityScalar, initial_temperature: Option>, initial_molefracs: Option<[f64; 2]>, options: SolverOptions, @@ -46,7 +47,7 @@ impl State { where QuantityScalar: std::fmt::Display, { - match tp { + match TPSpec::try_from(temperature_or_pressure)? { TPSpec::Temperature(t) => { Self::critical_point_binary_t(eos, t, initial_molefracs, options) } diff --git a/src/state/mod.rs b/src/state/mod.rs index 4854217..e22227a 100644 --- a/src/state/mod.rs +++ b/src/state/mod.rs @@ -16,6 +16,7 @@ use num_dual::linalg::{norm, LU}; use num_dual::*; use quantity::{QuantityArray1, QuantityScalar}; use std::cell::RefCell; +use std::convert::TryFrom; use std::fmt; use std::rc::Rc; @@ -785,11 +786,30 @@ fn validate( } #[derive(Clone, Copy)] -pub enum TPSpec { +pub enum TPSpec { Temperature(QuantityScalar), Pressure(QuantityScalar), } +impl TryFrom> for TPSpec +where + QuantityScalar: std::fmt::Display, +{ + type Error = EosError; + fn try_from(quantity: QuantityScalar) -> EosResult { + if quantity.has_unit(&U::reference_temperature()) { + Ok(Self::Temperature(quantity)) + } else if quantity.has_unit(&U::reference_pressure()) { + Ok(Self::Pressure(quantity)) + } else { + Err(EosError::WrongUnits( + "K or bar".into(), + format!("{}", quantity), + )) + } + } +} + mod critical_point; #[cfg(test)] From 969c98650467f940a3181c6e201558040163a914 Mon Sep 17 00:00:00 2001 From: Philipp Rehner Date: Mon, 21 Mar 2022 15:33:31 +0100 Subject: [PATCH 2/4] fixes --- build_wheel/src/cubic.rs | 4 +- example/user_defined_eos.ipynb | 213 +++++++++++++-------------------- src/errors.rs | 2 +- src/python/state.rs | 58 ++------- src/state/critical_point.rs | 4 +- src/state/mod.rs | 2 +- 6 files changed, 99 insertions(+), 184 deletions(-) diff --git a/build_wheel/src/cubic.rs b/build_wheel/src/cubic.rs index cffec8b..a7d8daa 100644 --- a/build_wheel/src/cubic.rs +++ b/build_wheel/src/cubic.rs @@ -1,5 +1,5 @@ use feos_core::cubic::PengRobinson; -use feos_core::python::cubic::PyPengRobinsonParameters; +use feos_core::python::cubic::{PyPengRobinsonParameters, PyPengRobinsonRecord, PyPureRecord}; use feos_core::*; use numpy::convert::ToPyArray; use numpy::{PyArray1, PyArray2}; @@ -44,6 +44,8 @@ impl_phase_equilibrium!(PengRobinson, PyPengRobinson); pub fn cubic(_py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_class::()?; m.add_class::()?; + m.add_class::()?; + m.add_class::()?; m.add_class::()?; m.add_class::()?; m.add_class::()?; diff --git a/example/user_defined_eos.ipynb b/example/user_defined_eos.ipynb index 085561e..71467ae 100644 --- a/example/user_defined_eos.ipynb +++ b/example/user_defined_eos.ipynb @@ -446,7 +446,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_7165/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_44237/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", " return n * (np.log(v / (v - b * n)) - ak_mix / (b * SQRT2 * 2.0 * state.temperature)\n" ] }, @@ -576,9 +576,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_7165/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_44237/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", " return n * (np.log(v / (v - b * n)) - ak_mix / (b * SQRT2 * 2.0 * state.temperature)\n", - "/tmp/ipykernel_7165/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_44237/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", " * np.log((v * (SQRT2 - 1.0) + b * n) / (v * (SQRT2 + 1.0) - b * n)))\n" ] } @@ -611,9 +611,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_7165/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_44237/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", " return n * (np.log(v / (v - b * n)) - ak_mix / (b * SQRT2 * 2.0 * state.temperature)\n", - "/tmp/ipykernel_7165/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_44237/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", " * np.log((v * (SQRT2 - 1.0) + b * n) / (v * (SQRT2 + 1.0) - b * n)))\n" ] } @@ -633,55 +633,15 @@ "cell_type": "code", "execution_count": 16, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[17885.65767341655, 17874.1788893546, 17862.675545128997, 17851.147539437217, 17839.59477063816, ..., 1950.036863971225, 1689.5006399946997, 1380.0591082552019, 976.2649461965975, 0] J/mol" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "enthalpy_of_vaporization = dia.vapor.molar_enthalpy - dia.liquid.molar_enthalpy\n", - "enthalpy_of_vaporization" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, + "outputs": [], "source": [ - "The full information about the states is also available from the `states` field" + "enthalpy_of_vaporization = [(vle.vapor.molar_enthalpy() - vle.liquid.molar_enthalpy()) / (KILO * JOULE) * MOL for vle in dia.states]" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[17885.65767341655, 17874.1788893546, 17862.675545128997, 17851.147539437217, 17839.59477063816, ..., 1950.036863971225, 1689.5006399946997, 1380.0591082552019, 976.2649461965975, 0] J/mol" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "enthalpy_of_vaporization = SIArray1([(vle.vapor.molar_enthalpy() - vle.liquid.molar_enthalpy()) for vle in dia.states])\n", - "enthalpy_of_vaporization" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, "outputs": [ { "data": { @@ -696,7 +656,7 @@ ], "source": [ "fig, ax = plt.subplots(figsize=(7, 4))\n", - "sns.lineplot(x=dia.vapor.temperature / KELVIN, y=enthalpy_of_vaporization / (KILO*JOULE/MOL), ax=ax);\n", + "sns.lineplot(x=dia.vapor.temperature / KELVIN, y=enthalpy_of_vaporization, ax=ax);\n", "ax.set_ylabel(r\"$\\Delta^{LV}h$ / kJ / mol\")\n", "ax.set_xlabel(r\"$T$ / K\");" ] @@ -711,7 +671,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -745,7 +705,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -769,100 +729,100 @@ " \n", " \n", " \n", - " molar enthalpy liquid\n", + " density liquid\n", " molar entropy liquid\n", + " pressure\n", " temperature\n", + " density vapor\n", " molar entropy vapor\n", - " density liquid\n", + " molar enthalpy liquid\n", " molar enthalpy vapor\n", - " pressure\n", - " density vapor\n", " \n", " \n", " \n", " \n", " 0\n", - " 3.888854\n", + " 13517.744128\n", " 0.041205\n", + " 216751.867612\n", " 250.000000\n", + " 110.874504\n", " 0.112747\n", - " 13517.744128\n", + " 3.888854\n", " 21.774512\n", - " 216751.867612\n", - " 110.874504\n", " \n", " \n", " 1\n", - " 3.895457\n", + " 13509.916346\n", " 0.041231\n", + " 218680.955365\n", " 250.240382\n", + " 111.801129\n", " 0.112659\n", - " 13509.916346\n", + " 3.895457\n", " 21.769636\n", - " 218680.955365\n", - " 111.801129\n", " \n", " \n", " 2\n", - " 3.902072\n", + " 13502.075331\n", " 0.041256\n", + " 220623.177946\n", " 250.480764\n", + " 112.733771\n", " 0.112570\n", - " 13502.075331\n", + " 3.902072\n", " 21.764747\n", - " 220623.177946\n", - " 112.733771\n", " \n", " \n", " 3\n", - " 3.908698\n", + " 13494.221046\n", " 0.041282\n", + " 222578.594255\n", " 250.721146\n", + " 113.672458\n", " 0.112481\n", - " 13494.221046\n", + " 3.908698\n", " 21.759845\n", - " 222578.594255\n", - " 113.672458\n", " \n", " \n", " 4\n", - " 3.915336\n", + " 13486.353455\n", " 0.041308\n", + " 224547.263292\n", " 250.961528\n", + " 114.617219\n", " 0.112393\n", - " 13486.353455\n", + " 3.915336\n", " 21.754930\n", - " 224547.263292\n", - " 114.617219\n", " \n", " \n", "\n", "" ], "text/plain": [ - " molar enthalpy liquid molar entropy liquid temperature \\\n", - "0 3.888854 0.041205 250.000000 \n", - "1 3.895457 0.041231 250.240382 \n", - "2 3.902072 0.041256 250.480764 \n", - "3 3.908698 0.041282 250.721146 \n", - "4 3.915336 0.041308 250.961528 \n", + " density liquid molar entropy liquid pressure temperature \\\n", + "0 13517.744128 0.041205 216751.867612 250.000000 \n", + "1 13509.916346 0.041231 218680.955365 250.240382 \n", + "2 13502.075331 0.041256 220623.177946 250.480764 \n", + "3 13494.221046 0.041282 222578.594255 250.721146 \n", + "4 13486.353455 0.041308 224547.263292 250.961528 \n", "\n", - " molar entropy vapor density liquid molar enthalpy vapor pressure \\\n", - "0 0.112747 13517.744128 21.774512 216751.867612 \n", - "1 0.112659 13509.916346 21.769636 218680.955365 \n", - "2 0.112570 13502.075331 21.764747 220623.177946 \n", - "3 0.112481 13494.221046 21.759845 222578.594255 \n", - "4 0.112393 13486.353455 21.754930 224547.263292 \n", + " density vapor molar entropy vapor molar enthalpy liquid \\\n", + "0 110.874504 0.112747 3.888854 \n", + "1 111.801129 0.112659 3.895457 \n", + "2 112.733771 0.112570 3.902072 \n", + "3 113.672458 0.112481 3.908698 \n", + "4 114.617219 0.112393 3.915336 \n", "\n", - " density vapor \n", - "0 110.874504 \n", - "1 111.801129 \n", - "2 112.733771 \n", - "3 113.672458 \n", - "4 114.617219 " + " molar enthalpy vapor \n", + "0 21.774512 \n", + "1 21.769636 \n", + "2 21.764747 \n", + "3 21.759845 \n", + "4 21.754930 " ] }, - "execution_count": 20, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -881,7 +841,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -909,7 +869,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -929,7 +889,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -959,7 +919,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -974,7 +934,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -988,7 +948,7 @@ "T = 300.00000 K, ρ = 40.96869 mol/m³, x = [0.50000, 0.50000]" ] }, - "execution_count": 25, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1007,7 +967,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1016,7 +976,7 @@ "[-15625.347451682397, -12435.866602695123] J/mol" ] }, - "execution_count": 26, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1027,7 +987,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -1037,7 +997,7 @@ " [-0.10593968, 4.85467746]])" ] }, - "execution_count": 27, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1055,7 +1015,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -1069,7 +1029,7 @@ "T = 401.65486 K, ρ = 3.99952 kmol/m³, x = [0.50000, 0.50000]" ] }, - "execution_count": 28, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1109,16 +1069,16 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_7165/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_44237/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", " return n * (np.log(v / (v - b * n)) - ak_mix / (b * SQRT2 * 2.0 * state.temperature)\n", - "/tmp/ipykernel_7165/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", + "/tmp/ipykernel_44237/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", " * np.log((v * (SQRT2 - 1.0) + b * n) / (v * (SQRT2 + 1.0) - b * n)))\n" ] } @@ -1129,12 +1089,12 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABEMAAAGMCAYAAAAx2mwkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACboklEQVR4nOzdd3hUZd7G8e+k94SQ0AJCQiAQeg1NelFs4KooUkQQG3Ysu6666772gtJExQIoig3sdESpIdRACEnoNSRAep857x+BUaRDkjOT3J/r2kv2OTOZHxYyuec592MxDMNARERERERERKSKcDF7ABERERERERGRiqQwRERERERERESqFIUhIiIiIiIiIlKlKAwRERERERERkSpFYYiIiIiIiIiIVCkKQ0RERERERESkSnEze4BTNmzYwJQpU0hKSiIjIwNfX18aN27M6NGj6dGjh/1xw4cPJzY29oznDxw4kAkTJlTkyCIiIuLkjhw5wvTp09m2bRuJiYnk5eUxc+ZMYmJiLur5+/bt49VXX2Xt2rXYbDbat2/P008/TWRkZDlPLiIiIlfCYcKQrKwswsPDufnmmwkJCSErK4s5c+YwduxY3n77ba677jr7Yxs0aMBrr7122vOrVatW0SOLiIiIk9u7dy8///wz0dHRdOrUiaVLl170c48dO8bQoUOpXr06r732Gq6urrz33nsMGzaMefPmUatWrXKcXERERK6Ew4QhPXv2pGfPnqet9erViz59+jBnzpzTwhAvLy9at25dsQOKiIhIpdOhQwdWr14NwOLFiy8pDPnoo4/Iysri22+/pWbNmgC0bt2aPn368N577/Hf//63XGYWERGRK+fQnSFubm74+/vj7u5u9igiIiJSCbm4XP5bocWLF9OlSxd7EAKlO1V79erFokWLymI8ERERKScOF4bYbDZKSkpITU1l4sSJ7Nmzh5EjR572mN27d9OhQweio6Pp378/U6dOpbi42KSJRUREpKopKChg3759NG7c+IxrUVFRHDt2jGPHjpkwmYiIiFwMh7lN5pRHH32UBQsWAODn58c777xD9+7d7dfbtWvHwIEDiYiIIC8vj8WLFzNx4kS2bdvGlClTzvl127dvf97Xzc7OxmKx4OfnVza/ERERkUogJycHFxcXEhISzB7FoWRmZmIYBoGBgWdcCwoKAiAjI4Pq1aufdk3vR0RERC5debwfcbgw5Mknn2TMmDGkp6fz008/8eijj/Lqq69y/fXXA6VhyV/16tWLkJAQpk2bRlxc3AXfZJyPYRhXMrqIiEilYxgGNpvN7DEclsViKfOvqfcjIiJS1dkMgyJrCUXWEgybDYthQBm/H3G4MKRevXrUq1cPgN69e3Pffffx4osvMnDgwHPe1zto0CCmTZvGpk2bzhmGxMXFnfd1Tz3vQo8TERGpSq7kQ4bKLDAwEIvFQkZGxhnXTq2d2iHyV3o/IiIicnYlNisL9iUwY/tqVh5Ipnj/UayZuXi4uBK0eBu+nl5l+noOF4b8XYsWLVi2bBnHjx8nJCTkrI859YnVlZSgiYiIiFwsLy8v6tWrR1JS0hnXkpKSCA4OPuMWGRERETnT0bxsZifF8tmOtRzJy8KanUfxvlRC3Xzo3ag9t7a7mvF/PFLmr+vQYYhhGMTGxhIQEHDWT1dO+f777wFo1apVBU0mIiIiVV3fvn35/PPPSUtLIzQ0FCjdFbJs2TKuu+46k6cTERFxXIZhEJu6h5mJa/hl71aKbVYMm4H1yHGa2Xzp3awnrWrUo1XLVvY7R8qaw4QhTzzxBGFhYTRr1oxq1aqRlpbG3LlzWbNmDc899xxubm7ExcXxwQcf0L9/f8LCwsjLy2PJkiV89913XHPNNbRr187s34aIiIg4mfnz5wMQHx8PwLp16zhx4gTe3t706NEDgOHDhxMbG8uOHTvszxs9ejQ//PADY8eO5cEHH8TNzY333nsPNzc37rvvvor/jYiIiDi4nOJCvtu5kRnbV7MjI9W+Hmi40bkkgC6NWhHq7U9QUBBt27bF19e33GZxmDCkTZs2/Pjjj8yZM4fs7Gz8/f1p3rw57733Hr179wawf+oyceJETpw4gYuLC+Hh4TzzzDMMHz7czPFFRETEST3yyOlbbydNmgRAWFgYS5cuPefzQkJC+Pzzz3nttdd46qmnMAyDdu3a8dlnn1GnTp1ynVlERMSZ7DiRyszENXy7cwM5xYX29Tah9RgY0IBamVbcKC0lb9SoEY0bNy73GgyLocpyQIVlIiIiZ6PvjxVLf79FRKSyKLZZWbB3GzMS17D6yC77uqerG4MiWjO0YTuMg8c4fPgwUNrH1bZt27N2bpXH90eH2RkiIiIiIiIiIs7tUG4ms5Ni+WJHLKn52fb1Bv7VGdm0E7dEtsOancfGjRspKCgAoE6dOrRs2RJ3d/cKm1NhiIiIiIiIiIhcNpthY+XhnczYvoZF+7djNU6e+Gqx0K9eU0Y06cTVdSLBgB07dpCSkgKAq6srLVq0KLeS1PNRGCIiIiIiIiIilyyjMI9vUjYwM3ENu7LS7eshXn4MbdyBO6NiCPMLAiA3N5f169eTmZkJUCElqeejMERERERERERELlp8+kFmJK5m3q7NFFiL7esxNRswoklnrq3fDA/XP+OGffv2sXXrVqxWK1BxJannozBERERERERERM4rv6SYn3ZvYUbiGjal77ev+7p58I/ItgyP6kTT4FqnPae4uJjNmzdfVElqRVMYIiIiIiIiIiJntSfrGLN2rGVOchwZhXn29aigmoxo0ombG7bB38PrjOelp6efVpJau3ZtWrVqVaElqeejMERERERERERE7Kw2G0sOJDIjcQ3LDybZ191dXBlYvznDm8QQUzMci8VyxnNtNpvDlKSej8IQERERERERESEtP5svk+L4bMdaDuZm2Nfr+AYyLCqG2xt1oIaP/zmf72glqeejMERERERERESkijIMg9jUPczcsYZf9myl2Ga1X+sR1piRTTrRu24Ubi6u5/06jliSej4KQ0RERERERESqmJziQr7buZEZ21ezIyPVvh7k6cOQyHYMaxJDeEDIBb+OI5ekno/CEBEREREREZEqIvHEEWYlruGblA3klhTZ11uH1GNkk05cH94Sb7eLKzl19JLU81EYIiIiIiIiIlKJFVlLmL93GzMS17A2dbd93dPVjUERrRnRpBOtQupe9Nc7W0lq8+bNueqqq8p89vKiMERERERERESkEjqUm8nnO9byRdI6juZn29fDA0IY0SSGWyPbEeTpc0lf05lKUs9HYYiIiIiIiIhIJWEYBisP7+TT7atZtH87VsMGgIvFQr96TRnZpDPd6jTExXLpxabOVpJ6PgpDRERERERERJxcZmE+3+zcwMzENezMTLOvh3r7MbRxR+5s3JE6fkGX9bWdtST1fBSGiIiIiIiIiDiphOOHmLF9Dd/t2kh+SbF9PaZmA0Y06cy19Zvh4Xr5P/o7c0nq+SgMEREREREREXEiRdYSftm7lRnbV7Pu6F77uo+bB/9o2IYRTTrTNLjWFb1GZShJPR+FISIiIiIiIiJO4FBOBp/tWMvspHWkF+TY1xsF1mBEk07cEtkWfw+vK36d3NxcNmzYQEZGBuC8JannozBERERERERExEEZhsGKwynM2L6GhfsTsBkGAK4WFwZcFc3IJp3oUrshFoulTF7v7yWpkZGRREVFOWVJ6vkoDBERERERERFxMNlFBXydsp4Z5ypEjYqhjm9gmb1eZSxJPR+FISIiIiIiIiIOYseJVGYkrubblA3klhTZ1zvWbMDIMihEPZtjx46xYcOGSleSej4KQ0RERERERERMVGKzsnDfdj7dvopVR3bZ173d3Lk5og0jm3YiOrhOmb9uZS9JPR+FISIiIiIiIiImSM/PYXZSLLMS13I4L9O+3sC/Onc17cytke0I9PQul9euCiWp56MwRERERERERKQCbUjbx6fbV/PT7i0U2UqLSi1Y6FMviruadqF7nUhcLOVXWFpVSlLPR2GIiIiIiIiISDkrtJbw4+4tfLJ9FZvTD9jXgzx9uL1Re0Y06cRV/sHlOsPZSlLbtGlDSEhIub6uI1IYIiIiIiIiIlJODuVm8lniGj5PiuVYQa59vVlwbUY17cJNEa3xdiv/otKqWJJ6PgpDRERERERERMqQYRisTd3NJ9tXM3/vNqyGDQA3iwsDGzRnVNMutK9RH4vFUu6zVOWS1PNRGCIiIiIiIiJSBvJLipi7axOfJKxi+4kj9vVQbz/ujIphWFQMtXwCKmyev5ekBgYG0q5duypTkno+CkNERERERERErsDBnAxmJK5mdtI6Mgrz7OttQ6/irqadua5BCzxdK/bHb5Wknp/CEBEREREREZFLZBgGa1J383HCShbsS8BmGAC4u7hyY3hLRjXtQuvQehU+l0pSL47CEBEREREREZGLdK5bYWp6+zO8SSfujOpIqLe/KbOpJPXiKQwRERERERERuYBDuZnM2L6az5NiT7sVpl3oVdwd3ZVr6zfDo4JvhTlFJamXTmGIiIiIiIiIyFkYhsH6o/v4KGElv+zdaj8VxsPFlRtMvBXmr1SSenkUhoiIiIiIiIj8RZG1hJ/2xPNRwko2px+wr4d6+zE8qhPDm8SYdivMX6kk9fIpDBEREREREREB0vNz+GzHWmYlriE1P9u+3rJ6GHdHd+WG8JYVfirM2agk9cqZ/09RRERERERExEQJxw/zUcJK5u3aRKG1BABXiwvX1m/G6OiutK9RH4vFYvKUpVSSWjYUhoiIiIiIiEiVYzNsLD2wgw+3rWDl4Z329UAPb4Y27shdTTsT5hdk3oB/o5LUsqUwRERERERERKqM3OJCvk7ZwEcJK9mdlW5fbxgYypjorvyjYVt83D1MnPBMKkktewpDREREREREpNI7mJPBJ9tX8UVSLJlFBfb1HnUaMbpZN3qGNcLF4njFoypJLR8KQ0RERERERKTS2pi2nw+3/cHPe/48GtfT1Y2bG7ZhTHQ3oqrVNHnCs1NJavlSGCIiIiIiIiKVitVmY8G+BD7c9gfrju61r9fw9mdkk04MaxJDdS8/Eyc8P5Wklj+FISIiIiIiIlIp5BYXMic5jo8SVrI3+7h9PTq4NmObdePG8FZ4OMDRuOdis9lISkoiOTkZUElqeXKYfws2bNjAlClTSEpKIiMjA19fXxo3bszo0aPp0aPHaY9duXIl7777LomJifj6+tKvXz/Gjx9PQECASdOLiIiIiIiIWQ7lZvLp9lV8vmPtaX0gfeo2YWyzbnSp3dBhjsY9F5WkViyHCUOysrIIDw/n5ptvJiQkhKysLObMmcPYsWN5++23ue666wBYu3YtY8eOpU+fPjz66KMcPXqUN998k6SkJGbPnq0SGRERERERkSpi27FDvL/tD37YtZmSv/SB3BrZjjHRXYkMqmHyhBdHJakVz2HCkJ49e9KzZ8/T1nr16kWfPn2YM2eOPQx54403aNSoEe+88479X4zQ0FDuvvtu5s+fz8CBAyt6dBEREREREakghmGw/FAy72/9nT8OpdjXQ7z8uKtpZ0Y06USwl3PsplBJqnkcJgw5Gzc3N/z9/e0lMampqcTHx/PMM8+clpB17dqVmjVrsmDBAoUhIiIiIiIilVCRtYTvd23m/W1/kHjiiH29cVANxja7mkERrfFyc56C0bOVpLZs2RIPDw+TJ6saHC4Msdls2Gw2jh07xpw5c9izZw9PPfUUAElJSQA0atTojOc1btzYXjIjIiIiIiIilUNmYT6f7VjLx9tXkZqXZV/vWrsh9zbvTq+wxg7fB/JXKkl1DA4Xhjz66KMsWLAAAD8/P9555x26d+8OcFqRzN8FBgaSkJBwzq/bvn37875udnY2/v7+lzm1iIiIiIiIlKWDORl8uO0PvkhaR25JEQCuFhduCG/Jvc2upkVImMkTXjqVpDoOhwtDnnzyScaMGUN6ejo//fQTjz76KK+++irXX3+9/THnSv2cKQ0UERERERGRMyUcP8y0rb/z/a7NWE+Wovq6eTA0qiNjorsR5hdk7oCXSSWpjsXhwpB69epRr149AHr37s19993Hiy++yMCBAwkKCgL+3CHyV5mZmWfdMXJKXFzceV/3QjtHREREREREpHwYhsHqI7uYGr+c3w4m2ddrevtzd3RXhkXFEOjpbeKEl6+4uJgtW7Zw6NAhQCWpjsLhwpC/a9GiBcuWLeP48eP2rpDk5GS6det22uOSkpJo06aNGSOKiIiIiIjIZbDabPy6bxvvxS9nc/oB+3pkYCj3t+jBoIjWeLo6/I+t56SSVMfl0P9WGYZBbGwsAQEBBAUF4ebmRvPmzfnxxx8ZOXKkfTvR6tWrSU1NpX///iZPLCIiIiIiIheSX1LMNynrmbb1D/ZmH7Ovd6hRn/tb9KBvvSa4WJz39hGVpDo+hwlDnnjiCcLCwmjWrBnVqlUjLS2NuXPnsmbNGp577jnc3EpHHT9+PKNHj+bxxx9nyJAhpKam8uabb9KqVSuuueYak38XIiIilYvNZjV7hHKVm5vLhAkTmD9/PllZWURGRvLggw/Sp0+fCz53wYIFfPLJJ+zcuROAiIgIRo4cycCBA8t7bBERp5VVVMDMxDV8lLCCtPwc+/qAq6K5r3l3OtRsYN5wZUQlqc7BYcKQNm3a8OOPPzJnzhz7yS7Nmzfnvffeo3fv3vbHde7cmWnTpjFp0iTGjh2Lr68vffv25cknn8TV1dXE34GIiIg4m3HjxpGQkMD48eOpW7cuc+fOZdy4cUybNo0ePXqc83lz587lmWeeYcCAAdx///0AfPvttzz22GPk5eVxyy23VNRvQUTEKRzNy2Z6wgpmJa4hu7gQAHcXV25u2Ib7mnenUVANkycsGypJdR4WwzAMs4dwBKcKVC9UtCoiIlKVtG1b2se1YcNGkycpe8uXL2fs2LFMnjyZfv36AaW36A4dOpSMjAx+/fXXcz53+PDhHDx4kMWLF9vf4NpsNvr27UtYWBizZs26rJn0fkREKps9Wcd4f+vvfJWynkJrCQA+bh4Mj4phTLNu1PY99yEYzkQlqeWrPL4/OszOEBEREZGKtGjRIvz9/U+7JcZisTB48GCee+45UlJSiIyMPOtz3dzc8PHxOe2TPhcXF3x8fFSKJyICbDt2iKnxy/lxzxZsJz9/r+bpw+joroxs2plqnj4mT1h2VJLqnBSGiIiIVEH5JUV8viOWWj4BXB/eEltRPhlLpuIV0QGfqO5mj1chkpOTiYyMPGPrclRUFFB6Ut25wpA777yThx56iPfee48hQ4YAMGfOHHbv3s1TTz1VvoOLiDiw2NQ9TNq8jGUHd9jXwnyDuLf51dzeqAM+7pUnIFBJqnNTGCIiIlLF/H4wmX+unsve7OO4u7jSs3ZDMqcNJXfTT7hVr0/EW7vMHrFCZGRk0KBBgzPWAwMD7dfPpW/fvrz33ns8+eSTvPPOOwD4+Pjw7rvv0r37ucOkU9t8z+VUb5qIiDMxDIPlh5KZtHkpa1P32NcbB9XggRY9uCmiNe4ulavfUSWpzk9hiIiISBVxrCCH/8b+zHc7/+z/KLGWcPjjezA2/QSANfOwWeOZwmKxXNa1lStX8sQTT3DdddcxYMAArFYrP/74I48//jgTJ06kZ8+e5TCtiIhjsRk2FuxLYPKW39icfsC+3iqkLg+37EW/q5o69fG457J//37i4+NVkurkFIaIiIhUcoZh8HXKel5c9wsZhXkAdKhRn3Wpe7h3128YB/4sIzNKirAVF+Li7mnWuBUmKCjorLs/MjMzgT93iPydYRg8/fTTdOrUiRdffNG+3r17d44cOcL//ve/c4YhFyp+u9DOERERR1Bis/LD7i1M2fIbOzJS7etdakXwUKtedKsded5A2VmpJLVyURgiIiJSie3KTOeZVd+x6kjprS+BHl78q/1A7mjcnudfGsBtJ4MQ76a9yd++FACjIBuqQBgSGRnJwoULsdlsp32al5SUBEDjxo3P+rz09HTS0tJo3rz5GdeaN29ObGwshYWFeHpW/r+HIlK1FFpL+DplPe/FL2dv9nH7ep+6TXi4VS/a1ahv4nTl69ixY2zcuJH8/HxAJamVgcIQERGRSqjIWsK0rb/z7ual9qMMbwxvyX863kANH38yfvuQESml4Ud6k960HzWNPU+V/vBvK8jG1b/yf8rVr18/vvnmG5YuXUrfvn3t6/PmzSM8PPyc5amBgYF4enqyZcuWM65t3ryZoKAgBSEiUqnklxTzZdI6psYv53Be6e45Cxaub9CCcS170qx6HZMnLD8qSa28FIaIiIhUMutS9/DMqrn2rcthvkG83HkQfeo1ASB73bccnfEAAHHV6nOkz6PE+ATZn2/Lz6rwmc3Qo0cPYmJiePbZZ8nIyKBu3brMmzeP9evXM3XqVPvjhg8fTmxsLDt2lJ6M4OHhwe23386MGTN49tlnGTBgADabzf7cRx991KTfkYhI2corLuKzHWuZtvV3juZnA+BmceHmhm14sGVPGgaGmjxh+TpbSWrbtm3x8/MzdzApEwpDREREKokTBbm8vH4+XyStA8DFYmFMdFeeaNMP35O3veTGL+DwtDvBsHE4JILnm9zALcVFuHj9eYKJrSDblPkrmsViYerUqbz99ttMmDCBrKwsIiMjmTx5Mr179z7vc59++mkiIiL46quvWLBgAS4uLjRo0IDXX3+dG2+8sYJ+ByIi5SOnuJAZ21fzwbY/OFaQC4C7iytDGrXnwRY9qOcfbPKE5U8lqZWfwhAREREnZxgG36Rs4H/rfuF4Yemb1pbVw3i1y2BahtS1Py4/eRWHJt0C1mI86kSzvN/TFOzZSlp+NhY3DyxunhglhVUmDAHw8/Pj+eef5/nnnz/nY2bNmnXGmqurK7fffju33357eY4nIlKhMgvz+WT7KqYnrLQXbnu6unFH4w480LwHdfyCzB2wAqgktepQGCIiIuLEkjOO8s/Vc1lzZDcAfu6ePN12ACOadML1L59eFe7bzMG3r8coysM9NJy6Ty4gYO922LOV9PwcAFy8A7Bmp1WZ22RERKRUZmE+0xNW8FHCSrKKCgDwdnNneFQM9zbvTk2fAJMnrBh/L0mtVasWrVq1UklqJaUwRERExAnllxQxcfMypm39nWJb6RbeG8Nb8nzH66n1tzetRUeSOPDmNdjyM3ENqk3Ykwtxq1aHkKP7AUgvOBmGePmXhiFVaGeIiEhVdrYQxNfNg7uadmFs825U96oa3RgqSa2aFIaIiIg4mWUHdvDs6u/Zl1N6rGF9/2Be6jyInmFnHgVbfGwfB17vjzXrKC6+wdR9cgEeNSIACD35JjftLztDAGz5CkNERCqzs4Ugfu6e3N20C/c060Y1L1+TJ6w4KkmtuhSGiIiIOIlDuZn8N/Ynft4TD5SW2T3QogfjWvbC2839jMeXZKZy4I0BlBzfj8XLj7pP/IJnWDP79RDv0tLUvJIi8v5SoqqdISIildO5QpDR0V0Z06wb1Tx9TJ6wYqkktWpTGCIiIuLgim1Wpm9bwYRNS8grKQKgc60IXuk8iMigGmd9jjXnOAfeGEDxkSQsbp6EPfI9XhEdTntMqPefn3qlFWTjdjIcUWeIiEjlohDkdCpJFVAYIiIi4tBWHd7Jv9d8T1LGUQBCvPz4d4eB/KNhGywWy1mfY83P4sBbAyk6EA+ubtQe9zU+TXue8bi/hiHp+TnU0c4QEZFKJbuogOkJK/hw2wqFICepJFVOURgiIiLigI7mZfO/dT8zd9cmAFwsFkY26cz4Nv0I9PQ+5/NshbkcmnADhbvXgcWF2vd+hl/r6876WG83D3zdPMgtKSItP4e69s4Q7QwREXFmucWFfLJ9NdO2/m4/IreqhyAqSZW/UxgiIiLiQEpsVmYkruHNDQvJLi4EoG3oVbzc+SaaVw8773NtRQUcmngz+UkrAKg15iP8O9563ueEePuTm32M9PwcdYaIiDi5/JJiZiWuYUr8bxwryAVKj8i9u2lX7mt+dZUqRv0rlaTK2SgMERERcRDrj+7lX6vnse34YQCqefrwr/bXMqRRO1ws5y9zM0qKOTx1CHnbFgNQY8RkArqOuOBrhnr7sTf7GGkF2X+eJqMwRETEqRRaS5i9I5ZJW5Zx9OSJYJ6uboxs0okHWvQkxLvq/tC/f/9+tm7dSklJCaCSVPmTwhARERGTpeVn80rcfL5KWQ+ABQtDG3fgmXYDLupTPMNawuH3h5G76ScAQoa8QVDv+y/qtUNOHq972s4QHa0rIuIUim1W5iTHMXHzUg7lZgLg4eLK0KiOjGvZi1o+ASZPaB6VpMqFKAwRERExSYnNyqfbV/PWxkX2W2JaVA/j5c6DaBNa76K+hmGzcmT6KHLWfQNA9UEvEHzt4xc9w6kS1bT8HFxOBiO2AnWGiIg4MqvNxve7N/PWxsXszT4GgJvFhSGN2vNwq96E+QWZO6DJVJIqF0NhiIiIiAlWHd7Jc2t+YEdGKgBBnj4803YAdzTugOtFbt01bDZSP76H7NWzAQi+/p8E3/TcJc1xaut0ekEOLiHBgG6TERFxVIZhsHBfAq9vWGj//uFisfCPhm14tHUf6vtXN3lCc6kkVS6FwhAREZEKdCg3k5fW/cL3uzcDpbfEDIvqyFNt+19SsZ1hGByd+QBZK2YAUO2ax6n+j/+d87jdcwn1Lr01pnRnSH1Ap8mIiDiilYdSeHXDAjam7bevXd+gBePb9CMyqIaJkzkGlaTKpVIYIiIiUgEKrSVM37aCdzcvJa+kCCg9JealTjfRIuT8p8T8nWEYpH32CJm/fQhAUN9xhAx5/ZKDEPhrZ8ifBapGSRG24kJc3D0v+euJiEjZ2pC2j9fXL2TF4RT7Wq+wKJ5q2/+Sv39UVipJlcuhMERERKScLT2wg/+s/ZFdWelAaQDxbPtr+UdkmwueEvN3hmGQ/uWTZCyZAkBgr3sJvfOdywpC4M/OkOziQordvP98nYJsUBgiImKaHSdSeX3DAhbsS7CvdazZgKfbDiCmVriJkzkOlaTKlVAYIiIiUk52Zabz39ifWHIgEQBXiwujmnbm8Tb9CPDwuuSvZxgG6XOe4sSCCQAEXD2KGsMnX3YQApx23GKGi6v917aCbFz99WZSRKSiHczJ4K2Ni/g6ZQMGBgDNg+vwdLsB9AxrfEV/5lcmKkmVK6UwREREpIzlFBfy7qalTE9YQbHNCkCXWhH8N+ZGmgbXuqyvWRqEPM2J+W8DENB1ODVHvY/lCrcAn+oMAThmWDjVWqLeEBGRinWiIJfJW37j08TVFFpLb/eICAjhqbb9Gdig+SXvJKysVJIqZUVhiIiISBmxGTa+27mRl+PmczS/9ESWun5BPNfhOgbWb37Zn+YZhkH6V89wYv5bAPh3GUbN0R9h+ctOjsvl6+aBt5s7+SXFpNuMP8MQnSgjIlIh8kuK+ChhJVPjl5NVVABATW9/HmvTl9sbtcetDP6sryxUkiplSWGIiIhIGdiUtp/n1v5gb/n3cnVnXMue3Nu8O95u7pf9dQ3DIP3rf3Li1zcB8O98J7XGfFwmQQiAxWIh1MuffTnHSSsppIGbJ0ZJocIQEZFyVmKz8mVyHBM2Lib1ZIAe4OHFAy16MDq6K95uut3jr1SSKmVNYYiIiMgVSMvP5tX185mTvN6+dmN4S55tP5Awv6Ar+tqlQci/OPHLGwD4dx5KrXs+KbMg5JQQb7/SMCSv9EQZa3aabpMRESknhmHw695tvLZhATsz0wDwdHXjriadGdey5yUds14VqCRVyovCEBERkctw6qjcSVuWkVNcCEB0cG1ejLmBTrUirvjr23eEnApCOt1BrXs+LfMgBP48USatIAcXL//SMEQ7Q0REytz6o3v537pfiDu6FwALFm6NbMsTbfpdcYBeGakkVcqTwhAREZFLYBgG8/dt4//W/cLe7OMAVPP04am2/RnauCOuZbBd1zAM0r4cT8aCd4DyDUKg9KhfgPT8HFy8AwCw5SsMEREpK7uz0nl1/QJ+3hNvX+tbrwnPtLuGJtUur1i7MjtVkpqSkoJhGCpJlXKhMEREROQiJRw/zH/W/siqI7sAcLO4cFfTzjzaug9Bnj5l8hqGYZD2+aNkLJ4MlJallmVHyNmcOl43Lb90ZwioQFVEpCwcL8jlnU1LmLVjrf10sZbVw/h3h4F0qd3Q5Okck0pSpaIoDBEREbmAYwU5vL5+IV8kr8NmGAD0rhvF8x2uIzKoRpm9jmGzcfSzh8hcOg2AgKvvouaoD8o1CIE/j9dNL8jB5eSv1RkiInL5CkqK+Xj7KiZvWWY/IaauXxBPt72GmyJa6pjcc1BJqlQkhSEiIiLnUGQt4ZPtq3hn0xKyT/aCRAaG8kLH6+lVN6pMX8uw2Uj99D6yfv8IgMCe91BjxFQsFfAG8NTOkPT8bO0MERG5AjbDxrxdm3lt/QIO5mYApSfEPNyyN3c17YzXFZwuVpmpJFXMoDBERETkbwzDYOG+BP4v7ld2Z6UDEOjhxeNt+jGiSSfcy3inhmGzkvrxPWStmFH6Wr3vp8awiRUShACEnuwMySwqwDj5a+0MERG5NLGpe/hv7E9sTj8AgLuLKyObdOKRVr11Qsx5qCRVzKIwRERE5C+2HjvIi7E/23tBXC0uDIuKYXybvuXyZtYoKebIByPIjv0KgKB+DxM69G0sFkuZv9a5nDpNBqDQ1QvQzhARkYu1L/s4L8f9yk9/KUe9oUFLnm43gAYB1U2czLGpJFXMpjBEREQESM3L4vUNC/gqeQMGpb0gPcMa81yH64iqVrNcXtNWVMDhqUPI3fQTANUGPkXIrS9XaBACEHKyJwQgz80DdxSGiIhcSHZRAZO2LGP6thUUnSxHbR1Sj/90vJ72NeubPJ1jy83NZePGjZw4cQJQSaqYQ2GIiIhUafklRby/9Q+mxi8nr6QIgMZBNXiuw3Vl3gvyV7bCPA5NHEzetsUAVB/8X4JvfLbCgxAAf3dPPF3dKLSWkOPqTjV0tK6IyLlYbTa+SF7HmxsWkV6QA0Btn0D+2f4aBkW0UjnqBfy9JLVhw4Y0adJEJalS4RSGiIhIlWQzbMzdtZlX4+ZzOC8TgOpevoxv0487GnfArRxPcLHmZ3Fowo3kJ/0BQOjtb1LtmsfK7fUuxGKxEOLlx8HcDLIsrqVhSIE6Q0RE/u6PQ8n8N/ZnEk8cAcDbzZ0HWvTgvubd8XZTx8X5qCRVHI3CEBERqXLWHtnNi+t+tpfcebi4Mjq6Gw+16kWAh1e5vrY15zgH376Ogl2xANQYMZmg3veX62tejBDv0jAkw+JKfXSbjIjIX+3OSud/sT+zcP92+9qtkW15qu0AavsGmjiZc1BJqjgihwlDVq9ezffff8/GjRs5cuQIgYGBtGzZkoceeoioqD+3KQ8fPpzY2Ngznj9w4EAmTJhQkSOLiIiT2ZWZxstx85m/b5t97foGLfhn+2uo71/+JXclGYc58OY1FB3YChYXao6eTmC3keX+uhfjVInqcaP0Nh2dJiMiAjnFhUzcvPS0XpCYmg14oeP1tAypa/J0ju9sJanNmjWjfn11qoj5HCYM+eKLL8jIyOCuu+6iYcOGpKenM336dG655RZmzZpF69at7Y9t0KABr7322mnPr1atWgVPLCIizuJ4QS7vbFrCzMQ1lBg2oLTk7vmO19GxZoMKmaE4bTcHXu9PcdoucHWn9r2z8O94a4W89sUIOXmkbtrJMMQoKcJWXGjmSCIiprEZNr7buYlX4n4l9WSHUphvEM91GMh1DVqY0u/kbFSSKo7OYcKQF154gerVT/9Urlu3bvTp04ePPvqISZMm2de9vLxOC0dERETOpqCkmE+2r2LSlmVkFRUAUM+vGv9sdw03hLessDezhQcTOPDGAKwZh7B4eFPnoW/xbTGgQl77YoWePFEm9eQnnwCGbpURkSpoU9p+nl/7IxvS9gHg6erGgy16cn8L9YJcLJWkijNwmDDk70EIQEBAAPXr1+fIkSMmTCQiIs7KMAx+2L2FV9fPZ39O6SdSAR5ePNyyN6Oiu+DpWnHf/gp2rePA29dhyzmGi3cgYY/9gHfjbhX2+hcr5ORtMkdsNvuaekNEpCpJy8/m1fXzmZO83r52Q4OW/LvDQML8gswbzImoJFWcicOEIWdz/PhxkpOTue66605b3717Nx06dCA3N5e6desyaNAg7rnnHtzd3U2aVEREHEVs6h5ejP2ZTen7AXCzuDCyaWcebdWbal6+FTpL3vbfOPjuTRgFObj6hxI2fj5e9VtX6AwXK/TkbTIHikvsa+oNEZGqoNhm5eOElUzYtISck7cHNq1Wixc73UjnWhEmT+c8jh8/zoYNG1SSKk7DYcMQwzB47rnnsNlsjB492r7erl07Bg4cSEREBHl5eSxevJiJEyeybds2pkyZcs6v1759+/O+XnZ2Nv7+/mU2v4iIVKyUjKO8sn4+C/Yl2Neurd+Mf7a7lojAiv9EKnv9XI68dydGSSFuwfWo++QCPGpHXfiJJjm1M+Sw9c/bZLQzREQqu5WHd/Lcmu9JyjgKQJCnD0+17c/Qcj5ivTJRSao4K4cNQ15//XUWL17MK6+8QsOGDe3rjz766GmP69WrFyEhIUybNo24uLgLhh4iIlK5HM3LZsKmxcxOWof1ZDlqm9B6PNeh4spR/y5z+XRSP70fDBvutaKo++R83KtfZcosF+tUZ0iJiyu4eUJJocIQEam0Dudm8n/rfuH73ZsBcLFYGB7VifFt+1HN08fk6ZyHSlLFmTlkGDJhwgQ+/vhjnn32WW6++eYLPn7QoEFMmzaNTZs2nTMMiYuLO+/XUIgiIuJccosLeX/rH0zb+jt5JUUA1Pevzj/bX8N19Zub0vRvGAbHf3qVY9/+GwDP8A7UffwnXP0d/17pUztDAAwvPyw5hbpNRkQqnWKblY+2rWTCpsXknvze0S70Kl7qfBPNq4eZPJ1zUUmqODuHC0Peffddpk2bxpNPPsmIESMu6jm2k2Vv+g9PRKTyK7FZ+TIpjrc2LSItPweAYE9fHm3dm2FRMXhUYDnqXxk2G2lfPEHGookA+DTrS52HvsXFyzk+HQvy8MbdxZVimxWruw9uHNPOEBGpVP5+S0x1L1+ebX8tt0S2xcWinyMulkpSpbJwqDBk8uTJTJ06lUceeYQxY8Zc9PO+//57AFq1alVeo4mIiMkMw2DhvgReWT+flMw0oPS4w7HNrub+Fj0I8PAyb7aSIo5Mv5vsNV8A4B8zhFr3fIrFiY5gtFgsVPfy5UheFsUe3rgBtnyFISLi/M52S8yIJp0Y36YfQbol5pKoJFUqE4cJQz7++GMmTZpEr1696NKlC5s2bbJf8/DwIDo6mri4OD744AP69+9PWFgYeXl5LFmyhO+++45rrrmGdu3amfcbEBGRcrMudQ8vx/3KuqN7AbBg4bZG7XiiTT/q+AaaOps1P4vDk28hb9sSAIL6PEjone9gccLdiqHe/hzJy6LAzRNvVKAqIs6txGbl0+2reWPDQvstMe1r1OelTjfRrHodk6dzLipJlcrIYcKQZcuW2f966tenhIWFsXTpUkJDQwGYOHEiJ06cwMXFhfDwcJ555hmGDx9e4TOLiEj5SspI5bX1C047IaZXWBT/an8tTYNrmThZqZKMwxx8+3oK920CoPrNLxJ8w79M6SspCyEnb+nJc/OkGjpaV0Sc14a0ffxz1Vy2HT8M6JaYK6GSVKmsHCYMmTVr1gUfU79+fT744IMKmEZERMx0KDeTtzcu4quU9dgMA4BWIXX5V/tr6Vq74QWeXTGKDiVy4K2BlBzbCy6u1Bz1PoFXjzJ7rCsSerJENdfFHdDOEBFxPpmF+by2YQGzEtdiYGDBwrCojjzdboBuibkMKkmVysxhwhAREZHMwnymxP/GRwkrKbSWvvEKDwjh6XYDTDsh5mzyk1dy8J1B2HKPY/H0pc6Dc/Btea3ZY12xUyfKZLm4AtoZIiLOwzAM5u3azIvrfrKXa0cH1+aVzoNpV8OxjzZ3RGcrSW3durV9p75IZaAwRERETFdQUsyMxNVM3LyMzKLSUrZQbz8ea92XOxp3wP3kD+eOIHv9XI5MG4ZRXIBrQA3CHvsRr/DKcTz7qZ0hGZaTYYh2hoiIE9iVmc6za+bxx6EUAHzcPHiybT9GNe2CmwN9/3AWKkmVqkJhiIiImKbEZuWblA28tXExh/MyAfB18+D+Fj24p1k3fN09TZ7wT4ZhkLFwImlfPgGGgXvNRoQ98QseNSLMHq3MhHj5A3DMKN2BozBERBxZobWEKVt+Y0r8b/bdhNfWb8Z/O95AHb8gU2dzRipJlapGYYiIiFQ4wzCYv28br69fSHLmUQDcXVy5M6ojj7bqY79dw1EYNitpnz9GxpIpAHg17ESdR+bhFlC5tguf2hlyjJNhiI7WFREHtfbIbp5a9R07Tx61XtcviP/rdBN96zU1eTLnpJJUqYoUhoiISIVadXgnr6yfz8a0/UDpMbmDG7bmiTZ9qe9f3eTpzmQryOHwe0PJ3fwzAH7tb6bW2Jm4eHibPFnZOxVC5bmWboW2FWQB/iZOJCJyuszCfF6O+5XPk2IBcLW4MLbZ1TzWug8+7rqN43KoJFWqKoUhIiJSIbYeO8gr6xew/GCSfa1P3SY83W4A0cG1TZzs3EoyDnNwwo0U7t0AQLVrxxNy6ytYKukbxBrepcFHrj0MyUZhiIg4il/2bOW5Nd+TenLXWquQurzR9Waig+uYPJlzUkmqVHUKQ0REpFztzkrnzQ2L+H73Zvta+xr1+We7a4ipFW7iZOdXeGArByfcQMmxfWBxocbwiQT1vt/sscpVkKc3rhYX8k+FIflZgH7IEBFzHc7N5N9rvmfBvgSgtCD1qbb9GdW0C66VNJwubypJFVEYIiIi5eRwbibvbFrCl8lxWA0bAFFBNXmm3QD61mvqMMfknk3ull85PPUObAXZWDx9qf3Al/i1Gmj2WOXOxeJCiJcvuW6lb4aNkiIwDHDgf1YiUnnZDBuf7YjllbhfyS4uBKBXWBSvdBlEXb9qJk/nnFSSKvInhSEiIlKmjhfkMmXLb3yauNre7l/XL4jxbfoxOKKNQ3+KZxgGGYsnkzb7cTBsuFULo86j3+NVv43Zo1WYEG8/+84QERGzJGcc5amV37Lu6F4Aqnv58p+ONzAoopVDh+mOTCWpIqdTGCIiImUip7iQD7f9wftb/yDn5Cd4od5+PNyyN0OjOuLp6tjfcoySYo5+/giZy94HwLNBO8IemYdbtap1m0iItz+Jbn890tgAKu8PHrm5uUyYMIH58+eTlZVFZGQkDz74IH369Lngcw3D4KuvvmLOnDns3LkTd3d3IiIieOaZZ2jbtm0FTC9S+RTbrEyL/50JmxZTZLMCcGtkW57vcB3VvHxNns55qSRV5EyO/c5UREQcXkFJMbN2rGHS5t84XpgLQKCHF/e36MHdTbs6Rbu/NTeDw1NvI2/bEgD82v+DWvd8iounj8mTVbxQLz82/nVniGFU5iyEcePGkZCQwPjx46lbty5z585l3LhxTJs2jR49epz3uc8++ywLFy5kzJgxtGnThvz8fLZu3Wq/B19ELk3C8UM8seJb4o8dBOAqv2Be6zqYq+s0Mnky56WSVJFzUxgiIiKXpdhm5euU9UzYuITDeZkAeLu5Mzq6K/c1706QkwQJRakpHHrnJooOJwIQfMOzVB/8n0p7YsyFhHj72Y/WreyWL1/OqlWrmDx5Mv369QOgU6dO7N+/n1dfffW8YciCBQuYO3cus2fPpk2bP2+j6tmzZ3mPLVLpFFlLmLRlGZM2L6PEsGHBwt3RXXi67QCnCNQdlUpSRc5PYYiIiFwSq83G97s38/bGxezJPgaAu4srd0Z15OGWvanh4zxHseZuW8zhqbdjyz2Bxc2Dmnd/SECXYWaPZapQbz9KXFwpdnHD3VZSujOkklq0aBH+/v6n3RJjsVgYPHgwzz33HCkpKURGRp71uZ999hnt27c/LQgRkUu3Jf0Aj6/4hsQTRwCICAjhrW630KFmA3MHc2IqSRW5OApDRETkohiGwfx923hzwyJ2ZKQC4GKxcHNEGx5v05er/INNnvDiGYZBxqJJpH3xBBg2XANqUOehb/Bu1NXs0UwX4l0aZuW5eRJYVEJpZ0jllJycTGRk5Bn3zEdFRQGQlJR01jCkuLiYTZs2MWTIEN5++22++eYbMjIyCA8PZ8yYMQwePLhC5hdxZgUlxUzYtIRpW3/HathwsVi4t1l3Hm/TF283d7PHc1oqSRW5eApDRETkvAzDYPmhZN7YsJDN6Qfs69c3aMETbfrRKKiGidNdOltxIUdnPkDWH58C4Fm/DXUe/g736leZO5iDCPUqfcOc6+JOoMmzlLeMjAwaNGhwxnpgYKD9+rmeV1RUxNy5c6lVqxbPPfccAQEBfPPNNzzzzDMUFxdz2223nfW57du3P+9M2dnZ+Ps7z+4qkcux/uhenljxDSmZaUDpsetvdruFNqH1TJ7MuR04cID4+HiVpIpcJIUhIiJyTmuP7Ob1DQtYm7rHvtanbhOebNuP5tXDzBvsMpVkHOHQ5FsoSFkNgH/H26g5+qMqWZR6LiHepWFInuvJT2Yr8W0ywHmP6DzXNZvNBkBhYSEffPABYWGl/y106dKF/fv3M2XKlHOGISJVWUFJMW9tXMy0rb9jYOBqcWFcy5483Kq3w5845shUkipyefSnjoiInGFT2n7e2LiI5QeT7GtdakXwVNsBtK/pnPccF+yO49Ckf1ByvHR3S/V//B/B1z9z3h+Gq6LQU2GI/XjdyhuGBAUFnXX3R2ZmaSHwqR0ifxcYGIjFYiEiIsIehEBpeHL11VczdepUjh07RvXq1c94blxc3HlnutDOERFnFZ9+kEf/+Mp+m2V0cG3e7naLUwbrjkQlqSKXT2GIiIjYJRw/xJsbFrFw/3b7WpvQejzddgDd6py9SNIZZP7xCUdnPIhRUojFy4/a987Cr82NZo/lkII9fXGxWP48UabyZiFERkaycOFCbDbbadvIk5JKQ8DGjRuf9XleXl7nLCI0Tu6kUcgmUqrYZmXS5mVM3LyUEsNm3w3ySKveeGg3yGVTSarIldOfQCIiQlJGKm9vXMxPe+Lta82CazO+TT/61mvqtD/YGSVFHJ39OJlL3wPAvWYkdR7+Ds+wZiZP5rhcXVwI9vT9y/G6lTcN6devH9988w1Lly6lb9++9vV58+YRHh5+zpNkTj33008/5cCBA9StWxcoDUJ+//136tWrR3Cw8xQKi5SXHSdSefSPr4g/dhCARoE1mHD1rbRWN8gVUUmqSNm4pDCkoKCA+fPnEx4eTqtWrcprJhERqSC7s9KZsGkJc3duwjj5Q2/joBo80aYf19ZvhovFeUvXSjIOc2jKEAqSVwLg22ogtcbOwtU3yNzBnECItx95bpU/DOnRowcxMTE8++yzZGRkULduXebNm8f69euZOnWq/XHDhw8nNjaWHTt22NdGjx7Njz/+yJgxYxg3bhz+/v58++23bNu2jQkTJpjx2xFxGFabjQ+3reCNjQsptJZgwcLYZt0Y37a/Toq5QipJFSk7lxSGeHh48O9//5tnn31WYYiIiBM7kHOCdzYt4euUDViN0jLIBv7VebxNX24Kb4Wrk7+pyk9ZzaHJt2LNOAxA8E3PU/2m57A4+e+rooR6+1WJ22QsFgtTp07l7bffZsKECWRlZREZGcnkyZPp3bv3eZ9brVo1Pv/8c15//XX++9//UlBQQOPGjZkyZcppu0xEqprdWek8/sfXrDu6F4D6/sG83e1WYmqFmzyZc1NJqkjZu6QwxMXFhdq1a5OTk1Ne84iISDk6lJvJ5C3L+CJpHcU2KwB1/YJ4rHVf/tGwDW4uriZPeGUMwyBz6TSOzn4MrMW4eAdQa+wM9YNcohAvvypxmwyAn58fzz//PM8///w5HzNr1qyzrtetW5eJEyeW12giTsUwDD7fEct/1/1EfkkxAMOjYvh3h4H4unte4NlyPipJFSkfl9wZMmjQIH744QdGjhyp/wBFRJzEkbwspmz5jc93rKXoZAhSyyeAR1r1Zkij9pWixM5WmEvqJ/eSveYLADzqNKXOQ9/iUTvK5MmcT6i3H8dPnSZTubMQESkD6fk5jF/5DYv3JwKl31/e7HYLPcPOXkIsF0clqSLl65Lf/bZt25ZFixZx0003MXToUOrXr4+3t/cZj+vQoUOZDCgiIpfvaF42U+N/Y9aOtRRaS+8vruHtzwMtejAsKgavSnLvdtGhRA5NvpWiQwkA+HW8lVqjPsTF29/kyZxTiLc/B6rIzhARuTKL929n/IpvSS8o3Tl+U0QrXup0E0GePiZP5tz+XpIaEBBAu3btVJIqUoYuOQwZNWqU/dcvvfTSGScMGIaBxWJh+/btf3+qiIhUkGMFOUyN/50Z21dTYC3drhzi5ceDLXswLKpTpSqwy479miMfj8EoyAFXN0Jvf5OgvuOc9gQcRxDq5UeuwhAROY+84iL+t+5nZu1YC0CAhxcvdRrE4IatzR2sElBJqkjFuOQw5JVXXimPOUREpAycKMhl2tY/+GT7KvJKigCo5unDAy16MLJJZ3zcK8/tjUZJMWlfPU3GwncBcKsWRu0HvsS7UReTJ3N+Id5+5FeBAlURuTyb0w/w0PIv2ZWVDkBMzXDe7X4bdf2qmTyZc1NJqkjFuuQwZPDgweUxh4iIXIETBbl8sG0FHyesJPdkCBLo4c39LbpzV9Mu+FWy8rri9L0cfm8oBTvXAOAT3Yda932GW0ANkyerHEK9/citAkfrisilsdpsTI1fzlsbF1Fi2HB3ceXJtv25t9nVTn8KmdlUkipS8Zy/MU9EpAo7ewjixdhmV3N3dFf8PbxMnrDs5Wz8gSPT78aWW3ofdfAN/6L64P9gcfKTcBxJiLf/nztDRESAfdnHeeT3OfYjcxsF1mBSjyE0rx5m8mTOTSWpIua57DAkPj6eLVu2kJmZic1mO+2axWLhwQcfvOLhRETk7E4U5vHh1j/4ePsqcooLgdL7te9p1o27m3Yl0PPMYmtnZ5QUkf71vzixYAIArv4h1Bo7E98WA0yerPKp7uVLrlvl2k0kIpfvh12beXrVd2Sf/H5zV9POPNv+WrzdFJpeCZWkipjrksOQgoICxo0bx8qVK+1lqYZRuoX21K8VhoiIlI9zhSBjorsxOrpyhiAAxWl7OPzeHRTsigXAO6o7te77DPdq+kSyPLi7uOLhHWj2GCJisrziIp5f+wNfJscBpbfQvdXtVnrX1ZHlV0olqSLmu+QwZMqUKaxcuZL77ruPzp07M2LECF599VWqV6/OBx98QEFBAa+99lp5zCoiUmWdKMxj+rYVfJSw0h6C+Lt7MqZZN8ZEd6u0IQhA9vq5pH40BlteBlgsBF//L6oPeh6Lq+70LE9+/sFmjyAiJko4fogHfvuClMw0AHqENeadq28lVEeWX5Hi4mLi4+M5ePAgoJJUETNd8jvJBQsWcM011/DII4/Yt3TVrFmTzp0707lzZ2655Rbmzp3LE088UebDiohUNac6QT75y04Qf3dPRjfrxpjorgR5+pg8YfmxFeWT9uV4MpdOA8DVP5Ra987Ct3k/kyerGqr5BFFkUQ+LSFVjGAafbl/N/8X9QqG1BHcXV55pN4B7mnXDxaJdC1dCJakijuWSw5DDhw9z1113AeDqWvomqbi4uPSLublx3XXX8cUXXygMERG5AscLcnl/6x98un2VvRjV392Tu6O7MqZZN6pV4hAEoPDAVg6/N5Sig9sA8G7ai9pjZ+JWrY7Jk1Udod7+5KkPQKRKOVGQyxMrvmHh/u0A1PevztSed9AqpK7Jkzk3wzBISkoiOTlZJakiDuSSwxBfX1+sVqv91y4uLhw9etR+3d/fn/T09LKbUESkCjlWkMO0+D+YkbiavJMhSICHF6OjuzK6ku8EgdI3jJlLp5H25XiM4gJwcSXk5hepNvBJnRZTwUK8/cjTiTIiVcaqwzt5+Pc5HMnLAmBwRGte7jyoUp5KVpFUkiriuC45DLnqqqvYs2cPULozJDIykgULFnDLLbdgGAaLFi2idu3aZT2niEillpafzbStfzAzcTX5JaW77QI9vBhTiU+H+TtrzjGOfDSG3I0/AOAeGk6tez/DO7KTyZNVTaEKQ0SqBKvNxoTNS3h301IMDHzcPHi58yBuiWxr9mhOTyWpIo7tksOQzp078+233/Kvf/0LV1dXhgwZwv/+9z/69u2LxWLhwIEDPPbYY+Uxq4hIpZOal8X7W39nZuJaCqynQhBvxjbrxqjorgRUkU/k8hKWcOTDUZScKC2U8+90OzVGTMXVRyeamCXEy488Ha8rUqml5mUxbvmXrD6yC4AW1cOY0uMOIgJDTJ7MuakkVcQ5XHIYMnbsWG666Sb7cbp33nknRUVF/PDDD7i4uPDYY49xzz33lPmgIiKVyaHcTN6LX87spFgKraWfGFXz9OHe5lczsknnKrMt2VZUQPq3z5Kx4B0ALJ6+1Bg+iYCuI7BYLOYOV8WFevtz0NUDMMweRUTKwcpDKYz7/UvS8nMAGBPdlX+2vxZPndR1RVSSKuI8LqszJCIi4rS1UaNGMWrUqDIbSkSksjqQc4IpW35jTnIcRbbS/qXqXr7c27w7I5p0ws+96nwSX7h/C4ffH07Rga0AeEXEUGvsDDxqNTJ5MoHSzpBkVw+g0OxRRKQMWW02Jm1ZxtubFmMzDAI8vHir2y1cW7+52aM5NZWkijgfRb8iIhVgT9YxJm9ZxjcpGygxbADU8PbnvubdGRYVg4971fnEyLDZOLHgHY59+yxGSRG4uFL9xn8TfMO/sOgTSYfx52kyCkNEKov0/Bwe/n0Ovx9KBqBl9TDe6zWU+v7VTZ7MueXl5bFhwwaVpIo4mct+11lUVMTatWvZv38/APXq1aNjx454eladTzVFRC5kV2Yak7Ys47udm7CeDEFq+gTwYIse3NG4I95u7iZPWLGKj+3nyPRR5G9fBoB7zUhqjZ2Jd8MYkyeTvwvx8nXKAtXi4mJGjx7NzJkzzR5FxKGsPbKbB5Z/QerJ02JGNunM8x2v020xV0glqSLO67L+9Js3bx6vvPIKWVlZ9u4Qi8VCQEAATz/9NDfffHOZDiki4mwSTxxh0uZl/LhnC7aTf07W8Q1kXMte3BbZDq8qFoIYhkHWihmkzX4MW37pG/HAnvcQevubuHjpkzNH5OHqhtXDFzhm9iiXxDAM1q1bZ/YYIg7DZth4L/53Xt+wEKthw8/dk9e73MyNEa3MHs2pqSRVxPldchjyyy+/8Mwzz1CnTh1Gjx5Nw4YNMQyDnTt38uWXX/Lss8/i5eXFwIEDL+nrrl69mu+//56NGzdy5MgRAgMDadmyJQ899BBRUVGnPXblypW8++67JCYm4uvrS79+/Rg/fjwBAQGX+tsRESlT8ekHeXfzUubv22Zfu8ovmHGtenJLw7Z4VMFP4EoyjpD66b3kbvoJAFf/UGre/QF+bW40eTK5EFdvf7NHOKsRI0ac89qpD2lEBE4U5vHo71+x5EAiAE2r1eL9XncSEagf2K+ESlJFKodLflc+bdo0IiIi+Oqrr067D65v374MHTqUW2+9lffee++Sw5AvvviCjIwM7rrrLho2bEh6ejrTp0/nlltuYdasWbRu3RqAtWvXMnbsWPr06cOjjz7K0aNHefPNN0lKSmL27NnakiYiplh/dC/vbl7K0gM77GsNA0N5qGVPbopojbuLq4nTmSd77RxSZ47DlnscAL/2N1NjxFTcAvRG3Bm4eTvm0cabNm1i1KhRBAcHn3GtpKSEuLg4E6YScSxbjx3knqWfsT+ntMdiaOOO/Dfmhip3e2ZZUkmqSOVyyWHI7t27eeSRR85aCOTv78/NN9/M5MmTL3mQF154gerVTy9v6tatG3369OGjjz5i0qRJALzxxhs0atSId955xx58hIaGcvfddzN//vxLDmFERC6XYRisPrKLiZuXseJwin09Kqgmj7TqzXUNWuBaRQNaa3Y6qbPGkRP7NQAuvtWoMXwS/jG368hcJ+LpW83sEc4qKiqKFi1a0Ldv3zOuFRYW8sYbb5gwlYjj+Dp5Pc+snkuhtQQvV3de7TKYWyLbmj2WU1NJqkjlc8lhSGho6Hm3oLq4uBASEnLJg/w9CIHSP2Tq16/PkSNHAEhNTSU+Pp5nnnnmtB0gXbt2pWbNmixYsEBhiIiUO8Mw+O1gEpO2LCM2dY99vWX1MB5p1Zt+VzXFxVI1QxCA7PVzOTrjQaxZqQD4thpIzbvex61aHZMnk0vl5Rtk9ghnNWjQoHNec3NzY9y4cRU3jIgDKbKW8J/Yn5iZuAaA+v7V+bD3MKKDa5s8mXNTSapI5XTJYcjgwYOZO3cuQ4cOxdfX97RrOTk5fPvtt2VWoHr8+HGSk5O57rrrAEhKSgKgUaNGZzy2cePGJCcnl8nrioicjc2wMX9vApO3LGPLsYP29fY16vNIq970DGtcpXc9lGQd5ehnD/+5G8TLn9ChbxNw9agq/ffFmfn6OeZxm3feeec5r7m6uioMkSrpcG4m9y77nA1p+wDoU7cJ73a/jSBPH5Mnc14qSRWp3C4Yhvy9kb19+/YsW7aMG264gaFDhxIREYHFYiElJYUvvviCatWq0a5duysezDAMnnvuOWw2G6NHjwYgIyMDgMDAM+9hDgwMJCEh4Zxfr3379ud9vezsbPz9HbMoTkTMVWKz8v3uLUzZsoykjKP29a61G/Jwq950qRVRpX/YNwyD7LVzSPv8EazZ6QD4NO9Hzbvexz1E91E7M/+AS9/pWR5efvllHn74YW1HFzmH1Ud2cf+y2aQX5GDBwuNt+vBIq95VepfilVJJqkjld8EwZPjw4We8yT91m8ybb75pv3Zq7dChQ9x9991s3779igZ7/fXXWbx4Ma+88goNGzY87dq5fuioyj+MiEjZK7SW8HXKet6LX87e7OP29b71mvBQy960q3GVidM5hpITh0id+QC5G38EwMU7kNChbxHQ7S79mVwJBPo7xqefs2fP5scff+SRRx5hyJAh+ndL5CTDMPhw2wpeivsVq2Ej0MOLST3uoHfdqAs/Wc5KJakiVccFw5BXXnmlIuY4zYQJE/j444959tlnT7vlJigoCPhzh8hfZWZmnnXHyCkXapa/0M4REak68oqLmJ0Uy7Stv3MkLwsACxaub9CCh1r1JDpY3ReGYZC14lPSZj+BLT8TAN82N1BzxFR1g1Qi1QJrmj0CAD/88AOvvPIK//nPf/jiiy/417/+RUxMjNljiZgqt7iQJ1d+yw+7twAQHVybD3sPo76/Y97e5gxUkipStVwwDBk8eHBFzGH37rvvMm3aNJ588klGjBhx2rVTXSHJycl069bttGtJSUm0adOmwuYUkconszCfGYmrmb5tJccLcwFws7hwc8M2PNiyJw0DHeNTcrMVpaaQ+un95G9fCoCLX3VqDJuIf4w+sa9sQoIcIwyJiIjgww8/5LfffuOVV17hrrvuol+/fjz99NOEhYWZPZ5IhdubfYy7F89kR0ZpUfU/Grbh1S6D8XbTLRyXSyWpIlXPJReolqfJkyczdepUHnnkEcaMGXPG9Vq1atG8eXN+/PFHRo4caf/DafXq1aSmptK/f/+KHllEKoG0/Gymb1vJjMTV5BQXAuDp6saQRu25v3l36vkHmzyhYzBKijkx/22Off8iRnEBAP4dbyN02Lu4BdQweTopD6F+wRiAo0RcPXv2pFu3bsyYMYP33nuPgQMHctddd3Hvvffi46OSSKkaVh5K4d7fZpNRmIebxYX/xNzAyCadFEZfJpWkilRdDhOGfPzxx0yaNIlevXrRpUsXNm3aZL/m4eFBdHQ0AOPHj2f06NE8/vjjDBkyhNTUVN58801atWrFNddcY9L0IuKMDuScYNrW3/kiaR2F1tJPgnzdPBjepBP3NOtGTZ8Akyd0HPk715L6yb0UHYgHwC24HjVGTMGv9XUmTyblycvNHceJQkq5ubkxevRoBg8ezFtvvcWHH37Id999xxNPPHHeI3dFnJ1hGHyyfRX/jf0Zq2GjupcvH/QaRkytcLNHc1oqSRWp2hwmDFm2bJn9r6d+fUpYWBhLl5Zux+7cuTPTpk1j0qRJjB07Fl9fX/r27cuTTz6Jq6trhc8tIs4nJeMoU+OX893OjZQYNgCCPH0YHd2Fu5p2oZqOIbSz5WeT/u2/yVgyBQwDLC4E9XuIkJtfxMVL91BXBTaLC4743TUzM5OOHTuyb98+1q1bxz//+U9mz57Nv//9b1q2bGn2eCJlqtBawrOr5/FlcmkHXrPg2nzUZwR1/aqZPJlzUkmqiIADhSGzZs266Md2796d7t27l+M0IlIZbUk/wJT45fyyZysGpSdg1fQJ4L7mVzO0cUd83T1NntBxGIZBzoZ5pH3+KCXHDwDgWa8VNUe9j1dEB5Onk4rk6uFt9gikpaWxZcsWtmzZQnx8PFu3biU7OxsoPUmuUaNGtGzZktjYWG6//XZGjRrF+PHjdduAVApp+dncs/Qz4o7uBeD6Bi14u9ut+Lhr98LlUEmqiJziMGGIiEh5MAyDVUd2MWXLb/x+KNm+Xt8/mAda9OSWyLZ4uuqPwr8qOrqLtM8eJnfLrwBY3L2oPvg/VOv/KBY3d5OnkwrnAIHC1VdfjcViwTAMAgMDadOmDa1ataJNmza0bNkSX19fAEpKSvjoo4+YOHEiFouF8ePHmzy5yJXZkn6A0UtmcTiv9NSup9r256GWvRT0XSaVpIrIX13UTwA9evSgb9++9O3bl44dO+p2FBFxeDbDxqJ925kc/xsb0/bb15tWq8UDLXpyQ3gL3Fz0Z9lf2YoLOfHrmxz/8WV7QapPy2uoMWwiHjUamjydVGW33XYbbdu2pVWrVoSHn7sfwc3NjXvvvZecnBzmzp2rMESc2rxdm3hixTcUWkvwdfNgUo/b6X9VtNljOSWVpIrI2VxUGNK7d28WL17M559/TkBAAD169KB///5069YNb2/zt8+KiJxSbLPy/a5NTI1fTlLGUft6hxr1GdeyF73rRukTtbPIS1hC6sxxFB9JAsAtuC6hQyfg126w/n6J6V588cVLenyTJk1IT08vp2lEypfNsPHa+oVMif8NgPr+1fm4zwiiqjnGUdfORiWpInIuFxWGvPDCC7zwwgts2bKFRYsWsXjxYn788Uc8PT3p0qUL/fr1o1evXlSrphInETFHfkkRXybF8f623zmQk2Ff7103igdb9FTb/jmUnDhE2pwnyV7zZemCiyvV+j9K9UHPqyBVnFa3bt146623zB5D5JLlFRfx8O9zmL9vGwBX14lkas+hKva+DCpJFZELuaQb5Vu2bEnLli154okn2LlzJ4sXL2bx4sU8++yzuLi40LZtW/r160efPn0ICwsrr5lFROxOFOYxc/tqPkpYxfHCXABcLBZuaNCSB1v2IDq4jskTOiajpIgTC9/l2A//h1GQA4BXo67UHDEFz3otTJ5O5MoEBgZy3XU69lmcy5G8LEYtnkH8sdJbOUY17cILHa/TLZ2XQSWpInIxLrs1sGHDhjRs2JB7772X1NRU+46R119/nVdeeYUmTZrw2GOP6dQXESkXh3Izmb7tDz7bEUteSREAHi6u3BrZjvtadCc8IMTkCR1X7pb5HJ39mP2WGFf/UEJue4WAriOxqERORKTCbT12kLsWz+BIXhYuFgsvxtzIXU07mz2WU/p7SWpERARNmzZVSaqInKFMjlCoWbMmw4YNY9iwYWRlZbF06VIWL15McnKywhARKVMpGUd5b+tyvtu5iWKbFQB/d0+GN+nE6Oiu1PQJMHlCx1V0dBdpXzxO7sYfSxdcXAnq8wDVB/0HV98gU2cTEamqFu5LYNzyL8krKcLP3ZP3eg6lV90os8dyOn8vSfX09KRNmzYqSRWRcyrz8yQDAgIYNGgQgwYNKusvLSJV2Ia0fUzdspwF+xIwMAAI9fZjTHQ3hjfpRICHl8kTOi5bYR7Hf3qVE7++iVFSCIB3k57UuPMd3RIjImISwzD4YNsf/N+6XzEwqOsXxKd976JJtVpmj+Z0jh8/zsaNG8nLywNUkioiF6fMwxARkbJiGAZLD+zgva3LWXNkt329vn8w9zfvwS2RbfFyczdxQsdm2Gxkr/mC9G/+RcnxA8DJU2JufwO/DrfqlBgREZMU26z8e/X3fJ4UC0Db0Kv4qM9wQr39TZ7MuagkVUSuhMIQEXE4xTYrP+zewnvxy0k8ccS+3jy4Dg+06MHABs1VKHcB+SmrSZv9BAW71gJgcfOg2rXjCb7+GVw8fU2eTkSk6soszOe+3z7nj0MpANwY3pK3ut2Kt8L9S6KSVBG5UgpDRMRh5BUXMTsplg+3reBgboZ9vVvtSB5o0YOr60RqN8MFFKfvJf3rf5K9do59za/9Pwi57VU8akSYOJmIiOzLPs6IRZ+QkpkGwCOtevNEm764WFTueSkOHjzIli1bVJIqIldEYYiImO5YQQ6fbF/Np9tXk1FYer+vi8XCdfVbcH+L7rQMqWvyhI7PVpDD8Z9f48T8tzGKCwDwrN+W0KFv4ROlImsREbNtST/AiEWfkl6Qg4eLK290u4V/NGxj9lhORSWpIlKWFIaIiGn2Zh/jg60rmJMcR4G1GABPVzeGNGrPPc266Xjci2DYrGT98Snpc1/AmnEYANeg2oTc8hIBXYbrqFwREQew9MAO7lv2OXklRQR6ePNxnxHE1Ao3eyynopJUESlrlxWGpKen8+uvv3Lw4EF8fHyIjo6ma9eueHt7l/V8IlIJbU4/wLT43/l5bzw2o/RkmEAPb+5q2plRTbsQ4q37fS/EMAxyN/9C+tf/pOjgNgAs7l6lvSADn8TFS38PRUQcwRdJ63hm1Vysho26fkF81u9uIoNqmD2W01BJqoiUl0sOQ+Li4rjnnnsoKCjAOPlDDEBQUBAPPPAAI0aMKNMBRaRyMAyD3w4m8V78clYd2WVfr+MbyD3NujG0cUd83T1NnNB5FOyOI23O0+Qn/la6YLEQ0GUY1W9+EffqV5k6m4iIlDIMg7c3LWbCpiVAaQn4jH53UdMnwOTJnIdKUkWkPF1yGPLaa68B8PLLL9O5c2dsNhubNm3i008/5eWXX2bz5s289dZbZT6oiDinYpuV73dtZtrW3087GaZptVrc16IHN4a3xF0nw1yU4rTdpH/7b7LXfGlf82nWl5DbXsOrfmvzBhMRkdMU26w8s2ouc5LjAOhRpxHv9x6Gn0L/i3bgwAHi4+NVkioi5eaSw5Dk5GRGjRrF4MGD7Wt16tRh4MCBfP311zz//PO0adOGYcOGlemgIuJccooLmb0jlukJKziUm2lf71q7Ife36EGPOo10MsxFsmanc+ynV8hcMhWjpAgAz3qtCBnyKr7N+5s8nYiI/FVucSH3Lvuc3w4mAXBbZDte63qzgv+LpJJUEakolxyG+Pr6UqdOnbNeu/XWW1mzZg1ffvmlwhCRKupIXhYfbVvJ50lrySoqPdXExWLh+gYtuK+5Toa5FLb8bE4smMCJ+W9jK8gGwC24HiH/eBH/zndi0RtrERGHcjQvm5GLPyX+WOkP8o+06s34Nv0U/l+kv5ek1qxZk9atW6skVUTKxSWHITExMSxfvpxbb731rNc7derEokWLrngwEXEuiSeO8MHWP5i7axPFNisAXq7uDGnUnrHNu1Hfv7rJEzoPW1EBmUvf4/jPr2LNTgfAxSeI4OueJqjfQ7h4qKxaRMTR7MxMY9jCj9mfcwIXi4WXOw9iWFSM2WM5hb+XpLq4uNCsWTMaNGhg9mgiUoldchhy22238cQTTzBjxgxGjhx5xvUDBw5Qo4YaskWqAsMwWHVkF9Pif2fZwR329epevoxq2oWRTTpRzcvXxAmdi2EtIWvFpxz7/n+UHD8AgMXDh2r9H6HateNx9Q0yd0ARETmrzekHGL7wE44X5uLt5s57PYfSt15Ts8dyCnl5eWzcuJHjx48DKkkVkYpzyWHIXXfdhZubG6+++iqLFy/mlltuoXnz5ri6urJu3TpmzpzJ+PHjy2NWEXEQJTYrP+/ZyrStv9u3AgNEBIQwtvnV/KNhW7zd3E2c0LkYNhs5cd+Q/t0LFB8pvcccV3eCeo4l+IZ/4RZUy9wBRSqx3NxcJkyYwPz588nKyiIyMpIHH3yQPn36XPTXMAyDkSNHsnbtWkaMGMGzzz5bjhOLo1l5KIW7l8wkt6SIYE9fZvS7izah9cweyykcPHiQLVu2qCRVRExxyWHIAw88QGJiIomJiaxbt45169addh9k06ZNCQgIICkpiYiICNzcLvklRMRB5RQX8kVSLB8lrORAToZ9vWPNBtzb7Gr6XdUUF4vewFwsw2YjZ8M8js17kaID8aWLp47JHfQC7qHh5g4oUgWMGzeOhIQExo8fT926dZk7dy7jxo1j2rRp9OjR46K+xldffcWuXbsu/ECpdH7Zs5Vxy7+gyGaljm8gs/uPJjJIO6QvRCWpIuIILjmpePjhh+2/zsrKIiEhgcTERLZv305CQgJJSUk8+eSTWCwW3NzcCA8PJyoqijfeeKNMBxeRinM4N5OPE1adVopqwcI19aO5r3kP2tW4yuQJnYthGORu+pFjc/9L4b5N9nXftjcR8o//4RnWzLzhRKqQ5cuXs2rVKiZPnky/fv2A0u6z/fv38+qrr15UGJKamsobb7zBSy+9dNp7JKn8vkhax9OrvsNmGEQGhjK7/2jq+AWZPZbDU0mqiDiKK9q2ERAQQKdOnejUqZN9raioiOTkZLZv324PSJYtW3bFg4pIxUs4foj3t/7B97s2U2LYAPB2c+e2yPaMadaV8IAQkyd0LoZhkLv5F47N+y+Fe9bb131bXUf1wS/g1aCdidOJVD2LFi3C39//tFtiLBYLgwcP5rnnniMlJYXIyMjzfo0XXniB9u3bM2DAgPIeVxzI1PjlvBz3KwCtQuoyq98ogtWRdV4qSRURR1Pm97B4eHjQrFkzmjXTJ5sizsgwDJYfSub9rb/zx6EU+3qotx+jmnZheFSMSlEvkWEY5MUv4Ni8/1KwK9a+7tNiANUH/wfviI4mTidSdSUnJxMZGXlGP0FUVBQASUlJ5w1DfvrpJ9auXcsvv/xSrnOK4zAMg5fifmXa1t8B6FY7kul9huPn7mnyZI7tbCWpbdu2xd/f3+TJRKQqU6GHiABQaC1h3q5NfLD1D3ZkpNrXGwXW4N7mVzMoojVeKkW9JKd2ghz/4SUKdq21r/s061sagkR2NnE6EcnIyDjrp9KBgYH26+dy/PhxXnrpJR577DFq16590a/Zvn37817Pzs7WD4gOqsRm5elVc5mTHAfAwPrNmdTjdjxd9Xb6fFSSKiKOSn96i1RxJwpymZm4hk8TV5OWn2Nf71q7IWObXU2vuo1VinqJDJuNnPVzOf7jy6d1gng37U3I4BfwbtzNvOFE5DR/LYG/lGsvvfQSdevWZdiwYeUxljiYgpJixi3/kvn7tgEwtHFHXuk8CFf9QH9OKkkVEUenMESkitqVmcaH21bwdcoGCqzFALhZXLghvCVjm11Ni5Awkyd0PobNSvbaORz/8RWKDiXY132a9yP4hn/hE9XdxOlE5O+CgoLOuvsjMzMT+HOHyN+tXLmSX375hRkzZpCTk3PataKiIrKysvDx8TnriXpxcXHnnelCO0ek4uUWFzJq8QxWHSk9MWhcy5483XbAecOyqk4lqSLiDBSGiFQhhmGwJnU3H2z9g8X7EzEwAAjw8OLOxjGMiu5CHd+zv/mXczNKisla/RnHf3qN4tRk+7pv6+sJvuFfeDeMMXE6ETmXyMhIFi5ciM1mO23LflJSEgCNGzc+6/OSk5Ox2WwMHz78jGtffvklX375JR9++CHduysAdXZZRQUMX/gx69P2AfBch4Hc21z/XM9FJaki4kwUhohUAcU2Kz/tjufDbX+w5dhB+/pVfsGMbtaVIY3aq/ztMtgK88j84xNO/PoWJcf2li5aLPi1u5ngG/6FV/3Wps4nIufXr18/vvnmG5YuXUrfvn3t6/PmzSM8PPyc5anXXHMNTZs2PWN9xIgRDBgwgDvvvNNewirO60RBLncu/Jgtxw5iwcJrXQcztLEKr89FJaki4mwUhohUYhmFecxOWsfHCSs5kpdlX28behVjm1/NtVc10/3Ol8Gac5yMJVPJWDwJa3Z66aLFBf9OtxN8/T/xDIs2d0ARuSg9evQgJiaGZ599loyMDOrWrcu8efNYv349U6dOtT9u+PDhxMbGsmPHDgBq1apFrVq1zvo1a9asSUyMdoM5u7T8bO5Y8BGJJ47ganFhwtW3cnPDNmaP5bBUkioizkhhiEgltDsrnY8SVvJV8nrySooAcLFYuLZ+c+6J7kb7mvVNntA5FR/bz4mF75D524cYhbkAWNw8COg2kmrXjsej5rmP4BQRx2OxWJg6dSpvv/02EyZMICsri8jISCZPnkzv3r3NHk9Mcjg3kzsWTCclMw03iwtTet7BdQ1amD2WQ1JJqog4M4UhIpWEYRjEpu7hg21/sHDfdnsfiJ+7J3c07sCopl24yj/Y5CmdU+Gh7Zz45Q2yVn8O1tJPvVy8AwjsdR/V+j+MW9DFH6spIo7Fz8+P559/nueff/6cj5k1a9ZFfa1TO0fEeR3IOcGQ+R+yN/s4nq5ufNBrGH3qNTF7LIekklQRcXYKQ0ScXJG1hJ/2xPNRwko2px+wr4f5BjE6uiu3N+5AgIeXiRM6J8MwyE9awYn5b5O78Qf7umtgLaoNeJTAnmNx9VHZrIhIZbE7K50h8z/kUG4mXq7ufNJ3BFfXaWT2WA5HJakiUlkoDBFxUicKcvk8KZZPtq8m9S99IG1C6zG22dVcW78Zbi6uJk7onIySYrLjvuHEgnco3P3nEZjuNSOpdu0TBHQZgYvCJRGRSiUpI5U75k8nNT8bXzcPZvS7i061Iswey+GoJFVEKhOFISJOJiXjKNMTVvJNygYKrMWA+kDKgjUvk8zlH5GxaCIlx/fb170iYqh2zWP4tb8Zi8IlEZFKJ+H4Ie5Y8BHHCnIJ9PBiVv+7aRt6ldljORyVpIpIZaMwRMQJGIbBH4dS+HDbCpYd/POedH93T4Y27shdTTtTT30gl6U4bQ8nFk8ia/lH2AqySxctFvzaDqLaNY/j3aiLuQOKiEi52ZJ+gDsWfERmUT7VPH34YsBomlcPM3ssh6KSVBGprBSGiDiw/JJi5u3axPRtK9iRkWpfr+8fzN3RXRnSqD1+7p4mTuicDMOgIGU1JxZNJGfdt2DYALB4+hJ49SiC+j+MR42GJk8pIiLlKT79oD0ICfX244sBY2hS7exHJldVKkkVkcpMYYiIAzqSl8WsxDXMSlzL8ZNHuALE1Aznnmbd6FevKa7alnrJbEUFZMfOIWPxFAr3rLevuwbVoVq/hwjseQ+uvtVMnFBERCrC1mMHuX3BdDKL8qnh7c9X19xDZFANs8dyGCpJFZGqQGGIiAPZkn6A6Qkr+XH3FoptVgDcXVy5Ibwl90R3o0WItu5ejuITB8lc+j6Zv32ANTvNvu7ZoB3V+j2Ef8wQLG76lEtEpCrYduwQt/9lR8gcBSGnUUmqiFQVCkNETFZis7JgXwIfJawkNnWPfT3Y05fhTWIY0aQTNX0CzBvQSZ26FSZj8WSy474Fa2nhG65u+Lf/B0H9HsKrYScsFou5g4qISIVJOH6IIQumk1GYR4hXaRDSSEGInUpSRaQqURgiYpLMwny+TF7HJ9tXcSAnw77epFotxkR3ZVBEa7zc3M0b0EnZivLJXjuHjCVTT78Vxj+UwF73EtTrXtyq1TFxQhERMUPC8cMMmV8ahFT38mXONffQOKim2WM5BJWkikhV5FBhyJEjR5g+fTrbtm0jMTGRvLw8Zs6cSUxMzGmPGz58OLGxsWc8f+DAgUyYMKGixhW5LDsz0/g4YSVfp2wgr6QIAAsW+tZrwpjornSp3VC7FS5D0ZEkMpa9T9aKGdhyT9jXS2+FGYdfxyG4qGxWRKRKSjxxhNvnT+dEYR7BnqVBSFQ1BSGgklQRqbocKgzZu3cvP//8M9HR0XTq1ImlS5ee87ENGjTgtddeO22tWjUVH4pjshk2lh9M5qOElfx2MMm+7uvmwa2N2nF3065EBIaYOKFzMkqKydn4A5nL3icvYcmfF1zd8e/wD4L6jtOtMCIiVdyOE6kMmf8hxwtzqebpw5xr7tGpMZTeTpqcnExSUpJKUkWkSnKoMKRDhw6sXr0agMWLF583DPHy8qJ169YVNJnI5cktLuSblA18sn0VKZl/Fnde5RfMqOjODGnUgQAPLxMndE7Fxw+QuXw6mcunY804bF93C2lAUM+xBHQfhVuA7gEXEanqkjJKg5BjBaeCkDE0DVYQopJUEREHC0NUziSVxf7s43yauIYvk2LJLCqwr3epFcHo6K701dG4l8ywWcnbuoiM3z4gd9NPcPK0HSwWfFteS2Cv+/BteQ0WF1dzBxUREYeQknGUIfM/JL0ghyBPH74cMIboYHVGqSRVRKSUQ4Uhl2L37t106NCB3Nxc6taty6BBg7jnnntwd1fhpJjDMAxWH9nFxwmrWLg/AZthAODp6sagiNaMju5KdHBtk6d0PsXH9pP1xydk/vEJJcf22dddA2oQ2P1uAnvcg3toA/MGFBERh7M3+xhDFkwnLT+HQA9vvhwwmmbVq3YQUlxczNatWzlw4ABQWpLaunVratTQTkoRqZqcMgxp164dAwcOJCIigry8PBYvXszEiRPZtm0bU6ZMOetz2rdvf96vmZ2dra2BclnyS4qZt2sTHyesZPuJI/b1mj4BjGzSiTujOlLdy8/ECZ2PUVJMzuafyFw+nbz4BXAyWALwjupBYK+x+Le/GYubyt1EROR0h3IzuX3+dFLzsgjw8OKLAaNpXj3M7LFMdbaS1FatWuHpqWJxEam6nDIMefTRR0/7/7169SIkJIRp06YRFxd3weBDpCwcyslg5o41fL4jlhOFefb1dqFXcXd0VwY2aI67btm4JEVHksn8/WOyVszAmpVqX3cNqElAt5EEdr8bj1qNTJxQREQcWXp+DkMXTGd/zgm83dyZ2XcULUPqmj2WaVSSKiJybk4ZhpzNoEGDmDZtGps2bTprGBIXF3fe5ytAkYthGAZxR/fyccIqftm7FathA8DdxZUbw1syqmkXWofWM3lK52IrzCNn/XdkLv+Y/B3L/7xgseDTYgCBPcbg1+p6LG66BU5ERM4tszCfOxd+REpmGh4urnzcZwTta9Y3eyzTqCRVROT8Kk0YYrOV/lCq8icpDwUlxfywezMfJ6xi6/FD9vVQbz+GR3ViWFQMNXz05uJiGYZBQfJKMlfMICf2a2wF2fZrbsH1COx+NwFX34V79atMnFJERJxFbnEhIxZ9wrbjh3G1uDCt151cXafq7iRUSaqIyIVVmjDk+++/B6BVq1YmTyKVyaHcTGYllt4Kc7ww177eKqQud0d35YYGLfBwrTT/GZW74mP7yFo5i6wVMyg+uvPPC67u+LW5gcDuo/Fp3k8nwoiIyEUrKCnm7iUzWZ+2DwsW3u1+G/2vijZ7LFOUlJQQHx+vklQRkYvgcD/FzZ8/H4D4+HgA1q1bx4kTJ/D29qZHjx7ExcXxwQcf0L9/f8LCwsjLy2PJkiV89913XHPNNbRr187M8aUSMAyDdUf38nHCSn7du+20W2Gua9CCu6O70DZUOxYulq0wl5z1c8laMZO87UtPK0P1DG9PYNeR+HcagqtfdROnFBERZ1Rss3L/b7NZebg0YH+1y2AGRbQ2dyiTqCRVROTSOFwY8sgjj5z2/ydNmgRAWFgYS5cuJTQ0FICJEydy4sQJXFxcCA8P55lnnmH48OEVPq9UHvknb4X55Cy3wgyLimFYVAw1fQJMnNB5GDYb+Tt+J2vVZ+Ss++a022BcA2oS0GUYAd1G4Fm3uYlTioiIM7PabDz6+1cs2r8dgBc6XsedUR1NnqriqSRVROTyOFwYsmPHjvNer1+/Ph988EEFTSNVwYGcE8xMXMMXSetOOxWmTWg9RjXtwvW6FeaiFe6PJ2v152Sv+ZKS4/vt6xY3D3xb30BAt5H4thiARX8/RUTkChiGwTOr5/L97s0APN66L/c0u9rkqSqeSlJFRC6ffiKRKskwDFYd3skn21ezcH8CtpO3bri7uHJ9gxaM0q0wF6342H6y135J1qrPKToQf9o1z/AOBHYdodtgRESkzBiGwYvrfuaLpHUA3Nvsah5r3cfkqSqeSlJFRK6MwhCpUnKLC/lu50Y+3b6aHRmp9vWaPgEMj4rhzqiOhHrr05QLseZmkBP3LVmrZ5ceh/uXHhD3Gg3x73wnAZ2H4lGr6jb5i4hI+ZgSv5wPt60A4M7GHfl3h4FYLBaTp6o4KkkVESkbCkOkStidlc7MxDXMSY4jq6jAvt6hRn1GNe3CtQ2a464TTM7LVpRP7uZfyF77JbmbfsYoKbRfc/UPxb/jbfh3uROviI5V6k2piIhUnDnJcby6vrRs/8bwlrzceVCV+p5z4sQJNmzYoJJUEZEyoDBEKi2bYWPZgSQ+3b6aZQf/7KLxdHVjUERrRjXtTPPqYSZO6PhsxYXkbV1A9tqvyNn0I0ZBjv2axcMbv7aD8O88FN9m/bC4uZs4qYiIVHaL92/nqZXfAdCtdiQTrr4N1ypyS4hKUkVEyp7CEKl0Mgrz+Cp5PTMS17A3+5h9Pcw3iBFNOjG0cQeqefmaOKFjM0qKyUtYQnbsV+Ssn4ctP/PPi65u+ET3IaDTHfi1HYSLbikSEZEKsP7oXu5bNhurYaN5cB0+7D0MzypSxq2SVBGR8lE1votIlZBw/BCfbl/Ddzs3UmAttq9fXSeSu5p0pm+9plXmE6RLZdis5CcuJzv2K7LjvsOW82eIhMUF7yY98Y+5Df/2N6sIVUREKlRyxlFGLp5BgbWY+v7BzOo/Cn8PL7PHqhAqSRURKT8KQ8SpFdus/LpnKzMSV7M2dY993dfNg1sbtWNkk840ClKh2NkY1hLyk/4gO+47ctZ9izUr9bTr3o274d9xCH7tb8YtqJZJU4qISFV2KDeTOxd+REZhHiFefnzW/+4qUXSuklQRkfKnMESc0pG8LD7fsZbPd8RyND/bvh4ZGMpdTbvwj4ZtqsynRpfCKCkiL2Ep2XHfkbvxe6zZ6add94qIwT/mNvw63IJ7cF2TphQRESm97XX4wo85lJuJr5sHM/vdRXhAiNljlTuVpIqIVAyFIeI0DMNgbepuPt2+mvl7t1Fi2ABwsVjoV68po5p2oWvthlWqVf5i2Iryydu6sDQA2fQTtryM0657hrfHv/0/8O94K+6h4eYMKSIi8hf5JcXcvWQmOzJScXdxZXqf4bQMqdwhvUpSRUQqlsIQcXi5xYV8t3Mjn25fzY6MP2/lCPb0ZWhUB4ZHdSLML8i8AR2QrSCH3C2/khP3HTlbfjntFBgsFrwiu+Df/mb82g3GPaS+eYOKiIj8TYnNyoO/zSb25O2v71x9G1fXaWTuUOVMJakiIhVPYYg4rJSMo8xMXMPXKevJLi60r7cJrcddTbtwfYMWVaZJ/mJYs9PJ2fQTORt/IC9+AUZxwZ8XXVzxjupxMgAZhFtQbfMGFREROQfDMPjn6nks3L8dgP90vJ6bIlqZPFX5UkmqiIg59JOkOJQSm5WF+7YzI3E1Kw/vtK97uroxKKIVI5t0rvTbZC9FUWoKORt+IHfjD+Qnr4STtw4B4OqOT7M++Le7Gb+2N+HqX/nvsxYREec2cfNSvkhaB8ADLXowplk3kycqPypJFRExl8IQcQipeVl8kbSOz3as5Uheln39Kr9ghjeJ4fZG7anm5WvihI7BsNko2L2O3I0/kLPhB4oOJZx23eLpi2+LAfi1vQnfVtfj6htkzqAiIiKXaO7OTbyxcREAtzRsyz/bXWPyROVHJakiIuZTGCKmOVWIOjNxDb/s2WovRLVgoXfdKEY06USvuo1xsVTtbaK2ogLyti8tDUA2/YQ14/Bp110Da+HX5gZ829yIT9PeuOgUHRERcTJrj+zmiRVfA9C5VgSvd725UhaiqyRVRMRxKAyRCpdzshB1xt8KUat5+nB7ow4MbxLDVf7BJk5ovpKMw+Ru/oXcLb+Qu23x6QWogEedaPza3ohvmxvxCu+ARfcVi4iIk9qVmc7opbMosllpGBjKh72H4VEJO8FUkioi4lgq33cacViJJ44wK3EN36RsILekyL7eJrQeI5t04voGLfFyczdxQvPYb3/Z/Au5m3+hcO+G0x9gccG7UVd829yIX9sb8agZac6gIiIiZehEQS4jFn1CRmEe1b18mdnvLoI8fcweq8ypJFVExPEoDJFyVWQt4de925iZuJq1J4/Ig1OFqK0Z0aQTrapoIao1N4O8bQtP7gCZjzU77bTrLt4B+DTrh2+rgfi2ug63gFCTJhURESl7hdYSRi+dxZ7sY3i6uvFxn5HU969u9lhlSiWpIiKOS2GIlIuDORl8vmMts5PWkf6XWzzCA0IY2aQTt0S2rZSf/JyPYRgUHdpu3/2Rn7wCbNbTHuNRu8nJ8GMg3o26YamiO2VERKRyMwyDJ1Z8Q+zJD0revfo22tW4ytyhytjfS1Jr1KhB69atVZIqIuIgFIZImbEZNpYfTGZW4hoWH0jEZhgAuFgs9K8Xzcimnehau2GVKkS15mWSl7CEvPgF5G5dSMmxfaddt7h54t2kB76trsO31UA8akSYNKmIiEjFeWvTYubt2gTAP9tdw/XhLc0dqAypJFVExDkoDJErdrwgly+T4/h8x1r2Zh+3r9fw9ueOxh24s3FH6vgFmTdgBTJsVgr3bCD3ZPhRsHPNGbs/3KqF2Xd/+ET3wcVTRwaLiEjV8XXyet7ZtASAoY078kCLHiZPVHZUkioi4jwUhshlMQyDuKN7mZm4hp/3xFP0lx/4O9eKYESTTgy4KrpStsH/XUnGYXLjF5C3dSG52xZjyzl22nWLmwdejbrh26I/vs3741GvZaU8LlBERORCVh7eyVOrvgOge51GvNT5pkrzPVElqSIizqXy/6QqZSqnuJC5OzcyI3ENiSeO2NcDPLy4pWFbhjfpRKOgyl0KZisqoCBlJbnxC8ndupCi/VvOeIx7zUb4Nu+PT4v++DTpiYuXnwmTioiIOI6UjKOMXTqLYpuVqKCaTOt1J+4urmaPdcVUkioi4pwUhshFSTh+mFmJa/hu58bTjsVtWT2M4U06cVN4K3zcPUycsPwYNiuFezeSl7CUvITF5CetxCguOO0xLl7+eDfthW+L/vg0H6DuDxERkb/IKMzjrsUzyCwqoIa3PzP7jSLAw8vssa6YSlJFRJyXwhA5p4KSYn7aE8+sxDWsT/uz+LP0WNxWDI/qROvQeiZOWD4Mw6A4NZm8bUtKy08Tf8OWe+KMx3nWb4tviwH4tOiPd8POOvlFRETkLEpsVh747Yu/HKE7gjAn7xJTSaqIiPNTGCJn2JWZzuc71jInZT0ZhXn29cjAUIZFxVTKY3FLMg6XBh8JS8lLWELJ8QNnPMY9NAKf6N74NOuDd5NeuAWEmjCpiIiIc3kp7ld+P5QMwJtdb3H6D1Ly8/PZsGGDSlJFRJycwhABoNhmZeG+BGYlrmXF4RT7upvFhWvrN2d4kxg614qoNCVn1pzj5Cf9Qd72ZeRtW0LRoYQzHuPqH1oafkT3xie6D+6h4SZMKiIi4ry+So7jw20rALi/eQ8GN2xt7kBX6ODBg8THx1NcXAyoJFVExJkpDKniDuScYPaOWL5MjuNofrZ9va5fEHc2jmFIo/bU8HH+TzqsOcfJ3/E7eTt+Jz9xOYX7N4NhnPYYi6cvPlHd8Ynug0+zPniENceiNzciIiKXZf3RvTyzai4AvetG8Uy7ASZPdPlUkioiUvkoDKmCrDYbyw7uYFbiWpYe2IFBaShgwULvulGMaNKJnmGNcXXiIMCac+xk8HEy/Diw5YzwA1d3vBvGlIYf0b3xiuiIxa1ylsCKiIhUpEO5mdyz9DOKbFYiA0OZ3OMOp31foZJUEZHKSWFIFZKal8WXSev4PCmWQ7mZ9vWa3v7c3rgDdzTuQF2/aiZOePn+DD+Wk5e4/KzH3Z4KP7yjeuDTtAdeDTvjUsm6T0RERMyWX1LMmCUzOZqfTaCHFx/3GeGUJ8ecrSQ1Ojqa8HDdNisiUhkoDKnkbIaNFYd2MmvHGhbu247VsNmvda/TiGFRMfS7qinuLq4mTnnpSk4cIj95Bfk7VpC343eKDsSf8RiLmwdeETF4N+mBT5MeeDXspPBDRESkHBmGwZMrv2XLsYO4WCxM7TmUiEDnKxxXSaqISOWnMKSSSs/PYU5yHLOTYtmbfdy+Huzpy5BG7Rka1YHwgBATJ7x4hmFQdDiR/KQVFCSvJD9pBcVpu894nMXNA6+GnU4PPzy8TZhYREScRW5uLhMmTGD+/PlkZWURGRnJgw8+SJ8+fc77vK+//polS5awY8cOjh07Rq1atejevTsPPPAAwcHBFTS945kav5x5uzYB8O/2A+kR1tjcgS6DSlJFRKoGhSGViGEYrDq8k892xDJ/3zaKbVb7tZia4QyLimFgg+Z4ujr2P3ajpIiCPRvIPxl85CevxJZz7IzHWTy8S8OPxt3wadITr4YxCj9EROSSjBs3joSEBMaPH0/dunWZO3cu48aNY9q0afTo0eOcz5s4cSIxMTE8/vjj1KxZk5SUFKZMmcLSpUuZN28eAQEBFfi7cAxL9ify6voFANwa2ZZ7mnUzeaJLo5JUEZGqxbF/KpaLcrwgl69T1vPZjlh2Z6Xb1wM9vLk1si13RsXQKMhxv5Fb87MoSFlNftJK8pNXUrBrLUZR/hmPc/UPwatRV7wbdcM7qhteV7XB4uZuwsQiIlIZLF++nFWrVjF58mT69esHQKdOndi/fz+vvvrqecOQefPmUb16dfv/79ixI5GRkQwfPpzvv/+e4cOHl/v8jiQ54yjjln+BgUGb0Hq80nkwFovF7LEumkpSRUSqHoUhTsowDNak7ubzHbH8sieeor/sAulQoz53RsVwXYMWeDtYWGAYBsWpKRTsXEP+zjUUpKyhcP8W+EuXySnuNRri3agr3o274t34atxrNXaqN1YiIuLYFi1ahL+//2m3xFgsFgYPHsxzzz1HSkoKkZGRZ33uX4OQU1q0aAHAkSNHymdgB5VVVMDdS2aSXVxITZ8ApvcejpeDvf84F5WkiohUXQpDnMyJgly+TtnA50mx7MxMs68HeHhxc8M2DIuKoUm1WiZOeDpbQQ4Fu9eRn7KGgpTVFOxaizU7/cwHWlzwvKp1afDRqPR/btXqVPzAIiJSZSQnJxMZGXlGF0RUVBQASUlJ5wxDzmbNmjUANGrUqOyGdHCGYfDYH1+xOysdT1c3Puo9nJo+znGL0N9LUv39/WnXrp1KUkVEqgiFIU7gfLtA2oZexZ1RHbkxvCXebh4mTvnXXR+rT4Yfayg8EH/WXR8u3oF4NeyIV8POeEd2wiuyM67ezvHmSUREKoeMjAwaNGhwxnpgYKD9+qV8rf/7v/+jQYMGDBw48JyPa9++/Xm/TnZ2tlP9MP7e1t9ZsC8BgP/rdBOtQ+uZPNHF+XtJanh4ONHR0SpJFRGpQhSGOLBz7QLxd/fk5oZtuTOqA9HB5u2esOVn/7nrY+eac+/6ADzqROMV2Qnvhp3wiuyER+2mWPSGQ0RETHa+2y8v9tbM/Px8HnzwQTIzM/nss8/w8DD3w4mKsvLwTl5dPx+AIY3ac0fjDiZPdGEqSRURkVMUhjgYwzBYfWQXnyfF8uueraftAmkTWo9hUTHc0KAlPu4V+0bLKCmicP8WCnato2D3Ogp2raPo8HYwjDMeW7rrIwbvyM54NYzBKyIGV9+gCp1XRETkQoKCgs66+yMzMxP4c4fI+RQUFHD//feTkJDARx99RJMmTc77+Li4uPNev9DOEUdxODeTB3/7Apth0Dy4Dv/X6SazR7oglaSKiMhfKQxxEMcKcvg6eQOzk2LZ9ZcTYUp3gbThzqiOFbYLxLDZKD6SRMHuWAp2xVGwex2F+zZhlBSd+WCLpXTXR8NOeDeMwSuyMx61m2jXh4iIOLzIyEgWLlyIzWY77faIpKQkABo3bnze5xcWFvLAAw+wadMmPvjgA9q2bVuu8zqKImsJ9y37nPSCHAI9vPig9zCHK2z/K5WkiojI2SgMMZHNsLH68MldIHu3UXyWLpDy3gViGAYlJw5SsCuWgt1xFOxaR+GeOGz5WWd9vFu1MLwiOuAV3hGviPZ4NmiPq8+FPzkTERFxNP369eObb75h6dKl9O3b174+b948wsPDz1ueWlRUxAMPPEBcXBzTpk2jY8eOFTGyQ/i/db+wPm0fABO7385V/sEmT3RuKkkVEZFzURhigrT8bL5O2cDsHbHsyT5mXw/w8OIfDdsytHFHmgaXz4kwJVlHKdyzgYI96+23u1gzz34EoItPEF7h7fGK6Fj61/AOOuFFREQqjR49ehATE8Ozzz5LRkYGdevWZd68eaxfv56pU6faHzd8+HBiY2PZsWOHfe3hhx9mxYoVPPjgg/j4+LBp0yb7teDgYK666qqK/K1UmHm7NvHx9lUAPNKqN33qnf+2IDOpJFVERM7HocKQI0eOMH36dLZt20ZiYiJ5eXnMnDmTmJiYMx67cuVK3n33XRITE/H19aVfv36MHz+egADHPJHEZtj4/VAKs3fEsnBfAiV/OWGlQ4363BnVkesatCizE2EMw8CacZiCPesp3LuRgr0bKNyzgZITB8/6eIu7F571254MPzrgFd4B95qRF10eJyIi4mwsFgtTp07l7bffZsKECWRlZREZGcnkyZPp3bv3eZ+7bNkyAKZMmcKUKVNOuzZ48GBeffXVcpvbLDtOpPLkym8B6FGnEY+37nuBZ5hDJakiInIxHCoM2bt3Lz///DPR0dF06tSJpUuXnvVxa9euZezYsfTp04dHH32Uo0eP8uabb5KUlMTs2bMdKvE/nJvJnOQ4vkxex4GcDPt6oIc3/2jYhjujYoiqVvOKXsMwDEqO7bMHHqV/3Yg1K/XsT3BxxSOsGV7hHfCKaI9XeEc8w5phceD7fUVERMqDn58fzz//PM8///w5HzNr1qwz1v66S6QqyC4q4J6ls8gvKSbMN4hJPW7H1YHeb52iklQREblYDhWGdOjQgdWrVwOwePHic4Yhb7zxBo0aNeKdd96xBx+hoaHcfffdzJ8/n4EDB1bYzGdTYrOy7MAOZietY8mBRGx/OXGlU61whjbuyLX1m19W2ZhhGBQf3Unh3g0U7NlI4d71FOzZiC33+Fkfb3HzwKNuC7zqt8GzQVu86rfFo24LXDy8Lvv3JyIiIlWHYRg8seIbdmWl4+Hiyvu97iTYy9fssU5jGAYpKSns2LFDJakiInJRHCoMuZgdHampqcTHx/PMM8+c9viuXbtSs2ZNFixYYFoYsj/7OF8mxzEnOY4jeX8WkAZ7+nJro3YMbdyBhoGhF/31bMWFFB1KoHDfJgr3baFw/xYK927Elp951sdb3L3wrNfqZOhRGn6U7vio2GN4RUREpPL4YNsf/LJ3KwAvxtxI69B6Jk90urOVpLZt29Zhb50WERHH4FBhyMU4ddxdo0aNzrjWuHFjkpOTK3SeImsJC/cl8EXSOn4/lILBn7tAutdpxNDGHeh/VTQeruf/W12SdZTCfZtLA499myjcv4Wiw4lgLTnr4y2evqWBx8n/eTVoV3qk7QVeR0RERORixabu4eW4+QDcGtmWO6Mc69Scs5WkNm3aFFdXV5MnExERR+d0PzlnZGQAEBh45nGugYGBJCQknPV57du3P+/Xzc7OvqRj1nZmpjE7aR3fpKznWEGufb2mtz+3NWrP7Y3bU9+/+hnPM6wlFB1JonD/5pO7PTZTuG/zOU90AXD1D8Xzqpaluz7qt8GrflvcazXC4qJv9CIiIlI+ThTm8eBvX2A1bDStVouXOw9ymGJ1laSKiMiVcrow5JRzfTMuz2/S+SXF/Lwnni+S/r+9+4+qqs7/Pf7igKgoQVJKCg7qEfwJkuCvaxCK2M2+09LpW5aazdQwGmqllt1wbFU4aZrOpANl01wz6zapI99Mx7KyGkPxV5b2Qw0qMtMxEFASQdj3D4czGmjAOWcf9jnPx1r94f71efNeLPa7997nfXYq//jXju02Pz+NjOil26MTNSIiRgH/blLUnjmlyqJ9/37j4/xbH1VHDsiormx4AT+bAq+JUevIfzc+up7/zz8kvMUUHwAAwPsZhqHZ29bq+x/LFBQQqGdTJrjsG++cxZBUAIArWK4ZEhoaKuk/b4hcqKysrME3RiRp9+7dl73uz705UlNbqzEblulQ6b8c2yLbX6nxPRN0a88EXdPu4nWr/lWooscGqbbiZIPXs7W94nzDIzL2/FsfXQcosEtf2QLbXjYOAAAAd/u/n+fpzaLzb9vOH3Jzk2aeuQtDUgEArmS5ZkjdrJDDhw9r+PDhF+07dOiQ4uPj3bKuIUM/nqtSK5u/RnftozuiB2l45x6y+V1i6Ou5KtVWnpYktbq6+38+5hIZq9Zd4xRwVRRvewAAgBbnQPF3ytq1SZI0rke8brFf6+GIGJIKAHA9yzVDwsPD1a9fP23YsEGTJ092fKPM9u3bdfz4caWlpbll3QCbv7aOnaVao1btWv38a5iBnXupx/Lzb5H4t+VGDQAAWr7T1Wc19b3/p6raGnW74qoWMSeEIakAAHdocc2QzZvPTyzfv3+/JGnXrl06efKk2rZtq+TkZEnS7Nmzdffdd2vmzJm67bbbdPz4cS1evFhxcXG64YYb3BZb24BWTTqeJggAALCSzO25+qr8BwXa/JWdfLvaN+IBkLswJBUA4E4trhly3333XfTvZcuWSZK6dOmid999V5I0dOhQPfvss1q2bJnS09PVrl07paam6sEHH+QpAQAAQDOs/XKP1hV8JEnKTLxR/a/q4rFYGJIKAHC3FtcMOXjwYKOOS0pKUlJSkpujAQDAt9n4GnefUFB2Qo9s/x9JUlpkb/2m9zCPxMGQVACAWVpcMwQAAADmqTxXranvvaIfz1XpmqAQPT38Fo/MCWFIKgDATDRDAAAAfFjW7k36rOR72fz8tDx5vK5s0870GBiSCgAwG80QAAAAH7X5m0+18vPtkqSZA1I1ONzcj6OcO3dOBw4c0LfffiuJIakAAPPQDAEAAPBB350u1axtayVJw8K7a3psiqnrMyQVAOBJNEMAAAB8TE1trWZ88DeVVZ1Rh9bt9EzyePnbbKaszZBUAEBLQDMEAADAx6z49J/KP/6VJGnpdf+t8CBzhpQyJBUA0FLQDAEAAPAhn5Uc1VN735IkTYoZrJGRvUxZ9+jRo/rkk08YkgoAaBFohgAAAPiIynPVmvHBa6qurVFUcJh+nzjG7WsyJBUA0BLRDAEAAPARiz7aoi9OHpO/n03PJN+moFaBbl3v5MmT+uijj1RRUSGJIakAgJaDZggAAIAPyPu+QCsO/FOSND0uRdde3dVtazEkFQDQ0tEMAQAA8HLlVZV64J9rZMhQ3FURui9uhNvWYkgqAMAKaIYAAAB4uXk7Xtd3FaVq499KzyTdplY29wwtZUgqAMAqaIYAAAB4sTe+3q+1BXslSXMTb1SPkKtdvsZPh6QGBgZqwIAB6tSpk8vXAgDAFWiGAAAAeKnjP5br4bz1kqTkLtGa3GuIy9dgSCoAwIpohgAAAHghwzA0a9talZ79USGBbfX08Fvk5+fn0uszJBUAYFU0QwAAALzQSwfz9d53hyRJC4eNVXiQ6waYMiQVAGB1NEMAAAC8TGHZCT2+c6MkaVyPeN3ULdZl12ZIKgDAG9AMAQAA8CLnams044PXVFlTrc7tQvTE4F+65roMSQUAeBGaIQAAAF7kL59+qH0/nG9YLB3+3wpp3dbpazIkFQDgbWiGAAAAeInCshNa9NFbkqTJvYbof3W2O3W9Sw1JjYqKcukwVgAAzEYzBAAAwAvUGrWatW2tztacU0T7UP2fhP/t1PUYkgoA8GY0QwAAALzAys+3a9e/vpEkPTXsV2rfqvkfYWFIKgDA29EMAQAAsLiiUyV6cs9mSdL4nglK6tKzWddhSCoAwFfQDAEAALAwwzD04IfrdOZctToFXaHfJ45p1nUYkgoA8CU0QwAAACzslUO79OH3BZKkhcPGNvnbYxiSCgDwRTRDAAAALOro6VI9sWujJGls9wFKjezdpPPPnDmjjz76SMXFxZIYkgoA8B00QwAAACzIMAzNyVuv09VndVWb9np88H816XyGpAIAfBnNEAAAAAtaV7BXW787KEnKGnqzrmzTrlHnMSQVAACaIQAAAJZz/MdyPZq/QZJ04y/66aao/o06jyGpAACcRzMEAADAQgzD0CPbc1VWVanQ1kHKGnJzo8756ZDU3r17q1u3bgxJBQD4JJohAAAAFvLG1/v1ZtFnkqTHBv+XOgYFX/Z4hqQCAFAfzRAAAACLqKg+q7k7/keSlBrZS+O6D7js8QxJBQCgYTRDAAAALKK4skInz/6okMA2enLo2Et+xIUhqQAAXB7NEAAAAIvoGtxBb9yUoQ5t2umadiENHlNaWqq9e/cyJBUAgMugGQIAAGAhsVdFNLidIakAADQezRAAAACLY0gqAABNQzMEAADAwhiSCgBA09EMAQAAsCCGpAIA0Hw0QwAAACyGIakAADiHZggAAIBFMCQVAADXoBkCAABgAQxJBQDAdSzZDMnPz9edd97Z4L5NmzapR48eJkcEAACsqKKiQkuXLtXmzZtVXl4uu92ujIwMjRw58mfPLSoq0oIFC5Sfn6/a2lolJCRozpw5stvtLo+TIakAALiWJZshdWbPnq3ExMSLtkVERHgoGgAAYDXTpk3TZ599ptmzZysiIkLr16/XtGnT9Oyzzyo5OfmS5xUXF+uOO+5QWFiYFi5cKH9/f+Xk5GjixInKzc1VeHi4S+JjSCoAAO5h6WZIt27dNGDAAE+HAQAALOj9999XXl6eli9frlGjRkmShgwZom+//VYLFiy4bDPkhRdeUHl5udatW+doTAwYMEAjR45UTk6OHnvsMafjY0gqAADuY/N0AAAAAJ6wZcsWBQcHX/SRGD8/P40dO1aFhYX68ssvL3nu22+/rWHDhl30hsaVV16plJQUbdmyxenYDh8+rG3btqmiokI2m019+/bVoEGDaIQAAOAilm6GzJs3T3369NHAgQP1u9/9TgcOHPB0SAAAwCIOHz4su90um+3icigmJkaSdOjQoQbPq6ysVFFRkaKjo+vti4mJUXFxsWPIaXOcO3dOX3zxhQzDUHBwsK677jp1796db4sBAMCFLPkxmeDgYE2ePFmDBg1SaGioCgoKtGLFCt1+++1avXq14uLi6p2TkJBw2WueOnWqUccBAOBLTp065bX/E15aWqqoqKh620NCQhz7G1JWVibDMBzHXSg0NNRxblhYWL39ja1H5s6dK5vNxoBUAADknnrEks2QPn36qE+fPo5/JyQkaMSIEbrpppu0dOlSrVy50nPB4WfVFXrBwcEejsT7kWtzkW/zkGtzGYbh6RDc5nKF1c8VXe5sErVq1cpt18Z5/B0xD7k2D7k2F/k2l6vrEUs2Qxpy9dVXa/jw4Xr33Xcb3L979+7Lnl/3pObnjoPzyLV5yLW5yLd5yLV5vPmNydDQ0Abf/igrK5OkBt/8qNvu5+fX4Ll12+reEPkp6pGWg1ybh1ybh1ybi3ybxx31iKVnhvxUbW2tp0MAAAAWYbfbVVBQUK9+qJsV0tBMEElq06aNIiMjG5wpcujQIXXo0KHBj8gAAICWw2uaISdOnFBeXh5ftQsAABpl1KhRKi8vr/dWaW5urrp16ya73X7Jc1NTU5WXl6cTJ044tpWWlmrr1q2Or+kFAAAtlyU/JjNr1ixFRkaqb9++uuKKK1RYWKjnn39elZWVmjlzpqfDAwAAFpCcnKzBgwcrMzNTpaWlioiIUG5urvbs2aPs7GzHcZMmTdLOnTt18OBBx7a7775br7/+utLT05WRkaGAgADl5OQoICBAU6ZM8cSPAwAAmsCSzZCYmBht3LhRq1ev1pkzZxQaGqpBgwZp6tSpl3ylFQAA4EJ+fn7Kzs7WkiVLtHTpUpWXl8tut2v58uUaMWLEZc+96qqr9PLLL2vhwoV66KGHZBiGBg4cqNWrV6tz584m/QQAAKC5LNkMSU9PV3p6uqfDAAAAFte+fXvNmzdP8+bNu+QxL730UoPbo6KilJOT467QAACAG3nNzBAAAAAAAIDGoBkCAAAAAAB8ip9hGIangwAAAAAAADALb4YAAAAAAACfQjMEAAAAAAD4FJohAAAAAADAp3h9M6SiokJZWVkaPny4YmNjNW7cOL3zzjuNOreoqEj33nuvBg4cqPj4eP32t7/Vl19+6eaIrau5uV6zZo2mTJmilJQUxcbGKi0tTVlZWSopKTEhamty5ve6jmEYuvPOOxUTE6P58+e7KVLv4Ey+DcPQ3/72N40bN05xcXFKSEjQrbfeqr1797o5amtyJtdvvvmmxo8fr8TERCUmJuq2227Tpk2b3ByxdR07dkxZWVm6/fbbFR8fr5iYGOXn5zf6fO6RTUM9Yh7qEfNQj5iHWsRc1CPm8WQ94vXNkGnTpmnDhg2677779Nxzz8lut2vatGl6//33L3tecXGx7rjjDn333XdauHChlixZorKyMk2cOFHHjh0zKXpraW6un3nmGbVv314zZ87UX/7yF9111136xz/+oVtuuUXl5eUmRW8tzc31hV577TUVFha6MUrv4Uy+MzMztWjRIqWlpWnFihVavHixkpKSdObMGRMit57m5nr9+vWaMWOGOnbsqMWLF2vx4sXq1KmTHnjgAa1du9ak6K3lm2++0caNGxUUFKQhQ4Y06VzukU1HPWIe6hHzUI+Yh1rEXNQj5vFoPWJ4sffee8+Ijo423nrrLce22tpaY/z48cYNN9xw2XMXLlxo9O/f3zh27JhjW0lJiREfH2/MmzfPbTFblTO5/uGHH+pty8/PN6Kjo41Vq1a5PFarcybXdY4dO2YMHDjQ2Lx5sxEdHW1kZWW5K1zLcybfmzdvNnr16mXs3bvX3WF6BWdyPXHiRCMlJcWoqalxbKupqTFSUlKMiRMnui1mK7swV1u2bDGio6ONHTt2NOpc7pFNQz1iHuoR81CPmIdaxFzUI+byZD3i1W+GbNmyRcHBwRo5cqRjm5+fn8aOHavCwsLLvj7z9ttva9iwYerUqZNj25VXXqmUlBRt2bLFrXFbkTO5DgsLq7etf//+ksRTrwY4k+s6jz76qBISEjR69Gh3huoVnMn36tWrlZCQoPj4eDNCtTxnch0QEKCgoCDZbP+5rdlsNgUFBSkwMNCtcVvVhblqKu6RTUM9Yh7qEfNQj5iHWsRc1CPm8mQ94tXNkMOHD8tut9dLcExMjCTp0KFDDZ5XWVmpoqIiRUdH19sXExOj4uJiFRcXuz5gC2turi9lx44dkqSePXu6JkAv4myu33jjDeXn5+vRRx91W4zepLn5rq6u1r59+xQTE6MlS5Zo2LBh6tOnj8aMGaP169e7PW4rcuZ3e8KECSooKFBOTo5KSkpUUlKinJwcffXVV5o8ebJb4/Y13CObjnrEPNQj5qEeMQ+1iLmoR6zBFffIAHcF1xKUlpYqKiqq3vaQkBDH/oaUlZXJMAzHcRcKDQ11nNvQEwRf1dxcX+paWVlZioqK0o033uiiCL2HM7kuKSnR/Pnz9cADD+iaa65xU4Tepbn5Li0tVVVVldavX6/w8HD9/ve/1xVXXKG1a9fq4YcfVnV1tW699VY3Rm49zvxup6amKicnRw8++KD++Mc/SpKCgoL0pz/9SUlJSW6I1ndxj2w66hHzUI+Yh3rEPNQi5qIesQZX3CO9uhkinX+lqTn7GrMfF3Mm13XOnDmjjIwMlZWVafXq1bxOdgnNzfX8+fMVERGhiRMnuiMsr9WcfNfW1kqSzp49qxUrVqhLly6SpGHDhunbb7/Vn//8ZwqQBjT3d/vDDz/UrFmzNGbMGI0ePVo1NTXasGGDZs6cqWeeeUbXX3+9G6L1bdwjm4Z6xDzUI+ahHjEPtYi5qEesw5l7pFc3Q0JDQxvs3JWVlUlSg12kuu1+fn4Nnlu3ra7bhPOam+sLVVZWaurUqfrss8/0wgsvqFevXq4O0ys0N9cffvihNm3apBdffFGnT5++aF9VVZXKy8sVFBSkgACv/rPQZM7+Henevbuj+JDO/8G+7rrrlJ2dreLiYp7oXqC5uTYMQ3PmzNGQIUP0+OOPO7YnJSXp2LFjeuKJJyg+XIh7ZNNRj5iHesQ81CPmoRYxF/WINbjiHunVM0PsdrsKCgocXdE6dZ/zaujzRZLUpk0bRUZGNvh5sEOHDqlDhw780fiJ5ua6ztmzZ3Xvvfdq3759eu6553Tttde6LVara26uDx8+rNraWk2aNMnxveeJiYmSpFdffVWJiYnKy8tzb/AW5MzfkV/84hcN7jMMQxJPe3+qubn+4YcfdOLECfXr16/evn79+unIkSM6e/as6wP2Udwjm456xDzUI+ahHjEPtYi5qEeswRX3SK9uhowaNUrl5eV69913L9qem5urbt26yW63X/Lc1NRU5eXl6cSJE45tpaWl2rp1q0aNGuW2mK3KmVxXVVXp3nvv1e7du5Wdna1Bgwa5O1xLa26ub7jhBq1ataref5I0evRorVq1SrGxsW6P32qc+d0eNWqUCgsLdeTIEcc2wzD0wQcfKDIyUh06dHBb3FbU3FyHhISodevW+uSTT+rt+/jjjxUaGqrWrVu7JWZfxT2yaahHzEM9Yh7qEfNQi5iLesQ6nL1HevX7Z8nJyRo8eLAyMzNVWlqqiIgI5ebmas+ePcrOznYcN2nSJO3cuVMHDx50bLv77rv1+uuvKz09XRkZGQoICFBOTo4CAgI0ZcoUT/w4LZozuZ4xY4a2bdumjIwMBQUFad++fY59HTp0UNeuXc38UVq85uY6PDxc4eHhDV6zU6dOGjx4sCnxW42zf0c2bNige+65R9OmTVNwcLDWrVunTz/9VEuXLvXEj9OiNTfXgYGBGj9+vF588UVlZmZq9OjRqq2tdZx7//33e+gnavk2b94sSdq/f78kadeuXTp58qTatm2r5ORkSdwjXYF6xDzUI+ahHjEPtYi5qEfM56l6xM+oe0fKS50+fVpLlizRm2++qfLyctntdmVkZCg1NdVxTEOJlaSvv/5aCxcuVH5+vgzD0MCBAzVnzhy+Xu0Smpvruq+pasjYsWO1YMECt8ZtRc78Xv9UTEyM7rzzTmVmZro7bMtyJt9HjhzRU089pe3bt6uyslLR0dGaOnXqRefiP5qb65qaGq1Zs0avvfaaioqKZLPZFBUVpQkTJuiXv/wlrwFfwqX+/nbp0sXxRIx7pGtQj5iHesQ81CPmoRYxF/WIuTxVj3h9MwQAAAAAAOBCXj0zBAAAAAAA4KdohgAAAAAAAJ9CMwQAAAAAAPgUmiEAAAAAAMCn0AwBAAAAAAA+hWYIAAAAAADwKTRDAAAAAACAT6EZAgAAAAAAfArNEADNVllZqaSkJF1//fWqqqq6aF9mZqZ69+6tjRs3umXtefPmKSYmRsePH6+3r7CwUP369VNWVpZb1gYAAABgbTRDADRbmzZtNH36dH3//fd65ZVXHNuffvpprV27VnPnztWYMWPcsnZ8fLwkaf/+/fX2Pfnkk2rXrp2mT5/ulrUBAIB38OSDHQCeRTMEgFPGjRunnj176rnnnlNFRYVWrlypFStWaPr06ZowYYLb1o2Li5MkffLJJxdtf++99/TBBx9oxowZCgkJcdv6AADA+jz5YAeAZ/kZhmF4OggA1rZ161ZNmTJFQ4cO1Y4dOzRx4kTNnTvX7esOHjxYvXv31sqVKyVJ1dXVuummmxQYGKjc3Fz5+/u7PQYAAGBtNTU1uvnmm1VcXKy3335ba9as0ZNPPqnp06dr2rRpng4PgJvwZggAp6WkpKhv377avn27brzxRmVmZtY75uWXX9Ytt9yi/v37a9KkSS5ZNy4uTgcOHFBdT3fVqlX6+uuv9cgjjzgaIe5YFwAAeA9/f3/NmjVLJSUlysjI0IIFCzRp0iQaIYCXoxkCwGmbNm3S559/Lklq166d/Pz86h1z9dVXKz09XXfddZfL1o2Li9OpU6dUWFio4uJiZWdnKzU1VUOHDnXrugAAwLt46sEOAM8J8HQAAKxt27ZteuihhzRq1CgFBARo3bp1uuuuu9SjR4+LjktLS5MkHT161GVrXzhEddeuXaqqqtLDDz/s9nUBAIB3acqDnf3792vfvn0mRwjA1XgzBECzffzxx5o+fbquvfZaLV68WPfff79sNpuefvppU9aPjY2VzWbT2rVr9fe//12TJ09WZGSkKWsDAADvcOGDnTFjxmjdunUqKCiod1xaWprS0tIUFhbmgSgBuBrNEADNUlBQoPT0dEVFRSk7O1uBgYHq2rWrfvWrX+mdd97Rnj17mnzNESNGKCYmptHHt2/fXna7Xbt27VJYWJimTJnS5DUBAIDv8vSDHQCeQzMEQJMdPXpUv/nNbxQcHKznn39e7du3d+zLyMhQmzZttGjRoiZft6KiQh07dmzSOf3795ckzZw586I4AAAALscdD3YAWAczQwA0WefOnfX+++83uK9jx476+OOPm3zNL774QqWlpfrDH/7Q6HOqq6u1c+dO9evXT2PHjm3ymgAAwDf93IOd3NxcLVq0SK+++qoHowTgTjRDAJji3LlzqqmpUU1NjWpra3X27Fn5+fkpMDBQ0vnP6/bq1atJTY2//vWvOnLkiBYvXtzgoLPGrAsAAHyPOx7sALAWmiEATJGTk6Ply5c7/h0bG6tBgwbppZdekiTdc889uueee372OqWlpdq2bZsOHjyoF154Qb/+9a81YMCAZq8LAADQGDxgAbyLn2EYhqeDAIDGeuONNzRr1iyFhYXp5ptv1uzZs+Xv7+/psAAAgJdbtmzZRQ9YJPGABbAwmiEAAAAAAMCn8G0yAAAAAADAp9AMAQAAAAAAPoVmCAAAAAAA8Ck0QwAAAAAAgE+hGQIAAAAAAHwKzRAAAAAAAOBTaIYAAAAAAACfQjMEAAAAAAD4lP8P7GThl7GNhTsAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1177,12 +1137,12 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "# rust\n", - "from feos_core.cubic import PengRobinson, State as StateR, PengRobinsonParameters, PhaseDiagram as PhaseDiagramR\n", + "from feos_core.cubic import PengRobinson, State as StateR, PengRobinsonParameters, PhaseDiagramPure as PhaseDiagramPureR\n", "eos_rust = PengRobinson(PengRobinsonParameters.from_json([\"propane\"], \"peng-robinson.json\"))\n", "\n", "# python\n", @@ -1195,7 +1155,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -1206,7 +1166,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -1218,7 +1178,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -1226,7 +1186,7 @@ "output_type": "stream", "text": [ "Critical point for pure substance\n", - "Python implementation is slower by a factor of 40.\n" + "Python implementation is slower by a factor of 34.\n" ] } ], @@ -1238,28 +1198,28 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_7165/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", + "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_81996/2221081275.py:65: RuntimeWarning: invalid value encountered in log\n", " return n * (np.log(v / (v - b * n)) - ak_mix / (b * SQRT2 * 2.0 * state.temperature)\n", - "/tmp/ipykernel_7165/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", + "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_81996/2221081275.py:66: RuntimeWarning: invalid value encountered in log\n", " * np.log((v * (SQRT2 - 1.0) + b * n) / (v * (SQRT2 + 1.0) - b * n)))\n" ] } ], "source": [ - "time_python = timeit.timeit(lambda: PhaseDiagram.pure(eos_python, 250*KELVIN, 100), number=100) * MILLI * SECOND\n", - "time_rust = timeit.timeit(lambda: PhaseDiagramR.pure(eos_rust, 250*KELVIN, 100), number=100) * MILLI * SECOND" + "time_python = timeit.timeit(lambda: PhaseDiagramPure(eos_python, 250*KELVIN, 100), number=100) * MILLI * SECOND\n", + "time_rust = timeit.timeit(lambda: PhaseDiagramPureR(eos_rust, 250*KELVIN, 100), number=100) * MILLI * SECOND" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -1267,7 +1227,7 @@ "output_type": "stream", "text": [ "Phase diagram for pure substance\n", - "Python implementation is slower by a factor of 21.\n" + "Python implementation is slower by a factor of 16.\n" ] } ], @@ -1276,13 +1236,6 @@ "print(f\"Phase diagram for pure substance\")\n", "print(f\"Python implementation is {'slower' if rel_dev < 0 else 'faster'} by a factor of {abs(time_python / time_rust):.0f}.\")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/src/errors.rs b/src/errors.rs index c8542c9..9561d5c 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -22,7 +22,7 @@ pub enum EosError { SuperCritical, #[error("No phase split according to stability analysis.")] NoPhaseSplit, - #[error("Wrong input units. Expected: {0}, got {1}")] + #[error("Wrong input units. Expected {0}, got {1}")] WrongUnits(String, String), #[error(transparent)] QuantityError(#[from] QuantityError), diff --git a/src/python/state.rs b/src/python/state.rs index d4aa5e3..8eed471 100644 --- a/src/python/state.rs +++ b/src/python/state.rs @@ -182,56 +182,16 @@ macro_rules! impl_state { )?)) } - /// Create a thermodynamic state at critical conditions for a binary system - /// with given temperature. + /// Create a thermodynamic state at critical conditions for a binary system. /// /// Parameters /// ---------- /// eos: Eos /// The equation of state to use. - /// temperature: SINumber - /// temperature. - /// initial_molefracs: [float], optional - /// An initial guess for the composition. - /// max_iter : int, optional - /// The maximum number of iterations. - /// tol: float, optional - /// The solution tolerance. - /// verbosity : Verbosity, optional - /// The verbosity. - /// - /// Returns - /// ------- - /// State : State at critical conditions. - #[staticmethod] - #[pyo3(text_signature = "(eos, temperature, initial_molefracs=None, max_iter=None, tol=None, verbosity=None)")] - fn critical_point_binary_t( - eos: $py_eos, - temperature: PySINumber, - initial_molefracs: Option<[f64; 2]>, - max_iter: Option, - tol: Option, - verbosity: Option, - ) -> PyResult { - Ok(PyState(State::critical_point_binary_t( - &eos.0, - temperature.into(), - initial_molefracs, - (max_iter, tol, verbosity).into(), - )?)) - } - - /// Create a thermodynamic state at critical conditions for a binary system - /// with given pressure. - /// - /// Parameters - /// ---------- - /// eos: Eos - /// The equation of state to use. - /// pressure: SINumber - /// pressure. + /// temperature_or_pressure: SINumber + /// temperature_or_pressure. /// initial_temperature: SINumber, optional - /// The initial temperature. + /// An initial guess for the temperature. /// initial_molefracs: [float], optional /// An initial guess for the composition. /// max_iter : int, optional @@ -245,19 +205,19 @@ macro_rules! impl_state { /// ------- /// State : State at critical conditions. #[staticmethod] - #[pyo3(text_signature = "(eos, pressure, initial_temperature=None, initial_molefracs=None, max_iter=None, tol=None, verbosity=None)")] - fn critical_point_binary_p( + #[pyo3(text_signature = "(eos, temperature_or_pressure, initial_molefracs=None, max_iter=None, tol=None, verbosity=None)")] + fn critical_point_binary( eos: $py_eos, - pressure: PySINumber, + temperature_or_pressure: PySINumber, initial_temperature: Option, initial_molefracs: Option<[f64; 2]>, max_iter: Option, tol: Option, verbosity: Option, ) -> PyResult { - Ok(PyState(State::critical_point_binary_p( + Ok(PyState(State::critical_point_binary( &eos.0, - pressure.into(), + temperature_or_pressure.into(), initial_temperature.map(|t| t.into()), initial_molefracs, (max_iter, tol, verbosity).into(), diff --git a/src/state/critical_point.rs b/src/state/critical_point.rs index 6690c56..5676171 100644 --- a/src/state/critical_point.rs +++ b/src/state/critical_point.rs @@ -176,7 +176,7 @@ impl State { } /// Calculate the critical point of a binary system for given temperature. - pub fn critical_point_binary_t( + fn critical_point_binary_t( eos: &Rc, temperature: QuantityScalar, initial_molefracs: Option<[f64; 2]>, @@ -261,7 +261,7 @@ impl State { } /// Calculate the critical point of a binary system for given pressure. - pub fn critical_point_binary_p( + fn critical_point_binary_p( eos: &Rc, pressure: QuantityScalar, initial_temperature: Option>, diff --git a/src/state/mod.rs b/src/state/mod.rs index e22227a..77cb130 100644 --- a/src/state/mod.rs +++ b/src/state/mod.rs @@ -803,7 +803,7 @@ where Ok(Self::Pressure(quantity)) } else { Err(EosError::WrongUnits( - "K or bar".into(), + "temperature or pressure".into(), format!("{}", quantity), )) } From 453201ef4ef6c3a8f834963eab59a7aaa354fdb2 Mon Sep 17 00:00:00 2001 From: Philipp Rehner Date: Mon, 21 Mar 2022 15:56:38 +0100 Subject: [PATCH 3/4] move StateVec to state module and fix some documentation issues --- src/lib.rs | 4 +- src/phase_equilibria/mod.rs | 2 +- src/phase_equilibria/phase_diagram_binary.rs | 2 - src/phase_equilibria/phase_diagram_pure.rs | 78 +------------------- src/phase_equilibria/vle_pure.rs | 2 +- src/python/phase_equilibria.rs | 36 ++++----- src/state/mod.rs | 2 +- src/state/properties.rs | 72 ++++++++++++++++++ 8 files changed, 98 insertions(+), 100 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index d66bf43..45e16b1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -40,9 +40,9 @@ pub use equation_of_state::{ }; pub use errors::{EosError, EosResult}; pub use phase_equilibria::{ - PhaseDiagram, PhaseDiagramHetero, PhaseEquilibrium, SolverOptions, StateVec, Verbosity, + PhaseDiagram, PhaseDiagramHetero, PhaseEquilibrium, SolverOptions, Verbosity, }; -pub use state::{Contributions, DensityInitialization, State, StateBuilder, StateHD}; +pub use state::{Contributions, DensityInitialization, State, StateBuilder, StateHD, StateVec}; #[cfg(feature = "python")] pub mod python; diff --git a/src/phase_equilibria/mod.rs b/src/phase_equilibria/mod.rs index ff67f48..a98efe6 100644 --- a/src/phase_equilibria/mod.rs +++ b/src/phase_equilibria/mod.rs @@ -14,7 +14,7 @@ mod stability_analysis; mod tp_flash; mod vle_pure; pub use phase_diagram_binary::PhaseDiagramHetero; -pub use phase_diagram_pure::{PhaseDiagram, StateVec}; +pub use phase_diagram_pure::PhaseDiagram; /// Level of detail in the iteration output. #[derive(Copy, Clone, PartialOrd, PartialEq)] diff --git a/src/phase_equilibria/phase_diagram_binary.rs b/src/phase_equilibria/phase_diagram_binary.rs index 8cc2462..41a9d5d 100644 --- a/src/phase_equilibria/phase_diagram_binary.rs +++ b/src/phase_equilibria/phase_diagram_binary.rs @@ -161,8 +161,6 @@ impl PhaseDiagram { let mut states = Vec::with_capacity(npoints); let tp: TPSpec = temperature_or_pressure.try_into()?; - // let feed = arr1(&[x_feed, 1.0 - x_feed]) * U::reference_moles(); - let tp_vec = QuantityArray1::linspace(min_tp, max_tp, npoints)?; let mut vle = None; for i in 0..npoints { diff --git a/src/phase_equilibria/phase_diagram_pure.rs b/src/phase_equilibria/phase_diagram_pure.rs index 9197ec6..dbc27f0 100644 --- a/src/phase_equilibria/phase_diagram_pure.rs +++ b/src/phase_equilibria/phase_diagram_pure.rs @@ -1,10 +1,10 @@ use super::{PhaseEquilibrium, SolverOptions}; -use crate::equation_of_state::{EquationOfState, MolarWeight}; +use crate::equation_of_state::EquationOfState; use crate::errors::EosResult; -use crate::state::{Contributions, State}; +use crate::state::{State, StateVec}; use crate::EosUnit; use ndarray::prelude::*; -use quantity::{QuantityArray1, QuantityScalar}; +use quantity::QuantityScalar; use std::rc::Rc; /// Pure component and binary mixture phase diagrams. @@ -67,75 +67,3 @@ impl PhaseDiagram { } } } - -/// A list of states for a simple access to properties -/// of multiple states. -pub struct StateVec<'a, U, E> { - pub states: Vec<&'a State>, -} - -impl<'a, U: EosUnit, E: EquationOfState> StateVec<'a, U, E> { - pub fn temperature(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].temperature) - } - - pub fn pressure(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| { - self.states[i].pressure(Contributions::Total) - }) - } - - pub fn compressibility(&self) -> Array1 { - Array1::from_shape_fn(self.states.len(), |i| { - self.states[i].compressibility(Contributions::Total) - }) - } - - pub fn density(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].density) - } - - pub fn molefracs(&self) -> Array2 { - Array2::from_shape_fn( - (self.states.len(), self.states[0].eos.components()), - |(i, j)| self.states[i].molefracs[j], - ) - } - - pub fn molar_enthalpy(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| { - self.states[i].molar_enthalpy(Contributions::Total) - }) - } - - pub fn molar_entropy(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| { - self.states[i].molar_entropy(Contributions::Total) - }) - } -} - -impl<'a, U: EosUnit, E: EquationOfState + MolarWeight> StateVec<'a, U, E> { - pub fn mass_density(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].mass_density()) - } - - pub fn massfracs(&self) -> Array2 { - Array2::from_shape_fn( - (self.states.len(), self.states[0].eos.components()), - |(i, j)| self.states[i].massfracs()[j], - ) - } - - pub fn specific_enthalpy(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| { - self.states[i].specific_enthalpy(Contributions::Total) - }) - } - - pub fn specific_entropy(&self) -> QuantityArray1 { - QuantityArray1::from_shape_fn(self.states.len(), |i| { - self.states[i].specific_entropy(Contributions::Total) - }) - } -} diff --git a/src/phase_equilibria/vle_pure.rs b/src/phase_equilibria/vle_pure.rs index c675a0c..db8b0cd 100644 --- a/src/phase_equilibria/vle_pure.rs +++ b/src/phase_equilibria/vle_pure.rs @@ -420,7 +420,7 @@ impl PhaseEquilibrium { } /// Calculate the pure component phase equilibria of all - /// components in the system for the given temperature. + /// components in the system. pub fn vle_pure_comps( eos: &Rc, temperature_or_pressure: QuantityScalar, diff --git a/src/python/phase_equilibria.rs b/src/python/phase_equilibria.rs index 11e2b9b..458b829 100644 --- a/src/python/phase_equilibria.rs +++ b/src/python/phase_equilibria.rs @@ -13,8 +13,8 @@ macro_rules! impl_phase_equilibrium { /// /// Parameters /// ---------- - /// eos : Saft - /// The SAFT equation of state. + /// eos : $py_eos + /// The equation of state. /// temperature_or_pressure : SINumber /// The system temperature or pressure. /// initial_state : PhaseEquilibrium, optional @@ -60,8 +60,8 @@ macro_rules! impl_phase_equilibrium { /// /// Parameters /// ---------- - /// eos : Saft - /// The SAFT equation of state. + /// eos : $py_eos + /// The equation of state. /// temperature : SINumber /// The system temperature. /// pressure : SINumber @@ -114,8 +114,8 @@ macro_rules! impl_phase_equilibrium { /// /// Parameters /// ---------- - /// eos : Saft - /// The SAFT equation of state. + /// eos : $py_eos + /// The equation of state. /// temperature_or_pressure : SINumber /// The system temperature_or_pressure. /// liquid_molefracs : numpy.ndarray @@ -173,8 +173,8 @@ macro_rules! impl_phase_equilibrium { /// /// Parameters /// ---------- - /// eos : Saft - /// The SAFT equation of state. + /// eos : $py_eos + /// The equation of state. /// temperature_or_pressure : SINumber /// The system temperature or pressure. /// vapor_molefracs : numpy.ndarray @@ -257,8 +257,8 @@ macro_rules! impl_phase_equilibrium { /// /// Parameters /// ---------- - /// eos : Saft - /// The SAFT equation of state. + /// eos : $py_eos + /// The equation of state. /// temperature_or_pressure : SINumber /// The system temperature or pressure. /// @@ -279,8 +279,8 @@ macro_rules! impl_phase_equilibrium { /// /// Parameters /// ---------- - /// eos : Saft - /// The SAFT equation of state. + /// eos : $py_eos + /// The equation of state. /// temperature : SINumber /// The system temperature. /// @@ -301,8 +301,8 @@ macro_rules! impl_phase_equilibrium { /// /// Parameters /// ---------- - /// eos : Saft - /// The SAFT equation of state. + /// eos : $py_eos + /// The equation of state. /// pressure : SINumber /// The system pressure. /// @@ -339,8 +339,8 @@ macro_rules! impl_phase_equilibrium { /// /// Parameters /// ---------- - /// eos : Saft - /// The SAFT equation of state. + /// eos : $py_eos + /// The equation of state. /// temperature_or_pressure : SINumber /// The system temperature or pressure. /// x_init : list[float] @@ -558,7 +558,7 @@ macro_rules! impl_phase_equilibrium { /// /// Parameters /// ---------- - /// eos: $eos + /// eos : $py_eos /// The equation of state. /// temperature_or_pressure: SINumber /// The constant temperature or pressure. @@ -616,7 +616,7 @@ macro_rules! impl_phase_equilibrium { /// /// Parameters /// ---------- - /// eos: $eos + /// eos : $py_eos /// The equation of state. /// temperature_or_pressure: SINumber /// The consant temperature or pressure. diff --git a/src/state/mod.rs b/src/state/mod.rs index 77cb130..86678f5 100644 --- a/src/state/mod.rs +++ b/src/state/mod.rs @@ -24,7 +24,7 @@ mod builder; mod cache; mod properties; pub use builder::StateBuilder; -pub use properties::Contributions; +pub use properties::{Contributions, StateVec}; /// Initial values in a density iteration. #[derive(Clone, Copy)] diff --git a/src/state/properties.rs b/src/state/properties.rs index 1da2814..3177e20 100644 --- a/src/state/properties.rs +++ b/src/state/properties.rs @@ -706,3 +706,75 @@ impl> State { .thermal_conductivity_reference(self.temperature, self.volume, &self.moles) } } + +/// A list of states for a simple access to properties +/// of multiple states. +pub struct StateVec<'a, U, E> { + pub states: Vec<&'a State>, +} + +impl<'a, U: EosUnit, E: EquationOfState> StateVec<'a, U, E> { + pub fn temperature(&self) -> QuantityArray1 { + QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].temperature) + } + + pub fn pressure(&self) -> QuantityArray1 { + QuantityArray1::from_shape_fn(self.states.len(), |i| { + self.states[i].pressure(Contributions::Total) + }) + } + + pub fn compressibility(&self) -> Array1 { + Array1::from_shape_fn(self.states.len(), |i| { + self.states[i].compressibility(Contributions::Total) + }) + } + + pub fn density(&self) -> QuantityArray1 { + QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].density) + } + + pub fn molefracs(&self) -> Array2 { + Array2::from_shape_fn( + (self.states.len(), self.states[0].eos.components()), + |(i, j)| self.states[i].molefracs[j], + ) + } + + pub fn molar_enthalpy(&self) -> QuantityArray1 { + QuantityArray1::from_shape_fn(self.states.len(), |i| { + self.states[i].molar_enthalpy(Contributions::Total) + }) + } + + pub fn molar_entropy(&self) -> QuantityArray1 { + QuantityArray1::from_shape_fn(self.states.len(), |i| { + self.states[i].molar_entropy(Contributions::Total) + }) + } +} + +impl<'a, U: EosUnit, E: EquationOfState + MolarWeight> StateVec<'a, U, E> { + pub fn mass_density(&self) -> QuantityArray1 { + QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].mass_density()) + } + + pub fn massfracs(&self) -> Array2 { + Array2::from_shape_fn( + (self.states.len(), self.states[0].eos.components()), + |(i, j)| self.states[i].massfracs()[j], + ) + } + + pub fn specific_enthalpy(&self) -> QuantityArray1 { + QuantityArray1::from_shape_fn(self.states.len(), |i| { + self.states[i].specific_enthalpy(Contributions::Total) + }) + } + + pub fn specific_entropy(&self) -> QuantityArray1 { + QuantityArray1::from_shape_fn(self.states.len(), |i| { + self.states[i].specific_entropy(Contributions::Total) + }) + } +} From 2c2df6a18724e17a044a09c9edfb028db154fda5 Mon Sep 17 00:00:00 2001 From: Philipp Rehner Date: Fri, 25 Mar 2022 19:15:35 +0100 Subject: [PATCH 4/4] add FromIterator implementation to StateVec --- src/phase_equilibria/phase_diagram_pure.rs | 8 ++------ src/state/properties.rs | 9 +++++++++ 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/src/phase_equilibria/phase_diagram_pure.rs b/src/phase_equilibria/phase_diagram_pure.rs index dbc27f0..ab2067d 100644 --- a/src/phase_equilibria/phase_diagram_pure.rs +++ b/src/phase_equilibria/phase_diagram_pure.rs @@ -55,15 +55,11 @@ impl PhaseDiagram { /// Return the vapor states of the diagram. pub fn vapor(&self) -> StateVec<'_, U, E> { - StateVec { - states: self.states.iter().map(|s| s.vapor()).collect(), - } + self.states.iter().map(|s| s.vapor()).collect() } /// Return the liquid states of the diagram. pub fn liquid(&self) -> StateVec<'_, U, E> { - StateVec { - states: self.states.iter().map(|s| s.liquid()).collect(), - } + self.states.iter().map(|s| s.liquid()).collect() } } diff --git a/src/state/properties.rs b/src/state/properties.rs index 3177e20..b56cf73 100644 --- a/src/state/properties.rs +++ b/src/state/properties.rs @@ -5,6 +5,7 @@ use crate::EosUnit; use ndarray::{Array1, Array2}; use num_dual::DualNum; use quantity::{QuantityArray, QuantityArray1, QuantityArray2, QuantityScalar}; +use std::iter::FromIterator; use std::ops::{Add, Sub}; #[derive(Clone, Copy)] @@ -713,6 +714,14 @@ pub struct StateVec<'a, U, E> { pub states: Vec<&'a State>, } +impl<'a, U, E> FromIterator<&'a State> for StateVec<'a, U, E> { + fn from_iter>>(iter: I) -> Self { + Self { + states: iter.into_iter().collect(), + } + } +} + impl<'a, U: EosUnit, E: EquationOfState> StateVec<'a, U, E> { pub fn temperature(&self) -> QuantityArray1 { QuantityArray1::from_shape_fn(self.states.len(), |i| self.states[i].temperature)