From 21e6789a66d616c961e540a58427279f17763ed8 Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Thu, 22 Dec 2022 15:53:10 +0100 Subject: [PATCH 01/14] implementation uvb3-theory --- examples/uvtheory_versions.ipynb | 653 ++++++++++++++++++ .../eos/attractive_perturbation_uvb3.rs | 522 ++++++++++++++ src/uvtheory/eos/hard_sphere_wca.rs | 113 ++- src/uvtheory/eos/mod.rs | 113 ++- .../eos/reference_perturbation_uvb3.rs | 104 +++ src/uvtheory/mod.rs | 2 +- src/uvtheory/python.rs | 3 +- 7 files changed, 1450 insertions(+), 60 deletions(-) create mode 100644 examples/uvtheory_versions.ipynb create mode 100644 src/uvtheory/eos/attractive_perturbation_uvb3.rs create mode 100644 src/uvtheory/eos/reference_perturbation_uvb3.rs diff --git a/examples/uvtheory_versions.ipynb b/examples/uvtheory_versions.ipynb new file mode 100644 index 000000000..ed6a6f72a --- /dev/null +++ b/examples/uvtheory_versions.ipynb @@ -0,0 +1,653 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from feos.si import *\n", + "from feos.uvtheory import UVParameters, Perturbation\n", + "from feos.pets import PetsParameters\n", + "from feos.eos import State, PhaseEquilibrium, PhaseDiagram, EquationOfState, Contributions\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Thol EoS for Comparison**" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Parameters for Thol EoS:\n", + "A = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0,\n", + " 2.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0])\n", + "N = np.array([0.005208073, 2.186252000, -2.161016000, 1.452700000, -2.041792000, 0.186952860, -0.090988445, \n", + " -0.497456100, 0.109014310, -0.800559220, -0.568839000, -0.620862500, -1.466717700, 1.891469000, \n", + " -0.138370100, -0.386964500, 0.126570200, 0.605781000, 1.179189000, -0.477326790, -9.921857500, -0.574793200, 0.003772923])\n", + "T = np.array([1.000, 0.320, 0.505, 0.672, 0.843, 0.898, 1.294, 2.590, 1.786, 2.770, 1.786,\n", + " 1.205, 2.830, 2.548, 4.650, 1.385, 1.460, 1.351, 0.660, 1.496, 1.830, 1.616, 4.970])\n", + "D = np.array([4.0, 1.0, 1.0, 2.0, 2.0, 3.0, 5.0, 2.0, 2.0, 3.0, 1.0,\n", + " 1.0, 1.0, 1.0, 2.0, 3.0, 3.0, 2.0, 1.0, 2.0, 3.0, 1.0, 1.0])\n", + "L = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 1.0, 2.0, 2.0,\n", + " 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])\n", + "ETA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2.067, 1.522,\n", + " 8.82, 1.722, 0.679, 1.883, 3.925, 2.461, 28.2, 0.753, 0.82])\n", + "BETA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.625,\n", + " 0.638, 3.91, 0.156, 0.157, 0.153, 1.16, 1.73, 383, 0.112, 0.119])\n", + "GAMMA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.71,\n", + " 0.86, 1.94, 1.48, 1.49, 1.945, 3.02, 1.11, 1.17, 1.33, 0.24])\n", + "EPSILON = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.2053,\n", + " 0.409, 0.6, 1.203, 1.829, 1.397, 1.39, 0.539, 0.934, 2.369, 2.43])\n", + "\n", + "class Thol:\n", + " def __init__(self, sigma, eps_k):\n", + " self.sigma = sigma * ANGSTROM\n", + " self.eps_k = eps_k * KELVIN\n", + " self.tc = 1.32 * self.eps_k / KELVIN\n", + " self.rhoc = 0.31 / self.sigma**3 * ANGSTROM**3\n", + " \n", + " def components(self): \n", + " return 1\n", + " \n", + " def subset(self, components):\n", + " return self\n", + " \n", + " def molar_weight(self):\n", + " return np.array([1.0])\n", + " \n", + " def max_density(self, moles):\n", + " return 0.04\n", + " \n", + " def helmholtz_energy(self, state):\n", + " \"\"\"\n", + " state (StateHD):\n", + " temperature in Kelvin als Float, Dual oder HD oder HD3, HDD, HDD3,\n", + " partial_density in # / Angstrom^3\n", + " volume in Angstrom^3\n", + " moles in mol\n", + " \"\"\"\n", + " tau = self.tc / state.temperature\n", + " delta = np.sum(state.partial_density) / self.rhoc\n", + " a = 0.0 #zero(state)\n", + " \n", + " # print(\"v\", state.volume)\n", + " # print(\"n\", state.moles)\n", + " #print(\"partial density\", state.partial_density)\n", + " #print(\"1\")\n", + " # print(\"delta: {}\".format(delta))\n", + " # print(\"tau: {}\".format(tau))\n", + " \n", + " for i in range(6):\n", + " a = a + N[i] * delta**D[i] * tau**T[i]\n", + " \n", + " # print(\"2\")\n", + " for i in range(6, 12):\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", + " # print(\"3\")\n", + " for i in range(12, 23):\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n", + " return a * np.sum(state.moles)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Class for dimensionless evaluation of LJ / Mie EoS**" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "class EOS_PROPERTIES():\n", + " def __init__(self, eos, sigma=3.7039, eps_k=150.03, rep=12, att=6.0):\n", + " \"\"\"Python class for the dimensionless evaluation of pure Mie-nu-6 EoS\n", + " Input: EquationOfState from feos,\n", + " Optional: diameter sigma, eps / kB, repulsive exponent rep, attractive exponent att\n", + " \"\"\"\n", + " self.sigma = sigma\n", + " self.nu = rep\n", + " self.eps_k = eps_k\n", + " self.eos = eos \n", + " \n", + " def eos_state(self, temp, rho): \n", + " temperature = temp * self.eps_k * KELVIN\n", + " density = rho / (self.sigma**3 * ANGSTROM**3 * NAV)\n", + " return State(self.eos, temperature=temperature, density=density) \n", + " \n", + " ##### dimensionless quantities ###########\n", + " def res_helmholtz_energy(self, rho, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " return self.eos_state(temp, rho).helmholtz_energy(Contributions.ResidualNvt) / (KB * temperature)\n", + " \n", + " def tot_helmholtz_energy(self, rho, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " return self.eos_state(temp, rho).helmholtz_energy() / (KB * temperature)\n", + " \n", + " def internal_energy(self, rho, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " return self.eos_state(temp, rho).internal_energy(Contributions.ResidualNvt) / (KB * temperature) * temp\n", + " \n", + " def chemical_potential(self, rho, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " return (self.eos_state(temp, rho).chemical_potential(Contributions.ResidualNvt) / RGAS / temperature)[0] * temp\n", + " \n", + " def total_pressure(self, rho, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " p_vec = self.eos_state(temp, rho).pressure() * (self.sigma)**3 * ANGSTROM**3 /(KB * temperature) * temp\n", + " return p_vec\n", + " \n", + " def residual_pressure(self, rho, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " p_vec = self.eos_state(temp, rho).pressure(Contributions.ResidualNvt) * (self.sigma)**3 * ANGSTROM**3 /(KB * temperature) * temp\n", + " return p_vec\n", + " \n", + " def heat_capacity_cv(self, rho, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " return self.eos_state(temp, rho).c_v(Contributions.ResidualNvt) / (RGAS) + 3.0 / 2.0 ## total\n", + " \n", + " def heat_capacity_cp(self, rho, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " return self.eos_state(temp, rho).c_p(Contributions.ResidualNvt) / (RGAS) + 5.0 / 2.0\n", + " \n", + " def compressibility(self, rho, temp):\n", + " return self.eos_state(temp, rho).compressibility()\n", + " \n", + " def isothermal_compressibility(self, rho, temp): # beta_t = 1 / rho*(dp/drho)\n", + " return -1.0 / (self.eos_state(temp, rho).dp_dv() / self.eos_state(temp, rho).density) * KB * self.eps_k * KELVIN * NAV / (self.sigma**3 * ANGSTROM**3)\n", + " \n", + " def thermal_pressure_coefficient(self, rho, temp):\n", + " return self.eos_state(temp, rho).dp_dt() / KB * self.sigma**3 * ANGSTROM**3\n", + " \n", + " def thermal_expansion_coefficient(self, rho, temp):\n", + " return self.thermal_pressure_coefficient(rho, temp) * self.isothermal_compressibility(rho, temp)\n", + " \n", + " def isotropic_compressibility(self, rho, temp):\n", + " return self.eos_state(temp, rho).isentropic_compressibility() * self.eps_k * KELVIN * KB / (self.sigma**3 * ANGSTROM**3)\n", + " \n", + " def speed_of_sound(self, rho, temp): \n", + " return (self.heat_capacity_cp(rho, temp) / self.heat_capacity_cv(rho, temp) / rho / self.isothermal_compressibility(rho, temp))**0.5\n", + " \n", + " \n", + " def joule_thomson(self, rho, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " return (self.isothermal_compressibility(rho, temp) * self.thermal_pressure_coefficient(rho, temp) * temp - 1.0) / (rho * self.heat_capacity_cp(rho, temp))\n", + " \n", + " def grueneisen_parameter(self, rho, temp):\n", + " return self.eos_state(temp, rho).dp_dt() / (rho * self.heat_capacity_cv(rho, temp)) / KB * self.sigma**3 * ANGSTROM**3\n", + " \n", + " def enthalpy(self, rho, temp):\n", + " return self.eos_state(temp, rho).enthalpy() / (KB * self.eps_k * KELVIN) \n", + " \n", + " ############ Virial coefficients ###############################\n", + " def second_virial_coefficient(self, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " return self.eos.second_virial_coefficient(temperature) / (self.sigma**3 * ANGSTROM**3 * NAV)\n", + " \n", + " def third_virial_coefficient(self, temp): # Recheck!\n", + " temperature = temp * self.eps_k * KELVIN\n", + " return self.eos.third_virial_coefficient(temperature) / (self.sigma**3 * ANGSTROM**3 * NAV)**2 \n", + " \n", + " ##### VLE #####\n", + " def vapor_pressure(self, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " vle = PhaseEquilibrium.pure(self.eos, temperature)\n", + " return vle.vapor_pressure(self.eos, temperature)[0] * self.sigma**3 * ANGSTROM**3 / (self.eps_k * KELVIN * KB)\n", + " \n", + " def critical_point(self, initial_temp = 340*KELVIN ):\n", + " return State.critical_point(self.eos, initial_temperature=initial_temp)\n", + " \n", + " def critical_pressure(self):\n", + " return State.critical_point(self.eos, initial_temperature=100*KELVIN).pressure() * self.sigma**3 * ANGSTROM**3 / (self.eps_k * KELVIN * KB)\n", + " \n", + " def critical_density(self):\n", + " return self.critical_point().density * (self.sigma**3 * ANGSTROM**3 * NAV)\n", + " \n", + " def critical_temperature(self):\n", + " return self.critical_point().temperature / (self.eps_k * KELVIN)\n", + " \n", + " def vle_pressure(self, p):\n", + " return PhaseEquilibrium.pure_p(self.eos, p * BAR)\n", + " \n", + " def vle_pressure_temperature(self, p):\n", + " return PhaseEquilibrium.pure_p(self.eos, p * BAR).temperature / (self.eps_k * KELVIN)\n", + " \n", + " def vle_pressure_density(self, p):\n", + " return PhaseEquilibrium.pure_p(self.eos, p * BAR).vapor.density * (self.sigma**3 * ANGSTROM**3 * NAV), VLEState.pure_p(self.eos, p * BAR).liquid.density * (self.sigma**3 * ANGSTROM**3 * NAV)\n", + " \n", + " def vle_temperature(self, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " return PhaseEquilibrium.pure_t(self.eos, temperature)\n", + " \n", + " def vle_temperature_dimensionless(self, temp):\n", + " vle = self.vle_temperature(temp)\n", + " return vle.vapor.density * (self.sigma**3 * ANGSTROM**3 * NAV), vle.liquid.density * (self.sigma**3 * ANGSTROM**3 * NAV)\n", + " \n", + " def vapor_density(self, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " vle = PhaseEquilibrium.pure(self.eos, temperature)\n", + " return vle.vapor.density * (self.sigma**3 * ANGSTROM**3 * NAV)\n", + " \n", + " def liquid_density(self, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " vle = PhaseEquilibrium.pure(self.eos, temperature)\n", + " return vle.liquid.density * (self.sigma**3 * ANGSTROM**3 * NAV)\n", + " \n", + " def enthalpy_of_vaporization(self, temp):\n", + " temperature = temp * self.eps_k * KELVIN\n", + " hv = self.enthalpy(self.vapor_density(temp), temp)\n", + " hl = self.enthalpy(self.liquid_density(temp), temp)\n", + " dhv = hv - hl\n", + " return dhv\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def get_eos(name, rep, sigma = 3.7039, eps_k = 150.03, att=6.0):\n", + " nu = rep\n", + " \n", + " if name == 'thol':\n", + " eos = EquationOfState.python(Thol(sigma, eps_k))\n", + " \n", + " if name == 'uv_wca':\n", + " parameters = UVParameters.from_lists([rep], [att], [sigma], [eps_k])\n", + " eos = EquationOfState.uvtheory(parameters, perturbation=Perturbation.WeeksChandlerAndersen)\n", + " \n", + " if name == 'uv_bh':\n", + " parameters = UVParameters.from_lists([nu], [rep], [sigma], [eps_k])\n", + " eos = EquationOfState.uvtheory(parameters, perturbation=Perturbation.BarkerHenderson) \n", + "\n", + " if name == 'uv_b3':\n", + " parameters = UVParameters.from_lists([nu], [rep], [sigma], [eps_k], virial_order=VirialOrder.Third)\n", + " eos = EquationOfState.uvb3(parameters)\n", + " \n", + " \n", + " return EOS_PROPERTIES(eos, sigma=sigma, eps_k=eps_k, rep=rep, att=att)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'VirialOrder' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0muv_bh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_eos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'uv_bh'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msigma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps_k\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0matt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0muv_wca\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_eos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'uv_wca'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msigma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps_k\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0matt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0muv_b3\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_eos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'uv_b3'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msigma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps_k\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0matt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36mget_eos\u001b[0;34m(name, rep, sigma, eps_k, att)\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'uv_b3'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mparameters\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mUVParameters\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_lists\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnu\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mrep\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0msigma\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0meps_k\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvirial_order\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mVirialOrder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mThird\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 17\u001b[0m \u001b[0meos\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEquationOfState\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muvb3\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'VirialOrder' is not defined" + ] + } + ], + "source": [ + "rep = 12\n", + "att = 6\n", + "sigma = 3.7039 # in Angstrom\n", + "eps_k = 150.03 # eps / kB in K\n", + "thol = get_eos('thol', rep, sigma, eps_k, att)\n", + "uv_bh = get_eos('uv_bh', rep, sigma, eps_k, att)\n", + "uv_wca = get_eos('uv_wca', rep, sigma, eps_k, att)\n", + "uv_b3 = get_eos('uv_b3', rep, sigma, eps_k, att)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.1384039006646205" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rho = 1.0\n", + "temp = 5\n", + "thol.res_helmholtz_energy(rho, temp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "sigma = 3.7039\n", + "sigma_a = sigma * ANGSTROM\n", + "eps_k = 150.03\n", + "eps_k_k = eps_k * KELVIN\n", + "\n", + "parameters = UVParameters.from_lists([12.0], [6.0], [sigma], [eps_k])\n", + "uvtheory_wca = EquationOfState.uvtheory(parameters)\n", + "uvtheory_bh = EquationOfState.uvtheory(parameters, perturbation=Perturbation.BarkerHenderson)\n", + "\n", + "parameters = PetsParameters.from_values(sigma, eps_k)\n", + "pets = EquationOfState.pets(parameters)\n", + "\n", + "thol = EquationOfState.python(Thol())\n", + "s3 = State(thol, temperature=300*KELVIN, pressure=1*BAR)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "s1 = State(uvtheory_wca, temperature=300*KELVIN, pressure=1*BAR)\n", + "s2 = State(pets, temperature=300*KELVIN, pressure=1*BAR)\n", + "s3 = State(thol, temperature=300*KELVIN, pressure=1*BAR)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.0016213224956115704" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s1.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.0009407040108813868" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s2.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.0016144150962601586" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s3.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.3200003469821506, 1.3097658041494302, 1.3208296613277393)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "State.critical_point(thol).temperature / eps_k_k, State.critical_point(uvtheory_wca).temperature / eps_k_k, State.critical_point(uvtheory_bh).temperature / eps_k_k" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 52.5 ms, sys: 1.45 ms, total: 54 ms\n", + "Wall time: 54.2 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "vle_uv = PhaseDiagram.pure(uvtheory_wca, 150*KELVIN, 500)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vle_uv.liquid" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 49 ms, sys: 1.77 ms, total: 50.7 ms\n", + "Wall time: 52.6 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "vle_uv_bh = PhaseDiagram.pure(uvtheory_bh, 150*KELVIN, 500)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:65: RuntimeWarning: overflow encountered in exp\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", + "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:65: RuntimeWarning: invalid value encountered in exp\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", + "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:68: RuntimeWarning: overflow encountered in exp\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n", + "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:68: RuntimeWarning: invalid value encountered in exp\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.9 s, sys: 16.4 ms, total: 1.92 s\n", + "Wall time: 1.93 s\n" + ] + } + ], + "source": [ + "%%time\n", + "vle_thol = PhaseDiagram.pure(thol, 150*KELVIN, 500)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 27 ms, sys: 1.68 ms, total: 28.7 ms\n", + "Wall time: 32.6 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "vle_pets = PhaseDiagram.pure(pets, 150*KELVIN, 500)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "s3 = NAV * sigma_a**3\n", + "plt.plot(vle_uv.vapor.density * s3 , vle_uv.vapor.temperature / eps_k_k, color='black')\n", + "plt.plot(vle_uv.liquid.density * s3, vle_uv.vapor.temperature / eps_k_k, color='black')\n", + "\n", + "plt.plot(vle_uv_bh.vapor.density * s3 , vle_uv_bh.vapor.temperature / eps_k_k, color='black', linestyle='dashed')\n", + "plt.plot(vle_uv_bh.liquid.density * s3, vle_uv_bh.vapor.temperature / eps_k_k, color='black', linestyle='dashed')\n", + "\n", + "plt.plot(vle_thol.vapor.density * s3, vle_thol.vapor.temperature / eps_k_k, color='red')\n", + "plt.plot(vle_thol.liquid.density * s3, vle_thol.vapor.temperature / eps_k_k, color='red')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "vle_thol = PhaseDiagram.pure(thol, 150*KELVIN, 500)\n", + "s3 = NAV * sigma_a**3\n", + "plt.plot(vle_uv.vapor.density * s3 , vle_uv.vapor.temperature / eps_k_k, color='black')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/src/uvtheory/eos/attractive_perturbation_uvb3.rs b/src/uvtheory/eos/attractive_perturbation_uvb3.rs new file mode 100644 index 000000000..90e6fbf06 --- /dev/null +++ b/src/uvtheory/eos/attractive_perturbation_uvb3.rs @@ -0,0 +1,522 @@ +use super::hard_sphere_wca::{ + diameter_wca, dimensionless_diameter_q_wca, WCA_CONSTANTS_ETA_A_UVB3, WCA_CONSTANTS_ETA_B_UVB3, +}; +use crate::uvtheory::parameters::*; +use feos_core::{HelmholtzEnergyDual, StateHD}; +use ndarray::Array1; +use num_dual::DualNum; +use std::{f64::consts::PI, fmt, sync::Arc}; + +const C_WCA: [[f64; 6]; 6] = [ + [ + -0.2622378162, + 0.6585817423, + 5.5318022309, + 0.6902354794, + -3.6825190645, + -1.7263213318, + ], + [ + -0.1899241690, + -0.5555205158, + 9.1361398949, + 0.7966155658, + -6.1413017045, + 4.9553415149, + ], + [ + 0.1169786415, + -0.2216804790, + -2.0470861617, + -0.3742261343, + 0.9568416381, + 10.1401796764, + ], + [ + 0.5852642702, + 2.0795520346, + 19.0711829725, + -2.3403594600, + 2.5833371420, + 432.3858674425, + ], + [ + -0.6084232211, + -7.2376034572, + 19.0412933614, + 3.2388986513, + 75.4442555789, + -588.3837110653, + ], + [ + 0.0512327656, + 6.6667943569, + 47.1109947616, + -0.5011125797, + -34.8918383146, + 189.5498636006, + ], +]; + +// Constants for delta B2 RSAP +const CONST_B2_RSAP: [[f64; 4]; 4] = [ + [-0.063550989, 6.206829830, -37.45829549, 40.72849774], + [1.519053409, 13.14989643, 85.35058674, 374.1906360], + [0.693456220, 9.459946180, -53.28984218, 315.8199084], + [0.007492596, 0.546171170, 7.979562575, -119.6126395], +]; + +// Constants for B3 +const CONST_B3_LJ_RSAP: [f64; 16] = [ + -3.98056703e+00, + 7.95645979e+01, + 5.48947334e-01, + 5.36319582e+00, + 1.42454153e+00, + 5.72923297e+01, + 3.80631996e-10, + 1.00308510e+00, + -3.97550628e+01, + -8.12130965e+01, + 6.98683893e-01, + 3.01563968e+01, + -2.36919346e+01, + -8.50060515e+01, + 7.76154927e-01, + 1.27979994e+01, +]; + +// Constants for B3 RSAP Mie nu-6 fluids +const B3_K_PARAMETER: [f64; 4] = [8.08442174e-01, -9.54092759e-02, 4.75253015e-01, -2.83282674]; +const B3_L_PARAMETER: [f64; 4] = [4.94848492, -21.2995618, 7.0, 3.21621955]; +const B3_M_PARAMETER: [f64; 4] = [ + 1.18534625e-01, + 7.85559789e-02, + -5.50389332e-01, + 9.16296297e-03, +]; + +/// Constants for WCA u-fraction. +const CU_WCA: [f64; 8] = [ + 26.45397287, + 1.80454811, + 1.79970006, + 161.95895155, + 11.60539317, + 12., + 0.4, + 2.0, +]; + +#[derive(Debug, Clone)] +pub struct AttractivePerturbationUVB3 { + pub parameters: Arc, +} + +impl fmt::Display for AttractivePerturbationUVB3 { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Attractive Perturbation") + } +} + +impl> HelmholtzEnergyDual for AttractivePerturbationUVB3 { + /// Helmholtz energy for attractive perturbation, eq. 52 + fn helmholtz_energy(&self, state: &StateHD) -> D { + let p = &self.parameters; + let t = state.temperature; + let density = state.partial_density.sum(); + let d = diameter_wca(p, t); + let x = &state.molefracs; + // vdw effective one fluid properties + let (rep_x, att_x, sigma_x, weighted_sigma3_ij, epsilon_k_x, d_x) = + one_fluid_properties(p, x, t); + let t_x = state.temperature / epsilon_k_x; + let rho_x = density * sigma_x.powi(3); + let rm_x = (rep_x / att_x).powd((rep_x - att_x).recip()); + let mean_field_constant_x = mean_field_constant(rep_x, att_x, rm_x); + let q_vdw = dimensionless_diameter_q_wca(t_x, rep_x, att_x); + let i_wca = + correlation_integral_wca(rho_x, mean_field_constant_x, rep_x, att_x, d_x, q_vdw, rm_x); + + let delta_a1u = state.partial_density.sum() / t_x * i_wca * 2.0 * PI * weighted_sigma3_ij; + + // state.partial_density.sum() / t_x * i_wca * 2.0 * PI * weighted_sigma3_ij; + let u_fraction_wca = u_fraction_wca( + rep_x, + density * (x * &p.sigma.mapv(|s| s.powi(3))).sum(), + t_x, + ); + + let b21u = delta_b12u(t_x, mean_field_constant_x, weighted_sigma3_ij, q_vdw, rm_x); + let b2bar = residual_virial_coefficient(p, x, state.temperature); + + let b3bar = residual_third_virial_coefficient(p, x, state.temperature, &d); + let db31u = delta_b31u(t_x, weighted_sigma3_ij, rm_x, rep_x, att_x, d_x); + let alpha = + (-rho_x * rep_x.recip() * CU_WCA[0] * (t_x.powi(2).recip() * CU_WCA[1] + 1.0)).exp(); + state.moles.sum() + * (delta_a1u + + (-u_fraction_wca + 1.0) + * ((b2bar - b21u) * density + density.powi(2) * alpha * (b3bar - db31u) * 0.5)) + } +} + +// (S43) & (S53) +fn delta_b12u>( + t_x: D, + mean_field_constant_x: D, + weighted_sigma3_ij: D, + q_x: D, + rm_x: D, +) -> D { + (-mean_field_constant_x - (rm_x.powi(3) - q_x.powi(3)) * 1.0 / 3.0) / t_x + * 2.0 + * PI + * weighted_sigma3_ij +} + +fn residual_virial_coefficient>(p: &UVParameters, x: &Array1, t: D) -> D { + let mut delta_b2bar = D::zero(); + + for i in 0..p.ncomponents { + let xi = x[i]; + + for j in 0..p.ncomponents { + //let q_ij = (q[i] / p.sigma[i] + q[j] / p.sigma[j]) * 0.5; + let t_ij = t / p.eps_k_ij[[i, j]]; + let rep_ij = p.rep_ij[[i, j]]; + let att_ij = p.att_ij[[i, j]]; + + let q_ij = dimensionless_diameter_q_wca(t_ij, D::from(rep_ij), D::from(att_ij)); + + // Recheck mixing rule! + delta_b2bar += + xi * x[j] * p.sigma_ij[[i, j]].powi(3) * delta_b2(t_ij, rep_ij, att_ij, q_ij); + } + } + delta_b2bar +} +fn residual_third_virial_coefficient>( + p: &UVParameters, + x: &Array1, + t: D, + d: &Array1, +) -> D { + let mut delta_b3bar = D::zero(); + + for i in 0..p.ncomponents { + let xi = x[i]; + + for j in 0..p.ncomponents { + //let q_ij = (q[i] / p.sigma[i] + q[j] / p.sigma[j]) * 0.5; + let t_ij = t / p.eps_k_ij[[i, j]]; + let rep_ij = p.rep_ij[[i, j]]; + let att_ij = p.att_ij[[i, j]]; + let q_ij = dimensionless_diameter_q_wca(t_ij, D::from(rep_ij), D::from(att_ij)); + + // Recheck mixing rule! + let rm_ij = (rep_ij / att_ij).powd((rep_ij - att_ij).recip()); // Anja frei erfunden + let d_ij = (d[i] / p.sigma[i] + d[j] / p.sigma[j]) * 0.5; // Recheck mixing rule! + // // Recheck mixing rule! + delta_b3bar += xi + * x[j] + * p.sigma_ij[[i, j]].powi(6) + * delta_b3(t_ij, rm_ij, rep_ij, att_ij, d_ij, q_ij); + } + } + delta_b3bar +} +fn correlation_integral_wca>( + rho_x: D, + mean_field_constant_x: D, + rep_x: D, + att_x: D, + d_x: D, + q_x: D, + rm_x: D, +) -> D { + let c = coefficients_wca(rep_x, att_x, d_x); + + (q_x.powi(3) - rm_x.powi(3)) * 1.0 / 3.0 - mean_field_constant_x + + mie_prefactor(rep_x, att_x) * (c[0] * rho_x + c[1] * rho_x.powi(2) + c[2] * rho_x.powi(3)) + / (c[3] * rho_x + c[4] * rho_x.powi(2) + c[5] * rho_x.powi(3) + 1.0) +} + +/// U-fraction with low temperature correction omega +fn u_fraction_wca>(rep_x: D, reduced_density: D, t_x: D) -> D { + // let omega = (-t_x.powi(2) * rep_x * CU_WCA[5]).exp() * (t_x.recip() * CU_WCA[6]).exp(); + let omega = if t_x.re() < 175.0 { + (-t_x * CU_WCA[5] * (reduced_density - CU_WCA[6]).powi(2)).exp() + * ((t_x * CU_WCA[7]).tanh().recip() - 1.0).powi(2) + } else { + (-t_x * CU_WCA[5] * (reduced_density - CU_WCA[6]).powi(2)).exp() * 0.0 + }; + + -(-(reduced_density.powi(2) * ((rep_x + CU_WCA[4]).recip() * CU_WCA[3] + CU_WCA[2]) + omega)) + .exp() + + 1.0 +} + +fn one_fluid_properties>( + p: &UVParameters, + x: &Array1, + t: D, +) -> (D, D, D, D, D, D) { + let d = diameter_wca(p, t); + // &p.sigma; + + let mut epsilon_k = D::zero(); + let mut weighted_sigma3_ij = D::zero(); + let mut rep = D::zero(); + let mut att = D::zero(); + let mut d_x_3 = D::zero(); + + for i in 0..p.ncomponents { + let xi = x[i]; + + d_x_3 += x[i] * d[i].powi(3); + for j in 0..p.ncomponents { + let _y = xi * x[j] * p.sigma_ij[[i, j]].powi(3); + weighted_sigma3_ij += _y; + epsilon_k += _y * p.eps_k_ij[[i, j]]; + + rep += xi * x[j] * p.rep_ij[[i, j]]; + att += xi * x[j] * p.att_ij[[i, j]]; + } + } + + //let dx = (x * &d.mapv(|v| v.powi(3))).sum().powf(1.0 / 3.0); + let sigma_x = (x * &p.sigma.mapv(|v| v.powi(3))).sum().powf(1.0 / 3.0); + let dx = d_x_3.powf(1.0 / 3.0) / sigma_x; + + ( + rep, + att, + sigma_x, + weighted_sigma3_ij, + epsilon_k / weighted_sigma3_ij, + dx, + ) +} + +// Coefficients for IWCA from eq. (S55) +fn coefficients_wca>(rep: D, att: D, d: D) -> [D; 6] { + let rep_inv = rep.recip(); + let rs_x = (rep / att).powd((rep - att).recip()); + let tau_x = -d + rs_x; + let c1 = rep_inv.powi(2) * C_WCA[0][2] + + C_WCA[0][0] + + rep_inv * C_WCA[0][1] + + (rep_inv.powi(2) * C_WCA[0][5] + rep_inv * C_WCA[0][4] + C_WCA[0][3]) * tau_x; + let c2 = rep_inv.powi(2) * C_WCA[1][2] + + C_WCA[1][0] + + rep_inv * C_WCA[1][1] + + (rep_inv.powi(2) * C_WCA[1][5] + rep_inv * C_WCA[1][4] + C_WCA[1][3]) * tau_x; + let c3 = rep_inv.powi(2) * C_WCA[2][2] + + C_WCA[2][0] + + rep_inv * C_WCA[2][1] + + (rep_inv.powi(2) * C_WCA[2][5] + rep_inv * C_WCA[2][4] + C_WCA[2][3]) * tau_x; + let c4 = rep_inv.powi(2) * C_WCA[3][2] + + C_WCA[3][0] + + rep_inv * C_WCA[3][1] + + (rep_inv.powi(2) * C_WCA[3][5] + rep_inv * C_WCA[3][4] + C_WCA[3][3]) * tau_x; + let c5 = rep_inv.powi(2) * C_WCA[4][2] + + C_WCA[4][0] + + rep_inv * C_WCA[4][1] + + (rep_inv.powi(2) * C_WCA[4][5] + rep_inv * C_WCA[4][4] + C_WCA[4][3]) * tau_x; + let c6 = rep_inv.powi(2) * C_WCA[5][2] + + C_WCA[5][0] + + rep_inv * C_WCA[5][1] + + (rep_inv.powi(2) * C_WCA[5][5] + rep_inv * C_WCA[5][4] + C_WCA[5][3]) * tau_x; + + [c1, c2, c3, c4, c5, c6] +} + +// Residual second virial coefficient from Revised series approximation RSAP +fn factorial(num: i64) -> i64 { + return if num == 1 { + 1 + } else { + num * factorial(num - 1) + }; +} + +fn delta_b2>(reduced_temperature: D, rep: f64, att: f64, q: D) -> D { + let rm = (rep / att).powd((rep - att).recip()); // Check mixing rule!! + let beta = reduced_temperature.recip(); + let b20 = q.powi(3) * 2.0 / 3.0 * PI; // eq. (16) + let y = beta.exp() - 1.0; + + let c1 = rep.recip() * CONST_B2_RSAP[0][1] + + (rep.powi(2)).recip() * CONST_B2_RSAP[0][2] + + (rep.powi(3)).recip() * CONST_B2_RSAP[0][3] + + CONST_B2_RSAP[0][0]; + + let c2 = rep.recip() * CONST_B2_RSAP[1][1] + + (rep.powi(2)).recip() * CONST_B2_RSAP[1][2] + + (rep.powi(3)).recip() * CONST_B2_RSAP[1][3] + + CONST_B2_RSAP[1][0]; + let c3 = rep.recip() * CONST_B2_RSAP[2][1] + + (rep.powi(2)).recip() * CONST_B2_RSAP[2][2] + + (rep.powi(3)).recip() * CONST_B2_RSAP[2][3] + + CONST_B2_RSAP[2][0]; + let c4 = rep.recip() * CONST_B2_RSAP[3][1] + + (rep.powi(2)).recip() * CONST_B2_RSAP[3][2] + + (rep.powi(3)).recip() * CONST_B2_RSAP[3][3] + + CONST_B2_RSAP[3][0]; + + let mut sum_beta = beta; + + for i in 2..16 { + let k = factorial(i as i64) as f64 * i as f64; + sum_beta = sum_beta + beta.powi(i as i32) / k; + } + + (b20 - rm.powi(3) * 2.0 / 3.0 * PI - c1) * y - sum_beta * c2 - beta * c3 - beta.powi(2) * c4 +} + +fn delta_b31u>( + t_x: D, + weighted_sigma3_ij: D, + rm_x: D, + rep_x: D, + att_x: D, + d_x: D, +) -> D { + let nu = rep_x; + let tau = rm_x - d_x; + + let k1 = nu.recip() * C_WCA[0][1] + + (nu.powi(2)).recip() * C_WCA[0][2] + + C_WCA[0][0] + + (nu.recip() * C_WCA[0][4] + (nu.powi(2)).recip() * C_WCA[0][5] + C_WCA[0][3]) * tau; + t_x.recip() * 4.0 * mie_prefactor(rep_x, att_x) * PI * k1 * weighted_sigma3_ij.powi(2) +} + +fn delta_b3>(t_x: D, rm_x: f64, rep_x: f64, _att_x: f64, d_x: D, q_x: D) -> D { + let beta = t_x.recip(); + let b30 = (q_x.powi(3) * PI / 6.0).powi(2) * 10.0; + + let b31 = ((t_x + CONST_B3_LJ_RSAP[2]) + .powf(((rep_x - 12.0) / (rep_x - 6.0) * B3_M_PARAMETER[0] + 1.0) * CONST_B3_LJ_RSAP[3])) + .recip() + * CONST_B3_LJ_RSAP[1] + * ((rep_x - 12.0) / (rep_x - B3_L_PARAMETER[0]) * B3_K_PARAMETER[0] + 1.0) + + CONST_B3_LJ_RSAP[0]; + + let b32 = ((t_x + CONST_B3_LJ_RSAP[6]) + .powf(((rep_x - 12.0) / (rep_x - 6.0) * B3_M_PARAMETER[1] + 1.0) * CONST_B3_LJ_RSAP[7])) + .recip() + * CONST_B3_LJ_RSAP[5] + * ((rep_x - 12.0) / (rep_x - B3_L_PARAMETER[1]) * B3_K_PARAMETER[1] + 1.0) + + CONST_B3_LJ_RSAP[4]; + + let b33 = ((t_x + CONST_B3_LJ_RSAP[10]) + .powf(((rep_x - 12.0) / (rep_x - 6.0) * B3_M_PARAMETER[2] + 1.0) * CONST_B3_LJ_RSAP[11])) + .recip() + * CONST_B3_LJ_RSAP[9] + * ((rep_x - 12.0) / (rep_x - B3_L_PARAMETER[2]) * B3_K_PARAMETER[2] + 1.0) + + CONST_B3_LJ_RSAP[8]; + + let b34 = ((t_x + CONST_B3_LJ_RSAP[14]) + .powf(((rep_x - 12.0) / (rep_x - 6.0) * B3_M_PARAMETER[3] + 1.0) * CONST_B3_LJ_RSAP[15])) + .recip() + * CONST_B3_LJ_RSAP[13] + * ((rep_x - 12.0) / (rep_x - B3_L_PARAMETER[3]) * B3_K_PARAMETER[3] + 1.0) + + CONST_B3_LJ_RSAP[12]; + + let b3 = b30 + b31 * beta + b32 * beta.powi(2) + b33 * beta.powi(3) + b34 * beta.powi(4); + + // Watch out: Not implemented for mixtures!!!! + let tau = -d_x + rm_x; + let tau2 = tau * tau; + let rep_inv = rep_x.recip(); + + let c1_eta_a = tau + * (rep_inv * WCA_CONSTANTS_ETA_A_UVB3[[0, 1]] + WCA_CONSTANTS_ETA_A_UVB3[[0, 0]]) + + tau2 * (rep_inv * WCA_CONSTANTS_ETA_A_UVB3[[0, 3]] + WCA_CONSTANTS_ETA_A_UVB3[[0, 2]]); + + let c1_eta_b = tau * WCA_CONSTANTS_ETA_B_UVB3[[0, 0]] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[[0, 1]]; + + let b30_uv = (d_x.powi(3) * PI / 6.0).powi(2) * 10.0 + - d_x.powi(3) * 5.0 / 9.0 + * PI.powi(2) + * ((-q_x.powi(3) + rm_x.powi(3)) * (c1_eta_a + 1.0) + - (-d_x.powi(3) + rm_x.powi(3)) * (c1_eta_b + 1.0)); + + b3 - b30_uv +} + +#[cfg(test)] +mod test { + use super::*; + use crate::uvtheory::parameters::utils::methane_parameters; + use approx::assert_relative_eq; + use ndarray::arr1; + + #[test] + fn test_attractive_perturbation_uvb3() { + let moles = arr1(&[2.0]); + let reduced_temperature = 4.0; + let reduced_density = 0.5; + let reduced_volume = moles[0] / reduced_density; + + let p = methane_parameters(12.0, 6.0); + let pt = AttractivePerturbationUVB3 { + parameters: Arc::new(p.clone()), + }; + let state = StateHD::new( + reduced_temperature * p.epsilon_k[0], + reduced_volume * p.sigma[0].powi(3), + moles.clone(), + ); + let x = &state.molefracs; + let (rep_x, att_x, sigma_x, weighted_sigma3_ij, epsilon_k_x, d_x) = + one_fluid_properties(&p, &state.molefracs, state.temperature); + + let t_x = state.temperature / epsilon_k_x; + let rho_x = state.partial_density.sum() * sigma_x.powi(3); + let rm_x = (rep_x / att_x).powd((rep_x - att_x).recip()); + let mean_field_constant_x = mean_field_constant(rep_x, att_x, rm_x); + + // Effective Diameters: + let q_vdw = dimensionless_diameter_q_wca(t_x, rep_x, att_x); + assert_relative_eq!(q_vdw.re(), 0.9606854684075393, epsilon = 1e-10); + assert_relative_eq!(d_x.re(), 0.934655265184067, epsilon = 1e-10); + + //u-fraction: + let u_fraction_wca = u_fraction_wca( + rep_x, + state.partial_density.sum() * (x * &p.sigma.mapv(|s| s.powi(3))).sum(), + t_x, + ); + assert_relative_eq!(u_fraction_wca.re(), 0.8852730008077649, epsilon = 1e-10); + // delta a1u + let i_wca = + correlation_integral_wca(rho_x, mean_field_constant_x, rep_x, att_x, d_x, q_vdw, rm_x); + let delta_a1u = state.partial_density.sum() / t_x * i_wca * 2.0 * PI * weighted_sigma3_ij; + assert!(delta_a1u.re() == -0.8992910890819197); + // Virial coeffecients: + let b2bar = residual_virial_coefficient(&p, x, state.temperature) / p.sigma[0].powi(3); + assert_relative_eq!(b2bar.re(), -1.6142316456384618, epsilon = 1e-12); + + let b21u = delta_b12u(t_x, mean_field_constant_x, weighted_sigma3_ij, q_vdw, rm_x) + / p.sigma[0].powi(3); + assert_relative_eq!(b21u.re(), -1.5103749286162982, epsilon = 1e-10); + + let db3 = delta_b3(t_x, rm_x, rep_x, att_x, d_x, q_vdw); + assert_relative_eq!(db3.re(), -0.6591646873435744, epsilon = 1e-10); + + let db31 = + delta_b31u(t_x, weighted_sigma3_ij, rm_x, rep_x, att_x, d_x) / p.sigma[0].powi(6); + assert_relative_eq!(db31.re(), -1.2465186585663823, epsilon = 1e-10); + + // b3.re() = 1.4326204530476152 + // b30_uv.re() = 2.0917851403911896 + + // Full attractive perturbation: + let a = pt.helmholtz_energy(&state) / moles[0]; + + assert_relative_eq!(-0.9027781726598461, a.re(), epsilon = 1e-5); + } +} diff --git a/src/uvtheory/eos/hard_sphere_wca.rs b/src/uvtheory/eos/hard_sphere_wca.rs index 5d256fa2b..54743fb6f 100644 --- a/src/uvtheory/eos/hard_sphere_wca.rs +++ b/src/uvtheory/eos/hard_sphere_wca.rs @@ -19,6 +19,23 @@ lazy_static! { [-2.905719617, -1.778798984, -1.556827067, -4.308085347], [0.429154871, 20.765871545, 9.341250676, -33.787719418], ]); + +// New Fit by Anja to numerical integrals for uv-B3-theory + // #Tmin = 0.0, eta_max = 0.52, simultaneous fit + + pub static ref WCA_CONSTANTS_ETA_A_UVB3: Array2 = arr2(&[ + [2.64043218, -1.2184421 , -22.90786387, 0.96433414], + [-16.75643936, 30.83929771, 73.08711814, -166.57701616], + [19.53170162, -88.87955657, -76.51387192, 443.68942745], + [-3.77740877, 83.04694547, 21.62502721, -304.8643176] , + ]); + + pub static ref WCA_CONSTANTS_ETA_B_UVB3: Array2 = arr2(&[ + [2.19821588, -20.45005484], + [-13.47050687, 56.65701375], + [12.90119266, -42.71680606],]); + + pub static ref WCA_CONSTANTS_Q: Array2 = arr2(&[ [1.92840364363978, 4.43165896265079E-01, 0.0, 0.0], [ @@ -81,44 +98,6 @@ pub fn diameter_wca>(parameters: &UVParameters, temperature: D) .collect() } -// Hard sphere diameter q for WCA division from eq. (S28) -// pub fn diameter_q_wca>(parameters: &UVParameters, temperature: D) -> Array1 { -// parameters -// .sigma -// .iter() -// .enumerate() -// .map(|(i, _c)| { -// let nu = parameters.rep[i]; -// let n = parameters.att[i]; -// let t = temperature / parameters.epsilon_k[i]; -// let rs = (nu / n).powf(1.0 / (nu - n)); -// let coeffs = arr1(&[ -// (nu * 2.0 * PI / n).sqrt(), -// WCA_CONSTANTS_Q[[0, 0]] + WCA_CONSTANTS_Q[[0, 1]] * (nu - 7.0), -// WCA_CONSTANTS_Q[[1, 0]] -// + WCA_CONSTANTS_Q[[1, 1]] * (nu - 7.0) -// + WCA_CONSTANTS_Q[[1, 2]] * (nu - 7.0).powi(2) -// + WCA_CONSTANTS_Q[[1, 3]] * (nu - 7.0).powi(3), -// WCA_CONSTANTS_Q[[2, 0]] -// + WCA_CONSTANTS_Q[[2, 1]] * (nu - 7.0) -// + WCA_CONSTANTS_Q[[2, 2]] * (nu - 7.0).powi(2) -// + WCA_CONSTANTS_Q[[2, 3]] * (nu - 7.0).powi(3), -// ]); - -// (t.powf(2.0) * coeffs[3] -// + t.powf(3.0 / 2.0) * coeffs[2] -// + t * coeffs[1] -// + t.powf(1.0 / 2.0) * coeffs[0] -// + 1.0) -// .powf(-1.0 / (2.0 * nu)) -// * rs -// * parameters.sigma[i] -// }) -// .collect() -// } - -// - pub fn dimensionless_diameter_q_wca>(t_x: D, rep_x: D, att_x: D) -> D { let nu = rep_x; let n = att_x; @@ -214,6 +193,28 @@ pub fn packing_fraction_b>( }) } +pub fn packing_fraction_b_uvb3>( + parameters: &UVParameters, + eta: D, + temperature: D, +) -> Array2 { + let n = parameters.att.len(); + let dimensionless_lengths = dimensionless_length_scale(parameters, temperature); + Array2::from_shape_fn((n, n), |(i, j)| { + let tau = (dimensionless_lengths[i] + dimensionless_lengths[j]) + / parameters.sigma_ij[[i, j]] + * 0.5; //dimensionless + let tau2 = tau * tau; + + let c = arr1(&[ + tau * WCA_CONSTANTS_ETA_B_UVB3[[0, 0]] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[[0, 1]], + tau * WCA_CONSTANTS_ETA_B_UVB3[[1, 0]] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[[1, 1]], + tau * WCA_CONSTANTS_ETA_B_UVB3[[2, 0]] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[[2, 1]], + ]); + eta + eta * c[0] + eta * eta * c[1] + eta.powi(3) * c[2] + }) +} + pub fn packing_fraction_a>( parameters: &UVParameters, eta: D, @@ -242,6 +243,42 @@ pub fn packing_fraction_a>( }) } +pub fn packing_fraction_a_uvb3>( + parameters: &UVParameters, + eta: D, + temperature: D, +) -> Array2 { + let dimensionless_lengths = dimensionless_length_scale(parameters, temperature); + let n = parameters.att.len(); + Array2::from_shape_fn((n, n), |(i, j)| { + let tau = (dimensionless_lengths[i] + dimensionless_lengths[j]) + / parameters.sigma_ij[[i, j]] + * 0.5; //dimensionless + + let tau2 = tau * tau; + let rep_inv = 1.0 / parameters.rep_ij[[i, j]]; + let c = arr1(&[ + tau * (WCA_CONSTANTS_ETA_A_UVB3[[0, 0]] + WCA_CONSTANTS_ETA_A_UVB3[[0, 1]] * rep_inv) + + tau2 + * (WCA_CONSTANTS_ETA_A_UVB3[[0, 2]] + + WCA_CONSTANTS_ETA_A_UVB3[[0, 3]] * rep_inv), + tau * (WCA_CONSTANTS_ETA_A_UVB3[[1, 0]] + WCA_CONSTANTS_ETA_A_UVB3[[1, 1]] * rep_inv) + + tau2 + * (WCA_CONSTANTS_ETA_A_UVB3[[1, 2]] + + WCA_CONSTANTS_ETA_A_UVB3[[1, 3]] * rep_inv), + tau * (WCA_CONSTANTS_ETA_A_UVB3[[2, 0]] + WCA_CONSTANTS_ETA_A_UVB3[[2, 1]] * rep_inv) + + tau2 + * (WCA_CONSTANTS_ETA_A_UVB3[[2, 2]] + + WCA_CONSTANTS_ETA_A_UVB3[[2, 3]] * rep_inv), + tau * (WCA_CONSTANTS_ETA_A_UVB3[[3, 0]] + WCA_CONSTANTS_ETA_A_UVB3[[3, 1]] * rep_inv) + + tau2 + * (WCA_CONSTANTS_ETA_A_UVB3[[3, 2]] + + WCA_CONSTANTS_ETA_A_UVB3[[3, 3]] * rep_inv), + ]); + eta + eta * c[0] + eta * eta * c[1] + eta.powi(3) * c[2] + eta.powi(4) * c[3] + }) +} + #[cfg(test)] mod test { use super::*; diff --git a/src/uvtheory/eos/mod.rs b/src/uvtheory/eos/mod.rs index 8b59fd532..4e914a7cc 100644 --- a/src/uvtheory/eos/mod.rs +++ b/src/uvtheory/eos/mod.rs @@ -8,17 +8,21 @@ use std::f64::consts::FRAC_PI_6; use std::sync::Arc; pub(crate) mod attractive_perturbation_bh; +pub(crate) mod attractive_perturbation_uvb3; pub(crate) mod attractive_perturbation_wca; pub(crate) mod hard_sphere_bh; pub(crate) mod hard_sphere_wca; pub(crate) mod reference_perturbation_bh; +pub(crate) mod reference_perturbation_uvb3; pub(crate) mod reference_perturbation_wca; pub(crate) mod ufraction; use attractive_perturbation_bh::AttractivePerturbationBH; +use attractive_perturbation_uvb3::AttractivePerturbationUVB3; use attractive_perturbation_wca::AttractivePerturbationWCA; use hard_sphere_bh::HardSphere; use hard_sphere_wca::HardSphereWCA; use reference_perturbation_bh::ReferencePerturbationBH; +use reference_perturbation_uvb3::ReferencePerturbationUVB3; use reference_perturbation_wca::ReferencePerturbationWCA; /// Type of perturbation. @@ -29,11 +33,19 @@ pub enum Perturbation { WeeksChandlerAndersen, } +#[derive(Clone)] +#[cfg_attr(feature = "python", pyo3::pyclass)] +pub enum VirialOrder { + Second, + Third, +} + /// Configuration options for uv-theory #[derive(Clone)] pub struct UVTheoryOptions { pub max_eta: f64, pub perturbation: Perturbation, + pub virial_order: VirialOrder, } impl Default for UVTheoryOptions { @@ -41,6 +53,7 @@ impl Default for UVTheoryOptions { Self { max_eta: 0.5, perturbation: Perturbation::WeeksChandlerAndersen, + virial_order: VirialOrder::Second, } } } @@ -63,27 +76,55 @@ impl UVTheory { let mut contributions: Vec> = Vec::with_capacity(3); match options.perturbation { - Perturbation::BarkerHenderson => { - contributions.push(Box::new(HardSphere { - parameters: parameters.clone(), - })); - contributions.push(Box::new(ReferencePerturbationBH { - parameters: parameters.clone(), - })); - contributions.push(Box::new(AttractivePerturbationBH { - parameters: parameters.clone(), - })); - } + Perturbation::BarkerHenderson => match options.virial_order { + VirialOrder::Second => { + contributions.push(Box::new(HardSphere { + parameters: parameters.clone(), + })); + contributions.push(Box::new(ReferencePerturbationBH { + parameters: parameters.clone(), + })); + contributions.push(Box::new(AttractivePerturbationBH { + parameters: parameters.clone(), + })); + } + VirialOrder::Third => { + panic!("Not implemeted!"); + } + }, Perturbation::WeeksChandlerAndersen => { - contributions.push(Box::new(HardSphereWCA { - parameters: parameters.clone(), - })); - contributions.push(Box::new(ReferencePerturbationWCA { - parameters: parameters.clone(), - })); - contributions.push(Box::new(AttractivePerturbationWCA { - parameters: parameters.clone(), - })); + match options.virial_order { + VirialOrder::Second => { + contributions.push(Box::new(HardSphereWCA { + parameters: parameters.clone(), + })); + contributions.push(Box::new(ReferencePerturbationWCA { + parameters: parameters.clone(), + })); + contributions.push(Box::new(AttractivePerturbationWCA { + parameters: parameters.clone(), + })); + } + VirialOrder::Third => { + if parameters.sigma.len() > 1 { + panic!("uv-B3-theory not implemented for mixtures!") + } + + if parameters.att[0] != 6.0 { + panic!("uv-B3-theory not implemented for attractive exponents other than 6!") + } + + contributions.push(Box::new(HardSphereWCA { + parameters: parameters.clone(), + })); + contributions.push(Box::new(ReferencePerturbationUVB3 { + parameters: parameters.clone(), + })); + contributions.push(Box::new(AttractivePerturbationUVB3 { + parameters: parameters.clone(), + })); + } + } } } @@ -167,6 +208,7 @@ mod test { let options = UVTheoryOptions { max_eta: 0.5, perturbation: Perturbation::BarkerHenderson, + virial_order: VirialOrder::Second, }; let eos = Arc::new(UVTheory::with_options(Arc::new(parameters), options)); @@ -184,6 +226,36 @@ mod test { assert_relative_eq!(a, 2.993577305779432, max_relative = 1e-12) } + #[test] + fn helmholtz_energy_pure_uvb3() { + let eps_k = 150.03; + let sig = 3.7039; + let r = UVRecord::new(12.0, 6.0, sig, eps_k); + let i = Identifier::new(None, None, None, None, None, None); + let pr = PureRecord::new(i, 1.0, r, None); + let parameters = UVParameters::new_pure(pr); + + let options = UVTheoryOptions { + max_eta: 0.5, + perturbation: Perturbation::WeeksChandlerAndersen, + virial_order: VirialOrder::Third, + }; + let eos = Arc::new(UVTheory::with_options(Arc::new(parameters), options)); + + let reduced_temperature = 4.0; + let reduced_density = 0.5; + let temperature = reduced_temperature * eps_k * KELVIN; + let moles = arr1(&[2.0]) * MOL; + let volume = (sig * ANGSTROM).powi(3) / reduced_density * NAV * 2.0 * MOL; + let s = State::new_nvt(&eos, temperature, volume, &moles).unwrap(); + let a = s + .molar_helmholtz_energy(Contributions::ResidualNvt) + .to_reduced(RGAS * temperature) + .unwrap(); + + assert_relative_eq!(a, 0.37659378806627525, max_relative = 1e-12) + } + #[test] fn helmholtz_energy_mixtures_bh() { // Mixture of equal components --> result must be the same as fpr pure fluid /// @@ -219,6 +291,7 @@ mod test { let options = UVTheoryOptions { max_eta: 0.5, perturbation: Perturbation::BarkerHenderson, + virial_order: VirialOrder::Second, }; let eos_bh = Arc::new(UVTheory::with_options(Arc::new(uv_parameters), options)); diff --git a/src/uvtheory/eos/reference_perturbation_uvb3.rs b/src/uvtheory/eos/reference_perturbation_uvb3.rs new file mode 100644 index 000000000..30d79d126 --- /dev/null +++ b/src/uvtheory/eos/reference_perturbation_uvb3.rs @@ -0,0 +1,104 @@ +use super::hard_sphere_wca::{ + diameter_wca, dimensionless_diameter_q_wca, packing_fraction, packing_fraction_a_uvb3, + packing_fraction_b_uvb3, +}; +use crate::uvtheory::parameters::*; +use feos_core::{HelmholtzEnergyDual, StateHD}; +use num_dual::DualNum; +use std::fmt; +use std::{f64::consts::PI, sync::Arc}; + +#[derive(Debug, Clone)] +pub struct ReferencePerturbationUVB3 { + pub parameters: Arc, +} + +impl fmt::Display for ReferencePerturbationUVB3 { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Reference Perturbation") + } +} + +impl> HelmholtzEnergyDual for ReferencePerturbationUVB3 { + /// Helmholtz energy for perturbation reference (Mayer-f), eq. 29 + fn helmholtz_energy(&self, state: &StateHD) -> D { + let p = &self.parameters; + let n = p.sigma.len(); + let x = &state.molefracs; + let d = diameter_wca(p, state.temperature); + //let q = diameter_q_wca(&p, state.temperature); + let eta = packing_fraction(&state.partial_density, &d); + let eta_a = packing_fraction_a_uvb3(p, eta, state.temperature); + let eta_b = packing_fraction_b_uvb3(p, eta, state.temperature); + let mut a = D::zero(); + + for i in 0..n { + for j in 0..n { + let rs_ij = ((p.rep[i] / p.att[i]).powf(1.0 / (p.rep[i] - p.att[i])) + + (p.rep[j] / p.att[j]).powf(1.0 / (p.rep[j] - p.att[j]))) + * 0.5; // MIXING RULE not clear!!! + let d_ij = (d[i] + d[j]) * 0.5; // (d[i] * p.sigma[i] + d[j] * p.sigma[j]) * 0.5; + + let t_ij = state.temperature / p.eps_k_ij[[i, j]]; + let rep_ij = p.rep_ij[[i, j]]; + let att_ij = p.att_ij[[i, j]]; + let q_ij = dimensionless_diameter_q_wca(t_ij, D::from(rep_ij), D::from(att_ij)) + * p.sigma_ij[[i, j]]; + + a += x[i] + * x[j] + * ((-eta_a[[i, j]] * 0.5 + 1.0) / (-eta_a[[i, j]] + 1.0).powi(3) + * (-q_ij.powi(3) + (rs_ij * p.sigma_ij[[i, j]]).powi(3)) + - ((-eta_b[[i, j]] * 0.5 + 1.0) / (-eta_b[[i, j]] + 1.0).powi(3)) + * (-d_ij.powi(3) + (rs_ij * p.sigma_ij[[i, j]]).powi(3))) + } + } + + -a * state.moles.sum().powi(2) * 2.0 / 3.0 / state.volume * PI + } +} + +#[cfg(test)] +mod test { + use super::*; + use crate::uvtheory::parameters::utils::test_parameters; + use approx::assert_relative_eq; + use ndarray::arr1; + + #[test] + fn test_delta_a0_uvb3_pure() { + let moles = arr1(&[2.0]); + // #temp = 2.0, rho = 0.5, nu = 12 + // Hard sphere adhs 1.3491645849732654 + // Delta a0 0.1130778070897391 + + let reduced_temperature = 2.0; + let reduced_density = 0.5; + let reduced_volume = moles[0] / reduced_density; + + let p = test_parameters(12.0, 6.0, 1.0, 1.0); + let pt = ReferencePerturbationUVB3 { + parameters: Arc::new(p), + }; + let state = StateHD::new(reduced_temperature, reduced_volume, moles.clone()); + let a = pt.helmholtz_energy(&state) / moles[0]; + dbg!(a.re()); + assert_relative_eq!(a, 0.1130778070897391, epsilon = 1e-10); + + // #temp = 3.0, rho = 1.1, nu = 20 + // Hard sphere adhs 5.458989212531771 + //Delta a0 0.3405167374787895 + let reduced_temperature = 3.0; + let reduced_density = 1.1; + let reduced_volume = moles[0] / reduced_density; + + let p = test_parameters(20.0, 6.0, 1.0, 1.0); + let pt = ReferencePerturbationUVB3 { + parameters: Arc::new(p), + }; + let state = StateHD::new(reduced_temperature, reduced_volume, moles.clone()); + let a = pt.helmholtz_energy(&state) / moles[0]; + + assert_relative_eq!(a, 0.3405167374787895, epsilon = 1e-10); + } +} diff --git a/src/uvtheory/mod.rs b/src/uvtheory/mod.rs index 481932928..9bcd8a9d2 100644 --- a/src/uvtheory/mod.rs +++ b/src/uvtheory/mod.rs @@ -4,7 +4,7 @@ mod eos; mod parameters; -pub use eos::{Perturbation, UVTheory, UVTheoryOptions}; +pub use eos::{Perturbation, UVTheory, UVTheoryOptions, VirialOrder}; pub use parameters::{UVBinaryRecord, UVParameters, UVRecord}; #[cfg(feature = "python")] diff --git a/src/uvtheory/python.rs b/src/uvtheory/python.rs index b442971d7..5454f8c77 100644 --- a/src/uvtheory/python.rs +++ b/src/uvtheory/python.rs @@ -1,5 +1,5 @@ use super::parameters::{NoRecord, UVBinaryRecord, UVParameters, UVRecord}; -use super::Perturbation; +use super::{Perturbation, VirialOrder}; use feos_core::parameter::{ BinaryRecord, Identifier, IdentifierOption, Parameter, ParameterError, PureRecord, }; @@ -112,6 +112,7 @@ pub fn uvtheory(_py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_class::()?; m.add_class::()?; + m.add_class::()?; m.add_class::()?; m.add_class::()?; m.add_class::()?; From cc4e6f64288e0597da635636feb1ad1adbddcbdb Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Fri, 23 Dec 2022 07:44:53 +0100 Subject: [PATCH 02/14] update python.rs --- src/python/eos.rs | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/src/python/eos.rs b/src/python/eos.rs index 8207c72a0..52ed21588 100644 --- a/src/python/eos.rs +++ b/src/python/eos.rs @@ -24,7 +24,7 @@ use crate::saftvrqmie::{FeynmanHibbsOrder, SaftVRQMie, SaftVRQMieOptions}; #[cfg(feature = "uvtheory")] use crate::uvtheory::python::PyUVParameters; #[cfg(feature = "uvtheory")] -use crate::uvtheory::{Perturbation, UVTheory, UVTheoryOptions}; +use crate::uvtheory::{Perturbation, UVTheory, UVTheoryOptions, VirialOrder}; use feos_core::cubic::PengRobinson; use feos_core::python::cubic::PyPengRobinsonParameters; @@ -220,13 +220,23 @@ impl PyEosVariant { /// The UV-Theory equation of state that can be used to compute thermodynamic /// states. #[cfg(feature = "uvtheory")] - #[args(max_eta = "0.5", perturbation = "Perturbation::WeeksChandlerAndersen")] + #[args( + max_eta = "0.5", + perturbation = "Perturbation::WeeksChandlerAndersen", + virial_order = "VirialOrder::Second" + )] #[staticmethod] - #[pyo3(text_signature = "(parameters, max_eta, perturbation)")] - fn uvtheory(parameters: PyUVParameters, max_eta: f64, perturbation: Perturbation) -> Self { + #[pyo3(text_signature = "(parameters, max_eta, perturbation, virial_order)")] + fn uvtheory( + parameters: PyUVParameters, + max_eta: f64, + perturbation: Perturbation, + virial_order: VirialOrder, + ) -> Self { let options = UVTheoryOptions { max_eta, perturbation, + virial_order, }; Self(Arc::new(EosVariant::UVTheory(UVTheory::with_options( parameters.0, From 84b2fc48757ce5e1e4f40920002e5ac46a9eeeb4 Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Fri, 23 Dec 2022 14:32:51 +0100 Subject: [PATCH 03/14] add expample, rounded parameters --- examples/uvtheory_versions.ipynb | 471 ++++++++++-------- .../eos/attractive_perturbation_uvb3.rs | 102 ++-- src/uvtheory/eos/mod.rs | 4 +- 3 files changed, 332 insertions(+), 245 deletions(-) diff --git a/examples/uvtheory_versions.ipynb b/examples/uvtheory_versions.ipynb index ed6a6f72a..801d2a39b 100644 --- a/examples/uvtheory_versions.ipynb +++ b/examples/uvtheory_versions.ipynb @@ -2,14 +2,13 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from feos.si import *\n", - "from feos.uvtheory import UVParameters, Perturbation\n", - "from feos.pets import PetsParameters\n", + "from feos.uvtheory import UVParameters, Perturbation, VirialOrder\n", "from feos.eos import State, PhaseEquilibrium, PhaseDiagram, EquationOfState, Contributions\n", "import matplotlib.pyplot as plt" ] @@ -23,8 +22,12 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, + "execution_count": 2, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, "outputs": [], "source": [ "# Parameters for Thol EoS:\n", @@ -114,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -267,9 +270,19 @@ "---" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Define different Versions of the uv-theroy**\n", + "- WCA uv-theory [J. Chem. Phys. 155, 244501 (2021)]\n", + "- BH uv-theory [J. Chem. Phys. 155, 244501 (2021)]\n", + "- uv-$B_3$-theory [to be published]" + ] + }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -281,42 +294,36 @@ " \n", " if name == 'uv_wca':\n", " parameters = UVParameters.from_lists([rep], [att], [sigma], [eps_k])\n", - " eos = EquationOfState.uvtheory(parameters, perturbation=Perturbation.WeeksChandlerAndersen)\n", + " eos = EquationOfState.uvtheory(parameters, perturbation=Perturbation.WeeksChandlerAndersen, virial_order=VirialOrder.Second)\n", " \n", " if name == 'uv_bh':\n", - " parameters = UVParameters.from_lists([nu], [rep], [sigma], [eps_k])\n", - " eos = EquationOfState.uvtheory(parameters, perturbation=Perturbation.BarkerHenderson) \n", + " parameters = UVParameters.from_lists([rep], [att], [sigma], [eps_k])\n", + " eos = EquationOfState.uvtheory(parameters, perturbation=Perturbation.BarkerHenderson, virial_order=VirialOrder.Second) \n", "\n", " if name == 'uv_b3':\n", - " parameters = UVParameters.from_lists([nu], [rep], [sigma], [eps_k], virial_order=VirialOrder.Third)\n", - " eos = EquationOfState.uvb3(parameters)\n", + " parameters = UVParameters.from_lists([rep], [att], [sigma], [eps_k])\n", + " eos = EquationOfState.uvtheory(parameters, perturbation=Perturbation.WeeksChandlerAndersen, virial_order=VirialOrder.Third)\n", " \n", " \n", " return EOS_PROPERTIES(eos, sigma=sigma, eps_k=eps_k, rep=rep, att=att)\n", " " ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Examples**" + ] + }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 5, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'VirialOrder' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0muv_bh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_eos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'uv_bh'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msigma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps_k\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0matt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0muv_wca\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_eos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'uv_wca'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msigma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps_k\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0matt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0muv_b3\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_eos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'uv_b3'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msigma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meps_k\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0matt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m\u001b[0m in \u001b[0;36mget_eos\u001b[0;34m(name, rep, sigma, eps_k, att)\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'uv_b3'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mparameters\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mUVParameters\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_lists\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnu\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mrep\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0msigma\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0meps_k\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvirial_order\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mVirialOrder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mThird\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 17\u001b[0m \u001b[0meos\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEquationOfState\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muvb3\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'VirialOrder' is not defined" - ] - } - ], + "outputs": [], "source": [ "rep = 12\n", - "att = 6\n", + "att = 6.0\n", "sigma = 3.7039 # in Angstrom\n", "eps_k = 150.03 # eps / kB in K\n", "thol = get_eos('thol', rep, sigma, eps_k, att)\n", @@ -325,296 +332,359 @@ "uv_b3 = get_eos('uv_b3', rep, sigma, eps_k, att)" ] }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2.1384039006646205" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rho = 1.0\n", - "temp = 5\n", - "thol.res_helmholtz_energy(rho, temp)" - ] - }, { "cell_type": "markdown", "metadata": {}, "source": [ - "---" + "**Lennard-Jones (LJ) Virial coefficients**" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "sigma = 3.7039\n", - "sigma_a = sigma * ANGSTROM\n", - "eps_k = 150.03\n", - "eps_k_k = eps_k * KELVIN\n", - "\n", - "parameters = UVParameters.from_lists([12.0], [6.0], [sigma], [eps_k])\n", - "uvtheory_wca = EquationOfState.uvtheory(parameters)\n", - "uvtheory_bh = EquationOfState.uvtheory(parameters, perturbation=Perturbation.BarkerHenderson)\n", - "\n", - "parameters = PetsParameters.from_values(sigma, eps_k)\n", - "pets = EquationOfState.pets(parameters)\n", - "\n", - "thol = EquationOfState.python(Thol())\n", - "s3 = State(thol, temperature=300*KELVIN, pressure=1*BAR)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "s1 = State(uvtheory_wca, temperature=300*KELVIN, pressure=1*BAR)\n", - "s2 = State(pets, temperature=300*KELVIN, pressure=1*BAR)\n", - "s3 = State(thol, temperature=300*KELVIN, pressure=1*BAR)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": 9, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "-0.0016213224956115704" + "
" ] }, - "execution_count": 8, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "s1.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" + "def plot_second_virial_coeff():\n", + " tvec = np.linspace(0.5, 20, 500)\n", + " b2_thol = []\n", + " b2_uv_wca = []\n", + " b2_uv_bh = []\n", + " b2_uv_b3 = []\n", + " for temp in tvec:\n", + " b2_thol.append(thol.second_virial_coefficient(temp))\n", + " b2_uv_wca.append(uv_wca.second_virial_coefficient(temp))\n", + " b2_uv_bh.append(uv_bh.second_virial_coefficient(temp))\n", + " b2_uv_b3.append(uv_b3.second_virial_coefficient(temp))\n", + "\n", + " plt.plot(1/tvec, b2_thol, '--', label='Thol')\n", + " #plt.plot(1/tvec, b2_uv_bh, ':', label='uv-BH')\n", + " plt.plot(1/tvec, b2_uv_wca, '.', label='uv-WCA')\n", + " plt.plot(1/tvec, b2_uv_b3, label='uv-$B_3$')\n", + " plt.ylim(-20, 2)\n", + " plt.ylabel('$B_2 / \\\\sigma^3$')\n", + " plt.xlabel('$\\\\varepsilon/(k_BT)$')\n", + " plt.legend(frameon=False)\n", + " return\n", + "plot_second_virial_coeff()" ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, + "execution_count": 10, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "-0.0009407040108813868" + "
" ] }, - "execution_count": 9, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "s2.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" + "def plot_third_virial_coeff():\n", + " tvec = np.linspace(0.5, 20, 800)\n", + " b2_thol = []\n", + " b2_uv_wca = []\n", + " b2_uv_bh = []\n", + " b2_uv_b3 = []\n", + " for temp in tvec:\n", + " b2_thol.append(thol.third_virial_coefficient(temp))\n", + " b2_uv_wca.append(uv_wca.third_virial_coefficient(temp))\n", + " b2_uv_bh.append(uv_bh.third_virial_coefficient(temp))\n", + " b2_uv_b3.append(uv_b3.third_virial_coefficient(temp))\n", + "\n", + " plt.plot(1/tvec, b2_thol, '--', label='Thol')\n", + " #plt.plot(1/tvec, b2_uv_bh, ':', label='uv-BH')\n", + " plt.plot(1/tvec, b2_uv_wca, '.', label='uv-WCA')\n", + " plt.plot(1/tvec, b2_uv_b3, label='uv-$B_3$')\n", + " plt.ylim(-10, 10)\n", + " plt.ylabel('$B_3 / \\\\sigma^6$')\n", + " plt.xlabel('$\\\\varepsilon/(k_BT)$')\n", + " plt.legend(frameon=False)\n", + " return\n", + "plot_third_virial_coeff()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**LJ Isotherms**" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 192, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "-0.0016144150962601586" + "
" ] }, - "execution_count": 10, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "s3.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" + "def plot_helmholtz_energy(temperature, dimensionless_density = np.linspace(0.01, 1.1, 100)):\n", + " \n", + " a_thol = []\n", + " a_uv_bh = []\n", + " a_uv_wca = []\n", + " a_uv_b3 = []\n", + " for rho in dimensionless_density:\n", + " a_thol.append(thol.res_helmholtz_energy(rho, temperature))\n", + " a_uv_bh.append(uv_bh.res_helmholtz_energy(rho, temperature))\n", + " a_uv_wca.append(uv_bh.res_helmholtz_energy(rho, temperature))\n", + " a_uv_b3.append(uv_b3.res_helmholtz_energy(rho, temperature))\n", + " \n", + " plt.plot(dimensionless_density, a_thol, '--', label='Thol')\n", + " plt.plot(dimensionless_density, a_uv_bh, ':', label='uv-BH')\n", + " plt.plot(dimensionless_density, a_uv_wca, '.', label='uv-WCA')\n", + " plt.plot(dimensionless_density, a_uv_bh, label='uv-$B_3$')\n", + " plt.xlabel('$\\\\rho^*$')\n", + " plt.ylabel('$A/(Nk_BT)$')\n", + " plt.title('$T^*={}$'.format(temperature))\n", + " plt.legend(frameon=False)\n", + " return\n", + "plot_helmholtz_energy(temperature=0.5, dimensionless_density=np.linspace(0.01, 1.0, 100))" ] }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, + "execution_count": 193, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "(1.3200003469821506, 1.3097658041494302, 1.3208296613277393)" + "
" ] }, - "execution_count": 11, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "State.critical_point(thol).temperature / eps_k_k, State.critical_point(uvtheory_wca).temperature / eps_k_k, State.critical_point(uvtheory_bh).temperature / eps_k_k" + "def plot_heat_capcities(temperature):\n", + " dimensionless_density = np.linspace(0.01, 1.0, 100)\n", + " a_thol = []\n", + " a_uv_bh = []\n", + " a_uv_wca = []\n", + " a_uv_b3 = []\n", + " for rho in dimensionless_density:\n", + " a_thol.append(thol.heat_capacity_cv(rho, temperature))\n", + " a_uv_bh.append(uv_bh.heat_capacity_cv(rho, temperature))\n", + " a_uv_wca.append(uv_bh.heat_capacity_cv(rho, temperature))\n", + " a_uv_b3.append(uv_b3.heat_capacity_cv(rho, temperature))\n", + " \n", + " plt.plot(dimensionless_density, a_thol, '--', label='Thol')\n", + " plt.plot(dimensionless_density, a_uv_bh, ':', label='uv-BH')\n", + " plt.plot(dimensionless_density, a_uv_wca, '.', label='uv-WCA')\n", + " plt.plot(dimensionless_density, a_uv_bh, label='uv-$B_3$')\n", + " plt.xlabel('$\\\\rho^*$')\n", + " plt.ylabel('$C_v/Nk_B$')\n", + " plt.title('$T^*={}$'.format(temperature))\n", + " plt.legend(frameon=False)\n", + " return\n", + "plot_heat_capcities(1.4)\n", + " \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Critical Point**" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 52.5 ms, sys: 1.45 ms, total: 54 ms\n", - "Wall time: 54.2 ms\n" + "Critical point LJ Fluid\n", + "Reference: Potoff and Panagiotopoulos (MC) Tc*=1.3120, rhoc*=0.316, pc*=0.1279\n", + "uv_b3\n", + "Tc*=1.31329, ADD: 0.099%\n", + "pc*=0.1286, ADD: 0.548%\n", + "rhoc*=0.31425, ADD: 0.553%\n", + "uv_wca\n", + "Tc*=1.30977, ADD: 0.17%\n", + "pc*=0.12448, ADD: 2.674%\n", + "rhoc*=0.30233, ADD: 4.327%\n", + "uv_bh\n", + "Tc*=1.32083, ADD: 0.673%\n", + "pc*=0.13486, ADD: 5.442%\n", + "rhoc*=0.31865, ADD: 0.838%\n" ] } ], "source": [ - "%%time\n", - "vle_uv = PhaseDiagram.pure(uvtheory_wca, 150*KELVIN, 500)" + "def evaluate_critical_points():\n", + " print('Critical point LJ Fluid')\n", + " print('Reference: Potoff and Panagiotopoulos (MC) Tc*=1.3120, rhoc*=0.316, pc*=0.1279')\n", + " for name in ['uv_b3', 'uv_wca', 'uv_bh']:\n", + " rep = 12\n", + " att = 6.0\n", + " sigma = 3.7039 # in Angstrom\n", + " eps_k = 150.03 # eps / kB in K\n", + " eos = get_eos(name, rep, sigma, eps_k, att)\n", + " print(name)\n", + " print('Tc*={}, ADD: {}%'.format(np.round(eos.critical_temperature(), 5), np.round(np.abs(eos.critical_temperature() - 1.3120 ) / 1.3120 * 100 ,3)))\n", + " print('pc*={}, ADD: {}%'.format(np.round(eos.critical_pressure(), 5), np.round(np.abs(eos.critical_pressure() - 0.1279 ) / 0.1279 * 100 ,3)))\n", + " print('rhoc*={}, ADD: {}%'.format(np.round(eos.critical_density(), 5), np.round(np.abs(eos.critical_density() - 0.316) / 0.316 * 100 ,3)))\n", + " return\n", + "\n", + "evaluate_critical_points()\n" ] }, { - "cell_type": "code", - "execution_count": 13, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "vle_uv.liquid" + "**VLE**" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 225, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 49 ms, sys: 1.77 ms, total: 50.7 ms\n", - "Wall time: 52.6 ms\n" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "%%time\n", - "vle_uv_bh = PhaseDiagram.pure(uvtheory_bh, 150*KELVIN, 500)" + "def plot_vle():\n", + " names = ['uv_wca', 'uv_bh', 'uv_b3']\n", + " for name in names:\n", + " axes = plt.gca()\n", + " color = next(axes._get_lines.prop_cycler)['color']\n", + " rep = 12\n", + " att = 6.0\n", + " sigma = 3.7039 # in Angstrom\n", + " eps_k = 150.03 # eps / kB in K\n", + " eos = get_eos(name, rep, sigma, eps_k, att)\n", + " tc = eos.critical_temperature()\n", + " eos_rhol = []\n", + " eos_rhov = []\n", + " temperatures = np.linspace(0.7, 0.99999 *tc, 100)\n", + " for temp in temperatures:\n", + " eos_rhol.append(eos.liquid_density(temp))\n", + " eos_rhov.append(eos.vapor_density(temp))\n", + " plt.plot(eos.critical_density(), eos.critical_temperature(), 'x', color=color)\n", + " plt.plot( eos_rhov, temperatures, color=color)\n", + " plt.plot( eos_rhol, temperatures, color=color, label='{}'.format(name))\n", + " plt.legend(frameon=False)\n", + " plt.xlabel('$\\\\rho^*$')\n", + " plt.ylabel('$T^*$')\n", + " return\n", + "plot_vle()" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 7, "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:65: RuntimeWarning: overflow encountered in exp\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:65: RuntimeWarning: invalid value encountered in exp\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:68: RuntimeWarning: overflow encountered in exp\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n", - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:68: RuntimeWarning: invalid value encountered in exp\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 1.9 s, sys: 16.4 ms, total: 1.92 s\n", - "Wall time: 1.93 s\n" - ] + "data": { + "text/plain": [ + "-8.215650382226158e-15" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "%%time\n", - "vle_thol = PhaseDiagram.pure(thol, 150*KELVIN, 500)" + "uv_b3.res_helmholtz_energy(1,1) - -1.975385053056555" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 8, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 27 ms, sys: 1.68 ms, total: 28.7 ms\n", - "Wall time: 32.6 ms\n" - ] + "data": { + "text/plain": [ + "-2.9976021664879227e-15" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "%%time\n", - "vle_pets = PhaseDiagram.pure(pets, 150*KELVIN, 500)" + "uv_b3.res_helmholtz_energy(1,2) - 0.9239674467936894" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "6.572520305780927e-14" ] }, - "execution_count": 17, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" } ], "source": [ - "s3 = NAV * sigma_a**3\n", - "plt.plot(vle_uv.vapor.density * s3 , vle_uv.vapor.temperature / eps_k_k, color='black')\n", - "plt.plot(vle_uv.liquid.density * s3, vle_uv.vapor.temperature / eps_k_k, color='black')\n", - "\n", - "plt.plot(vle_uv_bh.vapor.density * s3 , vle_uv_bh.vapor.temperature / eps_k_k, color='black', linestyle='dashed')\n", - "plt.plot(vle_uv_bh.liquid.density * s3, vle_uv_bh.vapor.temperature / eps_k_k, color='black', linestyle='dashed')\n", - "\n", - "plt.plot(vle_thol.vapor.density * s3, vle_thol.vapor.temperature / eps_k_k, color='red')\n", - "plt.plot(vle_thol.liquid.density * s3, vle_thol.vapor.temperature / eps_k_k, color='red')" + "uv_b3.residual_pressure(1,2) - 13.040302811478417" ] }, { @@ -622,18 +692,21 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "vle_thol = PhaseDiagram.pure(thol, 150*KELVIN, 500)\n", - "s3 = NAV * sigma_a**3\n", - "plt.plot(vle_uv.vapor.density * s3 , vle_uv.vapor.temperature / eps_k_k, color='black')" - ] + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "venv_feos05", "language": "python", - "name": "python3" + "name": "venv_feos05" }, "language_info": { "codemirror_mode": { diff --git a/src/uvtheory/eos/attractive_perturbation_uvb3.rs b/src/uvtheory/eos/attractive_perturbation_uvb3.rs index 90e6fbf06..edda6521a 100644 --- a/src/uvtheory/eos/attractive_perturbation_uvb3.rs +++ b/src/uvtheory/eos/attractive_perturbation_uvb3.rs @@ -66,47 +66,59 @@ const CONST_B2_RSAP: [[f64; 4]; 4] = [ [0.007492596, 0.546171170, 7.979562575, -119.6126395], ]; -// Constants for B3 +// Constants for B3 (full, not rounded) +// const CONST_B3_LJ_RSAP: [f64; 16] = [ +// -3.98056703e+00, +// 7.95645979e+01, +// 5.48947334e-01, +// 5.36319582e+00, +// 1.42454153e+00, +// 5.72923297e+01, +// 3.80631996e-10, +// 1.00308510e+00, +// -3.97550628e+01, +// -8.12130965e+01, +// 6.98683893e-01, +// 3.01563968e+01, +// -2.36919346e+01, +// -8.50060515e+01, +// 7.76154927e-01, +// 1.27979994e+01, +// ]; +//rounded values: const CONST_B3_LJ_RSAP: [f64; 16] = [ - -3.98056703e+00, - 7.95645979e+01, - 5.48947334e-01, - 5.36319582e+00, - 1.42454153e+00, - 5.72923297e+01, - 3.80631996e-10, - 1.00308510e+00, - -3.97550628e+01, - -8.12130965e+01, - 6.98683893e-01, - 3.01563968e+01, - -2.36919346e+01, - -8.50060515e+01, - 7.76154927e-01, - 1.27979994e+01, + -3.9806, 79.565, 0.5489, 5.3632, 1.4245, 57.292, 0.0, 1.0031, -39.755, -81.213, 0.6987, 30.156, + -23.692, -85.006, 0.7762, 12.798, ]; -// Constants for B3 RSAP Mie nu-6 fluids -const B3_K_PARAMETER: [f64; 4] = [8.08442174e-01, -9.54092759e-02, 4.75253015e-01, -2.83282674]; -const B3_L_PARAMETER: [f64; 4] = [4.94848492, -21.2995618, 7.0, 3.21621955]; -const B3_M_PARAMETER: [f64; 4] = [ - 1.18534625e-01, - 7.85559789e-02, - -5.50389332e-01, - 9.16296297e-03, -]; - -/// Constants for WCA u-fraction. -const CU_WCA: [f64; 8] = [ - 26.45397287, - 1.80454811, - 1.79970006, - 161.95895155, - 11.60539317, - 12., - 0.4, - 2.0, -]; +// // Constants for B3 RSAP Mie nu-6 fluids (not rounded) +// const B3_K_PARAMETER: [f64; 4] = [8.08442174e-01, -9.54092759e-02, 4.75253015e-01, -2.83282674]; +// const B3_L_PARAMETER: [f64; 4] = [4.94848492, -21.2995618, 7.0, 3.21621955]; +// const B3_M_PARAMETER: [f64; 4] = [ +// 1.18534625e-01, +// 7.85559789e-02, +// -5.50389332e-01, +// 9.16296297e-03, +// ]; + +// // Constants for B3 RSAP Mie nu-6 fluids ( rounded) +const B3_K_PARAMETER: [f64; 4] = [0.80844, -0.09541, 0.47525, -2.83283]; +const B3_L_PARAMETER: [f64; 4] = [4.9485, -21.3, 7.0, 3.2162]; +const B3_M_PARAMETER: [f64; 4] = [0.11853, 0.078556, -0.55039, 0.009163]; + +/// Constants for WCA u-fraction. (unrounded) +// const CU_WCA: [f64; 8] = [ +// 26.45397287, +// 1.80454811, +// 1.79970006, +// 161.95895155, +// 11.60539317, +// 12., +// 0.4, +// 2.0, +// ]; +// rounded values: +const CU_WCA: [f64; 8] = [26.454, 1.8045, 1.7997, 161.96, 11.605, 12., 0.4, 2.0]; #[derive(Debug, Clone)] pub struct AttractivePerturbationUVB3 { @@ -490,7 +502,8 @@ mod test { state.partial_density.sum() * (x * &p.sigma.mapv(|s| s.powi(3))).sum(), t_x, ); - assert_relative_eq!(u_fraction_wca.re(), 0.8852730008077649, epsilon = 1e-10); + //with unrounded params: assert_relative_eq!(u_fraction_wca.re(), 0.8852730008077649, epsilon = 1e-10); + assert_relative_eq!(u_fraction_wca.re(), 0.8852775506870431, epsilon = 1e-10); // delta a1u let i_wca = correlation_integral_wca(rho_x, mean_field_constant_x, rep_x, att_x, d_x, q_vdw, rm_x); @@ -505,18 +518,19 @@ mod test { assert_relative_eq!(b21u.re(), -1.5103749286162982, epsilon = 1e-10); let db3 = delta_b3(t_x, rm_x, rep_x, att_x, d_x, q_vdw); - assert_relative_eq!(db3.re(), -0.6591646873435744, epsilon = 1e-10); + assert_relative_eq!(db3.re(), -0.6591980196661884, epsilon = 1e-10); + //non rounded params fpr B3:assert_relative_eq!(db3.re(), -0.6591646873435744, epsilon = 1e-10); let db31 = delta_b31u(t_x, weighted_sigma3_ij, rm_x, rep_x, att_x, d_x) / p.sigma[0].powi(6); - assert_relative_eq!(db31.re(), -1.2465186585663823, epsilon = 1e-10); - // b3.re() = 1.4326204530476152 - // b30_uv.re() = 2.0917851403911896 + // non rounded params for B3:: b3.re() = 1.4326204530476152 + // b30_uv.re() = 2.0917851403911896 // Full attractive perturbation: let a = pt.helmholtz_energy(&state) / moles[0]; - assert_relative_eq!(-0.9027781726598461, a.re(), epsilon = 1e-5); + assert_relative_eq!(-0.9027781694834115, a.re(), epsilon = 1e-5); + //non rounded params for B3: assert_relative_eq!(-0.9027781726598461, a.re(), epsilon = 1e-5); } } diff --git a/src/uvtheory/eos/mod.rs b/src/uvtheory/eos/mod.rs index 4e914a7cc..2dd558e83 100644 --- a/src/uvtheory/eos/mod.rs +++ b/src/uvtheory/eos/mod.rs @@ -252,8 +252,8 @@ mod test { .molar_helmholtz_energy(Contributions::ResidualNvt) .to_reduced(RGAS * temperature) .unwrap(); - - assert_relative_eq!(a, 0.37659378806627525, max_relative = 1e-12) + dbg!(a); + assert_relative_eq!(a, 0.37659379124271003, max_relative = 1e-12) } #[test] From 44ab0aa55897d3a267c9461063a484bc5bd0a050 Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Mon, 9 Jan 2023 12:00:35 +0100 Subject: [PATCH 04/14] change constant names, delete unnecessary variables and comments --- examples/uvtheory_versions.ipynb | 228 +++--------------- .../eos/attractive_perturbation_uvb3.rs | 155 ++++-------- src/uvtheory/eos/hard_sphere_bh.rs | 15 +- src/uvtheory/eos/hard_sphere_wca.rs | 156 ++++++------ src/uvtheory/eos/mod.rs | 4 +- 5 files changed, 168 insertions(+), 390 deletions(-) diff --git a/examples/uvtheory_versions.ipynb b/examples/uvtheory_versions.ipynb index 801d2a39b..6a7291d5d 100644 --- a/examples/uvtheory_versions.ipynb +++ b/examples/uvtheory_versions.ipynb @@ -17,90 +17,28 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "**Thol EoS for Comparison**" + "# **Comparison of differrent versions of the uv-theory for Mie fluids**" ] }, { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "jupyter": { - "source_hidden": true - } - }, - "outputs": [], + "cell_type": "markdown", + "metadata": {}, "source": [ - "# Parameters for Thol EoS:\n", - "A = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0,\n", - " 2.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0])\n", - "N = np.array([0.005208073, 2.186252000, -2.161016000, 1.452700000, -2.041792000, 0.186952860, -0.090988445, \n", - " -0.497456100, 0.109014310, -0.800559220, -0.568839000, -0.620862500, -1.466717700, 1.891469000, \n", - " -0.138370100, -0.386964500, 0.126570200, 0.605781000, 1.179189000, -0.477326790, -9.921857500, -0.574793200, 0.003772923])\n", - "T = np.array([1.000, 0.320, 0.505, 0.672, 0.843, 0.898, 1.294, 2.590, 1.786, 2.770, 1.786,\n", - " 1.205, 2.830, 2.548, 4.650, 1.385, 1.460, 1.351, 0.660, 1.496, 1.830, 1.616, 4.970])\n", - "D = np.array([4.0, 1.0, 1.0, 2.0, 2.0, 3.0, 5.0, 2.0, 2.0, 3.0, 1.0,\n", - " 1.0, 1.0, 1.0, 2.0, 3.0, 3.0, 2.0, 1.0, 2.0, 3.0, 1.0, 1.0])\n", - "L = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 1.0, 2.0, 2.0,\n", - " 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])\n", - "ETA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2.067, 1.522,\n", - " 8.82, 1.722, 0.679, 1.883, 3.925, 2.461, 28.2, 0.753, 0.82])\n", - "BETA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.625,\n", - " 0.638, 3.91, 0.156, 0.157, 0.153, 1.16, 1.73, 383, 0.112, 0.119])\n", - "GAMMA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.71,\n", - " 0.86, 1.94, 1.48, 1.49, 1.945, 3.02, 1.11, 1.17, 1.33, 0.24])\n", - "EPSILON = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.2053,\n", - " 0.409, 0.6, 1.203, 1.829, 1.397, 1.39, 0.539, 0.934, 2.369, 2.43])\n", - "\n", - "class Thol:\n", - " def __init__(self, sigma, eps_k):\n", - " self.sigma = sigma * ANGSTROM\n", - " self.eps_k = eps_k * KELVIN\n", - " self.tc = 1.32 * self.eps_k / KELVIN\n", - " self.rhoc = 0.31 / self.sigma**3 * ANGSTROM**3\n", - " \n", - " def components(self): \n", - " return 1\n", - " \n", - " def subset(self, components):\n", - " return self\n", - " \n", - " def molar_weight(self):\n", - " return np.array([1.0])\n", - " \n", - " def max_density(self, moles):\n", - " return 0.04\n", - " \n", - " def helmholtz_energy(self, state):\n", - " \"\"\"\n", - " state (StateHD):\n", - " temperature in Kelvin als Float, Dual oder HD oder HD3, HDD, HDD3,\n", - " partial_density in # / Angstrom^3\n", - " volume in Angstrom^3\n", - " moles in mol\n", - " \"\"\"\n", - " tau = self.tc / state.temperature\n", - " delta = np.sum(state.partial_density) / self.rhoc\n", - " a = 0.0 #zero(state)\n", - " \n", - " # print(\"v\", state.volume)\n", - " # print(\"n\", state.moles)\n", - " #print(\"partial density\", state.partial_density)\n", - " #print(\"1\")\n", - " # print(\"delta: {}\".format(delta))\n", - " # print(\"tau: {}\".format(tau))\n", - " \n", - " for i in range(6):\n", - " a = a + N[i] * delta**D[i] * tau**T[i]\n", - " \n", - " # print(\"2\")\n", - " for i in range(6, 12):\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", - " # print(\"3\")\n", - " for i in range(12, 23):\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n", - " return a * np.sum(state.moles)" + "- WCA uv-theory [J. Chem. Phys. 155, 244501 (2021)]\n", + "- BH uv-theory [J. Chem. Phys. 155, 244501 (2021)]\n", + "- uv-$B_3$-theory [to be published]\n", + " - highly accurate\n", + " - only for attractive exponents of 6\n", + " - based on WCA divison of the potential" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -117,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -270,19 +208,9 @@ "---" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Define different Versions of the uv-theroy**\n", - "- WCA uv-theory [J. Chem. Phys. 155, 244501 (2021)]\n", - "- BH uv-theory [J. Chem. Phys. 155, 244501 (2021)]\n", - "- uv-$B_3$-theory [to be published]" - ] - }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -318,7 +246,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -326,7 +254,6 @@ "att = 6.0\n", "sigma = 3.7039 # in Angstrom\n", "eps_k = 150.03 # eps / kB in K\n", - "thol = get_eos('thol', rep, sigma, eps_k, att)\n", "uv_bh = get_eos('uv_bh', rep, sigma, eps_k, att)\n", "uv_wca = get_eos('uv_wca', rep, sigma, eps_k, att)\n", "uv_b3 = get_eos('uv_b3', rep, sigma, eps_k, att)" @@ -342,15 +269,11 @@ { "cell_type": "code", "execution_count": 9, - "metadata": { - "jupyter": { - "source_hidden": true - } - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -367,14 +290,12 @@ " b2_uv_bh = []\n", " b2_uv_b3 = []\n", " for temp in tvec:\n", - " b2_thol.append(thol.second_virial_coefficient(temp))\n", " b2_uv_wca.append(uv_wca.second_virial_coefficient(temp))\n", " b2_uv_bh.append(uv_bh.second_virial_coefficient(temp))\n", " b2_uv_b3.append(uv_b3.second_virial_coefficient(temp))\n", "\n", - " plt.plot(1/tvec, b2_thol, '--', label='Thol')\n", - " #plt.plot(1/tvec, b2_uv_bh, ':', label='uv-BH')\n", - " plt.plot(1/tvec, b2_uv_wca, '.', label='uv-WCA')\n", + " plt.plot(1/tvec, b2_uv_bh, ':', label='uv-BH')\n", + " plt.plot(1/tvec, b2_uv_wca, '--', label='uv-WCA')\n", " plt.plot(1/tvec, b2_uv_b3, label='uv-$B_3$')\n", " plt.ylim(-20, 2)\n", " plt.ylabel('$B_2 / \\\\sigma^3$')\n", @@ -386,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": { "jupyter": { "source_hidden": true @@ -395,7 +316,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -407,19 +328,17 @@ "source": [ "def plot_third_virial_coeff():\n", " tvec = np.linspace(0.5, 20, 800)\n", - " b2_thol = []\n", + " \n", " b2_uv_wca = []\n", " b2_uv_bh = []\n", " b2_uv_b3 = []\n", " for temp in tvec:\n", - " b2_thol.append(thol.third_virial_coefficient(temp))\n", " b2_uv_wca.append(uv_wca.third_virial_coefficient(temp))\n", " b2_uv_bh.append(uv_bh.third_virial_coefficient(temp))\n", " b2_uv_b3.append(uv_b3.third_virial_coefficient(temp))\n", "\n", - " plt.plot(1/tvec, b2_thol, '--', label='Thol')\n", " #plt.plot(1/tvec, b2_uv_bh, ':', label='uv-BH')\n", - " plt.plot(1/tvec, b2_uv_wca, '.', label='uv-WCA')\n", + " plt.plot(1/tvec, b2_uv_wca, '--', label='uv-WCA')\n", " plt.plot(1/tvec, b2_uv_b3, label='uv-$B_3$')\n", " plt.ylim(-10, 10)\n", " plt.ylabel('$B_3 / \\\\sigma^6$')\n", @@ -438,12 +357,12 @@ }, { "cell_type": "code", - "execution_count": 192, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -454,20 +373,17 @@ ], "source": [ "def plot_helmholtz_energy(temperature, dimensionless_density = np.linspace(0.01, 1.1, 100)):\n", - " \n", - " a_thol = []\n", + "\n", " a_uv_bh = []\n", " a_uv_wca = []\n", " a_uv_b3 = []\n", " for rho in dimensionless_density:\n", - " a_thol.append(thol.res_helmholtz_energy(rho, temperature))\n", " a_uv_bh.append(uv_bh.res_helmholtz_energy(rho, temperature))\n", " a_uv_wca.append(uv_bh.res_helmholtz_energy(rho, temperature))\n", " a_uv_b3.append(uv_b3.res_helmholtz_energy(rho, temperature))\n", " \n", - " plt.plot(dimensionless_density, a_thol, '--', label='Thol')\n", - " plt.plot(dimensionless_density, a_uv_bh, ':', label='uv-BH')\n", - " plt.plot(dimensionless_density, a_uv_wca, '.', label='uv-WCA')\n", + " plt.plot(dimensionless_density, a_uv_bh, '--', label='uv-BH')\n", + " plt.plot(dimensionless_density, a_uv_wca, ':', label='uv-WCA')\n", " plt.plot(dimensionless_density, a_uv_bh, label='uv-$B_3$')\n", " plt.xlabel('$\\\\rho^*$')\n", " plt.ylabel('$A/(Nk_BT)$')\n", @@ -586,7 +502,11 @@ { "cell_type": "code", "execution_count": 225, - "metadata": {}, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, "outputs": [ { "data": { @@ -626,80 +546,6 @@ " return\n", "plot_vle()" ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-8.215650382226158e-15" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "uv_b3.res_helmholtz_energy(1,1) - -1.975385053056555" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-2.9976021664879227e-15" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "uv_b3.res_helmholtz_energy(1,2) - 0.9239674467936894" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "6.572520305780927e-14" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "uv_b3.residual_pressure(1,2) - 13.040302811478417" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/src/uvtheory/eos/attractive_perturbation_uvb3.rs b/src/uvtheory/eos/attractive_perturbation_uvb3.rs index edda6521a..902b165f8 100644 --- a/src/uvtheory/eos/attractive_perturbation_uvb3.rs +++ b/src/uvtheory/eos/attractive_perturbation_uvb3.rs @@ -59,65 +59,23 @@ const C_WCA: [[f64; 6]; 6] = [ ]; // Constants for delta B2 RSAP -const CONST_B2_RSAP: [[f64; 4]; 4] = [ +const C_B2_RSAP: [[f64; 4]; 4] = [ [-0.063550989, 6.206829830, -37.45829549, 40.72849774], [1.519053409, 13.14989643, 85.35058674, 374.1906360], [0.693456220, 9.459946180, -53.28984218, 315.8199084], [0.007492596, 0.546171170, 7.979562575, -119.6126395], ]; -// Constants for B3 (full, not rounded) -// const CONST_B3_LJ_RSAP: [f64; 16] = [ -// -3.98056703e+00, -// 7.95645979e+01, -// 5.48947334e-01, -// 5.36319582e+00, -// 1.42454153e+00, -// 5.72923297e+01, -// 3.80631996e-10, -// 1.00308510e+00, -// -3.97550628e+01, -// -8.12130965e+01, -// 6.98683893e-01, -// 3.01563968e+01, -// -2.36919346e+01, -// -8.50060515e+01, -// 7.76154927e-01, -// 1.27979994e+01, -// ]; -//rounded values: -const CONST_B3_LJ_RSAP: [f64; 16] = [ +// // Constants for B3 Model for Mie nu-6 fluids +const K_LJ_B3: [f64; 16] = [ -3.9806, 79.565, 0.5489, 5.3632, 1.4245, 57.292, 0.0, 1.0031, -39.755, -81.213, 0.6987, 30.156, -23.692, -85.006, 0.7762, 12.798, ]; -// // Constants for B3 RSAP Mie nu-6 fluids (not rounded) -// const B3_K_PARAMETER: [f64; 4] = [8.08442174e-01, -9.54092759e-02, 4.75253015e-01, -2.83282674]; -// const B3_L_PARAMETER: [f64; 4] = [4.94848492, -21.2995618, 7.0, 3.21621955]; -// const B3_M_PARAMETER: [f64; 4] = [ -// 1.18534625e-01, -// 7.85559789e-02, -// -5.50389332e-01, -// 9.16296297e-03, -// ]; - -// // Constants for B3 RSAP Mie nu-6 fluids ( rounded) -const B3_K_PARAMETER: [f64; 4] = [0.80844, -0.09541, 0.47525, -2.83283]; -const B3_L_PARAMETER: [f64; 4] = [4.9485, -21.3, 7.0, 3.2162]; -const B3_M_PARAMETER: [f64; 4] = [0.11853, 0.078556, -0.55039, 0.009163]; - -/// Constants for WCA u-fraction. (unrounded) -// const CU_WCA: [f64; 8] = [ -// 26.45397287, -// 1.80454811, -// 1.79970006, -// 161.95895155, -// 11.60539317, -// 12., -// 0.4, -// 2.0, -// ]; -// rounded values: +const P_B3: [f64; 4] = [0.80844, -0.09541, 0.47525, -2.83283]; +const L_B3: [f64; 4] = [4.9485, -21.3, 7.0, 3.2162]; +const M_B3: [f64; 4] = [0.11853, 0.078556, -0.55039, 0.009163]; + const CU_WCA: [f64; 8] = [26.454, 1.8045, 1.7997, 161.96, 11.605, 12., 0.4, 2.0]; #[derive(Debug, Clone)] @@ -345,12 +303,9 @@ fn coefficients_wca>(rep: D, att: D, d: D) -> [D; 6] { } // Residual second virial coefficient from Revised series approximation RSAP -fn factorial(num: i64) -> i64 { - return if num == 1 { - 1 - } else { - num * factorial(num - 1) - }; + +pub fn factorial(num: u64) -> u64 { + (1..=num).product() } fn delta_b2>(reduced_temperature: D, rep: f64, att: f64, q: D) -> D { @@ -359,29 +314,29 @@ fn delta_b2>(reduced_temperature: D, rep: f64, att: f64, q: D) - let b20 = q.powi(3) * 2.0 / 3.0 * PI; // eq. (16) let y = beta.exp() - 1.0; - let c1 = rep.recip() * CONST_B2_RSAP[0][1] - + (rep.powi(2)).recip() * CONST_B2_RSAP[0][2] - + (rep.powi(3)).recip() * CONST_B2_RSAP[0][3] - + CONST_B2_RSAP[0][0]; - - let c2 = rep.recip() * CONST_B2_RSAP[1][1] - + (rep.powi(2)).recip() * CONST_B2_RSAP[1][2] - + (rep.powi(3)).recip() * CONST_B2_RSAP[1][3] - + CONST_B2_RSAP[1][0]; - let c3 = rep.recip() * CONST_B2_RSAP[2][1] - + (rep.powi(2)).recip() * CONST_B2_RSAP[2][2] - + (rep.powi(3)).recip() * CONST_B2_RSAP[2][3] - + CONST_B2_RSAP[2][0]; - let c4 = rep.recip() * CONST_B2_RSAP[3][1] - + (rep.powi(2)).recip() * CONST_B2_RSAP[3][2] - + (rep.powi(3)).recip() * CONST_B2_RSAP[3][3] - + CONST_B2_RSAP[3][0]; + let c1 = rep.recip() * C_B2_RSAP[0][1] + + (rep.powi(2)).recip() * C_B2_RSAP[0][2] + + (rep.powi(3)).recip() * C_B2_RSAP[0][3] + + C_B2_RSAP[0][0]; + + let c2 = rep.recip() * C_B2_RSAP[1][1] + + (rep.powi(2)).recip() * C_B2_RSAP[1][2] + + (rep.powi(3)).recip() * C_B2_RSAP[1][3] + + C_B2_RSAP[1][0]; + let c3 = rep.recip() * C_B2_RSAP[2][1] + + (rep.powi(2)).recip() * C_B2_RSAP[2][2] + + (rep.powi(3)).recip() * C_B2_RSAP[2][3] + + C_B2_RSAP[2][0]; + let c4 = rep.recip() * C_B2_RSAP[3][1] + + (rep.powi(2)).recip() * C_B2_RSAP[3][2] + + (rep.powi(3)).recip() * C_B2_RSAP[3][3] + + C_B2_RSAP[3][0]; let mut sum_beta = beta; for i in 2..16 { - let k = factorial(i as i64) as f64 * i as f64; - sum_beta = sum_beta + beta.powi(i as i32) / k; + let k = factorial(i as u64) as f64 * i as f64; + sum_beta += beta.powi(i as i32) / k } (b20 - rm.powi(3) * 2.0 / 3.0 * PI - c1) * y - sum_beta * c2 - beta * c3 - beta.powi(2) * c4 @@ -409,33 +364,33 @@ fn delta_b3>(t_x: D, rm_x: f64, rep_x: f64, _att_x: f64, d_x: D, let beta = t_x.recip(); let b30 = (q_x.powi(3) * PI / 6.0).powi(2) * 10.0; - let b31 = ((t_x + CONST_B3_LJ_RSAP[2]) - .powf(((rep_x - 12.0) / (rep_x - 6.0) * B3_M_PARAMETER[0] + 1.0) * CONST_B3_LJ_RSAP[3])) + let b31 = ((t_x + K_LJ_B3[2]) + .powf(((rep_x - 12.0) / (rep_x - 6.0) * M_B3[0] + 1.0) * K_LJ_B3[3])) .recip() - * CONST_B3_LJ_RSAP[1] - * ((rep_x - 12.0) / (rep_x - B3_L_PARAMETER[0]) * B3_K_PARAMETER[0] + 1.0) - + CONST_B3_LJ_RSAP[0]; + * K_LJ_B3[1] + * ((rep_x - 12.0) / (rep_x - L_B3[0]) * P_B3[0] + 1.0) + + K_LJ_B3[0]; - let b32 = ((t_x + CONST_B3_LJ_RSAP[6]) - .powf(((rep_x - 12.0) / (rep_x - 6.0) * B3_M_PARAMETER[1] + 1.0) * CONST_B3_LJ_RSAP[7])) + let b32 = ((t_x + K_LJ_B3[6]) + .powf(((rep_x - 12.0) / (rep_x - 6.0) * M_B3[1] + 1.0) * K_LJ_B3[7])) .recip() - * CONST_B3_LJ_RSAP[5] - * ((rep_x - 12.0) / (rep_x - B3_L_PARAMETER[1]) * B3_K_PARAMETER[1] + 1.0) - + CONST_B3_LJ_RSAP[4]; + * K_LJ_B3[5] + * ((rep_x - 12.0) / (rep_x - L_B3[1]) * P_B3[1] + 1.0) + + K_LJ_B3[4]; - let b33 = ((t_x + CONST_B3_LJ_RSAP[10]) - .powf(((rep_x - 12.0) / (rep_x - 6.0) * B3_M_PARAMETER[2] + 1.0) * CONST_B3_LJ_RSAP[11])) + let b33 = ((t_x + K_LJ_B3[10]) + .powf(((rep_x - 12.0) / (rep_x - 6.0) * M_B3[2] + 1.0) * K_LJ_B3[11])) .recip() - * CONST_B3_LJ_RSAP[9] - * ((rep_x - 12.0) / (rep_x - B3_L_PARAMETER[2]) * B3_K_PARAMETER[2] + 1.0) - + CONST_B3_LJ_RSAP[8]; + * K_LJ_B3[9] + * ((rep_x - 12.0) / (rep_x - L_B3[2]) * P_B3[2] + 1.0) + + K_LJ_B3[8]; - let b34 = ((t_x + CONST_B3_LJ_RSAP[14]) - .powf(((rep_x - 12.0) / (rep_x - 6.0) * B3_M_PARAMETER[3] + 1.0) * CONST_B3_LJ_RSAP[15])) + let b34 = ((t_x + K_LJ_B3[14]) + .powf(((rep_x - 12.0) / (rep_x - 6.0) * M_B3[3] + 1.0) * K_LJ_B3[15])) .recip() - * CONST_B3_LJ_RSAP[13] - * ((rep_x - 12.0) / (rep_x - B3_L_PARAMETER[3]) * B3_K_PARAMETER[3] + 1.0) - + CONST_B3_LJ_RSAP[12]; + * K_LJ_B3[13] + * ((rep_x - 12.0) / (rep_x - L_B3[3]) * P_B3[3] + 1.0) + + K_LJ_B3[12]; let b3 = b30 + b31 * beta + b32 * beta.powi(2) + b33 * beta.powi(3) + b34 * beta.powi(4); @@ -445,10 +400,10 @@ fn delta_b3>(t_x: D, rm_x: f64, rep_x: f64, _att_x: f64, d_x: D, let rep_inv = rep_x.recip(); let c1_eta_a = tau - * (rep_inv * WCA_CONSTANTS_ETA_A_UVB3[[0, 1]] + WCA_CONSTANTS_ETA_A_UVB3[[0, 0]]) - + tau2 * (rep_inv * WCA_CONSTANTS_ETA_A_UVB3[[0, 3]] + WCA_CONSTANTS_ETA_A_UVB3[[0, 2]]); + * (rep_inv * WCA_CONSTANTS_ETA_A_UVB3[0][1] + WCA_CONSTANTS_ETA_A_UVB3[0][0]) + + tau2 * (rep_inv * WCA_CONSTANTS_ETA_A_UVB3[0][3] + WCA_CONSTANTS_ETA_A_UVB3[0][2]); - let c1_eta_b = tau * WCA_CONSTANTS_ETA_B_UVB3[[0, 0]] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[[0, 1]]; + let c1_eta_b = tau * WCA_CONSTANTS_ETA_B_UVB3[0][0] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[0][1]; let b30_uv = (d_x.powi(3) * PI / 6.0).powi(2) * 10.0 - d_x.powi(3) * 5.0 / 9.0 @@ -502,7 +457,6 @@ mod test { state.partial_density.sum() * (x * &p.sigma.mapv(|s| s.powi(3))).sum(), t_x, ); - //with unrounded params: assert_relative_eq!(u_fraction_wca.re(), 0.8852730008077649, epsilon = 1e-10); assert_relative_eq!(u_fraction_wca.re(), 0.8852775506870431, epsilon = 1e-10); // delta a1u let i_wca = @@ -519,18 +473,13 @@ mod test { let db3 = delta_b3(t_x, rm_x, rep_x, att_x, d_x, q_vdw); assert_relative_eq!(db3.re(), -0.6591980196661884, epsilon = 1e-10); - //non rounded params fpr B3:assert_relative_eq!(db3.re(), -0.6591646873435744, epsilon = 1e-10); let db31 = delta_b31u(t_x, weighted_sigma3_ij, rm_x, rep_x, att_x, d_x) / p.sigma[0].powi(6); - // non rounded params for B3:: b3.re() = 1.4326204530476152 - // b30_uv.re() = 2.0917851403911896 - // Full attractive perturbation: let a = pt.helmholtz_energy(&state) / moles[0]; assert_relative_eq!(-0.9027781694834115, a.re(), epsilon = 1e-5); - //non rounded params for B3: assert_relative_eq!(-0.9027781726598461, a.re(), epsilon = 1e-5); } } diff --git a/src/uvtheory/eos/hard_sphere_bh.rs b/src/uvtheory/eos/hard_sphere_bh.rs index 4453310b9..ca8dc9af8 100644 --- a/src/uvtheory/eos/hard_sphere_bh.rs +++ b/src/uvtheory/eos/hard_sphere_bh.rs @@ -21,11 +21,11 @@ lazy_static! { } #[derive(Debug, Clone)] -pub struct HardSphere { +pub struct HardSphereBH { pub parameters: Arc, } -impl> HelmholtzEnergyDual for HardSphere { +impl> HelmholtzEnergyDual for HardSphereBH { /// Helmholtz energy for hard spheres, eq. 19 (check Volume) fn helmholtz_energy(&self, state: &StateHD) -> D { let d = diameter_bh(&self.parameters, state.temperature); @@ -39,7 +39,7 @@ impl> HelmholtzEnergyDual for HardSphere { } } -impl fmt::Display for HardSphere { +impl fmt::Display for HardSphereBH { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "Hard Sphere") } @@ -90,15 +90,6 @@ pub fn zeta_23>(molefracs: &Array1, diameter: &Array1) -> zeta[0] / zeta[1] } -//#[inline] -//pub fn dimensionless_length_scale>( -// parameters: &UVParameters, -//temperature: D, -//rep: f64, -//) -> Array1 { -// -diameter_bh(parameters, temperature) + 1.0 -//} - pub fn packing_fraction_b>( parameters: &UVParameters, diameter: &Array1, diff --git a/src/uvtheory/eos/hard_sphere_wca.rs b/src/uvtheory/eos/hard_sphere_wca.rs index 54743fb6f..a2a9c6064 100644 --- a/src/uvtheory/eos/hard_sphere_wca.rs +++ b/src/uvtheory/eos/hard_sphere_wca.rs @@ -1,58 +1,53 @@ use crate::uvtheory::parameters::UVParameters; use feos_core::{HelmholtzEnergyDual, StateHD}; -use lazy_static::lazy_static; use ndarray::prelude::*; use num_dual::DualNum; use std::f64::consts::PI; use std::fmt; use std::sync::Arc; -lazy_static! { - static ref WCA_CONSTANTS_ETA_B: Array2 = arr2(&[ - [-0.883143456, -0.618156214], - [-0.589914255, -3.015264636], - [-2.152046477, 4.7038689542], - ]); - static ref WCA_CONSTANTS_ETA_A: Array2 = arr2(&[ - [-0.888512176, 0.265207151, -0.851803291, -1.380304110], - [-0.395548410, -0.626398537, -1.484059291, -3.041216688], - [-2.905719617, -1.778798984, -1.556827067, -4.308085347], - [0.429154871, 20.765871545, 9.341250676, -33.787719418], - ]); - -// New Fit by Anja to numerical integrals for uv-B3-theory - // #Tmin = 0.0, eta_max = 0.52, simultaneous fit - - pub static ref WCA_CONSTANTS_ETA_A_UVB3: Array2 = arr2(&[ - [2.64043218, -1.2184421 , -22.90786387, 0.96433414], - [-16.75643936, 30.83929771, 73.08711814, -166.57701616], - [19.53170162, -88.87955657, -76.51387192, 443.68942745], - [-3.77740877, 83.04694547, 21.62502721, -304.8643176] , - ]); - - pub static ref WCA_CONSTANTS_ETA_B_UVB3: Array2 = arr2(&[ - [2.19821588, -20.45005484], - [-13.47050687, 56.65701375], - [12.90119266, -42.71680606],]); - - - pub static ref WCA_CONSTANTS_Q: Array2 = arr2(&[ - [1.92840364363978, 4.43165896265079E-01, 0.0, 0.0], - [ - 5.20120816141761E-01, - 1.82526759234412E-01, - 1.10319989659929E-02, - -7.97813995328348E-05 - ], - [ - 0.0, - 1.29885156087242E-02, - 6.41039871789327E-03, - 1.85866741090323E-05 - ], - ]); -} - +pub const WCA_CONSTANTS_Q: [[f64; 4]; 3] = [ + [1.92840364363978, 4.43165896265079E-01, 0.0, 0.0], + [ + 5.20120816141761E-01, + 1.82526759234412E-01, + 1.10319989659929E-02, + -7.97813995328348E-05, + ], + [ + 0.0, + 1.29885156087242E-02, + 6.41039871789327E-03, + 1.85866741090323E-05, + ], +]; + +const WCA_CONSTANTS_ETA_A: [[f64; 4]; 4] = [ + [-0.888512176, 0.265207151, -0.851803291, -1.380304110], + [-0.395548410, -0.626398537, -1.484059291, -3.041216688], + [-2.905719617, -1.778798984, -1.556827067, -4.308085347], + [0.429154871, 20.765871545, 9.341250676, -33.787719418], +]; + +const WCA_CONSTANTS_ETA_B: [[f64; 2]; 3] = [ + [-0.883143456, -0.618156214], + [-0.589914255, -3.015264636], + [-2.152046477, 4.7038689542], +]; + +// New Fit to numerical integrals for uv-B3-theory +pub const WCA_CONSTANTS_ETA_A_UVB3: [[f64; 4]; 4] = [ + [2.64043218, -1.2184421, -22.90786387, 0.96433414], + [-16.75643936, 30.83929771, 73.08711814, -166.57701616], + [19.53170162, -88.87955657, -76.51387192, 443.68942745], + [-3.77740877, 83.04694547, 21.62502721, -304.8643176], +]; + +pub const WCA_CONSTANTS_ETA_B_UVB3: [[f64; 2]; 3] = [ + [2.19821588, -20.45005484], + [-13.47050687, 56.65701375], + [12.90119266, -42.71680606], +]; #[derive(Debug, Clone)] pub struct HardSphereWCA { pub parameters: Arc, @@ -104,15 +99,15 @@ pub fn dimensionless_diameter_q_wca>(t_x: D, rep_x: D, att_x: D) let rs = (nu / n).powd((nu - n).recip()); let coeffs = arr1(&[ (nu * 2.0 * PI / n).sqrt(), - (nu - 7.0) * WCA_CONSTANTS_Q[[0, 1]] + WCA_CONSTANTS_Q[[0, 0]], - (nu - 7.0) * WCA_CONSTANTS_Q[[1, 1]] - + (nu - 7.0).powi(2) * WCA_CONSTANTS_Q[[1, 2]] - + (nu - 7.0).powi(3) * WCA_CONSTANTS_Q[[1, 3]] - + WCA_CONSTANTS_Q[[1, 0]], - (nu - 7.0) * WCA_CONSTANTS_Q[[2, 1]] - + (nu - 7.0).powi(2) * WCA_CONSTANTS_Q[[2, 2]] - + (nu - 7.0).powi(3) * WCA_CONSTANTS_Q[[2, 3]] - + WCA_CONSTANTS_Q[[2, 0]], + (nu - 7.0) * WCA_CONSTANTS_Q[0][1] + WCA_CONSTANTS_Q[0][0], + (nu - 7.0) * WCA_CONSTANTS_Q[1][1] + + (nu - 7.0).powi(2) * WCA_CONSTANTS_Q[1][2] + + (nu - 7.0).powi(3) * WCA_CONSTANTS_Q[1][3] + + WCA_CONSTANTS_Q[1][0], + (nu - 7.0) * WCA_CONSTANTS_Q[2][1] + + (nu - 7.0).powi(2) * WCA_CONSTANTS_Q[2][2] + + (nu - 7.0).powi(3) * WCA_CONSTANTS_Q[2][3] + + WCA_CONSTANTS_Q[2][0], ]); (t_x.powf(2.0) * coeffs[3] @@ -185,9 +180,9 @@ pub fn packing_fraction_b>( let tau2 = tau * tau; let c = arr1(&[ - tau * WCA_CONSTANTS_ETA_B[[0, 0]] + tau2 * WCA_CONSTANTS_ETA_B[[0, 1]], - tau * WCA_CONSTANTS_ETA_B[[1, 0]] + tau2 * WCA_CONSTANTS_ETA_B[[1, 1]], - tau * WCA_CONSTANTS_ETA_B[[2, 0]] + tau2 * WCA_CONSTANTS_ETA_B[[2, 1]], + tau * WCA_CONSTANTS_ETA_B[0][0] + tau2 * WCA_CONSTANTS_ETA_B[0][1], + tau * WCA_CONSTANTS_ETA_B[1][0] + tau2 * WCA_CONSTANTS_ETA_B[1][1], + tau * WCA_CONSTANTS_ETA_B[2][0] + tau2 * WCA_CONSTANTS_ETA_B[2][1], ]); eta + eta * c[0] + eta * eta * c[1] + eta.powi(3) * c[2] }) @@ -207,9 +202,9 @@ pub fn packing_fraction_b_uvb3>( let tau2 = tau * tau; let c = arr1(&[ - tau * WCA_CONSTANTS_ETA_B_UVB3[[0, 0]] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[[0, 1]], - tau * WCA_CONSTANTS_ETA_B_UVB3[[1, 0]] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[[1, 1]], - tau * WCA_CONSTANTS_ETA_B_UVB3[[2, 0]] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[[2, 1]], + tau * WCA_CONSTANTS_ETA_B_UVB3[0][0] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[0][1], + tau * WCA_CONSTANTS_ETA_B_UVB3[1][0] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[1][1], + tau * WCA_CONSTANTS_ETA_B_UVB3[2][0] + tau2 * WCA_CONSTANTS_ETA_B_UVB3[2][1], ]); eta + eta * c[0] + eta * eta * c[1] + eta.powi(3) * c[2] }) @@ -229,15 +224,16 @@ pub fn packing_fraction_a>( let tau2 = tau * tau; let rep_inv = 1.0 / parameters.rep_ij[[i, j]]; + let c = arr1(&[ - tau * (WCA_CONSTANTS_ETA_A[[0, 0]] + WCA_CONSTANTS_ETA_A[[0, 1]] * rep_inv) - + tau2 * (WCA_CONSTANTS_ETA_A[[0, 2]] + WCA_CONSTANTS_ETA_A[[0, 3]] * rep_inv), - tau * (WCA_CONSTANTS_ETA_A[[1, 0]] + WCA_CONSTANTS_ETA_A[[1, 1]] * rep_inv) - + tau2 * (WCA_CONSTANTS_ETA_A[[1, 2]] + WCA_CONSTANTS_ETA_A[[1, 3]] * rep_inv), - tau * (WCA_CONSTANTS_ETA_A[[2, 0]] + WCA_CONSTANTS_ETA_A[[2, 1]] * rep_inv) - + tau2 * (WCA_CONSTANTS_ETA_A[[2, 2]] + WCA_CONSTANTS_ETA_A[[2, 3]] * rep_inv), - tau * (WCA_CONSTANTS_ETA_A[[3, 0]] + WCA_CONSTANTS_ETA_A[[3, 1]] * rep_inv) - + tau2 * (WCA_CONSTANTS_ETA_A[[3, 2]] + WCA_CONSTANTS_ETA_A[[3, 3]] * rep_inv), + tau * (WCA_CONSTANTS_ETA_A[0][0] + WCA_CONSTANTS_ETA_A[0][1] * rep_inv) + + tau2 * (WCA_CONSTANTS_ETA_A[0][2] + WCA_CONSTANTS_ETA_A[0][3] * rep_inv), + tau * (WCA_CONSTANTS_ETA_A[1][0] + WCA_CONSTANTS_ETA_A[1][1] * rep_inv) + + tau2 * (WCA_CONSTANTS_ETA_A[1][2] + WCA_CONSTANTS_ETA_A[1][3] * rep_inv), + tau * (WCA_CONSTANTS_ETA_A[2][0] + WCA_CONSTANTS_ETA_A[2][1] * rep_inv) + + tau2 * (WCA_CONSTANTS_ETA_A[2][2] + WCA_CONSTANTS_ETA_A[2][3] * rep_inv), + tau * (WCA_CONSTANTS_ETA_A[3][0] + WCA_CONSTANTS_ETA_A[3][1] * rep_inv) + + tau2 * (WCA_CONSTANTS_ETA_A[3][2] + WCA_CONSTANTS_ETA_A[3][3] * rep_inv), ]); eta + eta * c[0] + eta * eta * c[1] + eta.powi(3) * c[2] + eta.powi(4) * c[3] }) @@ -258,22 +254,18 @@ pub fn packing_fraction_a_uvb3>( let tau2 = tau * tau; let rep_inv = 1.0 / parameters.rep_ij[[i, j]]; let c = arr1(&[ - tau * (WCA_CONSTANTS_ETA_A_UVB3[[0, 0]] + WCA_CONSTANTS_ETA_A_UVB3[[0, 1]] * rep_inv) + tau * (WCA_CONSTANTS_ETA_A_UVB3[0][0] + WCA_CONSTANTS_ETA_A_UVB3[0][1] * rep_inv) + tau2 - * (WCA_CONSTANTS_ETA_A_UVB3[[0, 2]] - + WCA_CONSTANTS_ETA_A_UVB3[[0, 3]] * rep_inv), - tau * (WCA_CONSTANTS_ETA_A_UVB3[[1, 0]] + WCA_CONSTANTS_ETA_A_UVB3[[1, 1]] * rep_inv) + * (WCA_CONSTANTS_ETA_A_UVB3[0][2] + WCA_CONSTANTS_ETA_A_UVB3[0][3] * rep_inv), + tau * (WCA_CONSTANTS_ETA_A_UVB3[1][0] + WCA_CONSTANTS_ETA_A_UVB3[1][1] * rep_inv) + tau2 - * (WCA_CONSTANTS_ETA_A_UVB3[[1, 2]] - + WCA_CONSTANTS_ETA_A_UVB3[[1, 3]] * rep_inv), - tau * (WCA_CONSTANTS_ETA_A_UVB3[[2, 0]] + WCA_CONSTANTS_ETA_A_UVB3[[2, 1]] * rep_inv) + * (WCA_CONSTANTS_ETA_A_UVB3[1][2] + WCA_CONSTANTS_ETA_A_UVB3[1][3] * rep_inv), + tau * (WCA_CONSTANTS_ETA_A_UVB3[2][0] + WCA_CONSTANTS_ETA_A_UVB3[2][1] * rep_inv) + tau2 - * (WCA_CONSTANTS_ETA_A_UVB3[[2, 2]] - + WCA_CONSTANTS_ETA_A_UVB3[[2, 3]] * rep_inv), - tau * (WCA_CONSTANTS_ETA_A_UVB3[[3, 0]] + WCA_CONSTANTS_ETA_A_UVB3[[3, 1]] * rep_inv) + * (WCA_CONSTANTS_ETA_A_UVB3[2][2] + WCA_CONSTANTS_ETA_A_UVB3[2][3] * rep_inv), + tau * (WCA_CONSTANTS_ETA_A_UVB3[3][0] + WCA_CONSTANTS_ETA_A_UVB3[3][1] * rep_inv) + tau2 - * (WCA_CONSTANTS_ETA_A_UVB3[[3, 2]] - + WCA_CONSTANTS_ETA_A_UVB3[[3, 3]] * rep_inv), + * (WCA_CONSTANTS_ETA_A_UVB3[3][2] + WCA_CONSTANTS_ETA_A_UVB3[3][3] * rep_inv), ]); eta + eta * c[0] + eta * eta * c[1] + eta.powi(3) * c[2] + eta.powi(4) * c[3] }) diff --git a/src/uvtheory/eos/mod.rs b/src/uvtheory/eos/mod.rs index 2dd558e83..b7a85b639 100644 --- a/src/uvtheory/eos/mod.rs +++ b/src/uvtheory/eos/mod.rs @@ -19,7 +19,7 @@ pub(crate) mod ufraction; use attractive_perturbation_bh::AttractivePerturbationBH; use attractive_perturbation_uvb3::AttractivePerturbationUVB3; use attractive_perturbation_wca::AttractivePerturbationWCA; -use hard_sphere_bh::HardSphere; +use hard_sphere_bh::HardSphereBH; use hard_sphere_wca::HardSphereWCA; use reference_perturbation_bh::ReferencePerturbationBH; use reference_perturbation_uvb3::ReferencePerturbationUVB3; @@ -78,7 +78,7 @@ impl UVTheory { match options.perturbation { Perturbation::BarkerHenderson => match options.virial_order { VirialOrder::Second => { - contributions.push(Box::new(HardSphere { + contributions.push(Box::new(HardSphereBH { parameters: parameters.clone(), })); contributions.push(Box::new(ReferencePerturbationBH { From 0acc89d351dafcfbd19e84d56ceab4cf45ce6704 Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Mon, 9 Jan 2023 13:15:59 +0100 Subject: [PATCH 05/14] reduce match arms for wca --- src/uvtheory/eos/mod.rs | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/uvtheory/eos/mod.rs b/src/uvtheory/eos/mod.rs index b7a85b639..2dba408f9 100644 --- a/src/uvtheory/eos/mod.rs +++ b/src/uvtheory/eos/mod.rs @@ -93,11 +93,11 @@ impl UVTheory { } }, Perturbation::WeeksChandlerAndersen => { + contributions.push(Box::new(HardSphereWCA { + parameters: parameters.clone(), + })); match options.virial_order { VirialOrder::Second => { - contributions.push(Box::new(HardSphereWCA { - parameters: parameters.clone(), - })); contributions.push(Box::new(ReferencePerturbationWCA { parameters: parameters.clone(), })); @@ -114,9 +114,6 @@ impl UVTheory { panic!("uv-B3-theory not implemented for attractive exponents other than 6!") } - contributions.push(Box::new(HardSphereWCA { - parameters: parameters.clone(), - })); contributions.push(Box::new(ReferencePerturbationUVB3 { parameters: parameters.clone(), })); From 27e5bcd215906a8aab50c6df2571445e0e06be36 Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Mon, 9 Jan 2023 14:23:09 +0100 Subject: [PATCH 06/14] remove multiple definition of eca one fluid properties --- .../eos/attractive_perturbation_bh.rs | 32 +------------ .../eos/attractive_perturbation_uvb3.rs | 47 ++----------------- .../eos/attractive_perturbation_wca.rs | 13 +---- 3 files changed, 5 insertions(+), 87 deletions(-) diff --git a/src/uvtheory/eos/attractive_perturbation_bh.rs b/src/uvtheory/eos/attractive_perturbation_bh.rs index a157724fc..c99580cb5 100644 --- a/src/uvtheory/eos/attractive_perturbation_bh.rs +++ b/src/uvtheory/eos/attractive_perturbation_bh.rs @@ -1,3 +1,4 @@ +//use super::attractive_perturbation_wca::one_fluid_properties; use super::hard_sphere_bh::diameter_bh; use crate::uvtheory::parameters::*; use feos_core::{HelmholtzEnergyDual, StateHD}; @@ -133,37 +134,6 @@ fn activation>(c: D, one_fluid_beta: D) -> D { one_fluid_beta * c.sqrt() / (one_fluid_beta.powi(2) * c + 1.0).sqrt() } -// fn one_fluid_properties>( -// p: &UVParameters, -// x: &Array1, -// t: D, -// ) -> (D, D, D, D, D, D) { -// let d = diameter_bh(p, t) / &p.sigma; -// let mut epsilon_k = D::zero(); -// let mut weighted_sigma3_ij = D::zero(); -// let mut rep = D::zero(); -// let mut att = D::zero(); -// for i in 0..p.ncomponents { -// let xi = x[i]; -// for j in 0..p.ncomponents { -// let _y = xi * x[j] * p.sigma_ij[[i, j]].powi(3); -// weighted_sigma3_ij += _y; -// epsilon_k += _y * p.eps_k_ij[[i, j]]; -// rep += xi * x[j] * p.rep_ij[[i, j]]; -// att += xi * x[j] * p.att_ij[[i, j]]; -// } -// } -// let dx = (x * &d.mapv(|v| v.powi(3))).sum().powf(1.0 / 3.0); -// ( -// rep, -// att, -// (x * &p.sigma.mapv(|v| v.powi(3))).sum().powf(1.0 / 3.0), -// weighted_sigma3_ij, -// epsilon_k / weighted_sigma3_ij, -// dx, -// ) -// } - fn one_fluid_properties>( p: &UVParameters, x: &Array1, diff --git a/src/uvtheory/eos/attractive_perturbation_uvb3.rs b/src/uvtheory/eos/attractive_perturbation_uvb3.rs index 902b165f8..fd5402fb0 100644 --- a/src/uvtheory/eos/attractive_perturbation_uvb3.rs +++ b/src/uvtheory/eos/attractive_perturbation_uvb3.rs @@ -1,3 +1,4 @@ +use super::attractive_perturbation_wca::one_fluid_properties; use super::hard_sphere_wca::{ diameter_wca, dimensionless_diameter_q_wca, WCA_CONSTANTS_ETA_A_UVB3, WCA_CONSTANTS_ETA_B_UVB3, }; @@ -227,48 +228,6 @@ fn u_fraction_wca>(rep_x: D, reduced_density: D, t_x: D) -> D { + 1.0 } -fn one_fluid_properties>( - p: &UVParameters, - x: &Array1, - t: D, -) -> (D, D, D, D, D, D) { - let d = diameter_wca(p, t); - // &p.sigma; - - let mut epsilon_k = D::zero(); - let mut weighted_sigma3_ij = D::zero(); - let mut rep = D::zero(); - let mut att = D::zero(); - let mut d_x_3 = D::zero(); - - for i in 0..p.ncomponents { - let xi = x[i]; - - d_x_3 += x[i] * d[i].powi(3); - for j in 0..p.ncomponents { - let _y = xi * x[j] * p.sigma_ij[[i, j]].powi(3); - weighted_sigma3_ij += _y; - epsilon_k += _y * p.eps_k_ij[[i, j]]; - - rep += xi * x[j] * p.rep_ij[[i, j]]; - att += xi * x[j] * p.att_ij[[i, j]]; - } - } - - //let dx = (x * &d.mapv(|v| v.powi(3))).sum().powf(1.0 / 3.0); - let sigma_x = (x * &p.sigma.mapv(|v| v.powi(3))).sum().powf(1.0 / 3.0); - let dx = d_x_3.powf(1.0 / 3.0) / sigma_x; - - ( - rep, - att, - sigma_x, - weighted_sigma3_ij, - epsilon_k / weighted_sigma3_ij, - dx, - ) -} - // Coefficients for IWCA from eq. (S55) fn coefficients_wca>(rep: D, att: D, d: D) -> [D; 6] { let rep_inv = rep.recip(); @@ -474,8 +433,8 @@ mod test { let db3 = delta_b3(t_x, rm_x, rep_x, att_x, d_x, q_vdw); assert_relative_eq!(db3.re(), -0.6591980196661884, epsilon = 1e-10); - let db31 = - delta_b31u(t_x, weighted_sigma3_ij, rm_x, rep_x, att_x, d_x) / p.sigma[0].powi(6); + // let db31 = + // delta_b31u(t_x, weighted_sigma3_ij, rm_x, rep_x, att_x, d_x) / p.sigma[0].powi(6); // Full attractive perturbation: let a = pt.helmholtz_energy(&state) / moles[0]; diff --git a/src/uvtheory/eos/attractive_perturbation_wca.rs b/src/uvtheory/eos/attractive_perturbation_wca.rs index 99d304a46..5e71fb547 100644 --- a/src/uvtheory/eos/attractive_perturbation_wca.rs +++ b/src/uvtheory/eos/attractive_perturbation_wca.rs @@ -155,17 +155,6 @@ fn correlation_integral_wca>( rm_x: D, ) -> D { let c = coefficients_wca(rep_x, att_x, d_x); - // dbg!(q_x.re()); - // dbg!(rm_x.re()); - // dbg!(mean_field_constant_x.re()); - // dbg!(mie_prefactor(rep_x, att_x).re()); - // dbg!(rho_x.re()); - // dbg!(c[0].re()); - // dbg!(c[1].re()); - // dbg!(c[2].re()); - // dbg!(c[3].re()); - // dbg!(c[4].re()); - // dbg!(d_x.re()); (q_x.powi(3) - rm_x.powi(3)) * 1.0 / 3.0 - mean_field_constant_x + mie_prefactor(rep_x, att_x) * (c[0] * rho_x + c[1] * rho_x.powi(2) + c[2] * rho_x.powi(3)) @@ -180,7 +169,7 @@ fn u_fraction_wca>(rep_x: D, reduced_density: D) -> D { .tanh() } -fn one_fluid_properties>( +pub fn one_fluid_properties>( p: &UVParameters, x: &Array1, t: D, From d1981948df0c3e7c0958422482215fac8fcb9847 Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Mon, 9 Jan 2023 14:32:26 +0100 Subject: [PATCH 07/14] removed comments with equations --- .../eos/attractive_perturbation_uvb3.rs | 28 ++++++++----------- 1 file changed, 11 insertions(+), 17 deletions(-) diff --git a/src/uvtheory/eos/attractive_perturbation_uvb3.rs b/src/uvtheory/eos/attractive_perturbation_uvb3.rs index fd5402fb0..026ad5f47 100644 --- a/src/uvtheory/eos/attractive_perturbation_uvb3.rs +++ b/src/uvtheory/eos/attractive_perturbation_uvb3.rs @@ -91,7 +91,7 @@ impl fmt::Display for AttractivePerturbationUVB3 { } impl> HelmholtzEnergyDual for AttractivePerturbationUVB3 { - /// Helmholtz energy for attractive perturbation, eq. 52 + /// Helmholtz energy for attractive perturbation fn helmholtz_energy(&self, state: &StateHD) -> D { let p = &self.parameters; let t = state.temperature; @@ -111,7 +111,6 @@ impl> HelmholtzEnergyDual for AttractivePerturbationUVB3 { let delta_a1u = state.partial_density.sum() / t_x * i_wca * 2.0 * PI * weighted_sigma3_ij; - // state.partial_density.sum() / t_x * i_wca * 2.0 * PI * weighted_sigma3_ij; let u_fraction_wca = u_fraction_wca( rep_x, density * (x * &p.sigma.mapv(|s| s.powi(3))).sum(), @@ -132,7 +131,6 @@ impl> HelmholtzEnergyDual for AttractivePerturbationUVB3 { } } -// (S43) & (S53) fn delta_b12u>( t_x: D, mean_field_constant_x: D, @@ -153,14 +151,14 @@ fn residual_virial_coefficient>(p: &UVParameters, x: &Array1, let xi = x[i]; for j in 0..p.ncomponents { - //let q_ij = (q[i] / p.sigma[i] + q[j] / p.sigma[j]) * 0.5; + let t_ij = t / p.eps_k_ij[[i, j]]; let rep_ij = p.rep_ij[[i, j]]; let att_ij = p.att_ij[[i, j]]; let q_ij = dimensionless_diameter_q_wca(t_ij, D::from(rep_ij), D::from(att_ij)); - // Recheck mixing rule! + delta_b2bar += xi * x[j] * p.sigma_ij[[i, j]].powi(3) * delta_b2(t_ij, rep_ij, att_ij, q_ij); } @@ -179,16 +177,15 @@ fn residual_third_virial_coefficient>( let xi = x[i]; for j in 0..p.ncomponents { - //let q_ij = (q[i] / p.sigma[i] + q[j] / p.sigma[j]) * 0.5; let t_ij = t / p.eps_k_ij[[i, j]]; let rep_ij = p.rep_ij[[i, j]]; let att_ij = p.att_ij[[i, j]]; let q_ij = dimensionless_diameter_q_wca(t_ij, D::from(rep_ij), D::from(att_ij)); - // Recheck mixing rule! - let rm_ij = (rep_ij / att_ij).powd((rep_ij - att_ij).recip()); // Anja frei erfunden - let d_ij = (d[i] / p.sigma[i] + d[j] / p.sigma[j]) * 0.5; // Recheck mixing rule! - // // Recheck mixing rule! + // No mixing rule defined for B3 yet! The implemented rule is just taken from B2 and not correct! + let rm_ij = (rep_ij / att_ij).powd((rep_ij - att_ij).recip()); + let d_ij = (d[i] / p.sigma[i] + d[j] / p.sigma[j]) * 0.5; + // Recheck mixing rule! delta_b3bar += xi * x[j] * p.sigma_ij[[i, j]].powi(6) @@ -215,7 +212,6 @@ fn correlation_integral_wca>( /// U-fraction with low temperature correction omega fn u_fraction_wca>(rep_x: D, reduced_density: D, t_x: D) -> D { - // let omega = (-t_x.powi(2) * rep_x * CU_WCA[5]).exp() * (t_x.recip() * CU_WCA[6]).exp(); let omega = if t_x.re() < 175.0 { (-t_x * CU_WCA[5] * (reduced_density - CU_WCA[6]).powi(2)).exp() * ((t_x * CU_WCA[7]).tanh().recip() - 1.0).powi(2) @@ -228,7 +224,7 @@ fn u_fraction_wca>(rep_x: D, reduced_density: D, t_x: D) -> D { + 1.0 } -// Coefficients for IWCA from eq. (S55) +// Coefficients for IWCA fn coefficients_wca>(rep: D, att: D, d: D) -> [D; 6] { let rep_inv = rep.recip(); let rs_x = (rep / att).powd((rep - att).recip()); @@ -268,9 +264,9 @@ pub fn factorial(num: u64) -> u64 { } fn delta_b2>(reduced_temperature: D, rep: f64, att: f64, q: D) -> D { - let rm = (rep / att).powd((rep - att).recip()); // Check mixing rule!! + let rm = (rep / att).powd((rep - att).recip()); let beta = reduced_temperature.recip(); - let b20 = q.powi(3) * 2.0 / 3.0 * PI; // eq. (16) + let b20 = q.powi(3) * 2.0 / 3.0 * PI; let y = beta.exp() - 1.0; let c1 = rep.recip() * C_B2_RSAP[0][1] @@ -353,7 +349,7 @@ fn delta_b3>(t_x: D, rm_x: f64, rep_x: f64, _att_x: f64, d_x: D, let b3 = b30 + b31 * beta + b32 * beta.powi(2) + b33 * beta.powi(3) + b34 * beta.powi(4); - // Watch out: Not implemented for mixtures!!!! + // Watch out: Not defined for mixtures! let tau = -d_x + rm_x; let tau2 = tau * tau; let rep_inv = rep_x.recip(); @@ -433,8 +429,6 @@ mod test { let db3 = delta_b3(t_x, rm_x, rep_x, att_x, d_x, q_vdw); assert_relative_eq!(db3.re(), -0.6591980196661884, epsilon = 1e-10); - // let db31 = - // delta_b31u(t_x, weighted_sigma3_ij, rm_x, rep_x, att_x, d_x) / p.sigma[0].powi(6); // Full attractive perturbation: let a = pt.helmholtz_energy(&state) / moles[0]; From 6a30744c43144c8788b2f824b7c709f8deb9857a Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Wed, 11 Jan 2023 07:44:31 +0100 Subject: [PATCH 08/14] add documentation for virial order --- src/uvtheory/eos/mod.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/uvtheory/eos/mod.rs b/src/uvtheory/eos/mod.rs index 2dba408f9..31518c5b0 100644 --- a/src/uvtheory/eos/mod.rs +++ b/src/uvtheory/eos/mod.rs @@ -33,6 +33,7 @@ pub enum Perturbation { WeeksChandlerAndersen, } +/// Order of the highest virial coefficient included in the model. #[derive(Clone)] #[cfg_attr(feature = "python", pyo3::pyclass)] pub enum VirialOrder { From 6f34b7fe2e580e3fa43bc317533ec2d903520dfe Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Wed, 11 Jan 2023 16:55:08 +0100 Subject: [PATCH 09/14] Added generic error type to EoSError, added constructor for simple, pure substance parameters to UVParameters, more documentation, removed panics from equation of state constructor --- feos-core/src/errors.rs | 2 + src/python/eos.rs | 10 +++-- src/uvtheory/eos/mod.rs | 84 ++++++++++++++++++++++---------------- src/uvtheory/mod.rs | 65 ++++++++++++++++++++++++++++- src/uvtheory/parameters.rs | 9 ++++ src/uvtheory/python.rs | 28 +++++++++++++ 6 files changed, 156 insertions(+), 42 deletions(-) diff --git a/feos-core/src/errors.rs b/feos-core/src/errors.rs index 0da42ea27..ed5840127 100644 --- a/feos-core/src/errors.rs +++ b/feos-core/src/errors.rs @@ -6,6 +6,8 @@ use thiserror::Error; /// Error type for improperly defined states and convergence problems. #[derive(Error, Debug)] pub enum EosError { + #[error("Error: {0}")] + Error(String), #[error("`{0}` did not converge within the maximum number of iterations.")] NotConverged(String), #[error("`{0}` encountered illegal values during the iteration.")] diff --git a/src/python/eos.rs b/src/python/eos.rs index 52ed21588..6d4fb92bf 100644 --- a/src/python/eos.rs +++ b/src/python/eos.rs @@ -213,6 +213,9 @@ impl PyEosVariant { /// Maximum packing fraction. Defaults to 0.5. /// perturbation : Perturbation, optional /// Division type of the Mie potential. Defaults to WCA division. + /// virial_order : VirialOrder, optional + /// Highest order of virial coefficient to consider. + /// Defaults to second order (original uv-theory). /// /// Returns /// ------- @@ -232,15 +235,14 @@ impl PyEosVariant { max_eta: f64, perturbation: Perturbation, virial_order: VirialOrder, - ) -> Self { + ) -> PyResult { let options = UVTheoryOptions { max_eta, perturbation, virial_order, }; - Self(Arc::new(EosVariant::UVTheory(UVTheory::with_options( - parameters.0, - options, + Ok(Self(Arc::new(EosVariant::UVTheory( + UVTheory::with_options(parameters.0, options)?, )))) } diff --git a/src/uvtheory/eos/mod.rs b/src/uvtheory/eos/mod.rs index 31518c5b0..2ff548491 100644 --- a/src/uvtheory/eos/mod.rs +++ b/src/uvtheory/eos/mod.rs @@ -2,7 +2,7 @@ #![allow(clippy::needless_range_loop)] use super::parameters::UVParameters; -use feos_core::{parameter::Parameter, EquationOfState, HelmholtzEnergy}; +use feos_core::{parameter::Parameter, EosError, EosResult, EquationOfState, HelmholtzEnergy}; use ndarray::Array1; use std::f64::consts::FRAC_PI_6; use std::sync::Arc; @@ -68,12 +68,15 @@ pub struct UVTheory { impl UVTheory { /// uv-theory with default options (WCA). - pub fn new(parameters: Arc) -> Self { + pub fn new(parameters: Arc) -> EosResult { Self::with_options(parameters, UVTheoryOptions::default()) } /// uv-theory with provided options. - pub fn with_options(parameters: Arc, options: UVTheoryOptions) -> Self { + pub fn with_options( + parameters: Arc, + options: UVTheoryOptions, + ) -> EosResult { let mut contributions: Vec> = Vec::with_capacity(3); match options.perturbation { @@ -90,7 +93,10 @@ impl UVTheory { })); } VirialOrder::Third => { - panic!("Not implemeted!"); + return Err(EosError::Error( + "Third virial coefficient is not implemented for Barker-Henderson" + .to_string(), + )) } }, Perturbation::WeeksChandlerAndersen => { @@ -108,13 +114,17 @@ impl UVTheory { } VirialOrder::Third => { if parameters.sigma.len() > 1 { - panic!("uv-B3-theory not implemented for mixtures!") + return Err(EosError::Error( + "Third virial coefficient is not implemented for mixtures!" + .to_string(), + )); } - if parameters.att[0] != 6.0 { - panic!("uv-B3-theory not implemented for attractive exponents other than 6!") + return Err(EosError::Error( + "Third virial coefficient is not implemented for attractive exponents other than 6!" + .to_string(), + )); } - contributions.push(Box::new(ReferencePerturbationUVB3 { parameters: parameters.clone(), })); @@ -126,11 +136,11 @@ impl UVTheory { } } - Self { + Ok(Self { parameters, options, contributions, - } + }) } } @@ -144,6 +154,7 @@ impl EquationOfState for UVTheory { Arc::new(self.parameters.subset(component_list)), self.options.clone(), ) + .expect("Not defined for mixture") } fn compute_max_density(&self, moles: &Array1) -> f64 { @@ -169,20 +180,14 @@ mod test { use quantity::si::{ANGSTROM, KELVIN, MOL, NAV, RGAS}; #[test] - fn helmholtz_energy_pure_wca() { - let eps_k = 150.03; + fn helmholtz_energy_pure_wca() -> EosResult<()> { let sig = 3.7039; - let r = UVRecord::new(24.0, 6.0, sig, eps_k); - //let r = UVRecord::new(12.0, 6.0, sig, eps_k); - let i = Identifier::new(None, None, None, None, None, None); - let pr = PureRecord::new(i, 1.0, r, None); - let parameters = UVParameters::new_pure(pr); - let eos = Arc::new(UVTheory::new(Arc::new(parameters))); + let eps_k = 150.03; + let parameters = UVParameters::new_simple(24.0, 6.0, sig, eps_k); + let eos = Arc::new(UVTheory::new(Arc::new(parameters))?); let reduced_temperature = 4.0; - //let reduced_temperature = 1.0; let reduced_density = 1.0; - //let reduced_density = 0.9; let temperature = reduced_temperature * eps_k * KELVIN; let moles = arr1(&[2.0]) * MOL; let volume = (sig * ANGSTROM).powi(3) / reduced_density * NAV * 2.0 * MOL; @@ -191,11 +196,12 @@ mod test { .molar_helmholtz_energy(Contributions::ResidualNvt) .to_reduced(RGAS * temperature) .unwrap(); - assert_relative_eq!(a, 2.972986567516, max_relative = 1e-12) //wca - //assert_relative_eq!(a, -7.0843443690046017, max_relative = 1e-12) // bh: assert_relative_eq!(a, 2.993577305779432, max_relative = 1e-12) + assert_relative_eq!(a, 2.972986567516, max_relative = 1e-12); //wca + Ok(()) } + #[test] - fn helmholtz_energy_pure_bh() { + fn helmholtz_energy_pure_bh() -> EosResult<()> { let eps_k = 150.03; let sig = 3.7039; let r = UVRecord::new(24.0, 6.0, sig, eps_k); @@ -208,7 +214,7 @@ mod test { perturbation: Perturbation::BarkerHenderson, virial_order: VirialOrder::Second, }; - let eos = Arc::new(UVTheory::with_options(Arc::new(parameters), options)); + let eos = Arc::new(UVTheory::with_options(Arc::new(parameters), options)?); let reduced_temperature = 4.0; let reduced_density = 1.0; @@ -221,11 +227,12 @@ mod test { .to_reduced(RGAS * temperature) .unwrap(); - assert_relative_eq!(a, 2.993577305779432, max_relative = 1e-12) + assert_relative_eq!(a, 2.993577305779432, max_relative = 1e-12); + Ok(()) } #[test] - fn helmholtz_energy_pure_uvb3() { + fn helmholtz_energy_pure_uvb3() -> EosResult<()> { let eps_k = 150.03; let sig = 3.7039; let r = UVRecord::new(12.0, 6.0, sig, eps_k); @@ -238,7 +245,7 @@ mod test { perturbation: Perturbation::WeeksChandlerAndersen, virial_order: VirialOrder::Third, }; - let eos = Arc::new(UVTheory::with_options(Arc::new(parameters), options)); + let eos = Arc::new(UVTheory::with_options(Arc::new(parameters), options)?); let reduced_temperature = 4.0; let reduced_density = 0.5; @@ -251,11 +258,12 @@ mod test { .to_reduced(RGAS * temperature) .unwrap(); dbg!(a); - assert_relative_eq!(a, 0.37659379124271003, max_relative = 1e-12) + assert_relative_eq!(a, 0.37659379124271003, max_relative = 1e-12); + Ok(()) } #[test] - fn helmholtz_energy_mixtures_bh() { + fn helmholtz_energy_mixtures_bh() -> EosResult<()> { // Mixture of equal components --> result must be the same as fpr pure fluid /// // component 1 let rep1 = 24.0; @@ -292,7 +300,7 @@ mod test { virial_order: VirialOrder::Second, }; - let eos_bh = Arc::new(UVTheory::with_options(Arc::new(uv_parameters), options)); + let eos_bh = Arc::new(UVTheory::with_options(Arc::new(uv_parameters), options)?); let state_bh = State::new_nvt(&eos_bh, t_x, volume, &moles).unwrap(); let a_bh = state_bh @@ -301,9 +309,11 @@ mod test { .unwrap(); assert_relative_eq!(a_bh, 2.993577305779432, max_relative = 1e-12); + Ok(()) } + #[test] - fn helmholtz_energy_wca_mixture() { + fn helmholtz_energy_wca_mixture() -> EosResult<()> { let p = test_parameters_mixture( arr1(&[12.0, 12.0]), arr1(&[6.0, 6.0]), @@ -320,18 +330,19 @@ mod test { let volume = (p.sigma[0] * ANGSTROM).powi(3) / reduced_density * NAV * total_moles; // EoS - let eos_wca = Arc::new(UVTheory::new(Arc::new(p))); + let eos_wca = Arc::new(UVTheory::new(Arc::new(p))?); let state_wca = State::new_nvt(&eos_wca, t_x, volume, &moles).unwrap(); let a_wca = state_wca .molar_helmholtz_energy(Contributions::ResidualNvt) .to_reduced(RGAS * t_x) .unwrap(); - assert_relative_eq!(a_wca, -0.597791038364405, max_relative = 1e-5) + assert_relative_eq!(a_wca, -0.597791038364405, max_relative = 1e-5); + Ok(()) } #[test] - fn helmholtz_energy_wca_mixture_different_sigma() { + fn helmholtz_energy_wca_mixture_different_sigma() -> EosResult<()> { let p = test_parameters_mixture( arr1(&[12.0, 12.0]), arr1(&[6.0, 6.0]), @@ -349,12 +360,13 @@ mod test { let volume = NAV * total_moles / density; // EoS - let eos_wca = Arc::new(UVTheory::new(Arc::new(p))); + let eos_wca = Arc::new(UVTheory::new(Arc::new(p))?); let state_wca = State::new_nvt(&eos_wca, t_x, volume, &moles).unwrap(); let a_wca = state_wca .molar_helmholtz_energy(Contributions::ResidualNvt) .to_reduced(RGAS * t_x) .unwrap(); - assert_relative_eq!(a_wca, -0.034206207363139396, max_relative = 1e-5) + assert_relative_eq!(a_wca, -0.034206207363139396, max_relative = 1e-5); + Ok(()) } } diff --git a/src/uvtheory/mod.rs b/src/uvtheory/mod.rs index 9bcd8a9d2..f24a800a4 100644 --- a/src/uvtheory/mod.rs +++ b/src/uvtheory/mod.rs @@ -1,6 +1,67 @@ -//! uv-theory equation of state +//! uv-theory for fluids interacting with a Mie potential. //! -//! [van Westen et al. (2021)](https://doi.org/10.1063/5.0073572) +//! # Implementations +//! +//! ## uv-theory +//! +//! [van Westen et al. (2021)](https://doi.org/10.1063/5.0073572): utilizing second virial coeffients and Barker-Henderson or Weeks-Chandler-Andersen perturbation. +//! +//! ```ignore +//! # use feos_core::EosError; +//! use feos::uvtheory::{Perturbation, UVTheory, UVTheoryOptions, UVParameters, VirialOrder}; +//! use std::sync::Arc; +//! +//! let parameters = Arc::new( +//! UVParameters::new_simple(24.0, 7.0, 3.0, 150.0) +//! ); +//! +//! let default_options = UVTheoryOptions { +//! max_eta = 0.5, +//! perturbation = Perturbation::WeeksChandlerAndersen, +//! virial_order = VirialOrder::Second +//! }; +//! // Define equation of state. +//! let uv_wca = Arc::new(UVTheory::new(parameters)); +//! // this is identical to above +//! let uv_wca = Arc::new( +//! UVTheory::with_options(parameters, default_options) +//! ); +//! +//! // use Barker-Henderson perturbation +//! let options = UVTheoryOptions { +//! max_eta = 0.5, +//! perturbation = Perturbation::BarkerHenderson, +//! virial_order = VirialOrder::Second +//! }; +//! let uv_bh = Arc::new( +//! UVTheory::with_options(parameters, options) +//! ); +//! ``` +//! +//! ## uv-B3-theory +//! +//! - utilizing third virial coefficients for pure fluids with attractive exponent of 6 and Weeks-Chandler-Andersen perturbation. Manuscript submitted. +//! +//! ```ignore +//! # use feos_core::EosError; +//! use feos::uvtheory::{Perturbation, UVTheory, UVTheoryOptions, UVParameters, VirialOrder}; +//! use std::sync::Arc; +//! +//! let parameters = Arc::new( +//! UVParameters::new_simple(24.0, 6.0, 3.0, 150.0) +//! ); +//! +//! // use uv-B3-theory +//! let options = UVTheoryOptions { +//! max_eta = 0.5, +//! perturbation = Perturbation::WeeksChandlerAndersen, +//! virial_order = VirialOrder::Third +//! }; +//! // Define equation of state. +//! let uv_b3 = Arc::new( +//! UVTheory::with_options(parameters, options) +//! ); +//! ``` mod eos; mod parameters; diff --git a/src/uvtheory/parameters.rs b/src/uvtheory/parameters.rs index 20d16fc51..4b54c22a7 100644 --- a/src/uvtheory/parameters.rs +++ b/src/uvtheory/parameters.rs @@ -1,3 +1,4 @@ +use feos_core::parameter::Identifier; use feos_core::parameter::{Parameter, PureRecord}; use lazy_static::lazy_static; use ndarray::concatenate; @@ -203,6 +204,14 @@ impl Parameter for UVParameters { } impl UVParameters { + /// Parameters for a single substance with molar weight one and no (default) ideal gas contributions. + pub fn new_simple(rep: f64, att: f64, sigma: f64, epsilon_k: f64) -> Self { + let model_record = UVRecord::new(rep, att, sigma, epsilon_k); + let pure_record = PureRecord::new(Identifier::default(), 1.0, model_record, None); + Self::new_pure(pure_record) + } + + /// Markdown representation of parameters. pub fn to_markdown(&self) -> String { let mut output = String::new(); let o = &mut output; diff --git a/src/uvtheory/python.rs b/src/uvtheory/python.rs index 5454f8c77..08c135a18 100644 --- a/src/uvtheory/python.rs +++ b/src/uvtheory/python.rs @@ -100,6 +100,34 @@ impl PyUVParameters { let binary = Array2::from_shape_fn((n, n), |(_, _)| UVBinaryRecord { k_ij: 0.0 }); Self(Arc::new(UVParameters::from_records(pure_records, binary))) } + + /// Create UV Theory parameters for pure substance. + /// + /// Parameters + /// ---------- + /// rep : float + /// repulsive exponents + /// att : float + /// attractive exponents + /// sigma : float + /// Mie diameter in units of Angstrom + /// epsilon_k : float + /// Mie energy parameter in units of Kelvin + /// + /// Returns + /// ------- + /// UVParameters + /// + /// # Info + /// + /// Molar weight is one. No ideal gas contribution is considered. + #[pyo3(text_signature = "(rep, att, sigma, epsilon_k)")] + #[staticmethod] + fn new_simple(rep: f64, att: f64, sigma: f64, epsilon_k: f64) -> Self { + Self(Arc::new(UVParameters::new_simple( + rep, att, sigma, epsilon_k, + ))) + } } impl_pure_record!(UVRecord, PyUVRecord, NoRecord, PyNoRecord); From acc11014fa65b07753accc6e0bdbf9151903fc70 Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Wed, 11 Jan 2023 17:50:05 +0100 Subject: [PATCH 10/14] cleanup error, inlcude uv-b3-theory in example, add nist simulation data in example notebook --- examples/data/lennard_jones_nist.csv | 614 +++++++++++++++++++++++++++ examples/lj_models.ipynb | 257 ++++++++--- feos-core/src/errors.rs | 2 +- 3 files changed, 819 insertions(+), 54 deletions(-) create mode 100644 examples/data/lennard_jones_nist.csv diff --git a/examples/data/lennard_jones_nist.csv b/examples/data/lennard_jones_nist.csv new file mode 100644 index 000000000..63c07e69d --- /dev/null +++ b/examples/data/lennard_jones_nist.csv @@ -0,0 +1,614 @@ +t rhov rhol p +7.00000E-01 2.01239E-03 8.43237E-01 1.38071E-03 +7.01000E-01 2.03841E-03 8.42829E-01 1.40027E-03 +7.02000E-01 2.06469E-03 8.42420E-01 1.42004E-03 +7.03000E-01 2.09123E-03 8.42010E-01 1.44004E-03 +7.04000E-01 2.11803E-03 8.41598E-01 1.46025E-03 +7.05000E-01 2.14510E-03 8.41186E-01 1.48069E-03 +7.06000E-01 2.17243E-03 8.40772E-01 1.50136E-03 +7.07000E-01 2.20003E-03 8.40357E-01 1.52225E-03 +7.08000E-01 2.22790E-03 8.39941E-01 1.54337E-03 +7.09000E-01 2.25604E-03 8.39524E-01 1.56473E-03 +7.10000E-01 2.28445E-03 8.39106E-01 1.58631E-03 +7.11000E-01 2.31314E-03 8.38686E-01 1.60813E-03 +7.12000E-01 2.34210E-03 8.38266E-01 1.63018E-03 +7.13000E-01 2.37134E-03 8.37845E-01 1.65247E-03 +7.14000E-01 2.40085E-03 8.37422E-01 1.67500E-03 +7.15000E-01 2.43065E-03 8.36999E-01 1.69777E-03 +7.16000E-01 2.46073E-03 8.36575E-01 1.72078E-03 +7.17000E-01 2.49109E-03 8.36149E-01 1.74404E-03 +7.18000E-01 2.52174E-03 8.35723E-01 1.76753E-03 +7.19000E-01 2.55267E-03 8.35296E-01 1.79128E-03 +7.20000E-01 2.58390E-03 8.34868E-01 1.81528E-03 +7.21000E-01 2.61541E-03 8.34439E-01 1.83952E-03 +7.22000E-01 2.64721E-03 8.34010E-01 1.86402E-03 +7.23000E-01 2.67931E-03 8.33579E-01 1.88877E-03 +7.24000E-01 2.71170E-03 8.33148E-01 1.91378E-03 +7.25000E-01 2.74439E-03 8.32716E-01 1.93904E-03 +7.26000E-01 2.77738E-03 8.32283E-01 1.96456E-03 +7.27000E-01 2.81067E-03 8.31849E-01 1.99035E-03 +7.28000E-01 2.84425E-03 8.31415E-01 2.01639E-03 +7.29000E-01 2.87815E-03 8.30979E-01 2.04270E-03 +7.30000E-01 2.91234E-03 8.30543E-01 2.06928E-03 +7.31000E-01 2.94685E-03 8.30107E-01 2.09612E-03 +7.32000E-01 2.98166E-03 8.29669E-01 2.12323E-03 +7.33000E-01 3.01678E-03 8.29231E-01 2.15061E-03 +7.34000E-01 3.05221E-03 8.28793E-01 2.17826E-03 +7.35000E-01 3.08795E-03 8.28353E-01 2.20619E-03 +7.36000E-01 3.12401E-03 8.27913E-01 2.23440E-03 +7.37000E-01 3.16039E-03 8.27473E-01 2.26288E-03 +7.38000E-01 3.19708E-03 8.27032E-01 2.29164E-03 +7.39000E-01 3.23410E-03 8.26590E-01 2.32068E-03 +7.40000E-01 3.27143E-03 8.26147E-01 2.35001E-03 +7.41000E-01 3.30909E-03 8.25704E-01 2.37962E-03 +7.42000E-01 3.34708E-03 8.25261E-01 2.40951E-03 +7.43000E-01 3.38539E-03 8.24817E-01 2.43970E-03 +7.44000E-01 3.42402E-03 8.24372E-01 2.47017E-03 +7.45000E-01 3.46299E-03 8.23927E-01 2.50094E-03 +7.46000E-01 3.50229E-03 8.23481E-01 2.53200E-03 +7.47000E-01 3.54192E-03 8.23035E-01 2.56335E-03 +7.48000E-01 3.58189E-03 8.22588E-01 2.59500E-03 +7.49000E-01 3.62219E-03 8.22141E-01 2.62695E-03 +7.50000E-01 3.66284E-03 8.21693E-01 2.65920E-03 +7.51000E-01 3.70382E-03 8.21245E-01 2.69175E-03 +7.52000E-01 3.74514E-03 8.20796E-01 2.72461E-03 +7.53000E-01 3.78681E-03 8.20347E-01 2.75777E-03 +7.54000E-01 3.82882E-03 8.19898E-01 2.79124E-03 +7.55000E-01 3.87118E-03 8.19448E-01 2.82502E-03 +7.56000E-01 3.91389E-03 8.18997E-01 2.85911E-03 +7.57000E-01 3.95695E-03 8.18547E-01 2.89352E-03 +7.58000E-01 4.00036E-03 8.18095E-01 2.92824E-03 +7.59000E-01 4.04413E-03 8.17644E-01 2.96327E-03 +7.60000E-01 4.08825E-03 8.17192E-01 2.99862E-03 +7.61000E-01 4.13272E-03 8.16740E-01 3.03430E-03 +7.62000E-01 4.17756E-03 8.16287E-01 3.07029E-03 +7.63000E-01 4.22276E-03 8.15834E-01 3.10661E-03 +7.64000E-01 4.26832E-03 8.15380E-01 3.14326E-03 +7.65000E-01 4.31424E-03 8.14926E-01 3.18023E-03 +7.66000E-01 4.36053E-03 8.14472E-01 3.21753E-03 +7.67000E-01 4.40719E-03 8.14018E-01 3.25516E-03 +7.68000E-01 4.45421E-03 8.13563E-01 3.29313E-03 +7.69000E-01 4.50161E-03 8.13108E-01 3.33143E-03 +7.70000E-01 4.54938E-03 8.12652E-01 3.37006E-03 +7.71000E-01 4.59753E-03 8.12197E-01 3.40904E-03 +7.72000E-01 4.64605E-03 8.11741E-01 3.44835E-03 +7.73000E-01 4.69496E-03 8.11284E-01 3.48801E-03 +7.74000E-01 4.74424E-03 8.10828E-01 3.52801E-03 +7.75000E-01 4.79390E-03 8.10371E-01 3.56836E-03 +7.76000E-01 4.84395E-03 8.09913E-01 3.60905E-03 +7.77000E-01 4.89438E-03 8.09456E-01 3.65009E-03 +7.78000E-01 4.94520E-03 8.08998E-01 3.69149E-03 +7.79000E-01 4.99641E-03 8.08540E-01 3.73324E-03 +7.80000E-01 5.04801E-03 8.08082E-01 3.77534E-03 +7.81000E-01 5.10001E-03 8.07623E-01 3.81780E-03 +7.82000E-01 5.15239E-03 8.07164E-01 3.86062E-03 +7.83000E-01 5.20518E-03 8.06705E-01 3.90379E-03 +7.84000E-01 5.25836E-03 8.06246E-01 3.94733E-03 +7.85000E-01 5.31195E-03 8.05787E-01 3.99124E-03 +7.86000E-01 5.36593E-03 8.05327E-01 4.03551E-03 +7.87000E-01 5.42032E-03 8.04867E-01 4.08015E-03 +7.88000E-01 5.47511E-03 8.04407E-01 4.12516E-03 +7.89000E-01 5.53032E-03 8.03946E-01 4.17054E-03 +7.90000E-01 5.58593E-03 8.03485E-01 4.21629E-03 +7.91000E-01 5.64195E-03 8.03025E-01 4.26242E-03 +7.92000E-01 5.69839E-03 8.02563E-01 4.30893E-03 +7.93000E-01 5.75524E-03 8.02102E-01 4.35582E-03 +7.94000E-01 5.81250E-03 8.01641E-01 4.40309E-03 +7.95000E-01 5.87019E-03 8.01179E-01 4.45074E-03 +7.96000E-01 5.92830E-03 8.00717E-01 4.49877E-03 +7.97000E-01 5.98682E-03 8.00255E-01 4.54720E-03 +7.98000E-01 6.04578E-03 7.99792E-01 4.59601E-03 +7.99000E-01 6.10516E-03 7.99330E-01 4.64521E-03 +8.00000E-01 6.16496E-03 7.98867E-01 4.69480E-03 +8.01000E-01 6.22520E-03 7.98404E-01 4.74479E-03 +8.02000E-01 6.28587E-03 7.97941E-01 4.79518E-03 +8.03000E-01 6.34698E-03 7.97478E-01 4.84596E-03 +8.04000E-01 6.40851E-03 7.97014E-01 4.89714E-03 +8.05000E-01 6.47049E-03 7.96551E-01 4.94873E-03 +8.06000E-01 6.53291E-03 7.96087E-01 5.00072E-03 +8.07000E-01 6.59577E-03 7.95623E-01 5.05311E-03 +8.08000E-01 6.65907E-03 7.95158E-01 5.10592E-03 +8.09000E-01 6.72281E-03 7.94694E-01 5.15913E-03 +8.10000E-01 6.78701E-03 7.94229E-01 5.21275E-03 +8.11000E-01 6.85165E-03 7.93765E-01 5.26679E-03 +8.12000E-01 6.91674E-03 7.93300E-01 5.32124E-03 +8.13000E-01 6.98229E-03 7.92835E-01 5.37611E-03 +8.14000E-01 7.04830E-03 7.92369E-01 5.43140E-03 +8.15000E-01 7.11476E-03 7.91904E-01 5.48712E-03 +8.16000E-01 7.18168E-03 7.91438E-01 5.54325E-03 +8.17000E-01 7.24906E-03 7.90973E-01 5.59981E-03 +8.18000E-01 7.31690E-03 7.90507E-01 5.65680E-03 +8.19000E-01 7.38521E-03 7.90041E-01 5.71421E-03 +8.20000E-01 7.45398E-03 7.89574E-01 5.77206E-03 +8.21000E-01 7.52323E-03 7.89108E-01 5.83034E-03 +8.22000E-01 7.59295E-03 7.88641E-01 5.88905E-03 +8.23000E-01 7.66314E-03 7.88174E-01 5.94820E-03 +8.24000E-01 7.73380E-03 7.87708E-01 6.00779E-03 +8.25000E-01 7.80494E-03 7.87240E-01 6.06783E-03 +8.26000E-01 7.87656E-03 7.86773E-01 6.12830E-03 +8.27000E-01 7.94867E-03 7.86306E-01 6.18922E-03 +8.28000E-01 8.02125E-03 7.85838E-01 6.25058E-03 +8.29000E-01 8.09432E-03 7.85370E-01 6.31239E-03 +8.30000E-01 8.16788E-03 7.84902E-01 6.37466E-03 +8.31000E-01 8.24193E-03 7.84434E-01 6.43737E-03 +8.32000E-01 8.31647E-03 7.83966E-01 6.50054E-03 +8.33000E-01 8.39151E-03 7.83497E-01 6.56417E-03 +8.34000E-01 8.46704E-03 7.83029E-01 6.62825E-03 +8.35000E-01 8.54306E-03 7.82560E-01 6.69280E-03 +8.36000E-01 8.61959E-03 7.82091E-01 6.75781E-03 +8.37000E-01 8.69662E-03 7.81622E-01 6.82328E-03 +8.38000E-01 8.77416E-03 7.81153E-01 6.88922E-03 +8.39000E-01 8.85220E-03 7.80683E-01 6.95562E-03 +8.40000E-01 8.93075E-03 7.80213E-01 7.02250E-03 +8.41000E-01 9.00981E-03 7.79744E-01 7.08985E-03 +8.42000E-01 9.08938E-03 7.79274E-01 7.15767E-03 +8.43000E-01 9.16947E-03 7.78803E-01 7.22597E-03 +8.44000E-01 9.25007E-03 7.78333E-01 7.29474E-03 +8.45000E-01 9.33120E-03 7.77863E-01 7.36400E-03 +8.46000E-01 9.41284E-03 7.77392E-01 7.43374E-03 +8.47000E-01 9.49501E-03 7.76921E-01 7.50396E-03 +8.48000E-01 9.57771E-03 7.76450E-01 7.57467E-03 +8.49000E-01 9.66093E-03 7.75979E-01 7.64587E-03 +8.50000E-01 9.74468E-03 7.75507E-01 7.71756E-03 +8.51000E-01 9.82897E-03 7.75035E-01 7.78973E-03 +8.52000E-01 9.91379E-03 7.74564E-01 7.86241E-03 +8.53000E-01 9.99915E-03 7.74092E-01 7.93558E-03 +8.54000E-01 1.00850E-02 7.73619E-01 8.00924E-03 +8.55000E-01 1.01715E-02 7.73147E-01 8.08341E-03 +8.56000E-01 1.02585E-02 7.72674E-01 8.15808E-03 +8.57000E-01 1.03460E-02 7.72202E-01 8.23325E-03 +8.58000E-01 1.04341E-02 7.71729E-01 8.30893E-03 +8.59000E-01 1.05227E-02 7.71255E-01 8.38512E-03 +8.60000E-01 1.06119E-02 7.70782E-01 8.46181E-03 +8.61000E-01 1.07016E-02 7.70308E-01 8.53902E-03 +8.62000E-01 1.07919E-02 7.69835E-01 8.61675E-03 +8.63000E-01 1.08828E-02 7.69361E-01 8.69499E-03 +8.64000E-01 1.09742E-02 7.68886E-01 8.77374E-03 +8.65000E-01 1.10661E-02 7.68412E-01 8.85302E-03 +8.66000E-01 1.11587E-02 7.67937E-01 8.93282E-03 +8.67000E-01 1.12518E-02 7.67463E-01 9.01314E-03 +8.68000E-01 1.13455E-02 7.66987E-01 9.09399E-03 +8.69000E-01 1.14397E-02 7.66512E-01 9.17537E-03 +8.70000E-01 1.15346E-02 7.66037E-01 9.25728E-03 +8.71000E-01 1.16300E-02 7.65561E-01 9.33972E-03 +8.72000E-01 1.17260E-02 7.65085E-01 9.42270E-03 +8.73000E-01 1.18226E-02 7.64609E-01 9.50621E-03 +8.74000E-01 1.19197E-02 7.64132E-01 9.59026E-03 +8.75000E-01 1.20175E-02 7.63656E-01 9.67485E-03 +8.76000E-01 1.21158E-02 7.63179E-01 9.75998E-03 +8.77000E-01 1.22147E-02 7.62702E-01 9.84565E-03 +8.78000E-01 1.23143E-02 7.62224E-01 9.93188E-03 +8.79000E-01 1.24144E-02 7.61747E-01 1.00186E-02 +8.80000E-01 1.25151E-02 7.61269E-01 1.01060E-02 +8.81000E-01 1.26165E-02 7.60791E-01 1.01938E-02 +8.82000E-01 1.27184E-02 7.60312E-01 1.02823E-02 +8.83000E-01 1.28209E-02 7.59834E-01 1.03713E-02 +8.84000E-01 1.29241E-02 7.59355E-01 1.04608E-02 +8.85000E-01 1.30279E-02 7.58876E-01 1.05509E-02 +8.86000E-01 1.31322E-02 7.58396E-01 1.06416E-02 +8.87000E-01 1.32372E-02 7.57917E-01 1.07328E-02 +8.88000E-01 1.33429E-02 7.57437E-01 1.08246E-02 +8.89000E-01 1.34491E-02 7.56957E-01 1.09170E-02 +8.90000E-01 1.35560E-02 7.56476E-01 1.10099E-02 +8.91000E-01 1.36635E-02 7.55995E-01 1.11034E-02 +8.92000E-01 1.37716E-02 7.55514E-01 1.11975E-02 +8.93000E-01 1.38804E-02 7.55033E-01 1.12922E-02 +8.94000E-01 1.39898E-02 7.54551E-01 1.13874E-02 +8.95000E-01 1.40998E-02 7.54070E-01 1.14833E-02 +8.96000E-01 1.42105E-02 7.53587E-01 1.15797E-02 +8.97000E-01 1.43218E-02 7.53105E-01 1.16767E-02 +8.98000E-01 1.44338E-02 7.52622E-01 1.17742E-02 +8.99000E-01 1.45464E-02 7.52139E-01 1.18724E-02 +9.00000E-01 1.46597E-02 7.51656E-01 1.19712E-02 +9.01000E-01 1.47736E-02 7.51172E-01 1.20705E-02 +9.02000E-01 1.48882E-02 7.50688E-01 1.21705E-02 +9.03000E-01 1.50034E-02 7.50204E-01 1.22710E-02 +9.04000E-01 1.51193E-02 7.49719E-01 1.23722E-02 +9.05000E-01 1.52359E-02 7.49234E-01 1.24739E-02 +9.06000E-01 1.53531E-02 7.48749E-01 1.25763E-02 +9.07000E-01 1.54710E-02 7.48264E-01 1.26792E-02 +9.08000E-01 1.55896E-02 7.47778E-01 1.27828E-02 +9.09000E-01 1.57089E-02 7.47292E-01 1.28870E-02 +9.10000E-01 1.58288E-02 7.46805E-01 1.29918E-02 +9.11000E-01 1.59494E-02 7.46318E-01 1.30972E-02 +9.12000E-01 1.60707E-02 7.45831E-01 1.32032E-02 +9.13000E-01 1.61927E-02 7.45343E-01 1.33098E-02 +9.14000E-01 1.63154E-02 7.44855E-01 1.34171E-02 +9.15000E-01 1.64388E-02 7.44367E-01 1.35250E-02 +9.16000E-01 1.65629E-02 7.43879E-01 1.36335E-02 +9.17000E-01 1.66877E-02 7.43390E-01 1.37426E-02 +9.18000E-01 1.68131E-02 7.42900E-01 1.38524E-02 +9.19000E-01 1.69393E-02 7.42411E-01 1.39628E-02 +9.20000E-01 1.70662E-02 7.41920E-01 1.40738E-02 +9.21000E-01 1.71938E-02 7.41430E-01 1.41855E-02 +9.22000E-01 1.73222E-02 7.40939E-01 1.42978E-02 +9.23000E-01 1.74512E-02 7.40448E-01 1.44107E-02 +9.24000E-01 1.75809E-02 7.39956E-01 1.45243E-02 +9.25000E-01 1.77114E-02 7.39464E-01 1.46385E-02 +9.26000E-01 1.78426E-02 7.38972E-01 1.47534E-02 +9.27000E-01 1.79746E-02 7.38479E-01 1.48689E-02 +9.28000E-01 1.81073E-02 7.37986E-01 1.49851E-02 +9.29000E-01 1.82407E-02 7.37493E-01 1.51019E-02 +9.30000E-01 1.83748E-02 7.36999E-01 1.52193E-02 +9.31000E-01 1.85097E-02 7.36504E-01 1.53375E-02 +9.32000E-01 1.86453E-02 7.36010E-01 1.54563E-02 +9.33000E-01 1.87817E-02 7.35514E-01 1.55757E-02 +9.34000E-01 1.89188E-02 7.35019E-01 1.56958E-02 +9.35000E-01 1.90567E-02 7.34523E-01 1.58166E-02 +9.36000E-01 1.91954E-02 7.34026E-01 1.59380E-02 +9.37000E-01 1.93348E-02 7.33529E-01 1.60601E-02 +9.38000E-01 1.94750E-02 7.33032E-01 1.61829E-02 +9.39000E-01 1.96159E-02 7.32534E-01 1.63064E-02 +9.40000E-01 1.97576E-02 7.32036E-01 1.64305E-02 +9.41000E-01 1.99001E-02 7.31537E-01 1.65553E-02 +9.42000E-01 2.00434E-02 7.31038E-01 1.66808E-02 +9.43000E-01 2.01874E-02 7.30539E-01 1.68069E-02 +9.44000E-01 2.03323E-02 7.30039E-01 1.69338E-02 +9.45000E-01 2.04779E-02 7.29538E-01 1.70613E-02 +9.46000E-01 2.06243E-02 7.29037E-01 1.71895E-02 +9.47000E-01 2.07715E-02 7.28536E-01 1.73184E-02 +9.48000E-01 2.09195E-02 7.28034E-01 1.74480E-02 +9.49000E-01 2.10683E-02 7.27531E-01 1.75783E-02 +9.50000E-01 2.12179E-02 7.27029E-01 1.77093E-02 +9.51000E-01 2.13683E-02 7.26525E-01 1.78410E-02 +9.52000E-01 2.15196E-02 7.26021E-01 1.79734E-02 +9.53000E-01 2.16716E-02 7.25517E-01 1.81065E-02 +9.54000E-01 2.18245E-02 7.25012E-01 1.82403E-02 +9.55000E-01 2.19782E-02 7.24507E-01 1.83748E-02 +9.56000E-01 2.21327E-02 7.24001E-01 1.85100E-02 +9.57000E-01 2.22880E-02 7.23494E-01 1.86459E-02 +9.58000E-01 2.24442E-02 7.22988E-01 1.87825E-02 +9.59000E-01 2.26012E-02 7.22480E-01 1.89199E-02 +9.60000E-01 2.27591E-02 7.21972E-01 1.90579E-02 +9.61000E-01 2.29178E-02 7.21464E-01 1.91967E-02 +9.62000E-01 2.30773E-02 7.20955E-01 1.93362E-02 +9.63000E-01 2.32377E-02 7.20445E-01 1.94764E-02 +9.64000E-01 2.33990E-02 7.19935E-01 1.96174E-02 +9.65000E-01 2.35611E-02 7.19424E-01 1.97591E-02 +9.66000E-01 2.37241E-02 7.18913E-01 1.99015E-02 +9.67000E-01 2.38879E-02 7.18401E-01 2.00446E-02 +9.68000E-01 2.40527E-02 7.17889E-01 2.01885E-02 +9.69000E-01 2.42182E-02 7.17376E-01 2.03331E-02 +9.70000E-01 2.43847E-02 7.16863E-01 2.04785E-02 +9.71000E-01 2.45521E-02 7.16348E-01 2.06246E-02 +9.72000E-01 2.47203E-02 7.15834E-01 2.07714E-02 +9.73000E-01 2.48895E-02 7.15319E-01 2.09190E-02 +9.74000E-01 2.50595E-02 7.14803E-01 2.10673E-02 +9.75000E-01 2.52304E-02 7.14286E-01 2.12164E-02 +9.76000E-01 2.54023E-02 7.13769E-01 2.13662E-02 +9.77000E-01 2.55750E-02 7.13252E-01 2.15168E-02 +9.78000E-01 2.57487E-02 7.12733E-01 2.16681E-02 +9.79000E-01 2.59232E-02 7.12215E-01 2.18202E-02 +9.80000E-01 2.60987E-02 7.11695E-01 2.19731E-02 +9.81000E-01 2.62752E-02 7.11175E-01 2.21267E-02 +9.82000E-01 2.64525E-02 7.10654E-01 2.22811E-02 +9.83000E-01 2.66308E-02 7.10133E-01 2.24362E-02 +9.84000E-01 2.68100E-02 7.09611E-01 2.25921E-02 +9.85000E-01 2.69901E-02 7.09088E-01 2.27488E-02 +9.86000E-01 2.71712E-02 7.08565E-01 2.29062E-02 +9.87000E-01 2.73533E-02 7.08041E-01 2.30645E-02 +9.88000E-01 2.75363E-02 7.07516E-01 2.32235E-02 +9.89000E-01 2.77203E-02 7.06991E-01 2.33833E-02 +9.90000E-01 2.79052E-02 7.06465E-01 2.35438E-02 +9.91000E-01 2.80911E-02 7.05938E-01 2.37052E-02 +9.92000E-01 2.82780E-02 7.05411E-01 2.38673E-02 +9.93000E-01 2.84658E-02 7.04883E-01 2.40302E-02 +9.94000E-01 2.86546E-02 7.04354E-01 2.41940E-02 +9.95000E-01 2.88445E-02 7.03825E-01 2.43585E-02 +9.96000E-01 2.90353E-02 7.03295E-01 2.45238E-02 +9.97000E-01 2.92271E-02 7.02764E-01 2.46898E-02 +9.98000E-01 2.94199E-02 7.02232E-01 2.48567E-02 +9.99000E-01 2.96137E-02 7.01700E-01 2.50244E-02 +1.00000E+00 2.98085E-02 7.01167E-01 2.51929E-02 +1.00100E+00 3.00043E-02 7.00633E-01 2.53622E-02 +1.00200E+00 3.02012E-02 7.00099E-01 2.55323E-02 +1.00300E+00 3.03991E-02 6.99563E-01 2.57033E-02 +1.00400E+00 3.05980E-02 6.99027E-01 2.58750E-02 +1.00500E+00 3.07979E-02 6.98491E-01 2.60475E-02 +1.00600E+00 3.09989E-02 6.97953E-01 2.62209E-02 +1.00700E+00 3.12010E-02 6.97415E-01 2.63951E-02 +1.00800E+00 3.14040E-02 6.96876E-01 2.65701E-02 +1.00900E+00 3.16082E-02 6.96336E-01 2.67459E-02 +1.01000E+00 3.18134E-02 6.95795E-01 2.69225E-02 +1.01100E+00 3.20196E-02 6.95254E-01 2.71000E-02 +1.01200E+00 3.22270E-02 6.94712E-01 2.72783E-02 +1.01300E+00 3.24354E-02 6.94169E-01 2.74574E-02 +1.01400E+00 3.26449E-02 6.93625E-01 2.76374E-02 +1.01500E+00 3.28555E-02 6.93080E-01 2.78182E-02 +1.01600E+00 3.30671E-02 6.92535E-01 2.79998E-02 +1.01700E+00 3.32799E-02 6.91989E-01 2.81823E-02 +1.01800E+00 3.34938E-02 6.91441E-01 2.83656E-02 +1.01900E+00 3.37088E-02 6.90894E-01 2.85497E-02 +1.02000E+00 3.39249E-02 6.90345E-01 2.87347E-02 +1.02100E+00 3.41421E-02 6.89795E-01 2.89206E-02 +1.02200E+00 3.43604E-02 6.89244E-01 2.91073E-02 +1.02300E+00 3.45799E-02 6.88693E-01 2.92949E-02 +1.02400E+00 3.48005E-02 6.88141E-01 2.94833E-02 +1.02500E+00 3.50223E-02 6.87588E-01 2.96725E-02 +1.02600E+00 3.52452E-02 6.87034E-01 2.98627E-02 +1.02700E+00 3.54693E-02 6.86479E-01 3.00537E-02 +1.02800E+00 3.56945E-02 6.85923E-01 3.02455E-02 +1.02900E+00 3.59209E-02 6.85366E-01 3.04382E-02 +1.03000E+00 3.61485E-02 6.84808E-01 3.06318E-02 +1.03100E+00 3.63772E-02 6.84250E-01 3.08263E-02 +1.03200E+00 3.66072E-02 6.83690E-01 3.10216E-02 +1.03300E+00 3.68383E-02 6.83130E-01 3.12178E-02 +1.03400E+00 3.70706E-02 6.82568E-01 3.14149E-02 +1.03500E+00 3.73042E-02 6.82006E-01 3.16128E-02 +1.03600E+00 3.75389E-02 6.81443E-01 3.18117E-02 +1.03700E+00 3.77749E-02 6.80878E-01 3.20114E-02 +1.03800E+00 3.80121E-02 6.80313E-01 3.22120E-02 +1.03900E+00 3.82505E-02 6.79747E-01 3.24135E-02 +1.04000E+00 3.84902E-02 6.79179E-01 3.26159E-02 +1.04100E+00 3.87311E-02 6.78611E-01 3.28192E-02 +1.04200E+00 3.89732E-02 6.78042E-01 3.30234E-02 +1.04300E+00 3.92166E-02 6.77472E-01 3.32284E-02 +1.04400E+00 3.94613E-02 6.76900E-01 3.34344E-02 +1.04500E+00 3.97073E-02 6.76328E-01 3.36413E-02 +1.04600E+00 3.99545E-02 6.75755E-01 3.38490E-02 +1.04700E+00 4.02030E-02 6.75180E-01 3.40577E-02 +1.04800E+00 4.04528E-02 6.74605E-01 3.42673E-02 +1.04900E+00 4.07040E-02 6.74028E-01 3.44778E-02 +1.05000E+00 4.09564E-02 6.73451E-01 3.46892E-02 +1.05100E+00 4.12101E-02 6.72872E-01 3.49016E-02 +1.05200E+00 4.14652E-02 6.72292E-01 3.51148E-02 +1.05300E+00 4.17216E-02 6.71712E-01 3.53290E-02 +1.05400E+00 4.19793E-02 6.71130E-01 3.55440E-02 +1.05500E+00 4.22384E-02 6.70547E-01 3.57600E-02 +1.05600E+00 4.24988E-02 6.69962E-01 3.59770E-02 +1.05700E+00 4.27606E-02 6.69377E-01 3.61948E-02 +1.05800E+00 4.30238E-02 6.68791E-01 3.64136E-02 +1.05900E+00 4.32883E-02 6.68203E-01 3.66334E-02 +1.06000E+00 4.35542E-02 6.67614E-01 3.68540E-02 +1.06100E+00 4.38215E-02 6.67024E-01 3.70756E-02 +1.06200E+00 4.40903E-02 6.66433E-01 3.72981E-02 +1.06300E+00 4.43604E-02 6.65841E-01 3.75216E-02 +1.06400E+00 4.46319E-02 6.65247E-01 3.77460E-02 +1.06500E+00 4.49049E-02 6.64653E-01 3.79714E-02 +1.06600E+00 4.51793E-02 6.64057E-01 3.81977E-02 +1.06700E+00 4.54552E-02 6.63460E-01 3.84250E-02 +1.06800E+00 4.57325E-02 6.62861E-01 3.86532E-02 +1.06900E+00 4.60113E-02 6.62262E-01 3.88824E-02 +1.07000E+00 4.62915E-02 6.61661E-01 3.91125E-02 +1.07100E+00 4.65732E-02 6.61059E-01 3.93436E-02 +1.07200E+00 4.68564E-02 6.60455E-01 3.95756E-02 +1.07300E+00 4.71411E-02 6.59851E-01 3.98087E-02 +1.07400E+00 4.74273E-02 6.59245E-01 4.00426E-02 +1.07500E+00 4.77150E-02 6.58637E-01 4.02776E-02 +1.07600E+00 4.80043E-02 6.58029E-01 4.05135E-02 +1.07700E+00 4.82951E-02 6.57419E-01 4.07504E-02 +1.07800E+00 4.85874E-02 6.56808E-01 4.09883E-02 +1.07900E+00 4.88813E-02 6.56195E-01 4.12271E-02 +1.08000E+00 4.91768E-02 6.55581E-01 4.14670E-02 +1.08100E+00 4.94738E-02 6.54966E-01 4.17078E-02 +1.08200E+00 4.97724E-02 6.54349E-01 4.19496E-02 +1.08300E+00 5.00726E-02 6.53731E-01 4.21924E-02 +1.08400E+00 5.03744E-02 6.53111E-01 4.24361E-02 +1.08500E+00 5.06778E-02 6.52491E-01 4.26809E-02 +1.08600E+00 5.09829E-02 6.51868E-01 4.29267E-02 +1.08700E+00 5.12896E-02 6.51244E-01 4.31734E-02 +1.08800E+00 5.15979E-02 6.50619E-01 4.34212E-02 +1.08900E+00 5.19079E-02 6.49992E-01 4.36699E-02 +1.09000E+00 5.22195E-02 6.49364E-01 4.39197E-02 +1.09100E+00 5.25329E-02 6.48734E-01 4.41704E-02 +1.09200E+00 5.28479E-02 6.48103E-01 4.44222E-02 +1.09300E+00 5.31647E-02 6.47471E-01 4.46750E-02 +1.09400E+00 5.34831E-02 6.46836E-01 4.49288E-02 +1.09500E+00 5.38033E-02 6.46200E-01 4.51836E-02 +1.09600E+00 5.41252E-02 6.45563E-01 4.54394E-02 +1.09700E+00 5.44489E-02 6.44924E-01 4.56963E-02 +1.09800E+00 5.47743E-02 6.44284E-01 4.59542E-02 +1.09900E+00 5.51015E-02 6.43642E-01 4.62131E-02 +1.10000E+00 5.54305E-02 6.42998E-01 4.64730E-02 +1.10100E+00 5.57613E-02 6.42353E-01 4.67339E-02 +1.10200E+00 5.60939E-02 6.41706E-01 4.69959E-02 +1.10300E+00 5.64283E-02 6.41057E-01 4.72589E-02 +1.10400E+00 5.67646E-02 6.40407E-01 4.75230E-02 +1.10500E+00 5.71027E-02 6.39755E-01 4.77881E-02 +1.10600E+00 5.74427E-02 6.39101E-01 4.80542E-02 +1.10700E+00 5.77846E-02 6.38446E-01 4.83214E-02 +1.10800E+00 5.81283E-02 6.37789E-01 4.85896E-02 +1.10900E+00 5.84740E-02 6.37130E-01 4.88589E-02 +1.11000E+00 5.88215E-02 6.36469E-01 4.91292E-02 +1.11100E+00 5.91711E-02 6.35807E-01 4.94006E-02 +1.11200E+00 5.95225E-02 6.35142E-01 4.96730E-02 +1.11300E+00 5.98759E-02 6.34476E-01 4.99465E-02 +1.11400E+00 6.02313E-02 6.33809E-01 5.02211E-02 +1.11500E+00 6.05887E-02 6.33139E-01 5.04967E-02 +1.11600E+00 6.09481E-02 6.32467E-01 5.07734E-02 +1.11700E+00 6.13096E-02 6.31794E-01 5.10511E-02 +1.11800E+00 6.16730E-02 6.31119E-01 5.13299E-02 +1.11900E+00 6.20385E-02 6.30441E-01 5.16098E-02 +1.12000E+00 6.24061E-02 6.29762E-01 5.18908E-02 +1.12100E+00 6.27758E-02 6.29081E-01 5.21728E-02 +1.12200E+00 6.31476E-02 6.28398E-01 5.24560E-02 +1.12300E+00 6.35215E-02 6.27713E-01 5.27402E-02 +1.12400E+00 6.38975E-02 6.27026E-01 5.30255E-02 +1.12500E+00 6.42757E-02 6.26337E-01 5.33118E-02 +1.12600E+00 6.46561E-02 6.25646E-01 5.35993E-02 +1.12700E+00 6.50386E-02 6.24953E-01 5.38879E-02 +1.12800E+00 6.54234E-02 6.24257E-01 5.41775E-02 +1.12900E+00 6.58104E-02 6.23560E-01 5.44683E-02 +1.13000E+00 6.61996E-02 6.22860E-01 5.47601E-02 +1.13100E+00 6.65911E-02 6.22159E-01 5.50531E-02 +1.13200E+00 6.69848E-02 6.21455E-01 5.53472E-02 +1.13300E+00 6.73809E-02 6.20749E-01 5.56423E-02 +1.13400E+00 6.77793E-02 6.20041E-01 5.59386E-02 +1.13500E+00 6.81800E-02 6.19330E-01 5.62360E-02 +1.13600E+00 6.85831E-02 6.18618E-01 5.65345E-02 +1.13700E+00 6.89885E-02 6.17903E-01 5.68341E-02 +1.13800E+00 6.93964E-02 6.17185E-01 5.71349E-02 +1.13900E+00 6.98067E-02 6.16466E-01 5.74367E-02 +1.14000E+00 7.02194E-02 6.15744E-01 5.77397E-02 +1.14100E+00 7.06346E-02 6.15019E-01 5.80439E-02 +1.14200E+00 7.10522E-02 6.14292E-01 5.83491E-02 +1.14300E+00 7.14724E-02 6.13563E-01 5.86555E-02 +1.14400E+00 7.18951E-02 6.12832E-01 5.89630E-02 +1.14500E+00 7.23204E-02 6.12098E-01 5.92717E-02 +1.14600E+00 7.27482E-02 6.11361E-01 5.95815E-02 +1.14700E+00 7.31786E-02 6.10622E-01 5.98924E-02 +1.14800E+00 7.36117E-02 6.09880E-01 6.02045E-02 +1.14900E+00 7.40474E-02 6.09136E-01 6.05178E-02 +1.15000E+00 7.44858E-02 6.08389E-01 6.08322E-02 +1.15100E+00 7.49268E-02 6.07639E-01 6.11477E-02 +1.15200E+00 7.53706E-02 6.06887E-01 6.14644E-02 +1.15300E+00 7.58172E-02 6.06132E-01 6.17823E-02 +1.15400E+00 7.62665E-02 6.05375E-01 6.21013E-02 +1.15500E+00 7.67186E-02 6.04614E-01 6.24215E-02 +1.15600E+00 7.71736E-02 6.03851E-01 6.27428E-02 +1.15700E+00 7.76314E-02 6.03085E-01 6.30654E-02 +1.15800E+00 7.80921E-02 6.02316E-01 6.33891E-02 +1.15900E+00 7.85557E-02 6.01544E-01 6.37139E-02 +1.16000E+00 7.90223E-02 6.00770E-01 6.40400E-02 +1.16100E+00 7.94918E-02 5.99992E-01 6.43672E-02 +1.16200E+00 7.99644E-02 5.99211E-01 6.46957E-02 +1.16300E+00 8.04399E-02 5.98428E-01 6.50253E-02 +1.16400E+00 8.09186E-02 5.97641E-01 6.53561E-02 +1.16500E+00 8.14003E-02 5.96851E-01 6.56881E-02 +1.16600E+00 8.18852E-02 5.96058E-01 6.60213E-02 +1.16700E+00 8.23732E-02 5.95262E-01 6.63556E-02 +1.16800E+00 8.28645E-02 5.94463E-01 6.66912E-02 +1.16900E+00 8.33589E-02 5.93660E-01 6.70280E-02 +1.17000E+00 8.38567E-02 5.92855E-01 6.73660E-02 +1.17100E+00 8.43577E-02 5.92045E-01 6.77052E-02 +1.17200E+00 8.48621E-02 5.91233E-01 6.80456E-02 +1.17300E+00 8.53698E-02 5.90417E-01 6.83873E-02 +1.17400E+00 8.58810E-02 5.89597E-01 6.87301E-02 +1.17500E+00 8.63956E-02 5.88774E-01 6.90742E-02 +1.17600E+00 8.69137E-02 5.87948E-01 6.94195E-02 +1.17700E+00 8.74353E-02 5.87118E-01 6.97660E-02 +1.17800E+00 8.79605E-02 5.86284E-01 7.01138E-02 +1.17900E+00 8.84893E-02 5.85447E-01 7.04628E-02 +1.18000E+00 8.90218E-02 5.84606E-01 7.08130E-02 +1.18100E+00 8.95580E-02 5.83761E-01 7.11644E-02 +1.18200E+00 9.00979E-02 5.82912E-01 7.15171E-02 +1.18300E+00 9.06416E-02 5.82060E-01 7.18711E-02 +1.18400E+00 9.11891E-02 5.81203E-01 7.22263E-02 +1.18500E+00 9.17405E-02 5.80342E-01 7.25827E-02 +1.18600E+00 9.22958E-02 5.79478E-01 7.29404E-02 +1.18700E+00 9.28552E-02 5.78609E-01 7.32994E-02 +1.18800E+00 9.34185E-02 5.77736E-01 7.36596E-02 +1.18900E+00 9.39859E-02 5.76859E-01 7.40211E-02 +1.19000E+00 9.45574E-02 5.75978E-01 7.43838E-02 +1.19100E+00 9.51331E-02 5.75092E-01 7.47479E-02 +1.19200E+00 9.57131E-02 5.74202E-01 7.51131E-02 +1.19300E+00 9.62973E-02 5.73308E-01 7.54797E-02 +1.19400E+00 9.68859E-02 5.72409E-01 7.58475E-02 +1.19500E+00 9.74789E-02 5.71505E-01 7.62167E-02 +1.19600E+00 9.80764E-02 5.70597E-01 7.65871E-02 +1.19700E+00 9.86783E-02 5.69684E-01 7.69588E-02 +1.19800E+00 9.92849E-02 5.68766E-01 7.73318E-02 +1.19900E+00 9.98961E-02 5.67844E-01 7.77061E-02 +1.20000E+00 1.00512E-01 5.66916E-01 7.80816E-02 +1.20100E+00 1.01133E-01 5.65983E-01 7.84585E-02 +1.20200E+00 1.01758E-01 5.65046E-01 7.88367E-02 +1.20300E+00 1.02389E-01 5.64103E-01 7.92162E-02 +1.20400E+00 1.03024E-01 5.63155E-01 7.95970E-02 +1.20500E+00 1.03665E-01 5.62201E-01 7.99792E-02 +1.20600E+00 1.04310E-01 5.61242E-01 8.03626E-02 +1.20700E+00 1.04961E-01 5.60278E-01 8.07474E-02 +1.20800E+00 1.05617E-01 5.59308E-01 8.11335E-02 +1.20900E+00 1.06279E-01 5.58332E-01 8.15209E-02 +1.21000E+00 1.06946E-01 5.57351E-01 8.19096E-02 +1.21100E+00 1.07618E-01 5.56363E-01 8.22997E-02 +1.21200E+00 1.08296E-01 5.55370E-01 8.26912E-02 +1.21300E+00 1.08980E-01 5.54370E-01 8.30839E-02 +1.21400E+00 1.09670E-01 5.53364E-01 8.34781E-02 +1.21500E+00 1.10366E-01 5.52352E-01 8.38735E-02 +1.21600E+00 1.11067E-01 5.51334E-01 8.42704E-02 +1.21700E+00 1.11775E-01 5.50309E-01 8.46685E-02 +1.21800E+00 1.12489E-01 5.49277E-01 8.50681E-02 +1.21900E+00 1.13209E-01 5.48239E-01 8.54690E-02 +1.22000E+00 1.13935E-01 5.47194E-01 8.58713E-02 +1.22100E+00 1.14668E-01 5.46141E-01 8.62749E-02 +1.22200E+00 1.15408E-01 5.45082E-01 8.66799E-02 +1.22300E+00 1.16154E-01 5.44015E-01 8.70864E-02 +1.22400E+00 1.16908E-01 5.42941E-01 8.74941E-02 +1.22500E+00 1.17668E-01 5.41859E-01 8.79033E-02 +1.22600E+00 1.18435E-01 5.40770E-01 8.83139E-02 +1.22700E+00 1.19210E-01 5.39672E-01 8.87259E-02 +1.22800E+00 1.19992E-01 5.38567E-01 8.91392E-02 +1.22900E+00 1.20782E-01 5.37453E-01 8.95540E-02 +1.23000E+00 1.21579E-01 5.36331E-01 8.99702E-02 +1.23100E+00 1.22384E-01 5.35201E-01 9.03878E-02 +1.23200E+00 1.23197E-01 5.34062E-01 9.08068E-02 +1.23300E+00 1.24019E-01 5.32914E-01 9.12272E-02 +1.23400E+00 1.24848E-01 5.31757E-01 9.16491E-02 +1.23500E+00 1.25686E-01 5.30590E-01 9.20724E-02 +1.23600E+00 1.26533E-01 5.29414E-01 9.24971E-02 +1.23700E+00 1.27388E-01 5.28229E-01 9.29233E-02 +1.23800E+00 1.28253E-01 5.27033E-01 9.33509E-02 +1.23900E+00 1.29127E-01 5.25827E-01 9.37799E-02 +1.24000E+00 1.30010E-01 5.24611E-01 9.42104E-02 +1.24100E+00 1.30902E-01 5.23385E-01 9.46424E-02 +1.24200E+00 1.31805E-01 5.22147E-01 9.50758E-02 +1.24300E+00 1.32718E-01 5.20898E-01 9.55107E-02 +1.24400E+00 1.33641E-01 5.19638E-01 9.59470E-02 +1.24500E+00 1.34574E-01 5.18367E-01 9.63848E-02 +1.24600E+00 1.35519E-01 5.17083E-01 9.68241E-02 +1.24700E+00 1.36474E-01 5.15787E-01 9.72649E-02 +1.24800E+00 1.37441E-01 5.14478E-01 9.77072E-02 +1.24900E+00 1.38419E-01 5.13157E-01 9.81510E-02 +1.25000E+00 1.39409E-01 5.11822E-01 9.85962E-02 +1.25100E+00 1.40412E-01 5.10474E-01 9.90430E-02 +1.25200E+00 1.41427E-01 5.09111E-01 9.94913E-02 +1.25300E+00 1.42454E-01 5.07735E-01 9.99411E-02 +1.25400E+00 1.43495E-01 5.06343E-01 1.00392E-01 +1.25500E+00 1.44550E-01 5.04936E-01 1.00845E-01 +1.25600E+00 1.45619E-01 5.03514E-01 1.01300E-01 +1.25700E+00 1.46702E-01 5.02076E-01 1.01755E-01 +1.25800E+00 1.47799E-01 5.00621E-01 1.02213E-01 +1.25900E+00 1.48912E-01 4.99148E-01 1.02672E-01 +1.26000E+00 1.50041E-01 4.97659E-01 1.03132E-01 +1.26100E+00 1.51186E-01 4.96151E-01 1.03595E-01 +1.26200E+00 1.52347E-01 4.94624E-01 1.04058E-01 +1.26300E+00 1.53526E-01 4.93078E-01 1.04523E-01 +1.26400E+00 1.54722E-01 4.91512E-01 1.04990E-01 +1.26500E+00 1.55937E-01 4.89925E-01 1.05459E-01 +1.26600E+00 1.57170E-01 4.88317E-01 1.05929E-01 +1.26700E+00 1.58424E-01 4.86686E-01 1.06400E-01 +1.26800E+00 1.59697E-01 4.85033E-01 1.06873E-01 +1.26900E+00 1.60992E-01 4.83356E-01 1.07348E-01 +1.27000E+00 1.62308E-01 4.81654E-01 1.07824E-01 +1.27100E+00 1.63647E-01 4.79926E-01 1.08302E-01 +1.27200E+00 1.65010E-01 4.78172E-01 1.08782E-01 +1.27300E+00 1.66397E-01 4.76390E-01 1.09263E-01 +1.27400E+00 1.67810E-01 4.74579E-01 1.09746E-01 +1.27500E+00 1.69249E-01 4.72738E-01 1.10231E-01 +1.27600E+00 1.70715E-01 4.70865E-01 1.10717E-01 +1.27700E+00 1.72211E-01 4.68960E-01 1.11205E-01 +1.27800E+00 1.73736E-01 4.67020E-01 1.11694E-01 +1.27900E+00 1.75293E-01 4.65044E-01 1.12185E-01 +1.28000E+00 1.76884E-01 4.63031E-01 1.12678E-01 +1.28100E+00 1.78509E-01 4.60979E-01 1.13173E-01 +1.28200E+00 1.80170E-01 4.58885E-01 1.13669E-01 +1.28300E+00 1.81869E-01 4.56747E-01 1.14167E-01 +1.28400E+00 1.83609E-01 4.54563E-01 1.14667E-01 +1.28500E+00 1.85392E-01 4.52331E-01 1.15168E-01 +1.28600E+00 1.87219E-01 4.50048E-01 1.15671E-01 +1.28700E+00 1.89094E-01 4.47710E-01 1.16176E-01 +1.28800E+00 1.91020E-01 4.45315E-01 1.16682E-01 +1.28900E+00 1.93000E-01 4.42858E-01 1.17191E-01 +1.29000E+00 1.95037E-01 4.40336E-01 1.17701E-01 +1.29100E+00 1.97136E-01 4.37744E-01 1.18213E-01 +1.29200E+00 1.99301E-01 4.35078E-01 1.18726E-01 +1.29300E+00 2.01537E-01 4.32331E-01 1.19242E-01 +1.29400E+00 2.03850E-01 4.29497E-01 1.19759E-01 +1.29500E+00 2.06245E-01 4.26570E-01 1.20278E-01 +1.29600E+00 2.08731E-01 4.23540E-01 1.20798E-01 +1.29700E+00 2.11316E-01 4.20400E-01 1.21321E-01 +1.29800E+00 2.14010E-01 4.17138E-01 1.21845E-01 +1.29900E+00 2.16824E-01 4.13742E-01 1.22372E-01 +1.30000E+00 2.19771E-01 4.10196E-01 1.22900E-01 +1.30100E+00 2.22869E-01 4.06485E-01 1.23430E-01 +1.30200E+00 2.26136E-01 4.02586E-01 1.23961E-01 +1.30300E+00 2.29596E-01 3.98474E-01 1.24495E-01 +1.30400E+00 2.33282E-01 3.94117E-01 1.25031E-01 +1.30500E+00 2.37231E-01 3.89473E-01 1.25568E-01 +1.30600E+00 2.41495E-01 3.84489E-01 1.26107E-01 +1.30700E+00 2.46147E-01 3.79091E-01 1.26648E-01 +1.30800E+00 2.51287E-01 3.73174E-01 1.27192E-01 +1.30900E+00 2.57074E-01 3.66577E-01 1.27736E-01 +1.31000E+00 2.63768E-01 3.59036E-01 1.28283E-01 +1.31100E+00 2.71882E-01 3.50035E-01 1.28832E-01 +1.31200E+00 2.82726E-01 3.38258E-01 1.29383E-01 \ No newline at end of file diff --git a/examples/lj_models.ipynb b/examples/lj_models.ipynb index 6e201df03..119497b67 100644 --- a/examples/lj_models.ipynb +++ b/examples/lj_models.ipynb @@ -4,37 +4,40 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Comparison of equations of state for the Lennard-Jones fluid\n", + "# Comparison of equations of state for model fluids\n", "\n", "In this notebook, we take a look at three model fluid equations of state and compare them.\n", "These EoS are:\n", "\n", "- The PeTS equation of state (from `feos.pets`),\n", - "- the uv-theory equation of state (from `feos.uvtheory`), and\n", + "- the uv-theory equation of state (from `feos.uvtheory`), \n", + "- the uv-B3-theory equation of state (from `feos.uvtheory` using `VirialOrder.Third`), and\n", "- the Thol equation of state (implemented in as Python class).\n", "\n", - "The PeTS equation of state is for a Lennard-Jones fluid with cut off distance of $r_c = 2.5 \\sigma$ and a potential shift while the uv-theory and Thol equation of state model the full Lennard-Jones potential. Thus, we don't expect similar results when comparing uv-theory and Thol to PeTS." + "The PeTS equation of state is for a Lennard-Jones fluid with cut off distance of $r_c = 2.5 \\sigma$ and a potential shift while the uv-theory and Thol equation of state model the full Lennard-Jones potential. Note that the uv-theory was developed to model Mie potentials and not primarily adjusted to the Lennard-Jones fluid. Thus, we don't expect similar results when comparing uv-theory and Thol to PeTS." ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from feos.si import *\n", - "from feos.uvtheory import UVParameters, Perturbation\n", + "from feos.uvtheory import UVParameters, Perturbation, VirialOrder\n", "from feos.pets import PetsParameters\n", "from feos.eos import State, PhaseEquilibrium, PhaseDiagram, EquationOfState, Contributions\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", + "import pandas as pd\n", "\n", "import warnings\n", "warnings.filterwarnings('ignore')\n", "\n", "sns.set_context('talk')\n", - "sns.set_palette('Dark2')\n", + "#sns.set_palette('asd')\n", + "sns.set_palette(\"hls\", 8)\n", "sns.set_style('ticks')\n", "colors = sns.palettes.color_palette('Dark2', 8)" ] @@ -48,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -102,15 +105,12 @@ " \"\"\"\n", " tau = self.tc / state.temperature\n", " delta = np.sum(state.partial_density) / self.rhoc\n", - " a = 0.0 #zero(state)\n", + " a = 0.0\n", " \n", " for i in range(6):\n", " a = a + N[i] * delta**D[i] * tau**T[i]\n", - " \n", - " # print(\"2\")\n", " for i in range(6, 12):\n", " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", - " # print(\"3\")\n", " for i in range(12, 23):\n", " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n", " return a * np.sum(state.moles)" @@ -125,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -134,9 +134,10 @@ "eps_k = 150.03\n", "eps_k_k = eps_k * KELVIN\n", "\n", - "parameters = UVParameters.from_lists([12.0], [6.0], [sigma], [eps_k])\n", + "parameters = UVParameters.new_simple(12.0, 6.0, sigma, eps_k)\n", "uvtheory_wca = EquationOfState.uvtheory(parameters)\n", "uvtheory_bh = EquationOfState.uvtheory(parameters, perturbation=Perturbation.BarkerHenderson)\n", + "uvtheory_b3 = EquationOfState.uvtheory(parameters, virial_order=VirialOrder.Third)\n", "\n", "parameters = PetsParameters.from_values(sigma, eps_k)\n", "pets = EquationOfState.pets(parameters)\n", @@ -154,18 +155,19 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "s1 = State(uvtheory_wca, temperature=300*KELVIN, pressure=1*BAR)\n", - "s2 = State(pets, temperature=300*KELVIN, pressure=1*BAR)\n", - "s3 = State(thol, temperature=300*KELVIN, pressure=1*BAR)" + "s2 = State(uvtheory_b3, temperature=300*KELVIN, pressure=1*BAR)\n", + "s3 = State(thol, temperature=300*KELVIN, pressure=1*BAR)\n", + "s4 = State(pets, temperature=300*KELVIN, pressure=1*BAR)" ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -174,7 +176,7 @@ "-0.0016213224956115704" ] }, - "execution_count": 51, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -185,16 +187,16 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "-0.000940704010881386" + "-0.0016138652202999679" ] }, - "execution_count": 52, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -205,7 +207,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -214,7 +216,7 @@ "-0.0016144150962601586" ] }, - "execution_count": 53, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -223,6 +225,26 @@ "s3.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" ] }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.000940704010881386" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s4.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -232,25 +254,26 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(1.320000346982154, 1.3097658041494296, 1.3208296613277397)" + "(1.3097658041494296, 1.3208296613277397, 1.3132940626554175)" ] }, - "execution_count": 54, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(\n", - " State.critical_point(thol).temperature / eps_k_k, \n", + " #State.critical_point(thol).temperature / eps_k_k, \n", " State.critical_point(uvtheory_wca).temperature / eps_k_k, \n", - " State.critical_point(uvtheory_bh).temperature / eps_k_k\n", + " State.critical_point(uvtheory_bh).temperature / eps_k_k,\n", + " State.critical_point(uvtheory_b3).temperature / eps_k_k\n", ")" ] }, @@ -263,15 +286,15 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 51.7 ms, sys: 0 ns, total: 51.7 ms\n", - "Wall time: 50.6 ms\n" + "CPU times: user 52.1 ms, sys: 0 ns, total: 52.1 ms\n", + "Wall time: 50.9 ms\n" ] } ], @@ -282,15 +305,15 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 41.8 ms, sys: 3.92 ms, total: 45.7 ms\n", - "Wall time: 45.1 ms\n" + "CPU times: user 36 ms, sys: 0 ns, total: 36 ms\n", + "Wall time: 33.9 ms\n" ] } ], @@ -301,15 +324,44 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.64 s, sys: 3.88 ms, total: 1.65 s\n", - "Wall time: 1.64 s\n" + "CPU times: user 51.9 ms, sys: 0 ns, total: 51.9 ms\n", + "Wall time: 50.8 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "vle_uv_b3 = PhaseDiagram.pure(uvtheory_b3, 150*KELVIN, 500)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "thread '' panicked at 'called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }', feos-core/src/python/user_defined.rs:210:1\n" + ] + }, + { + "ename": "PanicException", + "evalue": "called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mPanicException\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m:1\u001b[0m\n", + "\u001b[0;31mPanicException\u001b[0m: called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }" ] } ], @@ -320,15 +372,15 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 13.4 ms, sys: 2.94 ms, total: 16.4 ms\n", - "Wall time: 16 ms\n" + "CPU times: user 20.3 ms, sys: 0 ns, total: 20.3 ms\n", + "Wall time: 20.1 ms\n" ] } ], @@ -346,14 +398,106 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 71, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
trhovrholp
00.7000.0020120.8432370.001381
50.7050.0021450.8411860.001481
100.7100.0022840.8391060.001586
150.7150.0024310.8369990.001698
200.7200.0025840.8348680.001815
\n", + "
" + ], "text/plain": [ - "
" + " t rhov rhol p\n", + "0 0.700 0.002012 0.843237 0.001381\n", + "5 0.705 0.002145 0.841186 0.001481\n", + "10 0.710 0.002284 0.839106 0.001586\n", + "15 0.715 0.002431 0.836999 0.001698\n", + "20 0.720 0.002584 0.834868 0.001815" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nist_data = pd.read_csv(\"data/lennard_jones_nist.csv\", delim_whitespace=True)\n", + "nist_data = nist_data[::5]\n", + "nist_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] }, "metadata": {}, @@ -362,20 +506,20 @@ ], "source": [ "s3 = NAV * sigma_a**3\n", - "colors = sns.color_palette(\"Dark2\", n_colors = 4)\n", + "colors = sns.color_palette(\"Dark2\", n_colors = 6)\n", "plt.figure(figsize=(12, 6))\n", "\n", + "plt.plot(nist_data.rhov, nist_data.t, linestyle=\"\", color=\"k\", marker=\".\", label='MC', alpha=0.5)\n", + "plt.plot(nist_data.rhol, nist_data.t, linestyle=\"\", color=\"k\", marker=\".\", alpha=0.5)\n", + "\n", "plt.plot(vle_uv.vapor.density * s3 , vle_uv.vapor.temperature / eps_k_k, color=colors[0], label='uv (WCA)')\n", "plt.plot(vle_uv.liquid.density * s3, vle_uv.vapor.temperature / eps_k_k, color=colors[0])\n", "\n", "plt.plot(vle_uv_bh.vapor.density * s3 , vle_uv_bh.vapor.temperature / eps_k_k, color=colors[1], label='uv (BH)')\n", - "plt.plot(vle_uv_bh.liquid.density * s3, vle_uv_bh.vapor.temperature / eps_k_k, color=colors[1], )\n", - "\n", - "plt.plot(vle_thol.vapor.density * s3, vle_thol.vapor.temperature / eps_k_k, color=colors[2], label='Thol')\n", - "plt.plot(vle_thol.liquid.density * s3, vle_thol.vapor.temperature / eps_k_k, color=colors[2])\n", + "plt.plot(vle_uv_bh.liquid.density * s3, vle_uv_bh.vapor.temperature / eps_k_k, color=colors[1])\n", "\n", - "plt.plot(vle_pets.vapor.density * s3, vle_pets.vapor.temperature / eps_k_k, color=colors[3], label='PeTS')\n", - "plt.plot(vle_pets.liquid.density * s3, vle_pets.vapor.temperature / eps_k_k, color=colors[3])\n", + "plt.plot(vle_uv_b3.vapor.density * s3 , vle_uv_b3.vapor.temperature / eps_k_k, color=colors[2], label='uv (B3)')\n", + "plt.plot(vle_uv_b3.liquid.density * s3, vle_uv_b3.vapor.temperature / eps_k_k, color=colors[2])\n", "\n", "plt.ylabel(r\"$T*$\")\n", "plt.xlabel(r\"$\\rho*$\")\n", @@ -384,13 +528,20 @@ "plt.legend(frameon=False)\n", "sns.despine(offset=10);" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "venv_feos05", "language": "python", - "name": "python3" + "name": "venv_feos05" }, "language_info": { "codemirror_mode": { @@ -402,7 +553,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.8.5" } }, "nbformat": 4, diff --git a/feos-core/src/errors.rs b/feos-core/src/errors.rs index ed5840127..37936a4e6 100644 --- a/feos-core/src/errors.rs +++ b/feos-core/src/errors.rs @@ -6,7 +6,7 @@ use thiserror::Error; /// Error type for improperly defined states and convergence problems. #[derive(Error, Debug)] pub enum EosError { - #[error("Error: {0}")] + #[error("{0}")] Error(String), #[error("`{0}` did not converge within the maximum number of iterations.")] NotConverged(String), From 590ec88f54f106956cf52559927addd165530cc1 Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Thu, 12 Jan 2023 08:10:28 +0100 Subject: [PATCH 11/14] changed pub to pub(super), removed lazy statics from BH implementation, use new_simple parameters in tests --- .../eos/attractive_perturbation_uvb3.rs | 17 ++-- .../eos/attractive_perturbation_wca.rs | 9 +- src/uvtheory/eos/hard_sphere_bh.rs | 91 ++++++++----------- src/uvtheory/eos/hard_sphere_wca.rs | 32 ++++--- 4 files changed, 64 insertions(+), 85 deletions(-) diff --git a/src/uvtheory/eos/attractive_perturbation_uvb3.rs b/src/uvtheory/eos/attractive_perturbation_uvb3.rs index 026ad5f47..c703dee6a 100644 --- a/src/uvtheory/eos/attractive_perturbation_uvb3.rs +++ b/src/uvtheory/eos/attractive_perturbation_uvb3.rs @@ -151,14 +151,12 @@ fn residual_virial_coefficient>(p: &UVParameters, x: &Array1, let xi = x[i]; for j in 0..p.ncomponents { - let t_ij = t / p.eps_k_ij[[i, j]]; let rep_ij = p.rep_ij[[i, j]]; let att_ij = p.att_ij[[i, j]]; let q_ij = dimensionless_diameter_q_wca(t_ij, D::from(rep_ij), D::from(att_ij)); - delta_b2bar += xi * x[j] * p.sigma_ij[[i, j]].powi(3) * delta_b2(t_ij, rep_ij, att_ij, q_ij); } @@ -182,10 +180,10 @@ fn residual_third_virial_coefficient>( let att_ij = p.att_ij[[i, j]]; let q_ij = dimensionless_diameter_q_wca(t_ij, D::from(rep_ij), D::from(att_ij)); - // No mixing rule defined for B3 yet! The implemented rule is just taken from B2 and not correct! - let rm_ij = (rep_ij / att_ij).powd((rep_ij - att_ij).recip()); - let d_ij = (d[i] / p.sigma[i] + d[j] / p.sigma[j]) * 0.5; - // Recheck mixing rule! + // No mixing rule defined for B3 yet! The implemented rule is just taken from B2 and not correct! + let rm_ij = (rep_ij / att_ij).powd((rep_ij - att_ij).recip()); + let d_ij = (d[i] / p.sigma[i] + d[j] / p.sigma[j]) * 0.5; + // Recheck mixing rule! delta_b3bar += xi * x[j] * p.sigma_ij[[i, j]].powi(6) @@ -224,7 +222,7 @@ fn u_fraction_wca>(rep_x: D, reduced_density: D, t_x: D) -> D { + 1.0 } -// Coefficients for IWCA +// Coefficients for IWCA fn coefficients_wca>(rep: D, att: D, d: D) -> [D; 6] { let rep_inv = rep.recip(); let rs_x = (rep / att).powd((rep - att).recip()); @@ -259,14 +257,14 @@ fn coefficients_wca>(rep: D, att: D, d: D) -> [D; 6] { // Residual second virial coefficient from Revised series approximation RSAP -pub fn factorial(num: u64) -> u64 { +fn factorial(num: u64) -> u64 { (1..=num).product() } fn delta_b2>(reduced_temperature: D, rep: f64, att: f64, q: D) -> D { let rm = (rep / att).powd((rep - att).recip()); let beta = reduced_temperature.recip(); - let b20 = q.powi(3) * 2.0 / 3.0 * PI; + let b20 = q.powi(3) * 2.0 / 3.0 * PI; let y = beta.exp() - 1.0; let c1 = rep.recip() * C_B2_RSAP[0][1] @@ -429,7 +427,6 @@ mod test { let db3 = delta_b3(t_x, rm_x, rep_x, att_x, d_x, q_vdw); assert_relative_eq!(db3.re(), -0.6591980196661884, epsilon = 1e-10); - // Full attractive perturbation: let a = pt.helmholtz_energy(&state) / moles[0]; diff --git a/src/uvtheory/eos/attractive_perturbation_wca.rs b/src/uvtheory/eos/attractive_perturbation_wca.rs index 5e71fb547..9904e61a4 100644 --- a/src/uvtheory/eos/attractive_perturbation_wca.rs +++ b/src/uvtheory/eos/attractive_perturbation_wca.rs @@ -169,7 +169,7 @@ fn u_fraction_wca>(rep_x: D, reduced_density: D) -> D { .tanh() } -pub fn one_fluid_properties>( +pub(super) fn one_fluid_properties>( p: &UVParameters, x: &Array1, t: D, @@ -315,7 +315,6 @@ mod test { let q_vdw = dimensionless_diameter_q_wca(t_x, rep_x, att_x); let b21u = delta_b12u(t_x, mean_field_constant_x, weighted_sigma3_ij, q_vdw, rm_x) / p.sigma[0].powi(3); - //assert!(b21u.re() == -1.02233216); assert_relative_eq!(b21u.re(), -1.02233215790525, epsilon = 1e-12); let i_wca = @@ -323,8 +322,6 @@ mod test { let delta_a1u = state.partial_density.sum() / t_x * i_wca * 2.0 * PI * weighted_sigma3_ij; - //dbg!(delta_a1u); - //assert!(delta_a1u.re() == -1.1470186919354); assert_relative_eq!(delta_a1u.re(), -1.52406840346272, epsilon = 1e-6); let u_fraction_wca = u_fraction_wca( @@ -336,10 +333,8 @@ mod test { dbg!(b2bar); assert_relative_eq!(b2bar.re(), -1.09102560732964, epsilon = 1e-12); dbg!(u_fraction_wca); - //assert!(u_fraction_WCA.re() == 0.743451055308332); - assert_relative_eq!(u_fraction_wca.re(), 0.997069754340431, epsilon = 1e-5); - //assert!(b2bar.re() == -1.00533412744652); + assert_relative_eq!(u_fraction_wca.re(), 0.997069754340431, epsilon = 1e-5); let a_test = delta_a1u + (-u_fraction_wca + 1.0) diff --git a/src/uvtheory/eos/hard_sphere_bh.rs b/src/uvtheory/eos/hard_sphere_bh.rs index ca8dc9af8..a3001cb4b 100644 --- a/src/uvtheory/eos/hard_sphere_bh.rs +++ b/src/uvtheory/eos/hard_sphere_bh.rs @@ -1,24 +1,22 @@ use crate::uvtheory::parameters::UVParameters; use feos_core::{HelmholtzEnergyDual, StateHD}; -use lazy_static::lazy_static; use ndarray::prelude::*; use num_dual::DualNum; use std::fmt; use std::sync::Arc; -lazy_static! { - static ref BH_CONSTANTS_ETA_B: Array2 = arr2(&[ - [-0.960919783, -0.921097447], - [-0.547468020, -3.508014069], - [-2.253750186, 3.581161364], - ]); - static ref BH_CONSTANTS_ETA_A: Array2 = arr2(&[ - [-1.217417282, 6.754987582, -0.5919326153, -28.99719604], - [1.579548775, -26.93879416, 0.3998915410, 106.9446266], - [-1.993990512, 44.11863355, -40.10916106, -29.6130848], - [0.0, 0.0, 0.0, 0.0], - ]); -} +const BH_CONSTANTS_ETA_B: [[f64; 2]; 3] = [ + [-0.960919783, -0.921097447], + [-0.547468020, -3.508014069], + [-2.253750186, 3.581161364], +]; + +const BH_CONSTANTS_ETA_A: [[f64; 4]; 4] = [ + [-1.217417282, 6.754987582, -0.5919326153, -28.99719604], + [1.579548775, -26.93879416, 0.3998915410, 106.9446266], + [-1.993990512, 44.11863355, -40.10916106, -29.6130848], + [0.0, 0.0, 0.0, 0.0], +]; #[derive(Debug, Clone)] pub struct HardSphereBH { @@ -48,7 +46,7 @@ impl fmt::Display for HardSphereBH { /// Dimensionless Hard-sphere diameter according to Barker-Henderson division. /// Eq. S23 and S24. /// -pub fn diameter_bh>(parameters: &UVParameters, temperature: D) -> Array1 { +pub(super) fn diameter_bh>(parameters: &UVParameters, temperature: D) -> Array1 { parameters .cd_bh_pure .iter() @@ -63,7 +61,7 @@ pub fn diameter_bh>(parameters: &UVParameters, temperature: D) - .collect() } -pub fn zeta>(partial_density: &Array1, diameter: &Array1) -> [D; 4] { +pub(super) fn zeta>(partial_density: &Array1, diameter: &Array1) -> [D; 4] { let mut zeta: [D; 4] = [D::zero(), D::zero(), D::zero(), D::zero()]; for i in 0..partial_density.len() { for k in 0..4 { @@ -74,13 +72,16 @@ pub fn zeta>(partial_density: &Array1, diameter: &Array1) zeta } -pub fn packing_fraction>(partial_density: &Array1, diameter: &Array1) -> D { +pub(super) fn packing_fraction>( + partial_density: &Array1, + diameter: &Array1, +) -> D { (0..partial_density.len()).fold(D::zero(), |acc, i| { acc + partial_density[i] * diameter[i].powi(3) * (std::f64::consts::PI / 6.0) }) } -pub fn zeta_23>(molefracs: &Array1, diameter: &Array1) -> D { +pub(super) fn zeta_23>(molefracs: &Array1, diameter: &Array1) -> D { let mut zeta: [D; 2] = [D::zero(), D::zero()]; for i in 0..molefracs.len() { for k in 0..2 { @@ -90,7 +91,7 @@ pub fn zeta_23>(molefracs: &Array1, diameter: &Array1) -> zeta[0] / zeta[1] } -pub fn packing_fraction_b>( +pub(super) fn packing_fraction_b>( parameters: &UVParameters, diameter: &Array1, eta: D, @@ -100,16 +101,17 @@ pub fn packing_fraction_b>( let tau = -(diameter[i] / parameters.sigma[i] + diameter[j] / parameters.sigma[j]) * 0.5 + 1.0; //dimensionless let tau2 = tau * tau; + let c = arr1(&[ - tau * BH_CONSTANTS_ETA_B[[0, 0]] + tau2 * BH_CONSTANTS_ETA_B[[0, 1]], - tau * BH_CONSTANTS_ETA_B[[1, 0]] + tau2 * BH_CONSTANTS_ETA_B[[1, 1]], - tau * BH_CONSTANTS_ETA_B[[2, 0]] + tau2 * BH_CONSTANTS_ETA_B[[2, 1]], + tau * BH_CONSTANTS_ETA_B[0][0] + tau2 * BH_CONSTANTS_ETA_B[0][1], + tau * BH_CONSTANTS_ETA_B[1][0] + tau2 * BH_CONSTANTS_ETA_B[1][1], + tau * BH_CONSTANTS_ETA_B[2][0] + tau2 * BH_CONSTANTS_ETA_B[2][1], ]); eta + eta * c[0] + eta * eta * c[1] + eta.powi(3) * c[2] }) } -pub fn packing_fraction_a>( +pub(super) fn packing_fraction_a>( parameters: &UVParameters, diameter: &Array1, eta: D, @@ -117,19 +119,21 @@ pub fn packing_fraction_a>( let n = parameters.att.len(); Array2::from_shape_fn((n, n), |(i, j)| { let tau = - -(diameter[i] / parameters.sigma[i] + diameter[j] / parameters.sigma[j]) * 0.5 + 1.0; //dimensionless//-(diameter[i] + diameter[j]) * 0.5 + 1.0; + -(diameter[i] / parameters.sigma[i] + diameter[j] / parameters.sigma[j]) * 0.5 + 1.0; let tau2 = tau * tau; let rep_inv = 1.0 / parameters.rep_ij[[i, j]]; + let c = arr1(&[ - tau * (BH_CONSTANTS_ETA_A[[0, 0]] + BH_CONSTANTS_ETA_A[[0, 1]] * rep_inv) - + tau2 * (BH_CONSTANTS_ETA_A[[0, 2]] + BH_CONSTANTS_ETA_A[[0, 3]] * rep_inv), - tau * (BH_CONSTANTS_ETA_A[[1, 0]] + BH_CONSTANTS_ETA_A[[1, 1]] * rep_inv) - + tau2 * (BH_CONSTANTS_ETA_A[[1, 2]] + BH_CONSTANTS_ETA_A[[1, 3]] * rep_inv), - tau * (BH_CONSTANTS_ETA_A[[2, 0]] + BH_CONSTANTS_ETA_A[[2, 1]] * rep_inv) - + tau2 * (BH_CONSTANTS_ETA_A[[2, 2]] + BH_CONSTANTS_ETA_A[[2, 3]] * rep_inv), - tau * (BH_CONSTANTS_ETA_A[[3, 0]] + BH_CONSTANTS_ETA_A[[3, 1]] * rep_inv) - + tau2 * (BH_CONSTANTS_ETA_A[[3, 2]] + BH_CONSTANTS_ETA_A[[3, 3]] * rep_inv), + tau * (BH_CONSTANTS_ETA_A[0][0] + BH_CONSTANTS_ETA_A[0][1] * rep_inv) + + tau2 * (BH_CONSTANTS_ETA_A[0][2] + BH_CONSTANTS_ETA_A[0][3] * rep_inv), + tau * (BH_CONSTANTS_ETA_A[1][0] + BH_CONSTANTS_ETA_A[1][1] * rep_inv) + + tau2 * (BH_CONSTANTS_ETA_A[1][2] + BH_CONSTANTS_ETA_A[1][3] * rep_inv), + tau * (BH_CONSTANTS_ETA_A[2][0] + BH_CONSTANTS_ETA_A[2][1] * rep_inv) + + tau2 * (BH_CONSTANTS_ETA_A[2][2] + BH_CONSTANTS_ETA_A[2][3] * rep_inv), + tau * (BH_CONSTANTS_ETA_A[3][0] + BH_CONSTANTS_ETA_A[3][1] * rep_inv) + + tau2 * (BH_CONSTANTS_ETA_A[3][2] + BH_CONSTANTS_ETA_A[3][3] * rep_inv), ]); + eta + eta * c[0] + eta * eta * c[1] + eta.powi(3) * c[2] + eta.powi(4) * c[3] }) } @@ -158,27 +162,4 @@ mod test { 0.95583586434435486 ); } - - // #[test] - // fn helmholtz_energy() { - // let p = methane_parameters(12); - // let p = test_parameters(12, 1.0, 1.0); - // let reduced_density = 1.0; - // let reduced_temperature = 4.0; - - // let hs = HardSphere { - // parameters: Arc::new(p.clone()), - // }; - // let particles = arr1(&[1000.0]); - // let n = &particles / 6.02214076e23; - // let volume = particles[0] / reduced_density * p.sigma[0].powi(3); - // let temperature = reduced_temperature * p.epsilon_k[0]; - // let s = StateHD::new(temperature, volume, n.clone()); - // dbg!(particles[0] / volume * p.sigma[0].powi(3)); - // dbg!(&s.temperature); - // dbg!(&s.volume); - // dbg!(&s.moles); - // let a = hs.helmholtz_energy(&s); - // assert_relative_eq!(a / particles[0], 1.9859860794723039, epsilon = 1e-10) - // } } diff --git a/src/uvtheory/eos/hard_sphere_wca.rs b/src/uvtheory/eos/hard_sphere_wca.rs index a2a9c6064..8a8e57270 100644 --- a/src/uvtheory/eos/hard_sphere_wca.rs +++ b/src/uvtheory/eos/hard_sphere_wca.rs @@ -6,7 +6,7 @@ use std::f64::consts::PI; use std::fmt; use std::sync::Arc; -pub const WCA_CONSTANTS_Q: [[f64; 4]; 3] = [ +pub(super) const WCA_CONSTANTS_Q: [[f64; 4]; 3] = [ [1.92840364363978, 4.43165896265079E-01, 0.0, 0.0], [ 5.20120816141761E-01, @@ -36,14 +36,14 @@ const WCA_CONSTANTS_ETA_B: [[f64; 2]; 3] = [ ]; // New Fit to numerical integrals for uv-B3-theory -pub const WCA_CONSTANTS_ETA_A_UVB3: [[f64; 4]; 4] = [ +pub(super) const WCA_CONSTANTS_ETA_A_UVB3: [[f64; 4]; 4] = [ [2.64043218, -1.2184421, -22.90786387, 0.96433414], [-16.75643936, 30.83929771, 73.08711814, -166.57701616], [19.53170162, -88.87955657, -76.51387192, 443.68942745], [-3.77740877, 83.04694547, 21.62502721, -304.8643176], ]; -pub const WCA_CONSTANTS_ETA_B_UVB3: [[f64; 2]; 3] = [ +pub(super) const WCA_CONSTANTS_ETA_B_UVB3: [[f64; 2]; 3] = [ [2.19821588, -20.45005484], [-13.47050687, 56.65701375], [12.90119266, -42.71680606], @@ -74,7 +74,10 @@ impl fmt::Display for HardSphereWCA { } /// Dimensionless Hard-sphere diameter according to Weeks-Chandler-Andersen division. -pub fn diameter_wca>(parameters: &UVParameters, temperature: D) -> Array1 { +pub(super) fn diameter_wca>( + parameters: &UVParameters, + temperature: D, +) -> Array1 { parameters .sigma .iter() @@ -93,7 +96,7 @@ pub fn diameter_wca>(parameters: &UVParameters, temperature: D) .collect() } -pub fn dimensionless_diameter_q_wca>(t_x: D, rep_x: D, att_x: D) -> D { +pub(super) fn dimensionless_diameter_q_wca>(t_x: D, rep_x: D, att_x: D) -> D { let nu = rep_x; let n = att_x; let rs = (nu / n).powd((nu - n).recip()); @@ -119,7 +122,7 @@ pub fn dimensionless_diameter_q_wca>(t_x: D, rep_x: D, att_x: D) * rs } -pub fn zeta>(partial_density: &Array1, diameter: &Array1) -> [D; 4] { +pub(super) fn zeta>(partial_density: &Array1, diameter: &Array1) -> [D; 4] { let mut zeta: [D; 4] = [D::zero(), D::zero(), D::zero(), D::zero()]; for i in 0..partial_density.len() { for k in 0..4 { @@ -130,13 +133,16 @@ pub fn zeta>(partial_density: &Array1, diameter: &Array1) zeta } -pub fn packing_fraction>(partial_density: &Array1, diameter: &Array1) -> D { +pub(super) fn packing_fraction>( + partial_density: &Array1, + diameter: &Array1, +) -> D { (0..partial_density.len()).fold(D::zero(), |acc, i| { acc + partial_density[i] * diameter[i].powi(3) * (std::f64::consts::PI / 6.0) }) } -pub fn zeta_23>(molefracs: &Array1, diameter: &Array1) -> D { +pub(super) fn zeta_23>(molefracs: &Array1, diameter: &Array1) -> D { let mut zeta: [D; 2] = [D::zero(), D::zero()]; for i in 0..molefracs.len() { for k in 0..2 { @@ -147,7 +153,7 @@ pub fn zeta_23>(molefracs: &Array1, diameter: &Array1) -> } #[inline] -pub fn dimensionless_length_scale>( +pub(super) fn dimensionless_length_scale>( parameters: &UVParameters, temperature: D, ) -> Array1 { @@ -166,7 +172,7 @@ pub fn dimensionless_length_scale>( #[inline] -pub fn packing_fraction_b>( +pub(super) fn packing_fraction_b>( parameters: &UVParameters, eta: D, temperature: D, @@ -188,7 +194,7 @@ pub fn packing_fraction_b>( }) } -pub fn packing_fraction_b_uvb3>( +pub(super) fn packing_fraction_b_uvb3>( parameters: &UVParameters, eta: D, temperature: D, @@ -210,7 +216,7 @@ pub fn packing_fraction_b_uvb3>( }) } -pub fn packing_fraction_a>( +pub(super) fn packing_fraction_a>( parameters: &UVParameters, eta: D, temperature: D, @@ -239,7 +245,7 @@ pub fn packing_fraction_a>( }) } -pub fn packing_fraction_a_uvb3>( +pub(super) fn packing_fraction_a_uvb3>( parameters: &UVParameters, eta: D, temperature: D, From 819618a87baa0e3a0dac291f85f7b9491c186ca0 Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Thu, 12 Jan 2023 12:02:15 +0100 Subject: [PATCH 12/14] Combine example notebooks, clean up tests in mod --- examples/lj_models.ipynb | 426 ++++++++++++++++++----- examples/uvtheory.ipynb | 390 --------------------- examples/uvtheory_versions.ipynb | 572 ------------------------------- 3 files changed, 338 insertions(+), 1050 deletions(-) delete mode 100644 examples/uvtheory.ipynb delete mode 100644 examples/uvtheory_versions.ipynb diff --git a/examples/lj_models.ipynb b/examples/lj_models.ipynb index 119497b67..59a9eb7e7 100644 --- a/examples/lj_models.ipynb +++ b/examples/lj_models.ipynb @@ -6,20 +6,20 @@ "source": [ "# Comparison of equations of state for model fluids\n", "\n", - "In this notebook, we take a look at three model fluid equations of state and compare them.\n", + "In this notebook, we take a look at various model fluid equations of state and compare them.\n", "These EoS are:\n", "\n", "- The PeTS equation of state (from `feos.pets`),\n", "- the uv-theory equation of state (from `feos.uvtheory`), \n", "- the uv-B3-theory equation of state (from `feos.uvtheory` using `VirialOrder.Third`), and\n", - "- the Thol equation of state (implemented in as Python class).\n", + "- the Thol equation of state (implemented in this notebook as Python class).\n", "\n", "The PeTS equation of state is for a Lennard-Jones fluid with cut off distance of $r_c = 2.5 \\sigma$ and a potential shift while the uv-theory and Thol equation of state model the full Lennard-Jones potential. Note that the uv-theory was developed to model Mie potentials and not primarily adjusted to the Lennard-Jones fluid. Thus, we don't expect similar results when comparing uv-theory and Thol to PeTS." ] }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -125,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -142,8 +142,7 @@ "parameters = PetsParameters.from_values(sigma, eps_k)\n", "pets = EquationOfState.pets(parameters)\n", "\n", - "thol = EquationOfState.python(Thol())\n", - "s3 = State(thol, temperature=300*KELVIN, pressure=1*BAR)" + "thol = EquationOfState.python(Thol())" ] }, { @@ -155,7 +154,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -167,7 +166,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -176,7 +175,7 @@ "-0.0016213224956115704" ] }, - "execution_count": 17, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -187,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -196,7 +195,7 @@ "-0.0016138652202999679" ] }, - "execution_count": 18, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -207,7 +206,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -216,7 +215,7 @@ "-0.0016144150962601586" ] }, - "execution_count": 19, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -227,7 +226,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -236,7 +235,7 @@ "-0.000940704010881386" ] }, - "execution_count": 20, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -249,52 +248,100 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Compare critical temperatures" + "## Compare critical points\n", + "- Reference data for the Lennard-Jones from Potoff and Panagiotopoulos (MC): $T_c^*=1.3120$, $\\rho_c^*=0.316$, $p_c^*=0.1279$" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 84, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "(1.3097658041494296, 1.3208296613277397, 1.3132940626554175)" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "uvtheory_b3:\n", + "Tc*=1.31329, Error: 0.099%\n", + "pc*=0.1286, Error: 0.548%\n", + "rhoc*=0.31425, Error: 0.553%\n", + "\n", + "uvtheory_wca:\n", + "Tc*=1.30977, Error: 0.17%\n", + "pc*=0.12448, Error: 2.674%\n", + "rhoc*=0.30233, Error: 4.327%\n", + "\n", + "uvtheory_bh:\n", + "Tc*=1.32083, Error: 0.673%\n", + "pc*=0.13486, Error: 5.442%\n", + "rhoc*=0.31865, Error: 0.838%\n", + "\n", + "thol:\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "thread '' panicked at 'called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }', feos-core/src/python/user_defined.rs:210:1\n" + ] + }, + { + "ename": "PanicException", + "evalue": "called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mPanicException\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[84], line 21\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m---> 21\u001b[0m \u001b[43mevaluate_critical_points\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[84], line 11\u001b[0m, in \u001b[0;36mevaluate_critical_points\u001b[0;34m()\u001b[0m\n\u001b[1;32m 9\u001b[0m eps_k \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m150.03\u001b[39m \u001b[38;5;66;03m# eps / kB in K\u001b[39;00m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m:\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mformat(names[i]))\n\u001b[0;32m---> 11\u001b[0m Tc \u001b[38;5;241m=\u001b[39m \u001b[43mState\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcritical_point\u001b[49m\u001b[43m(\u001b[49m\u001b[43meos\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mtemperature \u001b[38;5;241m/\u001b[39m eps_k_k\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mTc*=\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m, Error: \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mformat(np\u001b[38;5;241m.\u001b[39mround(Tc, \u001b[38;5;241m5\u001b[39m), np\u001b[38;5;241m.\u001b[39mround(np\u001b[38;5;241m.\u001b[39mabs(Tc \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1.3120\u001b[39m ) \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m1.3120\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m100\u001b[39m ,\u001b[38;5;241m3\u001b[39m)))\n\u001b[1;32m 13\u001b[0m pc \u001b[38;5;241m=\u001b[39m State\u001b[38;5;241m.\u001b[39mcritical_point(eos)\u001b[38;5;241m.\u001b[39mpressure() \u001b[38;5;241m*\u001b[39m (sigma \u001b[38;5;241m*\u001b[39m ANGSTROM)\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m3\u001b[39m \u001b[38;5;241m/\u001b[39m KB \u001b[38;5;241m/\u001b[39m eps_k_k\n", + "\u001b[0;31mPanicException\u001b[0m: called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }" + ] } ], "source": [ - "(\n", - " #State.critical_point(thol).temperature / eps_k_k, \n", - " State.critical_point(uvtheory_wca).temperature / eps_k_k, \n", - " State.critical_point(uvtheory_bh).temperature / eps_k_k,\n", - " State.critical_point(uvtheory_b3).temperature / eps_k_k\n", - ")" + "def evaluate_critical_points():\n", + " names = ['uvtheory_b3', 'uvtheory_wca', 'uvtheory_bh', 'thol']\n", + " print('')\n", + " i = 0\n", + " for eos in [uvtheory_b3, uvtheory_wca, uvtheory_bh, thol]:\n", + " rep = 12\n", + " att = 6.0\n", + " sigma = 3.7039 # in Angstrom\n", + " eps_k = 150.03 # eps / kB in K\n", + " print('{}:'.format(names[i]))\n", + " Tc = State.critical_point(eos).temperature / eps_k_k\n", + " print('Tc*={}, Error: {}%'.format(np.round(Tc, 5), np.round(np.abs(Tc - 1.3120 ) / 1.3120 * 100 ,3)))\n", + " pc = State.critical_point(eos).pressure() * (sigma * ANGSTROM)**3 / KB / eps_k_k\n", + " print('pc*={}, Error: {}%'.format(np.round(pc, 5), np.round(np.abs(pc - 0.1279 ) / 0.1279 * 100 ,3)))\n", + " rhoc = State.critical_point(eos).density * (sigma * ANGSTROM)**3 * NAV\n", + " print('rhoc*={}, Error: {}%'.format(np.round(rhoc, 5), np.round(np.abs(rhoc - 0.316) / 0.316 * 100 ,3)))\n", + " i += 1\n", + " print('')\n", + " return\n", + "\n", + "evaluate_critical_points()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Phase diagrams" + "## Compare Phase diagrams" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 74, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 52.1 ms, sys: 0 ns, total: 52.1 ms\n", - "Wall time: 50.9 ms\n" + "CPU times: user 40.1 ms, sys: 0 ns, total: 40.1 ms\n", + "Wall time: 38.6 ms\n" ] } ], @@ -305,15 +352,15 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 75, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 36 ms, sys: 0 ns, total: 36 ms\n", - "Wall time: 33.9 ms\n" + "CPU times: user 39.8 ms, sys: 0 ns, total: 39.8 ms\n", + "Wall time: 38.2 ms\n" ] } ], @@ -324,15 +371,15 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 76, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 51.9 ms, sys: 0 ns, total: 51.9 ms\n", - "Wall time: 50.8 ms\n" + "CPU times: user 49.9 ms, sys: 0 ns, total: 49.9 ms\n", + "Wall time: 47.6 ms\n" ] } ], @@ -343,25 +390,25 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 77, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "thread '' panicked at 'called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }', feos-core/src/python/user_defined.rs:210:1\n" + "thread '' panicked at 'called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }', feos-core/src/python/user_defined.rs:210:1\n" ] }, { "ename": "PanicException", - "evalue": "called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }", + "evalue": "called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mPanicException\u001b[0m Traceback (most recent call last)", "File \u001b[0;32m:1\u001b[0m\n", - "\u001b[0;31mPanicException\u001b[0m: called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }" + "\u001b[0;31mPanicException\u001b[0m: called `Result::unwrap()` on an `Err` value: PyErr { type: , value: AttributeError(\"'builtins.StateHDDV2' object has no attribute 'temperature'\"), traceback: Some() }" ] } ], @@ -372,15 +419,15 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 78, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 20.3 ms, sys: 0 ns, total: 20.3 ms\n", - "Wall time: 20.1 ms\n" + "CPU times: user 26.5 ms, sys: 0 ns, total: 26.5 ms\n", + "Wall time: 24.4 ms\n" ] } ], @@ -389,16 +436,9 @@ "vle_pets = PhaseDiagram.pure(pets, 150*KELVIN, 500)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Compare phase diagrams" - ] - }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -431,71 +471,79 @@ " \n", " \n", " 0\n", - " 0.700\n", + " 0.70\n", " 0.002012\n", " 0.843237\n", " 0.001381\n", " \n", " \n", - " 5\n", - " 0.705\n", - " 0.002145\n", - " 0.841186\n", - " 0.001481\n", - " \n", - " \n", " 10\n", - " 0.710\n", + " 0.71\n", " 0.002284\n", " 0.839106\n", " 0.001586\n", " \n", " \n", - " 15\n", - " 0.715\n", - " 0.002431\n", - " 0.836999\n", - " 0.001698\n", - " \n", - " \n", " 20\n", - " 0.720\n", + " 0.72\n", " 0.002584\n", " 0.834868\n", " 0.001815\n", " \n", + " \n", + " 30\n", + " 0.73\n", + " 0.002912\n", + " 0.830543\n", + " 0.002069\n", + " \n", + " \n", + " 40\n", + " 0.74\n", + " 0.003271\n", + " 0.826147\n", + " 0.002350\n", + " \n", " \n", "\n", "" ], "text/plain": [ - " t rhov rhol p\n", - "0 0.700 0.002012 0.843237 0.001381\n", - "5 0.705 0.002145 0.841186 0.001481\n", - "10 0.710 0.002284 0.839106 0.001586\n", - "15 0.715 0.002431 0.836999 0.001698\n", - "20 0.720 0.002584 0.834868 0.001815" + " t rhov rhol p\n", + "0 0.70 0.002012 0.843237 0.001381\n", + "10 0.71 0.002284 0.839106 0.001586\n", + "20 0.72 0.002584 0.834868 0.001815\n", + "30 0.73 0.002912 0.830543 0.002069\n", + "40 0.74 0.003271 0.826147 0.002350" ] }, - "execution_count": 71, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "# import reference data from the NIST database\n", "nist_data = pd.read_csv(\"data/lennard_jones_nist.csv\", delim_whitespace=True)\n", - "nist_data = nist_data[::5]\n", + "nist_data = nist_data[::10]\n", "nist_data.head()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the Phase-Diagrams" + ] + }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABDgAAAJBCAYAAACj7QW8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD95klEQVR4nOzdd3hUVfrA8e/0lEmvEFqAkEDovYOAKB2xAHZsqz/Luquurm7Tte2qi6hrXRU7oFIkNKWX0DshtBAgvU+SyUym3t8fIRNCCqGGwPt5njzJ3HPOnXOVTGbee877qhRFURBCCCGEEEIIIYRowtSNPQEhhBBCCCGEEEKIiyUBDiGEEEIIIYQQQjR5EuAQQgghhBBCCCFEkycBDiGEEEIIIYQQQjR5EuAQQgghhBBCCCFEkycBDiGEEEIIIYQQQjR5EuAQQgghhBBCCCFEkycBDiGEEEIIIYQQQjR5EuAQQgghhBBCCCFEkycBDiGEEEIIIYQQQjR52saeQEPl5eWxadMmDhw4wP79+0lOTsZms9G3b1+++eabCzrnsmXLSExMJCkpidzcXEwmEzqdjjZt2jBs2DDuu+8+goKCah0bGxtb77lDQ0PZtGnTBc1LCCGEEEIIIYQQ56fJBDiWLFnCG2+8cUnP+fHHH3Po0CH0ej1hYWHExsZSWFjIwYMHOXjwIPPmzeOLL74gLi6uznN07twZvV5f43hgYOAlnasQQgghhBBCCCHq1mQCHEajkYEDB9KlSxe6dOnCwYMH+fDDDy/qnHfddRfR0dF0794dnU7nOX748GGeffZZjhw5wjPPPMOSJUvqPMesWbNo0aLFRc1DCCGEEEIIIYQQF6fJBDhuu+02brvtNs/jnJyciz7nHXfcUevx2NhYXnvtNW6//XaOHTtGSkoK7dq1u+jnE0IIIYQQQgghxOUhSUbr0LZtW8/PVqu1EWcihBBCCCGEEEKIc2kyKziutJ07dwLg4+NDdHR0nf0+/PBDcnNzcblcRERE0L9/f8aOHVtrXg4hhBBCCCGEEEJcHhLgOIPb7fZUa3n77bcBePbZZ/H19a1zzM8//1zt8YIFC3jvvfd4//33iY+PP+dzzpkzh3nz5jVofunp6fj4+NCrVy/eeeedBo0RQgghhBBCCCGuBxLgAGbPnl2jQkvXrl158803GTp0aK1jRo4cyaRJk4iLiyMyMpKysjI2b97MzJkzSUtL44EHHmDhwoU0a9as3ufOy8sjKSmpwXMtLi4mNTW1wf2FEEIIIYQQQojrgQQ4gIiICHr27InL5SIzM5P8/HySk5NZtGgR3bt3x9/fv8aYsyu4GAwGxo0bx4ABA7j11lvJzMzkgw8+4LXXXqv3ucPCwhq00gMgJSWF8vLyhl+YEEIIIYQQQghxnVApiqI09iQuxLfffss///lP+vbtyzfffHNJz33o0CH++c9/smPHDjp27MjPP/+MRqNp8PgffviBf/zjHwQGBrJlyxZUKtUlmdeUKVNISkoiPj6e+fPnX5JzCiGEEEIIIYQQ1wKpolKLuLg4PvnkE4KCgkhOTmbJkiXnNb5Hjx4AmEwmTCbTZZihEEIIIYQQQgghziQBjjoYjUb69u0LcF45MgB0Op3nZ5fLdUnnJYQQQgghhBBCiJokwFEPp9MJnH+Q4ujRo0BFXo7AwMBLPS0hhBBCCCGEEEKcRQIcdTCZTGzbtg2Ajh07Nnic0+nkyy+/BKB///5otZLHVQghhBBCCCGEuNyu+QDH9OnTGTFiBLNnz652fNu2bXz44Yekp6fXGJOUlMSDDz5IaWkpERER3HzzzdXa3377bRYsWIDZbK52PCsri6eeeoo9e/ag1Wp5/PHHL/n1CCGEEEIIIYQQoqYms7wgKyuLyZMnex7b7XYAdu3aRb9+/TzHH3roIR5++GHP45ycHDIyMigtLa12vpKSEmbNmsWsWbMICwsjPDwcjUZDVlYWeXl5QEX52E8++QRfX99qY48fP85nn33GSy+9RMuWLQkICKC0tJTU1FQURcFgMPDqq6/SrVu3S/2fQQghhBBCCCGEELVoMgEOl8tVa0USp9NZ7Xh5eXmDztejRw/+/Oc/s3XrVo4dO8aJEyew2+34+/vTr18/RowYwW233YbRaKwxdvr06YSGhnLgwAFyc3PJyMhAp9MRExPDgAEDuPvuu2nVqtWFXqoQQgghhBBCCCHOk0pRFKWxJyEaZsqUKSQlJREfH8/8+fMbezpCCCGEEEIIIcRV45rPwSGEEEIIIYQQQohrnwQ4hBBCCCGEEEII0eRJgEMIIYQQQgghhBBNngQ4hBBCCCGEEEII0eRJgEMIIYQQQgghhBBNngQ4hBBCCCGEEEII0eRJgEMIIYQQQgghhBBNngQ4hBBCCCGEEEII0eRJgEMIIYQQQgghhBBNngQ4hBBCCCGEEEII0eRJgEMIIYQQQgghhBBNngQ4hBBCCCGEEEII0eRpG3sCQgghhBBCCCGubffccw/btm0DoHv37sydO7fOvmazmcGDB2O1WgF44oknePLJJ2vtu27dOpYtW8auXbvIz8/HbrcTGBhIXFwcw4cPZ8KECQQEBFz6CxJXJQlwCCGEEEIIIYS4Yvbs2UNqairR0dG1ti9btswT3KhLbm4uTz/9NDt37gTAy8uLli1bYjAYyMvLY8OGDWzYsIH33nuPWbNmMWDAgEt+HeLqI1tUhBBCCCGEEEJcEW3btgVg4cKFdfapbKvse7a8vDzuuOMOdu7cSVRUFDNnzmT79u0kJCTw888/s379elasWMH9999PeXk5hw8fvtSXIa5SEuAQQgghhBBCCHFFjBs3Dp1Ox+LFi1EUpUZ7WloaO3fuJD4+npiYmFrP8ac//YmsrCzatGnDjz/+yNixY9Hr9dX6tGnThj//+c/8+OOPtGrV6rJci7j6SIBDCCGEEEIIIZqYvLw8Dh8+TF5eXmNP5bwEBgYybNgwMjIy2Lp1a432hQsXoigKkydPrnX8jh07SExMBOC1114jJCSk3ueLjY1lxIgRFz1v0TRIDg4hhBBCCCGEaCIsFgtz5sxh8+bNmM1mjEYjAwYMYNq0afj4+DT29BrklltuYeXKlSxcuJD+/ft7jiuKwsKFC9HpdIwfP54dO3bUGLt48WIA4uLi6N279xWbs2gaZAWHEEIIIYQQQjQRc+bMISEhAZ1OR3R0NDqdjoSEhHqrklxthg0bRlBQECtWrMBisXiO79ixg/T0dIYOHUpwcHCtY3ft2gVAnz59rshcRdMiAQ4hhBBCCCGEaALy8vLYvHkzkZGRhIeHo9frCQ8PJzIyksTExCazXUWn0zFu3DgsFgu//vqr5/iCBQsA6tyeApCTkwNAy5YtL+scRdMkAQ4hhBBCCCGEaAIKCwsxm80EBgZWOx4YGIjZbKawsLBxJnYBKoMYlRVTrFYry5cvJzAwkOHDh9c5rqysDKDJbMcRV5YEOIQQQgghhBCiCQgODsZoNGIymaodN5lMGI3GOrd1XI26dOlC+/bt2bp1K9nZ2fz222+UlZUxbty4GhVRzuTr6wtQbWuLEJUkwCGEEEIIIYQQTUBYWBgDBgwgOzub3Nxc7HY7ubm5ZGdnM3DgQMLCwhp7iudl8uTJuN1uFi1a5FnJUd/2FICIiAgA0tPTL/PsRFMkAQ4hhBBCCCGEaCKmTZvGhAkTcDgcpKam4nA4mDBhAlOnTm3sqZ23iRMnolar+f7779m8eTPt2rWja9eu9Y7p2bMnANu2bbsSUxRNjJSJFUIIIYQQQogmwsfHhxkzZjB+/HgKCwsJDg5ucis3KkVERDBw4EA2btwInHv1BsD48eOZM2cOhw4dYseOHVIqVlQjKziEEEIIIYQQookJCwsjNja2yQY3Kt1zzz0MGDCAAQMGMHHixHP279OnD/379wfgpZdeoqCgoN7+R44cYfXq1ZdkruLqJys4hBBCiEtEURQUuxXFbsFtt6DYrae/W3CfPu45ZrPidpzua7OgOKwV3+1n/Owox2234CzMwG0pQu0bjDaoOWq9DyqdF2qDDyqdNyq9j+dnz3e9DyqDd/VjBp+KvjpvVGf1V6nlnocQQogrb/jw4fVWTanNW2+9xW233caJEye4/fbbefbZZxk1alS15KRpaWl8//33fPfdd/zxj3+8xLMWVysJcAghhBDn4C434yhMw1WcjbM4G1dxbsX3khycJTm4inNwFufgKs0Fl/OyzcNlysRlyrz0J1Zr0PiFofWPQBMQjjYgEo1/BBr/CLQB4ae/R6INbonaJwCVSnXp5yCEEEI0UHh4OD/++CO///3v2b17N3/4wx/w9vamZcuWGAwG8vLyyM7OBipK6MbGxjbyjMWVIgEOIYQQ1z13uRl7zjEcuSk4C07hKDiJo+BUxc/5J3GXFTb2FC8vtwtXcTau4mxIq7+r2ssPbUgrtCEt0YW0RhfSCm1wS3ThbdGFt0fjFyoBECGEEJddREQEc+bMYe3atSxdupTdu3eTnp6Ow+EgMDCQoUOHcsMNNzBx4kSMRmNjT1dcISpFUZTGnoRomClTppCUlER8fDzz589v7OkIIUSTorjdOPJTsacfwJ6ZjD3nKI6cY9hzjlV8sL8cNLqKrSJ6b893ld7n9M9ep7/7oD59vKpf5bGKLSRo9LiKs9AENgdH+entLlbPtpfK7TBnboWpOFaxxUVxWFFslootMbaKNlyOy3LJam9/dOHt0UW0Qx/eHl1kDPrmHdE3i0Pj7X9ZnlMIIYQQAmQFhxBCiGuMoig4izKwpx/AlpGEPSPp9PeDKHbLhZ9Yo/Vs3dAGRHi2bWgCItD6h6MJiETrH4HaJxC1wbcimKG5ev/MKi5nRZDEYcVdVlS11aYkF1dxTs3tN8XZKE7bOc/rtpZgO7kL28ldNdq0QVHom8ehb94JQ8uuGFp1R9+8E2q91+W4RCGEEEJcZ67ed15CCCHEOShuN46co5Snbqc8dQflJ3ZhTz+A21p83udS6bzQhbVFF9YGbUgrdCGtT39vhTa0NdqASFRqzWW4isah0mhRefuh9vYD/3D0zerfn6woCq7SvNNbeE5V/55/Ekduyjn/uzuLMnAWZWBJWlV1UK1B3ywOQ6tuGFp2w9CqIvCh9Q+/FJcphBBCiOuIBDiEEEI0CYqi4Mw/eUYwYye2EztxW0vO6zy6sLboozqhj4xFF9m+YhtFRAzaoCipJFIPlUqF1j8crX84XtG9a7QrioK7rLAil8npfCb2nKPYsw5jzzqEYiur/cRuF/bTK21KN3/vOawJbIZXdG+82vbDu11fDNF9ZIuLEEIIIeolAQ4hhBBXJcXlxJa2F+uRTViPbMR6dNN55crQBDbH0CIeQ1Rn9JXfm3dE7SWJxi4HlUqFxhiCtzEE73b9qrUpbjfOovSK3CeZh7Cl78eWtg97+oE6t724TFmU7V5M2e7FlU+AvllHvNr1xattX7zb9UffovM1tapGCCGEEBdHAhxCCCGuCm57OeUpm7Ee3oD16Easx7bUfdf/TCoV+mZxeEX3xtCmd8VWh6h4NMbgyz9p0SAqtRrd6e0+vl1u8hxXXE7s2Yexndpb8ZW2F9upfbhKcmqeRFGwZx7EnnmQkg2zAVB7B+DdYRDesUPx7jAYrza9UGn1V+iqhBBCCHG1kQCHEEKIRqG4XdhO7MJycDWW5FVYj2xCcZSfc5wuvJ0nmOHVtjderXpU5JEQTY5Ko8UQFY8hKh4G3Ok57jRlU35iJ+XHt1F+fCvlx7fjtphqjHdbiynbu5SyvUsrzqf3xqvdAHxih+DTaQRebfuh0uqu1OUIIYQQopFJmdgmRMrECiGaOkdhOmX7llK2bznWQ+tq/dBajUaHV3RvvGMGVdypbz8QjV/oFZnr2Rx2F1arA6fTjcPpwmF343S6Kh47Kr47HRXHHA531XFHRf/KtorHbpyOyrFV4x0OJ2VmOw6HGy9vLT4+erRaNTqdGq1Wg1arRqvToNOq0Z4+VtF25nFNtTE63ZnHKs+hRnf6fF7eOvT6q3ubhyeZ7PGtWFO2UX58G7ZTe8DtqnecysuIT+xQfDqNwid+JPqoeFQq1ZWZtBBCCCGuOFnBIYQQ4rJR3C7KU7Z67rLb0vbW21+l98G7w2C8OwzBO3YwXtF9UOu9L8vc7DYnxcXllJSUU2a2U1bmwFJmx2y2UVZmx1LmoKzM7vly2Ov/MH2pWcocWMocV+S5dDo1Pr56fH31+Pjo8TXq8fXVVfzsq8fHWPHdz8+Av78XPr66KxooUKnV6JvFom8Wi/+gewFwl5uxHju9penIRspTttTI56GUm6ut8ND4R+DbZTS+3cbiEz8ajW/gFbsGIYQQQlx+EuAQQghxSbnKiijbv4KyvUso278Ct7mg7s4aLd7t+uPdcQQ+nUbg3a5fnTkU8vLyKCwsJDg4mLCwsHrnUF7uxFRkobDQiqnISrHJSkmxzRPQKCkup7zceTGXeU1xONwUm8opNp17ixCARqPGz9+Av78B/wCviu/+XgQEehMY5EVQkA8BgV5oNOrz+v92PtReRnw734hv5xsBcDts2FK3Yzm8AeuhNVgPb6wR8HCV5FCy6RtKNn0Dag3eMYPx7TYW325j0TfvKKs7hBBCiCZOtqg0IbJFRQhxtXKV5mPetZDS7T9hSV4DrrqDB7qwthV30LvchE/s0HNWNbFYLMyZM4fNmzdjNpsxGo307z+AsWMnU2Z2k59XRn5+GUUFFQGNoiLLZV/5cOYWD62uautHjS0gZ20Tqba15OxtJqfb1Ro1FosdX1/9WdtbztwK46rY5lLrVpea22BqnOf0z5eTSgUarYvychM2eylqjY22bZsxZuwNtGgZjK+v/rIGFNx2K+XHEilLWoXl4CpsJ3ZCPW95tKFt8O02FmO3sXh3HIFaZ7hscxNCCCHE5SEBjiZEAhxCiKuJszgH884FmHfMx3Jobd35EDRavDsMwbdrxYdHXbPYBn+wdbncfPrJNyQm7iU4qAVe+mCcTgMqvFGrL34Rolqtwuinx2g0YDQa8PHV4etbuUXj9PYM36qfvX10aLVqz/xdbjd2t5NylxOby4nN5aDcWfG9zGHjZGkhrf1D8NXqMWh06DUaDBodXhothtNf2kYqc6ooCk6nG6vFgcVyeiuO2Y7F4ji9Radqe46lzEGZ2U5JafklC4x4eWkJDfOt+Ar1rfazj++lr4TiMhdiObiyYsvKvuW4SvPq7Kv29se32ziMvafg2+Vm1AafSz4fIYQQQlx6EuBoQiTAIYRobK7SfEq3/Ujpth+xHllf5x1xjX84vl3HnM51cCMan4B6z+t2KxQUlJGTVUpOtpns7FJyskvJzTHjdl/YnymNRk1QsDf+gQa8/LSovVUo3goOgxObzoHT4MKhc2JXXJQ7HacDFFWBCpvrrMDFGccrvxznSHLZoHmq1J5gh16jPSP4ofMcN2i06NVaDNrK9uptBo0OH62eQIM3QQYfggw+BJ7+btQZLtlKCUVRKC93UlJcsc2npMTm2fJTUmKj2GSlqNBKaant3Cerh6+vnohII5HN/Ils5kez5v5ERBrx8ro0FVEUt5vy1O1VuWFO7qqzr0rvg2/XmyuCHd3GofH2vyRzEEIIIcSlJwGOJkQCHEKIxuC2l1O2ZzElm7+jbN+yOrefaIOiMPaegrH3rXjHDERVx8oEt1shP6+M9DQT6WnFZKQXk5FRjN12/sECnZcK7yAdilHB5u2gVFdOidZCvsZMjruYQpuFcteVSdR5tdKpNTUCH8FevoR7+1V8+fh5fg7z9sPrEpRVPXgwmTde/w9RUe3Ranxwuw0obgMupx63S49afWHbP4KCvIls5kdkc38iI/1oHuVPWLgRtfriAjjOokzK9i3FvHcplgO/otittfZTaQ34dL4Rv/7TMPaYiNrge1HPK4QQQohLS5KMCiGEqEFxu7EeXk/J5u8wb/8Jt7Wk1n7akFb49b4VY59b8WrbD5VaXf08ioLJVM6J1ELSTpouKJih4KZcY6XMqxyTVxkF3hYKva2U6stxas46j+P0VyPyOr26QlEUrC4HXhodapWqYiuL04nClb2v4HC7yLOaybOaG9Q/QO9NuLcfkb7+NPcNpLlvAM19A4k642cfXf1bSMLCQvHyhpLSk4SHh3uO5+bm4nA4+MtfXgbFuyJ/yukcKnm5ZvLzy+r9t1FUZKWoyErywVzPMb1eQ/OoAFq0rPiKahlAWNj5BT20Qc0JGPYQAcMewm2zULZ/OeYd8ynbk4C7vNTTT3HaKNuTQNmeBFQGX4w9J+HXfzq+8TeiugSBISGEEEJcHAlwCCGE8HAUplOyYTbF67/AWXCy1j6awGb495uGX7+pGKJ7V9v+4HK5ycwo4eSJIk6kFnIytYji4oZV5lBQcHg7KTKUkacvpdhQRrGXhRKDFbf64oMC/novggy+BHv5EGzwxVenr3UryJk5MrzObNNW/Vxzm0jFGJ1aU+92EEVRcCruqm0wzoptMHZ33dtj7Gcdr2w7+7jZYaPIZsFks1Bks1Bib9h/97MV260U260cLc6ts0+wwZfW/sG08QuhtX8IbfyCaeMXSmv/YEK9jISFhTFgwAASEhIACAwMxGQykZ2dzYQJE2jdujkArdsE1fjvYy61kZtrJjuzlKysUrKzSsjOLq0z8GG3uziRWsiJ1ELPMb1BQ1RUAC1aBdKmTRCt2gQREODVoOtXG3zw6z0Fv95TcDtsWJJWYt45H/OuX3CXVT2HYiujdPP3lG7+Ho1fKMY+t+M/YDpe7QdKNRYhhBCikcgWlSZEtqgIIS4HxemgbN9Sitf9j7J9y0GpmURSZfDF2OsWlPgJlAZ3Ijg0jLCwMJxON+mnTKQcKyDlWD4nT5pw2M+9OkNBocRgpdDbTKGPmUJvM0VeZpya80tgGeLlS6SPP5E+AUT6+BPh40+Ily/BlV+nAxpBBh/0musrpu90uyi2Wykqrwh4eL7KLRSUl5FnLSXXWkqOpYQ8q5lCW9kleV5frZ7W/iG08AnAkp5LUcop1IVmwhQ9N/QdwNSpU/HxOb+knYqiUFRkJTuzlOzsiqBHVmYpuTml9RVGqSYoyJvW0UGEhOow+rlp1z6SyMiIhs/B6cByeB2lW+Zg3jEft7W41n66iPb4D7oP/8H3ogtu0eDzCyGEEOLiSYCjCZEAhxDiUnLknaB43WcUb5iNqzi7ZgeVGp/4UfgPvBt1x9HMW7CYzZs3YyvX4+/XirCQ9tjtPg0KaJTqreT7lJ5XMEOv1hBlDKKVMYiWfsEEqXT4uzW0D21GXPNWhPv4Y7jOghaXk93lJN9q9gQ9siwlZJaZyCgzkVVWTIbZRLalBFctAbCGCvHyJSYwnA6BEXQIjDj9czihXsYLWvVgtznJzCypyOWSVkx6moncXHODgh6K4sTXz03//nHEdoykZatAtFr1uQdyOi/NvqWUbvmBsj1LUJy1JFVVqfCJv5GAIffj22MSan3DVpAIIYS4sl555RW+++47vv/+e3r16tXY07nsvvjiC/71r3/x5ptvcssttzT2dC45CXA0IRLgEEJcLEVRsBxchWnlfynbk1Drag1dWDT+Qx7Af8h96IKiKC0p53+fzefI4XyMPi1QqerPv+BSuSn0NpPvU0Kebyn5PiWU62pPjKFXa2jjH0K0f6jnq21AKG38Qojw8UOtatgHTnFluNxucqylpJUWcqK0gJMlBZw8/fOJknyKL3BbTJDBhw6B4cQFRRIf0pzOwc2JDYq8oACW3eYkM6OEtDQTp06aOHmiCFNR7UlDz6TTqWndJoi27UNo1y6EVm2C0GjO/e/PVWbCvGsBpZt/wJK8utbKQmrfIPz730nADY9gaNH5vK9JCCHE5ZGSksLEiRPp378/n3/+uef4fffdx5YtW3jggQd4/vnnax376KOPsmbNGlQqFYmJiQQHB9foc/ToUcaPHw/AqlWraNGi5sq+I0eO8NNPP7F161ays7MpKyvD19eXtm3b0r9/f2655RZatWpV73VMnz6dXbsqKoIlJCQQExNTZ1+r1cqoUaPQarWsWLECL69rKwDfZG595eXlsWnTJg4cOMD+/ftJTk7GZrPRt29fvvnmmws657Jly0hMTCQpKYnc3FxMJhM6nY42bdowbNgw7rvvPoKCguocX1ZWxqeffsqKFSvIzMzEx8eHbt268cADD9CvX78LvVQhhLjk3NZSSjZ9g2nVf7FnHarRrtLqMfacjP+wB/GKvYH09BK2bcrm8KEUMjNKAH/8fGsvj+lSucnzLSHHt5hcYzEF3qU1cmaoUNHGP4TYwAhigyLoGBRJbFAkbfxD0NVRbUVcfTRq9elEowH0i4yu0V5ks1QFPUryPcGPI6ZcTDZLnectslnYmnOCrTknPMe0KjUxgeF0DmlOfHBz4k9/9z/HSgi9QUubtsG0aVv1RvP48Qze/vcn6HVheBnCcLt8gOrBC4fDzbGjBRw7WgCAwaClfUwIMbFhdIgNIzSs9oopGt9AAobMIGDIDBwFpyjZ9A0lG2bjyDvu6eMuK8K06r+YVv0X7w6DCbjhdxh734pad2HVZIQQQlwab7/9Nk6nk8cee6za8T59+rBlyxZ27NhR6zi3283OnTuBiptHO3fu5MYbb6zRb9u2bQBERUXVCG7Y7XZeffVV5s2bh6IoqNVqWrVqRatWrTCZTOzZs4ddu3bx6aef8vTTT/Pwww/XOpeTJ096ghsA8+fPrzMoA+Dt7c0DDzzAv//9b2bPns2jjz5aZ9+mqMkEOJYsWcIbb7xxSc/58ccfc+jQIfR6PWFhYcTGxlJYWMjBgwc5ePAg8+bN44svviAuLq7G2MLCQu68805SU1PR6/W0b9+ewsJC1q5dy7p16/jrX//KXXfddUnnK4QQ58tRcIqiX2dRsu7zatUgKuki2hN4w6P49LuL1GxI3J9N0tzVmEtrWXJ/mhs3+T6l5BqLyTYWk+9TUi2g4avV0yU0iq4hUcQFRRIXFElMYDje2vpXfoimL8jgQ1CYD93DWlY7rigK+eVmjphyOWrK5Ygpp+KrKLfO3B9OxU1yUTbJRdn8SNUbt3YBYXQPbUGPsFZ0D21Bp+Bm58yv4nCYKSo+SnS0E72+AEVR4Xb54rD5YCnT4+vTDJerelDOZnOSdCCHpAM5AASH+NAhNowOsaG0iwnF27tm1RRdSCtCJr5E8Pg/Yz2ygZINX1K6/WcUe1Vwx3pkI9YjG9F8/0f8h8wg8IZH0IXVDBYJIYS4vNLS0lizZg1t2rShd+/e1dr69u0LwMGDB7FYLDVyRx0+fJiSkhJatmxJWloa27dvrzXAURkg6dOnT7Xjbrebxx57jI0bN+Lt7c3jjz/O7bffTmBgoKdPYWEhCQkJfPrpp+zevbvO66hc2e/v709JSQmLFy/m2WefRaOp+wbS5MmT+c9//sP333/PQw89hFbbZMIC59RkrsRoNDJw4EC6dOlCly5dOHjwIB9++OFFnfOuu+4iOjqa7t27o9NVvVE5fPgwzz77LEeOHOGZZ55hyZIlNca+9NJLpKamEh8fz0cffURERASKojBv3jz+9re/8dprr9GzZ086dux4UXMUQogLYTu1l8Jlb1O6bR64nNUbVSp8u9yM19DHOaXqQmJSLof+tQubzVn7yYAyXTmZfkVk+RWRbSz2lGdVuxXig5vTq1kbuoe2oFtoS9oFhMrWElGNSqUizNuPMG8/BjVrV62t4HTg43BRDkmFmSQVZHKoKBu7u/bcLinFeaQU5/FzSsWbPb1aQ3xIc7qHtqRnWCv6RbShuTGw2pjg4GCMRiMmk4nw8HBUKgWN1kxB4XEcDgd/fuZVyq06jp9OlnsitQins/r2rcICC1sST7Il8SRqtYpWrYPoFB9Op86RhIX7VssholKr8Ykbhk/cMMLufo/SrXMpXvMptpNVgRpXaR5FS/9N0bK38OlyE4E3PIpvt7GoZEWTEEJcEXPmzEFRFCZOnFijrVu3buj1eux2O7t372bQoEHV2rdv3w7Avffey1tvvVXnSo/KfmcHOD755BM2btyIXq9n9uzZdO/evcbY4OBg7r33XiZNmsTSpUtrPb/b7eaXX34B4Pnnn+eNN94gLy+PjRs3MmzYsDqvPSQkhIEDB7J+/XrWrl3LqFGj6uzb1DSZAMdtt93Gbbfd5nmck5Nz0ee84447aj0eGxvLa6+9xu23386xY8dISUmhXbuqN2QHDx5k9erVqNVqZs6cSURERRZ2lUrF1KlT2blzJ4sWLeLDDz/k/fffv+h5CiFEQyiKgiVpJUXL3saStLJGu9o7AO9BD5EZNY1NKS6OzMnF5dpT67ncKOQai8n0KyTTr4gSgxVUYLC7ibKo8Su0opzM5fahN/LQLQ9c5isT17IQLyMDIo0MiGzrOeZwuzhmyiOpMIMDBZkkFWaRVJhZa+lbu9vF7rw0duel8WVyIgAtjUH0jWhDv8ho+kVE0zY0tN6ytc2aVfwdj24bzMjRMdjtLlKPF3DkUB5HDueTk1199ZPbrXhK0y5NOERomC+d4iOI7xyBj9GFyVREcHAwYWFhaLz9CRz+MAHDHqI8dTvFqz+mdOtcFMfpa1EULPuWY9m3HF14OwJvfIqAIfej9jJejv/cQgjRaGJjY4GKm8m1ef/99/nggw944oknePLJJwGYNWsWH374IWPGjOHdd9+tdZyiKIwcOZKMjAw++ugjRowY0aD5VN7EHjlyZI02g8FAt27d2L59O9u2baszwDFo0CCWL1/O7t27MZvNGI1Vr90nTpwgLy8PqFoRAmA2m/niiy+AijwetQU3zhQQEMD06dNrbdu6dasnVcK4cePYvXs3P/30EwsWLKg3wFF53evXr2fx4sUS4LgetG1b9UbLaq2enGzFihUA9O/fn9atW9cYO3XqVBYtWsS6detqXdIkhBCXkuJ2UbrtR4qWvoXt1J4a7QWKP4mGCVjDx2HZ54dzZ2at53GqXGT5FZEWUECmXxF2rZN2AWGMi+hM98DmZG/bR/KOHZSd/gM+cOhopk6depmvTlyPdGoNHYMj6RgcyW3tKzLaK4rCidIC9uSlszvvFHvy00kqzMR29golIM1cRJq5yLPKI9TLSK+WLQmdMJj8vUcoTE3Fz2hkwoQJtf4b1us1xMaFExsXDoDJZOXo4XyOHM7j6JE8LGXVk+bm55Wxfu1x1q89jluxYS3PQCGfnr3bcOed0/Dx8UGlUuHdti/ebfsSNu1tSjZ9jWnNJziyj3jO48hNIe+731Mw/28EDHuIwBufQBdSf2I5IcTVz+q0Y3edu+LY1Uav0TT69tKJEyfy4YcfsmbNmhoBhEo7duwgIyODoKAghgwZ0qDzpqWlkZWVhbe3d50JOXv37s327dtrXZ2xY8cOgoODadeuHb1792bnzp3s3LmzWlChMggSERFRLUno+vXrKSkpQaPR1Bm4aKjK7SmjR4/G29ubSZMm8dNPP7Fq1SpKSkrw9689fxpUrFKpvJZriQQ46lCZNMbHx4fo6Op7Y/fs2QNQY69Wpa5du6LX67HZbCQnJ18X5YaEEFee4nJSunUOBb+8jiO7+t0QBTig6sN+30mU6eJQoYMSgOrL7ss1DjL8C0n3LyDbz0So0cjgZu14uvlwBjVrTzPfgKrO8QPIGz+FwsJCz91pIa4UlUrlqbRzS7vuQEVp2+Si7NMrOE6xPeckp8yFNcbml5tZkZ5c8aBbIL6aMHqHtoI2sWQ7yohWvOstUxsY6E2ffi3p068lbrdCRnoxyUk5HEzKOZ2Et4paZcDXuy3QlkP7Hbzz76VMmjyQuE4R6PUV2080xmCCbnqawNG/x5q8GtOqjzDvWuSpauS2FlO0/B2Kfn0Xv963EnjzH/Bu2/fsaQkhmoC/b13Ml8mJuJtg4Uq1SsWMjgN5ud+ERptDdHQ0Xbp0Yf/+/axYsYJbb721Rp/KLRpjxoyplnagPpVJOePi4urMVdG3b18++ugj9u3bh81mw2CoSAydkpJCYWGhJ+dG5We97du3Vwtw1JV/o/JzZvv27WutvNJQZrOZ3377DYBJkyZ5nisqKoqMjAyWLFlSbwClQ4cOeHl5kZ+fz/Hjx6vd4G/KJMBxBrfb7anW8vbbbwPw7LPP4utbPXP6iRMnAOos16PT6WjWrBknT54kNTW13gDHnDlzmDdvXoPml5KS0qB+Qohrm+JyUrrl+4rARs7Ram0WVRApUQ+xtbQzqAMBOPtjm13tJC2ggJOBeZgCzPRv1pZHWgxiaPMY2geE1ftBLywsTAIb4qqh12jpFtqCbqEtuL/jAACyyorZlnOCrTmpbM1O5bCp5pbWMpeDdTkprMup+Lsa5RvI4ObtGdo8hsHN2xFSz/YQtVpFy1aBtGwVyOgxsRQVWdm25RjLl25HqwlFdUb+GbVaR2mxjm+/2oVOr6Fjp3C6dmvmCXaoVCp8Oo3Ep9NIHHknMK38gOL1n+O2ng6auF2UbptH6bZ5eMUMInjsc/h2H1/v76gQ4uoyO3lzkwxuALgVhdnJmxs1wAEVH97379/P4sWLawQ47Ha7Z3V95Yf8hsjIyAAgPDy8zj49evRAp9Nht9vZu3evZ5tJZWWUypvdPXv2RK1We1ZsVKp8fOb2FKhKtdCyZfWE3Odr2bJlWK1WIiIi6N+/P1BxM2DChAl8/PHHLFiwoN4Ah0ajISQkhIyMDDIzMyXAcS2ZPXt2jQotXbt25c0332To0KE1+hcXFwMV+6HqUtlWUlJSZx+oKH+blJR0vlMWQlyHFKeDks3fUrj4DRy5VQFPNxpO6ftwOPRu0spbQJnq7AqYOFUuMvwLORmYjzPExo3t4nms5UAGRrbDRyfVTcS1o5lvAJPadmNS24qlt0XlZWzPPcnWnBNsy0llf34GTqX6SqaMMhNzj+5g7tGKu22dg5szpHkMI1rG0ie8Ndp6En8GBXnTpq2e7PzfaNOmPRp1KC5HIC5HAGe+zXLYXezbk8W+PVno9BriO0fQo1cUHWLD0GjU6MLaEDb9bYIn/42S9V9S9Nt7OPNPeMaXH91E5qxN6Ft0Jnjc8/j1vQPVOarHCCEa3/0dBzTZFRwaldoTPG5M48aN480332Tr1q3k5OR48h8CrFu3juLiYlq3bn3OXBZnKiysWO13ZtWSs3l7e9O5c2d2797N9u3bPYGKypUZlQEOPz8/YmNjSUpKwmq14u3tTVZWlieIcvYKjrKyiuphF5vGYOHChUDFfx+1uuqN3+TJk/n444/Zu3fvOVdmBAQEkJGRQUFBwUXN5Woifxmp2BfVs2dPXC4XmZmZ5Ofnk5yczKJFi+jevXuNvUs2W0X5xPqWQOn1FR8YystrJkQ7U1hYGPHx8Q2aZ0pKyjnPJ4S49ihuN6Xb5lEw/2/VAhtmVSiHvG4m2WcsNrcvWGuOzTIWkRqUS5lXEUGFZbROtfL+na/Ue8dCiGtJkJcvo1t1YnSrTgBYHHa25qSyIfMo6zOPcagou8aYA4WZHCjM5KMD6wjQezG8RSw3tuzI8KgOBBpqviGtrNJSXFxAeLgGra4IRVFRWKCgJgI/Yxvstqr99w67iz27MtmzKxOjUU/3nlH06BVFi5YBaLz9Cbrp9wTe+ATmnQsp+nUW5Uc3ecba0w+Q/ck9FMz/O0FjnsF/8P2o9V6X4b+cEOJSeLnfBF7odZPk4LgIwcHBDBo0iHXr1pGQkMCDDz7oaavcnjJhwvmtMrHb7UDVZ7a69OnTh927d1fLU7F9+3aMRmO1apm9e/cmOTmZPXv2MGDAAM8qj9DQ0BoBhsrdARaLhQuVlpbm2epy9sqV6Ohounbtyr59+1iwYAHPPPNMneep3HZT+d/jWiABDir2a40ZM8bz+NChQ/zzn/8kISGBlJQUfv7552p7swwGA1arFYfDUdvpgKp/JF5e9b/pmDZtGtOmTWvQPKdMmSKrPYS4jiiKguXAr+T/9BK2kxXJEhUgU9uVg4ZxnNT3BdRnp9WgTFfO8aBcsrSnCC0vp1uxN8qxYrKzs7l5wgQJbojrmo9Ozw0tYrmhRUU2/1xLKRuyjrEh4ygbMo+SY61eMaXYXs6i43tZdHwvGpWa3uGtGdUyjhtbdqTd6S1dYWFh9VZpufvu0Rw5nMf+PVkkHcipVpLZbLazcX0qG9enEh5upEfvKHr1bkFgkDd+fW7Fr8+tWI9toXDJvyjb/YtnnCPvOLlfP07Bon9W5PMY8ZhUXhHiKuWt1eMtn7ouyqRJk1i3bh2LFy/2BDhKS0tZu3YtQK2lXutTuXLjXKvt+/Tpw6effsqePXtwOBxkZWWRk5PDkCFDqn0+7NWrF9988w3btm1jwIABdZaHBTwrUNLT089rzmeaP38+iqLQoUMH4uLiarRPnjyZffv28csvv/CHP/yh2gqPM1XuTKhvJUtTI79qtYiLi+OTTz5h1KhRJCcns2TJkmq/NP7+/litVs8/iNpUttWXuVYIIepiPbaF/J9ewnpoLQAODBwxjOSgYRzFmhY1+rtUbtL8C1DaOBnZqwNPRQwgccmvJCYmUmjOwVhPxQghrmfhPn7c2q4Ht7brgaIoHDHlsiHzKGsyjrA5KwW7u+quq0txV+T2yEnltR3LiPYPZVybzoxt3ZmpU6eiUqlITEwkNTW12u+cTqchvnMk8Z0jcThcHE7OZdfODJKTcnG5qiKUublmViw9zK/LDtMhLoy4joEEhyiEhrUj6vcLsGUkUbjk35Ru+QFOz8tVnE3+vBcoXPoWwWOeJXDk/0mgQwhxVVMUpdZcQvWtaBg5ciS+vr4kJydz7Ngx2rdvz/Lly7Hb7XTv3r3Wypb1CQkJAaj38xxU5NfQaDRYLBaSkpI8ORHPLjZR+bhypUd9AY5evXrx7bffcvToUU/i9vOhKAqLFi0C4MiRI57yu7XJzs4mMTGRwYMH19puMpkALirZ6dVGAhx1MBqN9O3blxUrVpCUlFQtwNGmTRtycnI4efJkrWMdDgeZmZmevkII0VD27CPkzXuBsl0Vf7gsqgAOGsaTbBiDTe1Xo79ZX05OpIle/aL4XaexdAis2pcaO2MG48ePl6onQjSQSqUiNiiC2KAIHoofjNlhY0PmUVamJbMq7TD55eZq/VNL8vlg31o+2LeWlsYgxsZ3ZuqgJ4hyGwgNCan1d06n09C5azM6d22GpczOvr1Z7NqRwYnUquovigKHk/M4nJyHy2XF4UqnU+dg7r3vdpo98hWht/yDwmXvULL+CxRnxbZZt7mA/B//TNHydwga8xyBIx9DbfCt8fxCCNFYfHx8sFgs5Ofn1/r6WFnIoTZeXl6MHj2aBQsWsGjRIp555hnP9pTzXb0B0KlTxbbFY8eO1duvcivKgQMH2L59O8ePHwdqBjjCwsJo3bo1e/fuJSMjw3MtZycYBRg6dCh+fn6Ulpbyww8/8Pjjj5/X3Ldu3UpGRgYqlcoTqKmNxWLBYrGwYMGCWgMchYWFFBYWotFoal0F0lRJgKMeTmfFElLXWXvmunfvztatWz37ns62b98+HA4HBoOh2t4sIYSoi6usiIJfXsW08gNwOTGpo9jvNYlj+htwqWruD83xNxHW2Ye7B/Wgf7No1Kralx5K1RMhLpxRZ2BM686Mad0Zt+Jmb34GK9OSWZmWTFJhVrW+aeYiPknawCdApI8/Y1p3ZpK7G73CW9VZ9cTHV0//ga3pP7A1hQUWdu/MYMf2NAryq+5iajTeaDQxHD8C/359ORMn96VL11ZE3PsBIZP+StGKmZhWfYhiq0ha5yrNJ3/e81WBjhGPoq4lb4gQQlxprVu39uSpqCyxWiktLY2NGzfWO37SpEksWLCAhIQEpk+fzvbt29HpdNVSDTRUt27dMBgMpKenn3MVRd++fT0BjpSUFAwGA127dq3Rr1evXsyfP58vvvgCgKCgINq3b1+jn9FoZMaMGbz33nt8/PHHDBo0qN4EqcXFxSxdutRTEWXBggUADBgwgC+//LLOcStXruTxxx9n5cqVmM1mjMbqq/v27dsHVAR7zq4a2pTV/o5YYDKZPMlhzg5S3HTTTUBF9Ky2VRxz584FKqJz19I/FiHEpac4HRSt/C+pz8diWvEu2cTwq++L/BTwIYcNN1ULbjjUTlL902h3iy8f/3Uqb98+hYHN29UZ3BBCXDpqlZoeYS15rudoVkz6PVtvf4F/9B1Pn/DWqM4qxpxtKeHL5EQmL/2IgT/9mzd2LCe5sGYy0zMFh/gwcnQMMx7uTKl1Ew5XBmcn2LGU6Znz3R5efXklCYsOUuL0I+yON4l+K4Wgsc+h0lcFMlwlueTPfY7U59pjWvURirPuvGFCCHElDB8+HICZM2dWyz9x6tQpnn76aZRzVJrp168fERERZGZm8vLLL6MoCoMHD76g7RV6vZ5+/foBsGvXrnr7Vm4z2bJlC+np6XTt2rXW5KSVqzp+/PFHz7i6AtyPPvooAwcOxG63M2PGDP73v//V2C5jMpn47rvvGDduHBs2bAAqKrD8+uuvQEWejfoMGzaMoKAgysvLWbZsWY32ym00Q4YMqfc8Tc01/654+vTpjBgxgtmzZ1c7vm3bNj788MNak7skJSXx4IMPUlpaSkREBDfffHO19vj4eG644QZcLhd/+MMfyM3NBSr2Q82dO5dFixahVqt57LHHLtt1CSGavrJ9yzn5tx7kffsU6eXNSDC+SoL/m5zS96vWz6q1kRV0EptxB9oj6xke0Rxvbd1VnIQQl1+UMZCH4gezYNxj7Jj6Z17rP4lBzdqhPuvNbJq5iP/uX8uNi95l5IKZfLBvDadKC2s/KVBUVISp+ATexpN4++1F53UKlbr6vnSrxcH6tcf512ur+fJ/2zmeBaG3v0H02ykE3fwMKr23p6+rJIfcb57gxIvxlGyZg+J2n/2UQghxRTzwwANERUWRkpLCzTffzIQJExg3bhyjR4/Gbrdz11131TterVYzbtw4gAtOLnqmO+64A4DFixfX2693796o1WpPJc1evXrV2Q+qKm7Wln+jkkaj4ZNPPuH222/HarXy1ltvMWDAAG6++WZuv/12Ro8ezcCBA3nllVcwmUyecy9fvhyLxYKvry+jR4+ud946nY7x48cDFUlJz6QoCkuXLkWtVnPbbbfVe56mpslsUcnKyqoWpaqsUrJr1y5P9A3goYce4uGHH/Y8zsnJISMjg9LS6lnRS0pKmDVrFrNmzSIsLIzw8HA0Gg1ZWVnk5eUBFRluP/nkk1pXYbz++utMnz6dpKQkRo4cSfv27SkqKiIrKwuVSsWLL77Y4PKvQojriyP/JLnf/wHzrkVkabuwy/ga2brONfqV6spw+mYT7i4ixA25eYUYjcZrKhGUENeCCB9/7us4gPs6DqCwvIzlp5JYnLqPTVkpuM+4I3nYlMObO1fw5s4V9IuIZlpMb8a16YKPrupOYGXJWZPJRHi4Hp0hF60+l4J8GxpVC4w+0TgcFUEKRYHkpBySk3IIDzcycEgbek5+naAxz1C07G1Mqz9CsVfUj3bkppD98V0ULXuH0Ntfx7dz9eXhQghxufn7+/PDDz/w7rvvsn79elJTU4mIiODBBx/k8ccf5/PPPz/nOSZNmuTZAmI0Ghk5cuQFz+eGG24gPDycNWvWUFpaip9fzVxnlfOOjY0lOTkZqDtw0bp1a8LCwjyfJWvLv3EmvV7Pq6++yt13381PP/3Etm3byMrKIi0tDaPRSLdu3Rg4cCBTpkwhKioKgIULFwIVOwq8vb3rOXuFyZMn880337Br1y5OnjzpSca6fft2MjMzGTZsmOfc1wqVcq61QFeJ9PT0Bv0DfuKJJ3jyySc9j0eMGEFGRkaN4wUFBSxevJitW7dy7NgxCgoKsNvt+Pv70759e0aMGMFtt91WY6/SmcxmM5999hnLly8nMzMTHx8funbtyoMPPkj//v0v7oJrUVkmNj4+vkYUTghx9cvNyqBoxUyUjR+RTQy7vKbVGthwhTjxMRaStD6ByMjIGiUnZ8yY0QizF0KcrxxLCYtT97Hw+F725KfV2sdXq2dCdFemxvSmd3hrVCoVX3zxBQkJtf/+T5t2Nzu3p5O48QT5eWU1zuflpaV335YMGRaNvTAFU8JrqPbN91RdqeTTaSSht7+OV3TvGucQQojrxXfffccrr7zCM888wyOPPNLY07liHnvsMdasWcO8efNqzSfSlDWZAIeQAIcQTZXFYmHZx/8g4sDnKKoItnvfW2tgQxehYvL4zvTp3BqLxcLcuXNJTEz0JIYaOHAgU6dOxcdHEgYK0dSkluSz6PheFhzfQ0pxXq192vqHckdMb8ZFdWTtL0vr/f13uxWOHs5j04YTHD6US813cwp2RwaFxfuINOQzOfAEofk1k6Mb+95O2O1voAuLvsRXLIQQVz+n08mECRMoLCxk1apV9d7cvlYcOHCAW2+9lfHjx/POO+809nQuOQlwNCES4BCi6XGaslj92iQCC7LZ7n0PJ/UDavTxaabljond6RQXWaMtLy9PyrwKcQ1RFIXd+WnMPbKDX1L3Uuqw1eijVqm4ISqWSc06Eqf1JywktN7f//y8MjZvOsH2rWmUlztrtDvd+eTk7WBS3yAG2DZjTV5TrV2l1RN40x8IHv8CGm//i79IIYRoQvbs2cOGDRsYPXo0sbGxjT2dy27dunXs27eP2267jWbNmjX2dC45CXA0IRLgEKLpUBSFQ0vfpnjRLA5qJ3NYfyOKSlOtj1ldwP3TBtK3T0wjzVII0ZisTjvLTiYx9+gONmWl1NqnpTGIu2L7Mb1Db0K86r+zaLM5Wbs6mV+XH0Sjrpk/zOkqZuLkHvQKOUXhzy9hO7WnWrvGP4LQW1/Bf8gMVGpNjfFCCCHE1U4CHE2IBDiEaBqOpWwn5dPfUVDcmf1ek3CpDNXaHVozBvUJTp7ayz/+8Y/r4m6BEKJ+p0oL+fHYTn48tpN0s6lGu16tYVybLtwb19+Tq6M2hw8f5h//eJnWrXqBqwVuV81AR0ioD8NHtKODcz1F81/CWZRRrd3Qshthd76DT8cbLsm1CSGEEFeKBDiaEAlwCHF1Sy8p4LdvniFoXyZ7vO7Goq5e7cSlKcdLn45WZyIvLxeHw8Hrr78uW0+EEB5uxc3GzBS+ObyFX08l41JqlnXtGBTJfR0HcGu7Hnhr9dXa8vLyePHFF9HpdISFheN2+eGwReB2BtY4T2CQN8OHtaRt/hxKV/zbU3Glkm/PSYRNext9eNtLeo1CCCHE5SIBjiZEAhxCXJ3MDhtfr/mKgISvyVRuIU971ooMjYPc3O34GIsJDAyQiihCiAbJLCvm+yPb+OHwNnKspTXagww+3BPbj/s6DiDCpyp3Rm1VWAoLyukSP5bSYm/c7upv/fwDDAzpF0L0ifco3/pNtTaV1kDw+BcIGvscav25SxIKIYQQjUkCHE2IBDiEuLo43S4+37GKjGXvE5UbQ4p+RLV2tdrNsBEx9B8YxcKFP0tFFCHEBXG4Xfx66iBfH9pSa64OnVrDxOiuPBw/mM4hUfVWYbJaFNasOsbO7em4XNXfAhr9DAztrqX57j9D2vbqzxHWlrC7Z2HsNvayXqsQQghxMSTA0YRIgEOIq8eKlH28u+xTJhw1kaGagENVfZ97p45BTLytB8HBVQEMqYgihLhYx0y5zD60mXlHd2Jx2mu0D4hsyyPxgxnZMo6C/II6X3OKiqysXXWMbVvScLmqb4NxuS0YzauZ4Poef8qqtfn2mEj4nTPRhbW55NcmhBBCXCwJcDQhEuAQovGllRbyj62L0W9aSZv8nhRoq1dA8daWcs8jN9I+JrSRZiiEuB6YbBa+P7KdLw8mkmUprtHeITCc/+syjEltu6OrpyJKscnKujXH2bL5JE5H9UCH4i6lecl8xiiLUOPyHFfpvAie8CJBY55FrTOcfUohhBCi0UiAowmRAIcQjcfmcvLJgfV8v2UptxyCQmVItbKvWsWKzXmYEtspXn/9NVmhIYS4IhxuF0tO7OezpI3szU+v0d7CGMijnYcxNaY33lpdnedJPZ7BzHfmY9C1RqVSV290FTDGfxXN07/jzNotushYImZ8gk/skEt0NUIIIcTFUZ+7ixBCXN/WZRxh1MJ32fnLQm462IUChlcLbvipjqPzP4zB34LZXEphYWEjzlYIcT3RqTVMbtudhPGPM3/so9zcKh7VGWGIdLOJv2xZxIAf/8UH+9ZQYi+v9Tx2h5m8wkS0XrvR6PKBM+5/aUJYVnYHK9r/TL5/f89hR/Zh0t8YTs7sx3DVsopECCGEuNK0jT0BIYS4WuVZS/nblsWsOrqPqUd8sblGYz0jLOztykXrm4nL4EQFmEwmjEYjwcHBdZ5TCCEuB5VKRd+INvSNaMNRUy4f7V/H/JTdOE+Xmc0vN/PmzhX8d99aHowfzMOdBhNgqKqKEhwcjNFopLgkh/BwBbcrG0d5c1zOqtez9AIt6Zo/E9s2m+4n/4afKweA4rWfYt6zmPC738Ov95Qre+FCCCHEGWQFhxBCnEVRFH46tpPh8//Dye0HueNgJ2yuHp52teKktXcSB9KXklWcid1uJzc3l+zsbAYOHCjbU4QQjSomMJz/DLmdTbf9iRkdB+KlqdqaUuqw8e6eVQz46V/M3LPSs6IjLCyMAQMGkJ2dTW5uLk5XCcVlW0jLWoSvn63a+Q8XRfJT4KfsCH8W2+kEyy5TFlkf3E7Ge1NwFGVcuYsVQgghziA5OJoQycEhxOWXYTbxfOJ8Np1KYXxKEN7lcdXaw9UZTL1vACHt29dZhlFKvwohriYF5WY+T9rE7EOba2xRCdB787vOQ3ig0yDUDledr2uZGRYSFh0kM6Ok2nhvnZPupV/T0ZrgSUSq9vYn9PY3CBj+CCq13EsTQghx5UiAowmRAIcQl49bcfP1oa28sWMZIQV6hp2MxkWAp12tOBgUdYKbn/gdOm8p/SqEaHpK7OX8L2kj/zu4sUagI8jgw+86D2VGxwFYTCW1vq653Qq7d2awfMkhiourj/dxZTPE8iktnTs9x7xjhxLx4Ofow9te3gsTQgghTpMARxMiAQ4hLo9TpYX8YcM8tmedZEhaJFHF7aq1BzuP0bpZDtNffKORZiiEEJeOyWbhs6SNfH5wE2ZH9e0nwQZfnup2A/fE9cegqT1Vm93uYsPa4/y6IhnFXX2FRpR9O4Os/8PfnQ2AyuBL2NR/ETD8d7KaQwhxVXrllVf47rvv+P777+nVq1djT6eaf/7zn3z77bd888039O3bt7Gn0yTIXxohxHVLURTmHd3BjQvfJflkDlMOdawW3FArDjraf6HQsYvVqfnk5eU14myFEOLSCDT48FzP0Wy+/Xme7HoDvlq9p63QVsY/tiUwfP47zE/Zjft0ktIz6fUauvYIpKj0VxyuU5xZcSVD34cf/T9gh9edONGj2MrI/foJMt6+GUf+yStxeUII0WApKSnMnTuXwYMH1whuzJ8/n9jY2BpfnTp1ol+/ftxzzz38+OOPuFyuWs/9wgsvEBsbywsvvFDvHNLT0z3nTk+vXu77kUcewWAw8K9//QtZl9AwEuAQQlyXisrLeGTNt/xxw09EZQcx/khX9GdUCwhynaSz8jWnQiPRBrfAbDZL+VchxDUlyODD871uYvPtz/N/XYbhra1KRppmLuKp9XO5+Zf3WZtxpMYb68LCQkpLC/A2puNlPIhaU+ppU1Q69nhP5afAj0jVDUQBLAdXcfIv3She9z95ky6EuGq8/fbbOJ1OHnvssTr76PV6evbs6fmKi6vIz7Zt2zb+8pe/8PDDD+N0Oi/L/CIiIrjttts4cOAACQkJl+U5rjUS4BBCXHfWZhxh1MJ3WZ1ymJHHY+mdGQNUvbGPLV9GiD6RY0HdUFRqKf8qhLimBXv58mLvMSTe9ifuixuAVlX19vBgYRZ3//oF01b8j735VXcWK8vKmkwm1BorBt/D6L2P41aqcnOYVaGsMj7PMuMrmNRRuMtLyfnyd2T8ZxyOwup3KYUQ4kpLS0tjzZo1tGnTht69e9fZLywsjB9++MHzNX/+fDZv3sybb76JWq1m06ZN/Pjjj5dtnrfeeisAX3/99WV7jmuJBDiEENcNm8vJ37b8wt2/foErHyYc7kpEWVUCPS+3iWGOD9iad5Q9lgAp/yqEuK6Eefvx2oBJrJnyRyZGd63WtikrhXGLP+DxtT+Qbi6qUVbW4bBTaDpEato8QsIsaDQqz9hMXTfm+89ip9c0nOiw7F/B8T93JuO3z670JQohhMecOXNQFIWJEyee91i1Ws0tt9zCjTfeCEBiYuKlnp5HfHw87dq1Y9++fSQnJ1+257lWSIBDCHFdOFFSwKTF/+WLg4nE5jXnxpTO6F1V1VBaOHZwb7tVDHvlawaMm47D4SA1NRWHw8GECROYOnVqI85eCCGunGj/UD4cfidLJjzBoGbVky4vSt3LsPnv8NauX5l42xQmTJhQ7fVy/PgxPPn0eP74p2HExp1RgUWlY7f3dBb4zyJT2wWVrZSy7x5l458GYS7IvtKXKIRoBJV5Jury/vvvExsby/vvv+85NmvWLGJjY3n66afrHKcoCiNGjCA2NpbVq1c3eD5LliwBYOTIkQ0ec7aoqCgAHA7HBZ+jISrnuHjx4sv6PNeC2tNjCyHENWTJif08u/EnysudDEmLpWVJ1ZtuleKkj/UbRtwylKCb/o5KpWLGjBmMHz9eyr8KIa5r3UJbMOemh1iXeZTXdyzjYGEWULEabtbe1cw5uoMXh47h1XHjMBUVVXu99PGBBx7pS9KBHBbNP0CxqWLrSrEmiqV+rxJjW0U/65eE527h+EvdiHlmPt4xgxrtWoUQV6eJEyfy4YcfsmbNGsxmM0ajsUafHTt2kJGRQVBQEEOGDGnQedPS0sjKysLb25uYmJgLnt/+/fsBiI6OvuBzNES3bt0A2L59+2V9nmuBBDiEENcsm8vJq9uX8mVyIoFWX8acjMdor1q14ePOZ5D5PRKJYlivO1GpqpZUh4WFSWBDCHHdU6lUDI/qwNDm7fnp2C7e3LmCXGtFQtEcSwm/Xz+XHmEtebnfBGLPes1UqVR07hJJ+5hQFs3fw45tWZ7X2aOGkZzS9aGf9UtiyleT9vpwgie+RMjEv6CqozytEE2V22ZBcdobexrnTaXVozb4nLvjZRQdHU2XLl3Yv38/K1as8OSjONMvv/wCwJgxY9DpdDXaa7Nr1y4A4uLi0Gg05zUnm81Geno6X331Fdu3b8ff35+77777vM5xvrp06QLAwYMHsVgs+Pg07v+Xq5n8BRFCXJPSSgt5dO337M1Pp5UplAFpMWiUqj9gUY7d9LR9xYaQmziUVkhhYaEENIQQog5qlZo7Ynoztk0XPti3hs+SNmJzVVQN2J2XxsSED5nSrgcv9R5DhI9/tbFeXlq69/JjybIviQwbAkrFHVib2p/1vr/nuH4Ig8v+C4v+iWX/r0Q++g368HY15iBEU5T73R8wrfwAaim5fNVTqQkc9QThd81s1GlMmjSJ/fv3s3jx4hoBDrvdzooVKzz9GiojIwOA8PDwBvWta2vNuHHjePLJJz1bVWqzYMECFixY0OC51SYsLAy1Wo3T6SQnJ+eyrxhpyiQHhxDimrMx8xhjF3/A3rx0uma3ZvCpuKrghuKmp/V7Oru+Z12z20k3K1IhRQghGsioM/BCr5tZc8sfGdu6c7W2+Sm7GT7/Hb44uAmXu/qHueDgYAxedszlG9B5nQJcnrZ0XU9+DnifQ/rRWI9v5eTfelKS+O2VuBwhLjvTqv82zeAGgOKumH8jGzduHFqtlq1bt5KTk1Otbd26dRQXF9O6dWu6d+/e4HMWFhYCEBgYeM6+Z5eJ7d69O5GRkahUKlavXs0PP/xQb5nYkJCQauPP/urcuXOdYyup1Wr8/PwAKCgoaNhFXqdkBYcQ4pqhKAqfJW3k1R1LUTvVDD3VkRalIZ52g7uUG8reIRs3q8MmUZRfTHZ2NhMmTJDVG0IIcR5a+QXz6Yi7ScxK4e9bF5NcVJEotNRh429bFzPv6E5eHziZnmGtADxVVxISEgCFAP9cbJZWaDUVd08dKh82+j7Ocf1ghlg+QPn0PizJawm/+71GXyIvxMUIHPl4013BodYQOPLxxp4FwcHBDBo0iHXr1pGQkMCDDz7oaavcnjJhwoTzOqfdXrFlSK/Xn7NvZZnYsx09epTnnnuOr776iuLiYv71r3/VOn7o0KG8+eabdZ4/PT29QYlODQZDtbmL2kmAQwhxTbA67fxp03wWHN+Dn82LoSc6EWCrelMc6ErjRsu/yG03ijXHVZhPnMRoNEqFFCGEuAgDm7Vj+cSn+O7INt7cuZwSe0Uy0QOFmUxK+Ii7YvvyfK+bCDL4MG3aNFQqFYmJiZw4eRijMYNOHW+gKC+Y8vKKu5+Zum787P8efa1f0XHDbIqTNxBw/+dEdh7cmJcpxAULv2smobe9Jjk4LtKkSZNYt24dixcv9gQ4SktLWbt2LcB5l3qtXLlRUlJywXOKiYnhzTffZNKkSSxatIgHHnig3ioxF6u4uBho2KqT65kEOIQQTV6G2cSDq77mQGEmkaWBDD4Zi95dlWSqlX0rI1RfEf2n7/HuMJi+eXlSIUUIIS4RjVrNvXH9GdM6nte2L+OnlIrkfQoK3x7eytITB/hLnzHc3r5XrVWqSorLWfDTfpIOVCw9d6q8SfR5lFTdIIYUvo/j7ZHs6HA3I55+XxLriSZJbfCBqyRQcDVQFKVaYvdKFoulzjEjR47E19eX5ORkjh07Rvv27Vm+fDl2u53u3bvTunXr85pDSEjFCt/KoMGFiouLw9fXl7KyMvbt23fZAhxWqxWbzQZUzV3UTnJwCCGatN15aYxP+IADhZm0K4hgeGqnasGN7ta5DHF9Rvu/rMS7Q8UdwLCwMGJjYyW4IYQQl1CYtx/vDr2DH8c8QofAqsR9hbYy/rjxJ25d9glHTbk1XoP9A7y494HeTL+nBz6+Va/fWbouLPCfRap+GDFHZrPz5Ztw28qu+HUJIS6NygBlfn5+re0nTpyoc6yXlxejR48GYNGiRUDV9pTzXb0B0KlTJwCOHTt23mPPpCgKiqIAUFRUdFHnqk/lPENDQ4mIiLhsz3MtkACHEKLJWnJiP7ct+4Q8i5luWa3plxGD+vTLmlYpZ4T5X7Sw/8YXzlEUa4IaebZCCHF9GBDZlhWTfs9Lvcfgra0KWGzLOcFNi2bx3t7VONyuamNUKhU9ekZx/4NdsDszPccdKm82+D7FSt8/4597gON/7YUt/cAVuxYhxKVTucpiz549NdrS0tLYuHFjveMrq6QkJCSQmZnJ9u3b0el0jBkz5rzn0q1bNwwGA+np6Z6EoxciOTnZs/KkVatWF3yec9m3bx8AvXv3vmzPca2QAIcQoslRFIUP96/jd2u+w+FwMehULPF5LT3tPu4Cxpe+gEGbx8rwu8ktc13UHy8hhBDnR6fW8FiXYay95RnGtI73HLe7Xfx716+M/eV99uWn1xhns5eSk78Gte4wqKqqEpzU92e+/3ucKPTn1Cv9Kdn09RW5DiHEpTN8+HAAZs6cSXp61e//qVOnePrppz0rIerSr18/IiIiyMzM5OWXX0ZRFAYPHnxBlfD0ej39+vUDYNeuXec9HuDw4cO88MILQMXKiiFDhlzQeRpi+/btAJf1Oa4VkoNDCNGkONwu/py4gDlHd6B3ahl6oiPhlgBPe5DzBDeZ/0m2b0u2h4wlPy9fysAKIUQjiTIG8tmIe/jt1EH+vHkh2ZaKhH7JRdmMT/gvv4sfyh97jPKs9AgODsZoNFJiTiE0tBy7tQ1uZ8VrvFUdxK9+fyPOtox+nz1KaMo2wu/8DyrtuasgCCEa3wMPPMAvv/xCSkoKN998M9HR0bjdblJSUoiJieGuu+5i9uzZdY5Xq9WMGzeOL7744oKTi57pjjvuYP369SxevJhRo0bV2S8vL4/p06d7HrvdbrKzs8nJyUFRFIxGIzNnzsTX1/eC51Ifs9nM2rVrMRqNjB079rI8x7VEVnAIIZqMEns59/z6JXOO7sBo82L0sa7VghtRjt1MKP0z+7Rt2Oh3Izl5+WRnZzNw4EDJtyGEEI3oxladWH3LH7k7tp/nmFtR+OjAOkYvmsXm7ONAVTnZ7Oxs8vMzUGmTsDmTcLurVnMcMoxhgf9Mjq5bSdqbI8g5to/Dhw+Tl5d3xa9LCNFw/v7+/PDDD0yZMoWAgABSU1MpLy/nwQcfZO7cuRiNxnOeo3KbCoDRaGxQedW63HDDDYSHh7NmzRpKS0vr7Ge329m1a5fna8+ePZSUlNChQwcefPBBli5dSt++fS94Hufy22+/YbVamThxoiRabgCVcq61QOKqMWXKFJKSkoiPj2f+/PmNPR0hrqgcSwl3Lv+cw8U5BFp9uSE1Hm9n1V27DrbfGGz9mNT2U5l/woDZbMZoNDJw4ECmTp0qfxCEEOIqkZiVwnOb5nOytKDa8Xvj+vNS7zGoHC7mzp1LYmKi57W8V88hWEpbkZ1l9vRXKU76WL+lrW058+z9KPBty4ABA5g2bZq85gshGuS7777jlVde4ZlnnuGRRx5p7OnUoCgKt9xyC8ePH2f58uU0b968sad01ZMARxMiAQ5xvUotyeeuFV9wylxIWJk/w1I7oXdX7bDrZf2W7o4FNHt4Nv79p5MnZWCFEOKqZnXaeWf3Sj5N2oD7jLeirf1CeHfI7fSJaFPjtdzpdPPbiiOsXXWMM9+9tnDsYkjZLHZoO7KsIIwJEyYyY8aMRrgqIURT43Q6mTBhAoWFhaxatapBq0iupBUrVvDUU0/xu9/9jj/+8Y+NPZ0mQQIcTYgEOMT16EBBBnf/+iX55WaalwQx+GQcWkUDgEpxMcTyAdH2dQQ9MJvmQ+9s5NkKIYQ4H3vz03lm408cKsr2HFOh4tHOQ3m2540YNDXTxaWmFPDtVzspLbV7jnm7Cxle9i5mxcwy1UBefuMtCXALIRpkz549bNiwgdGjRxMbG9vY06lm8eLFnDx5kvvvv/+qC75crSTA0YRIgENcbxKzUnhg1deYHTbaFIXRP62qDKxGsTOi7C2aOffwrW0QM/7+36vuj5IQQohzs7uczNq7mvf3ram2miM2MIL3hk4lPqTmkux9ew/y6cfr8PGqqqCF4qZb+c+0sCQQ+X9zie1fd9JAIYQQ1yZJMiqEuCotO3mAu3/9ArPDRof8ZgxMi/UEN3SKhZvMLxPh2s+PhvEU+EZLlRQhhGii9Botz/UczcJxj9HWP9Rz/LAph3GLP+C9vatxul3VxjRrHobNuQubIwlwVxxUqdnrfTvbA17A8vXjWJLXXrmLEEIIcVWQAIcQ4qqz8PgeHl3zPXa3i465UfTObOdp83IXM670LwS5j/Ojfhz7c11SJUUIIa4BPcNasWLSU8zoONBzzKm4+feuX7ll6cecKKlKSlpZbSUtcysW+yZQWTxtudqOzNf9nS0zn8e0+qMreg1CCCEalwQ4hBBXlXlHd/Dkurm4FDedclvQIzva0+brzmN86Z/xdmXwefkQsl3+TJgwgalTpzbijIUQQlwq3lo9/+w/kTk3PURz36oy4Lvz0rhp0Sx+OrbLc2zatGlMmDABm72Q9OzF2BynPG02tT/LfV5i+bwNZM/+P3KzM6WUrBBCXAckB0cTIjk4xLXu28NbeSFxASjQObclXXNae9r8XVmMLf0LAf5afB+eR7EuVKqkCCHENazEXs7ft/7Cj2cENQBuadud1wZMxl/vBVCt2srJ1HIW/LgXh7OqfwvHTtpbvuNna2fUxhApJSuEENewmqmphRCiEXx+cBN/37oYFOia04rOua08bf6uDMaV/gX/AAMtn1+FvlkskY04VyGEEJefv96LmUPuYGSLOJ5PnE+xvRyABcf3sDP3FO8Pm0av8FaEhYV5gt1hYRDVIoCvP99KQaENgHRdL0zGlkzV/JcNGj0JCQmoVCopJSuEENcg2aIihGh0nxxY7wludM9uUy24EeBKY3zpS7iVcnwf+Rl9M6mUIoQQ15Px0V35ddLT9I1o4zl2ylzIlKUfM2vPKlxud7X+zZr789Szw4mJ8fccM2vCWe37F3ooFvqF2UlMTJTtKkIIcQ2SAIcQolF9fnAT/9y+FICuOa3plNfC0xbkOsG40pdQVA6+sA2jWBPYSLMUQgjRmKKMgcy7+WGe6TEKtUoFgEtx89bu35i64jNyLCXV+nt76xgyIhxTyU5QKgIgbpWOLT6PEKiJJc5ygMLCwit+HUIIIS4vCXAIIRrNt4e2VqzcAOJzWtA5t6WnLdiZytjSv6JSOflRPw67sZmUghVCiOuYVq3hD91H8fOY39HCGOg5viU7lZsWvcemzGPV+oeEhKCo07E4tqLB6jmeYrgBZ/BUHGs+QTmr/KwQQoimTQIcQohGMe/oDl7YvACAuLzmdMtp42kLcp1grPmvqLDzk34sh3LLpRSsEEIIAPpEtGHFxN8zMbqr51h+uZlpKz5n5p6Vni0rlaVkM7OSKbEloiPf079A2555yT3Z8faTuG2WGs8hhBCiaZIAhxDiiluQsodnNv4MQPuCSHpmtfW0BbgyGFP6N1RKObNtg8l2+UkpWCGEENUEGLz577DpvDngFvRqDQAKCu/sXsm9v31JQbkZqCola3eYOZ79Ky77Ic85ytWB/JQ5mmUvP0tOSpKUkRVCiGuAlIltQqRMrLgWLDmxn/9b+wMuxU10YTgD0jt42vxc2YwvfRGjzorxoTmUBLSXUrBCCCHqtT8/g0fXfsfJ0qqcGpE+/nw4/E5PYtIzS8mmHjax4OeDuNB4+re1reSg6RhW32ZSRlYIIZowWcEhhLhiVqcf5vHTwY1WplD6pcd42nzdeYw1/xVviol6eiHN+o4jNjZWghtCCCHq1SU0imUTn2Js686eY9mWEm5f9ikf7V+HW3ETFhbm+ZvSd3AMv3tyEL66ck//44ZRtAoZRht1CQkJCcydO7cxLkUIIcRF0jb2BBoqLy+PTZs2ceDAAfbv309ycjI2m42+ffvyzTffnPf5FEVh9+7drF69mp07d3L8+HHMZjN+fn506tSJyZMnM2HCBFSnM3WfLTa2/lKVoaGhbNq06bznJcS1amfuSR5Z/S1OxU1kaSADT3VATcXvl7e7kLGlf8XXnccCzSgeCuuK3DcTQgjRUP56Lz654S6+SE7k1e1LcbhduBQ3r+1Yxo7ck7w75A789F6e/m3ahnLP7/rz5btLsGmjAMjVdsRXHcrA8F9JTExk/PjxEmQXQogmpsms4FiyZAnPP/8833zzDXv27MFms13U+bZs2cL06dP57LPP2LVrF35+fsTGxqIoCps2beK5557j0UcfxW6313uezp0707NnzxpfXbt2rXecENeTI6Yc7v1tNuUuByEWI0NPdkR9+uXHy13M2NK/EeDOYmPgWPZZgqR0nxBCiPOmUql4sNMgfh77O6J8Az3HV5w6yISE/5JSXD2/hsNZxrH89Ripqr5Spg6j0GsKMa4S+VskxHXilVdeITY2lp07dzb2VABYsWIFsbGxfPDBB409lSapyazgMBqNDBw4kC5dutClSxcOHjzIhx9+eMHnUxSFFi1acN999zFu3DhCQkI8bQsXLuSvf/0ra9euZdasWTz33HN1nmfWrFm0aNHiguchxLUuw2zirhVfUGy34lfuzfDUeLTuin3PWsXKTeZXCHKnsStoFLtsLTAaHVIOVgghxAXrGdaK5ZOe4vfr57I6/TAAx4rzGLf4A94bOpXRrToBEBwcjNHoQ7btCFG+Vkoc8SgqNU6VNwX+d3J40SJinnkGtUZT39MJIZqwlJQU5s6dy+DBg+nVq1e1tvnz5/PnP/+5xhiNRoOfnx8dOnRg4sSJTJkyBU0trxMbN25kzZo1HDhwgKysLIqKitBoNERFRTFw4EBmzJhB8+bNa4wbPXo0sbGxfP7559xxxx2Eh4dfugu+DjSZFRy33XYbX375JX/84x+58cYbqwUkLkTXrl1Zvnw59957b41zTZ48mccffxyAn376CffpcmNCiPNTWF7GXb9+TpalGG+HnhtS4zG4dACoFQejzG8Q5jrGAd++rLe1Izs7W8rBCiGEuGhBBh9mj7qP33cb4Tlmdth4YNXXvL37N09ejgEDBpCdnU1GWRq+2h1oFSsAikrDxqxO/PDqezht5eTl5UmVFSGuQW+//TZOp5PHHnuszj56vb7aSv24uDgAtm3bxl/+8hcefvhhnE5njXHff/893377LQcOHECtVtOhQwdCQkJITU3l66+/Zty4cSQmJtYYp1Kp+L//+z8sFgvvv//+pbvY60STWcFxqRmNxnrbhw4dysyZMzGZTBQWFhIaGnqFZibEtcHisHPfytkcK85D59JwQ2o8RkfV/udhZbNo4dxLkqodPxW2xtfokHKwQgghLhm1Ss1zPUfTJSSKpzfMw+yo2N787p5VHCjIYNaQqUybNg2VSkViYiLJGUeJ9MsnwKc/FlXFSsK9phiyn/8vKeZkisrKMBqNUmVFiGtEWloaa9asoU2bNvTu3bvOfmFhYfzwww/VjrndbhYtWsSLL77Ipk2b+PHHH5k+fXq1PuPGjePOO++kd+/eeHlVvQdOS0vjxRdfZNu2bfzxj39kzZo1eHt7Vxs7cuRIAgMDWbRoEc8++ywBAQGX4IqvD9dtgONcysurMmuf+Q/ybB9++CG5ubm4XC4iIiLo378/Y8eORa/XX4lpCnFVcrpdPLb2e3bnpaF2qxh2ohOB5b6e9v6Wz2jn2IBP15sZdOdndCoulXKwQgghLoubW8ezOOBxHlr9jScPx8q0Q4xP+C+fj7yHGTNmMH78eE8ZWZ2i4vO3F5LjiAQgRxVLMx9fwoNTyTWXkpCQgEqlYsaMGY15WUKIizRnzhwURWHixInnPVatVnPLLbewZs0aVqxYQWJiYq0Bjtq0bNmSmTNnMmjQIIqKiti2bRvDhg2r1ken0zFmzBh++OEHFixYwP3333/ec7xeNZktKlfakiVLAIiLi6t3tcfPP//Mhg0bSExMZMGCBTz//PPcfPPNJCUlNeh55syZw5QpUxr0lZKSckmuTYjLSVEU/r51MavSD4EC/dNjCC+rijp3s/5IZ1sCWapQ9FP/S3hkcykHK4QQ4rKKCQwnYfzjjG7Z0XMstSSfiQkfsirtULUysoHhoTz+9ztp65Pq6VuqaYHb1pWW/iFERkaSmJgo21WEOE+xsbH1VqJ8//33iY2NrbYtY9asWcTGxvL000/XOU5RFEaMGEFsbCyrV69u8HwqP++NHDmywWPOFhVVUYXJ4XCc17jQ0FACAwOB6jfWz1Q5r4SEhAue3/VIVnDU4sCBA8yZMweARx55pNY+I0eOZNKkScTFxREZGUlZWRmbN29m5syZpKWl8cADD7Bw4UKaNWtW73Pl5eU1OBgiRFPw+cFNfHVoCwBdclrRxlSVGCnGtore5d9i1vjzrWUAz5ptSNokIYQQV4Kf3ov/jbyHWXtX887ulUBFXo4Zq77ir33G8lCnwahUFeXLvXx9GH73SEre/Yx8n4oPGeXqABzlPWjmvZuDRccoLCyU4LxoELvdhcvV9HL6aTRq9PrGTbI7ceJEPvzwQ9asWYPZbK71xvOOHTvIyMggKCiIIUOGNOi8aWlpZGVl4e3tTUxMzAXPb//+/QBER0ef17iUlBRMJhNqtZpOnTrV2qdr166oVCoOHjxY57WLmiTAcZb8/HyefPJJnE4nN954Y51Li86u4GIwGBg3bhwDBgzg1ltvJTMzkw8++IDXXnut3ucLCwsjPj6+QXNLSUmpM8InxNVg+ckkXt5WEQ2PLgynS24rT1tzx16GWP6LQ2Vgge4mMPpJtRQhhBBXlFql5g/dR9E5uDlPrJtDmdOOW1F4edsSDhfl8PqAyeg1FW+PQ0LDOOoqpWN5AjmGm1FUWlwqPWZXH6IDpOKXaJhfFiSxaUMqitLYMzl/KhUMGhLNxFsa9lnlcoiOjqZLly7s37+fFStWcOutt9bo88svvwAwZswYdDpdg867a9cuoGK1fm0VUOpjs9lIT0/nq6++Yvv27fj7+3P33Xefc5yiKBQWFrJz507efvttAB544AFatmxZa/+AgABat27NiRMn2L17d4ODN9c7CXCcobS0lIcffpjMzEzi4+N58803z/scwcHBPPLII/zjH/9g5cqVvPrqq567AbWZNm0a06ZNa9C5p0yZIqs9xFVrb346T6ybg4JCuDmAfhntPW2BrjRGlv0LcJOgH0VSrp0JE6RaihBCiMZxY6tOLBz3f8xYNZt0swmAOUd3kFpSwGcj7ibYy7eiysrAgSQkJDAwfAEmw1jsat+KUrLeg9m6fBfj7h5d7/s8IRI3nmiSwQ0ARamYf2MGOAAmTZrE/v37Wbx4cY0Ah91uZ8WKFZ5+DZWRkQHQoBKsGRkZdW6tGTduHE8++aRnq0ptVq5c6anQWalt27a8/fbbTJgwod7nDg8P58SJE2RmZp5znqKC5OA4raysjIceeoiDBw8SExPD559/fsHLgHr06AGAyWTCZDJdwlkKcXXKMJuYsfIryl0O/Mu9GXqyI2ql4uXFy23iJvMrGJQyEhw9SXFHSLUUIYQQja5jcCQJ45+gT3hrz7GtOalMSPgvR0w5QMWNqAkTJnDYpUdbNAcfd4Gn7/pdDuZ8tASXyy1lZEWdBg5uQ1ONganVKgYObtPY02DcuHFotVq2bt1KTk5OtbZ169ZRXFxM69at6d69e4PPWVhYCODJg1Gfs8vEdu/encjISFQqFatXr+aHH36otUxspcDAQHr27EmPHj1o3rw5arWaEydO8Msvv5CVlVXvc1dWTykoKKi3n6giKzgAq9XK7373O/bs2UObNm348ssvCQoKuuDznbk0yuVyXYopCnHVsjjszFj1FbnWUvROLcNSO6F3Vby0aBQbo82v4efOxTD8cSYMeJz7pFqKEEKIq0Sot5E5Nz/MC4nz+fFYxZL1k6WFTEz4kI+G38kNLWKrVVlRTuxl/tI0TOqKJeW7j8KJF7/keOF2zOZiKSMraph4Szw3j4uTHBwXITg4mEGDBrFu3ToSEhJ48MEHPW2V21POtRLibHa7HaBBlS9rKxMLcPToUZ577jm++uoriouL+de//lXr+N69e1cbn5aWxptvvsnKlSuZOnUqS5Yswc/Pr9axBoMBqNgWIxrmul/BYbPZeOyxx9i+fTtRUVHMnj37oj98HT16FKj4B9mQqKAQTZWiKPxx448cLMxCpcDgU3H4OarqeA8vm0m46wjG3lNode+7Ui1FCCHEVceg0fKfwbfzUu8xqKi41W522Lh/5Vd8e3grgKfKStxNd/DIA52IdB/2jC+yRxDh3Ys2bWLQ6XQkJCQwd+7cRrkWcXXS6zV4e+ua3NfVENyoVLn9ZPHixZ5jpaWlrF27FuC8S71WfkYrKSm54DnFxMR4UhosWrSIw4cPn2NEhZYtW/Lee+/Rvn17cnJy+Pbbb+vsW1xcDHBRN9+vN9d1gMPhcPDkk0+yefNmIiIi+Oqrr85Z9eRcnE4nX375JQD9+/dHq5VFMuLa9cG+tSScqMge3SMrmkhzoKetj+Vroh2byVaFoL3lbVTq6/rlRgghxFVMpVLxWJdhfD7yHny1FXd0XYqbFxIX8K+dK1DOSKIQ2m0YDz85nDbuHZ5jdk0ztOUxhIa2kDKyQpyDUkdSEovFUueYkSNH4uvrS3JyMseOHQNg+fLl2O12unfvTuvWrescW5uQkBCgKoBwoeLi4vD19UVRFPbt29fgcRqNhqFDhwLUm2OxMt2BJDVuuGv+E8f06dMZMWIEs2fPrnbc5XLxzDPPsG7dOsLCwvjqq6/qzGB7trfffpsFCxZgNpurHc/KyuKpp55iz549aLXaGslkhLiW/HbqIP/e9SsAbQvDicuvSq7Uzr6Orrafsap9+a58AEVmqf4jhBDi6je6VSfmj32UCB9/z7H3963hyfVzsbmq9tj7te/FDbf3oV35Cs8xG0G4StoS4N8Ms9ns2eMvhKhQuW0rPz+/1vYTJ07UOdbLy4vRo0cDFasloGp7yvmu3gA8pVkrgyUXSlEUT8CmqKjovMZW5u2oK3+H2+3m+PHjAA2uuimaUA6OrKwsJk+e7HlcuW9q165d9OvXz3P8oYce4uGHH/Y8zsnJISMjg9LS0mrnW7ZsmSfjrl6v58UXX6zzuf/6179Wq098/PhxPvvsM1566SVatmxJQEAApaWlpKamoigKBoOBV199lW7dul3UNQtxtTpqyuXJ9XNRUAgp86PvGRVTQpzHGFL2AW7U/KIbhVsTIlFnIYQQTUZ8SHMWj/s/7vntSw6fTja68Pgesi3F/G/EPQQaKj6khcb25YjjG7op8zjgfQcADpURTXksAX7F8rdPiLO0bt2a5ORk9uzZw4033litLS0tjY0bN9Y7ftKkSSxYsICEhASmT5/O9u3b0el0jBkz5rzn0q1bNwwGA+np6RQWFl7w72tycrJn5UmrVq0aPM5ut3u215z5OfNMKSkplJWVERISQrt27S5oftejJrOCw+VyeaqSmEwmzz8kp9NZ7Xh5ecPuFFcGSKCi9M+uXbvq/Do7ODJ9+nSmTp1KXFwcZWVlHDx4kOzsbGJiYrjvvvtISEi4oEiiEE1Bsc3KA6u+xuyw4e3Q16iYcqP5DbTYWaMfzO48GDhQysEKIYRoWpobA1kw7jEGN6sK4G/JTuWWJR+TVlqxMiMsLIz4gaNZnZdHT8v/UCkVieVdKh+CfAdiOn0zVyqsCFFh+PDhAMycOZP09HTP8VOnTvH000/XuXWlUr9+/YiIiCAzM5OXX34ZRVEYPHjwBQUn9Hq95yb5rl27zns8wOHDh3nhhRcACA0NZciQIZ6248eP8+9//7vWFSInTpzgscce49SpU/j4+HDHHXfUev7t27cDMHjw4Aua3/WqyazgaNGiRYMTt5xp9erVtR6fMmUKU6ZMuaC5DBkypNo/YCGuF27FzRPr5pBako/arWLIiY54Oyv2KqsVB6PMb2JU8tnqas9upT0TJgyUcrBCCCGaJH+9F1/feD/Pn1Fh5WhxLhOXfMjsUffTLbQF06ZNQ6VSsWXTSgaa/8su42O4VTpc6Pni40QiW5Zy4OA6zGazVFgR170HHniAX375hZSUFG6++Waio6Nxu92kpKQQExPDXXfdVSOtwJnUajXjxo3jiy++uODkome64447WL9+PYsXL2bUqFF19svLy2P69Omex263m+zsbHJyclAUBaPRyMyZM/H19fX0sdlsfP7553z++ecEBgYSFRWFVqslPz+fjIwMoKIE7MyZM4mMjKz1eRMSEjzzFA3XZAIcQojGN2vvatZkVAQae2e2I9RaVdJqoOVTIl3JaNsOoO9tH3NzWISs3BBCCNGk6U9XWGlhDGLmnlUA5FnN3LbsEz694W5PGdm88eMpTDtK2Jy3+NV+Ny6VAZeiIeOkH9761oRFWzCZTCQkJKBSqZgxY0YjX5kQV56/vz8//PAD7777LuvXryc1NZWIiAgefPBBHn/8cT7//PNznmPSpEl88cUXABiNRkaOHHnB87nhhhsIDw9nzZo1lJaW1lmq1W6311jl4ePjQ4cOHRg8eDD33XcfERER1dpbtWrF3//+d7Zu3cqhQ4c4deoUVqsVo9FIjx49GDJkCNOmTfMkOz1beno6u3btIiYmht69e1/wNV6PVMq51gKJq8aUKVNISkoiPj6e+fPnN/Z0xHVmfcZR7vr1CxQUogvDGZDewdMWZ1vGYMvHFGOk1d+3EBHdsRFnKoQQQlx6c4/u4PlN83EqbgC0KjX/GXI7U9r18PRxleaz/Y2HSCibhl1t9BzXeZ1EZ8gjNzcXh8PB66+/LjcBhLgKfPfdd7zyyis888wzPPLII409HY9XX32Vb775hnffffeCcoxcz5pMDg4hROPJLCvmiXVzUFAItPrSN6Mq0VG48xADLP/DhYYf7AMw2eVlRQghxLVnakxvvr5xhqeMrFNx89T6ufwvqSoxosYvlD4vfsFYw5d4uU2e447y1jjKIwkMDJQKK0JcRaZOnUrbtm35/PPPa1TIbCw5OTnMmzePHj16SHDjAsgnESFEvRxuF4+t+Y5CWxk6l4ahJ+PQKBoAvNzFjDC/hQYna/SDKPVtKVnjhRBCXLOGRsUwb8wjhHhV7bX/x7YE3ty53JMgUWMMpt0T/6Wv+d8YXbmefg5bCyylYRiNRvlbKcRVQqvV8sYbb3D33Xd7cmM0toyMDB5++GFefvnlxp5KkyQ5OIQQ9Xp9xzJ25p0CBfqndcBo965oUNwML/sPRiWfJE0HVuYHMmGCVEwRQghxbesW2oIFYx/lzl8/J91sAuCDfWvJt5p5c+AtaNUaIlq1p6DfI/TY+Cb7Av9IsaYFAHptDM2imxMaGtqIVyCEOFP37t3p3r17Y0/Do2fPnvTs2bOxp9FkyQoOIUSdlpzYz2enl97G5UfRsqQqEVLP8jm0cO4h2x3Ar6r+TJgwUSqmCCGEuC60DQhj4bj/IzawKrHgnKM7+N2a77A6HQDcfvcDFA35Az3N7xLoOuXpV5Dny+KFB1EURUrICiHEJSZJRpsQSTIqrqSTpQXcvOg9Sh02wsr8GZnSBTUqAFo4dnGT+RVUXkaU++YR3L6HrNwQQghx3THZLMxY+RXbc096jvWLiObLUffhr/cCIDctlcwP72G5eSqF2mhPv8BgC6mnfpMSskIIcQnJCg4hRA0Ot4sn1s2h1GFD79Qy6GQHT3DD153H8LL/oEKh+cOziR0wWoIbQgghrkuBBh++v+lBRrWM8xzbmpPKtOWfUVReBkB4y2i6/HUJtwT/TIjzmKefqdAHo1cP2rSJRqfTkZCQwNy5c6/4NQghxLVEAhxCiBr+s3slu/PSQIF+6TH4OCvuQqkUJyPN/8ZLKWWbujPWVoMaeaZCCCFE4/LW6vnfiHu4o30vz7F9BRnctuxTci2lAGh8Amj/pwXcEvQTYc7Dnn46bStwdSAsLJzIyEgSExNlu4oQQlwECXAIIarZlHmMD/atBSCmILJa3o0+1m8Jdx0hT9eMZdY4KXMnhBBCAFq1hncG38aDnaoC/4dNOdy67BMyTici1fgG0e5Pi7jZ8A0RzoOefi5HKHZrNAEBUkJWCCEulgQ4hBAeheVlPLV+LgoKAVYfemW19bRFOXbTxbYQu8rAYs1wfIz+UuZOCCGEOE2lUvGPvuN5qusNnmOpJflMWfoxqSX5AGiMIYQ//j19St8l0rHf08/lCKG8rLWUkBVCiIskAQ4hBACKovDMxp/IsZaicasZnBaHWql4ifBymxhW9i4qFH7TDeFIroWBA6UkrBBCCHEmlUrFn3rdxAu9bvIcyygzcdvSTzhiygEgIroTJ/s/R8/i/9DcscfTT6eJok2LmwgJkRKyQghxoSTAIYQAYHbyZn5LSwagZ2Y0AeVVWdyHl72Lj2Jih6stB5VWTJgwQUrCCiGEEHV4ousNvNxvgudxjrWU25Z+yv78DABuvfd3ZAx6kb7m94hy7Pb0KzZ58dPcfbjdUkJWCCEuhJSJbUKkTKy4XI6Zcrnpl/ewuZy0KA5h6MmOnrYu5QvoZ52NOiIW1z3fExwRJSs3hBBCiAb44ch2/rRpPgoVb7f99V58c+MMeoW3BiDn6B7y37+FX90Pk6Xr6hkXEGTlRNqvUkJWCCHOk6zgEOI653S7+P2GedhcTrwcOvqlt/e0hTmP0Nv6LS61jpZP/Uhs5+4S3BBCCCEaaHqHPrw/bCoaVcVb7hJ7OdNXfM7W7FQAImK6E/Pir4xRf0qk44BnXHGRN0bv7lJCVgghzpMEOIS4zn2wby1789M9JWENLh0AWqWc4WX/QYOTVfShRB/eyDMVQgghmp7Jbbvz6Q13oVdrALA47dzz25dsyT4OgD4yhujnfuFm9/vVqqvoNK1RudtJCVkhhDgPEuAQ4jq2Pz+Dd/esAqBdYQRRpVWZ2/tZviTAnUWaoR2brFFStk4IIYS4QDe1jufLUfdh0GiBiiDHvb/N9gQ5DC27Ev3Hnxld/hbhzkOecU57BI7yFlJCVgghGkgCHEJcp8qdDn6/YS5OxY3R5lWtJGwLxw7i7MspV/uwTD0Qo9FPytYJIYQQF2FYVAe+HFl3kMO7fX9CZnzCqNJ/Euo86hnntEdiNUdICVkhhGgACXAIcZ16a9evHDHlolKgf1oMWnfF0lmDu4ShZR+gAn7TDuZ4TomUhBVCCCEugaFRMcw+ayXHPb99yebTQY7mA6dwotN9jC79ByHOFM84vbYdHdqPJCwsTKqrCCFEPaSKShMiVVTEpbIl+zi3L/sMBYVOuS3ont3G0zbC/C/aOhLZ5YpmldcNDBw4kKlTp0rmdiGEEOIS2ZB5lPtXfoXN5QTAW6vj6xtnMCCyLRaLhdXvPU2rw/NYYnyVIm0bz7iI5qUcOrJaqqsIIUQdZAWHENcZi8POMxt/QkEh0OpL1+xWnrZ2trW0dSRi0QfT47l5vP7668yYMUPeOAkhhBCX0JDmMXw16n68NBWJva1OB/f+9iWJWSn4+Pgw/oVPCZr8ImPMf8ffleEZl5Pph7ehNdHRUl1FCCFqIwEOIa4zb+3+lZOlhagUFQPSYlCffhnwcecz0PopCrDQ1Z/gZi1lW4oQQghxmQxu3p6vRt1XLchx38rZnu0qLSf9iVa3PsfY0r/h667ajuKl64ZaFU54uFRXEUKIs0mAQ4jryM7cU/wvaRMAnXKjCCo3etqGlr2HQSljv7E/hy1GydQuhBBCXGaDagty/DabnbknAQga9zwtRt3J2NK/4eU2nR6lwm5pi8vhT2CgVFcRQogzSYBDiOuEzeXkuU0VW1P8y73pklu1NSXWtoIWzr2YdGGsc3WWTO1CCCHEFTKoeXu+urFqu0pl4tH9+RmoVCrCpr9DaNe+jDH/Hb3bfHqUGpulHSXFKvmbLYQQZ5AAhxDXiff3ramqmpLeAbVStTWln2U2blQsVQ8hIydPqqYIIYQQV9CgZu34YuS96NUVFc1K7OVM//VzDhVlo1Kraf3496j9vLnJ/ApaxXp6lAaDtic9ewyVv9lCCHGaBDiEuA4cLMzig71rAIjNb06oxc/TNrjsQ/RY2OiMJcMdyIQJE5g6dWpjTVUIIYS4Lg2NiuGTG+5Cq6p4e26yWZi+4n+kFOeh1hmI/9sqfL2t3Gh+HbXiAECjNpCTGU5urlnKxwohBFImtkmRMrHiQjjdLiYt+Yi9+ekYbV6MO9IDjVJxh6i9bQ3DLe+iCmuP+/4fCQ5vJneBhBBCiEaUkLqP/1v3A+7Tb9EjffyZP/ZRWvkF4yzO4cQrA0ktCWel7wsoqoq/51qdi3zTSkpL86V8rBDiuiYrOIS4xn1+cBN789NBgX7pMZ7ghpfbRH/r57gV2NPiDmLju0pwQwghhGhk46O7MnPIHahQAZBtKWHq8s/INJvQBkTQ6vlfaet9gmGWWZ4xTocGP++BtGnTXsrHCiGuaxLgEOIalmE28c7ulQC0K4wgoizA0zbI8gleSim7dF359UC2LGkVQgghrhK3tuvBGwMnex6nmYuYuuJ/5FpK0Ye3I+qZpXRQ76K/5TNPH43aD8XRibCwCCkfK4S4bkmAQ4hr2N+2/oLFacfLoaNndrTneBt7ItGOREq0wSSHjZISc0IIIcRV5u7Yfvyj73jP49SSfKav+B+F5WV4te5B86fmE+9YTjfrj54+bpcfdktbAgKkfKwQ4vokAQ4hrlEr05JZceogAD2zotG5tADolDIGWj5FAbaETqSguExKzAkhhBBXoYfiB/NCr5s9jw+bcrjnty8xO2z4dBqBcdr79C7/lg62lZ4+LmcQ5WUt5G+7EOK6JAEOIa5BVqedv2xZBEBkaSBtTOGetj7Wb/BRijjs04ODJQays7OlLKwQQghxlXqi63B+322E5/He/HQeWvUNNpeTqNGPcLLNZAZb/ktL+zZPH52mFTFtRxEWFibVVYQQ1xVtY09ACHHpvbtnNelmE2q3ij4Z7TzHw5xHiLOtwIw384taozM6pCysEEIIcZV7tseNlNrL+SI5EYCNWcd4ct0cPhp+J4Oe+5qd/xzHyOy3WKr+J7naOADyc315560fOHRkNWazWaqrCCGuCxLgEOIac8SUwycH1gMQn9sSP7s3ACrFxWDLh6hxE3H3LP7ccjDBwcGyckMIIYS4yqlUKv7RbzxFNgsLju8BYOnJA7yweQH/HjiFIa/+Ruq/xzD66D9J8HsTk6YlANkZRrwMLQkLK8dkMpGQkIBKpWLGjBmNeDVCCHH5yBYVIa4hiqLw58SFOBU3/uXexOe28LTF2xYT4kolRdUSXdcJxMbGSnBDCCGEaCLUKjX/GXI7I1vEeY79cGQ7b+5cgUqro/Uf5uPfoi03l/4DX3c+UBEY8dZ1R6MOJjw8XKqrCCGueRLgEOIa8tOxXWzNSQUF+mS0R336V9zXnUcv6w84VDp+Ke9KUVFRI89UCCGEEOdLp9bw8Q130ie8tefYf/ev5eP969F4+xP1h8UEBhq4ufQfGNylp3uosVna43YZCAyU6ipCiGubBDiEuEaU2st5fecyAKJN4USUBXjaBlo+RUc5m7W9cBojJKu6EEII0UR5a/XMHnU/HYMiPcde3bGUOUe2owtuQdQfFhOkK+JG82uoFUdFB0WLzRKDyWSR6ipCiGuaBDiEuEa8u3c1eVYzOpeGHlnRnuOt7Vto7dhGriqE5QVhUjFFCCGEaOICDN58N/pBWvuFeI79KXE+y04ewNCqG1FPzCPCdZhhZbM87YrbCy1d6d9f3gcIIa5dEuAQ4hpwvDiPLw5uAqBzTiu8nDoANIqNAZbPcCuwQj2QcRMmScUUIYQQ4hoQ7uPH9zc9QLi3HwBuReGJdXPYmp2Kb5ebCL5rFu0cG+hj+dozxssQjlrphNutSPlYIcQ1SaqoCHEN+Me2BBxuF/7l3sTmN/Mc717+I0YlH6XXdJ6aPlPu2AghhBDXkNZ+IXw7+gFuX/YJxfZybC4nD6z6moXjHiPmxv9DVZxB14Q3KdWEc8hwMwDJSXn8640fOX7iNykfK4S45sgKDiGauFVph1idfhgU6JXZ1pNY1M+VTZfyhTh0Rto/8J4EN4QQQohrUKfgZnw56n4Mmor7lsV2K3f/+gXZlhJCpvwTv16TGWj5hBaOnZ4xRfk++BjaEx0djU6nIyEhgblz5zbWJQghxCUjAQ4hmjC7y8nL2xIAaFESTDNzkKetn/ULtDhY5e5GodXVWFMUQgghxGXWN6IN7w2digoVABllJu79f/buO0zK6vz/+HtmdmbbbO+FLZSlLL03UbCRCLYYQZOoxBaNJTHNoPFnjC3fGI3diAJKVDAqFqxBxAICSmdZ+tIWtsCydXb68/tjYRYElLJtdj+v6/IKz3nOPHsmh2HP3nvOff9vBrVeN6k3vEx4dj/G1f6DBO+2wGtCrb0wm5JUPlZE2hUFOESC2IzCxWyr3ofFb2bgns6B9gzPSrI9Sym3prHEka5ycCIiIu3cBTl9uHfYhMD1+oq93PDZf/CGhJJ++9uEx8RwXu3fiPTvO9jDhNvRGZ83QuVjRaTdUIBDJEiV19fwr1WfAtCzPAO7JwwAk+FlhGMaAPPNw4m0R6kcnIiISAdwba9R3Nh7TOD6yz1b+MOiNwmJyyD99rlEWhycV3sfVsNxsIcFl6MbVZVOlY8VkXZBAQ6RIPXIiv9R43ER4Q4lvzwz0N7b9R6x/mLWWXqwutyvsrAiIiIdyF2Dx3NRbr/A9ZtbV/L3FR8T3nkoaddPJ8G3g7NrH8ZkeBs6GFZCTP0YPkzrBREJfgpwiAShTZWlvLb5GwD6783B4rcAEO4/wID6OdQbVj43DWDixIkqCysiItKBmE1mHj3jp4xIbTy6+tSahby8YQlRwyYRfcFUMr2rGeV4LnA/1JaAyd9T5WNFJOipTKxIEHrw2w/xGwYJDjs5VY2/bRlS/zI26nGP+xN/+fFv9ZsYERGRDijUEsIL437BpR88x8bKUgDuXvIOKeFRnHfZfRjlW+ix7HUqLZ1YF3YRABsK9/GPh19nS9F8lY8VkaClHRwiQWbR3q3M37UBDI5ILJrg3Uo392fs9UXzja+zghsiIiIdWExoOLPOnUJqRDQAfsPg15/PZvW+3aRcN53Q3CEMrZ9JJ8+3gdfsL48kPDRH5WNFJGgFTYCjvLyct99+m/vvv59JkybRt29funfvzi9+8YtTep5hGKxYsYJHHnmEK664gmHDhpGfn8/w4cP55S9/ybvvvothGN/7jLq6Oh577DHGjx9P3759GT58ODfeeCNLly49pTGJ/BC/4ef+bz4AoFNVAkmO6MC9YfUzMGGwKGIMi79eqq2lIiIiHVy6PZZZ5/6SKGsoAE6fh19++jJ73S4ybp+LLS6NsbWPEOfbEXhNmLUPFnO8yseKSFAKmgDH+++/z5/+9CdmzZrFqlWrcLlcp/W8JUuWcMUVVzBt2jRWrFhBVFQU3bt3xzAMFi1axB/+8Ad+9atf4Xa7j/n6iooKfvKTn/Dcc89RXFxMly5dCA0NZeHChVx99dW88sorpzU+kWN5e9tq1u4vxuw30b8kJ9Ce5V5Gunctu8LzqE3IV6k3ERERAaBnfCrTxv2CEFPDsr+svoar58+kPiKO9FvfJDTEz3m19xPmrzr4CjMuRxf8fpvKx4pI0AmaAIfdbmfkyJHceOONPPXUU9x8882n9TzDMMjMzOSuu+5i8eLFzJ8/n7feeoulS5fy97//HZvNxsKFC3n88ceP+fq77rqLoqIi8vPzmT9/PnPnzmXhwoXcd999GIbBAw88QGFh4WmNUeRwTq+Hvy//GIC8/WlEucMBMBk+htbPxI+ZVfHnUFlZqVJvIiIiEjA6vSsPjrw4cL3hQAk3L3yNkJyBpEx5jih/GefUPoTZ8DR0MKy46rpSWVmjNYWIBJWgCXBcdtllzJgxgzvuuINzzz2XhISE03pe3759+eijj7jqqquOetbFF1/Mr3/9awDeeOMN/H7/EffXr1/PggULMJvNPPbYY6SkpABgMpmYNGkSF110ET6fj2eeeea0xihyuBmFiymuq8TmDaF3WVagvYfrY2L9xRRGDmTrAR8lJSUqDSsiIiJHuDJvKDf1PjNw/VnxRu5dNo/oUVcRe97tpPoKGe14OnDf8Edg8vVkxIiRAKqsIiJBIWgCHE3NbrdjtVqPe3/MmDEAVFZWHrUt7+OPG36LPnz4cLKzs4967aGynJ9//jkOh6OphiwdWKXLwVNrPgOgd1knbL6GAkhWo46Bzteox8a7FZl4PB6VhhUREZFj+vPg8/lRdn7gembh10xfv4ikSf9HaPczyXN/Rl/nm4H7kRFZ7N0dytSpU7n33nuZOnUq06dP1/pWRNqsDhvg+CFOpzPw57CwsCPurVq1CoDBgwcf87V9+/bFZrPhcrl0TEWaxHPrvqDK7cTuCiNvX1qgvX/9G4Qb1RRl/Jg7732QBx98kClTpqicm4iIiBzFbDLzxJhJ9EvMDLTdu2weC/ZsIfOW1wlJzGFI/Syy3UsC96sORBMemqXKKiISFEJaewBt1fvvvw9Ajx49sNvtR9zbvn07AFlZWd99GQBWq5W0tDR27NhBUVERgwYNOu7XmT17Nq+//voJjWnr1q0n1E/alzJHDS+uXwRA39IszAfjknZfGfmu96gwxfJhaSyj4uN1LEVERES+V3iIjelnX8XEeU+zp64Kv2Fw08JXefuCX9Hl9rns/Nsozqp7jHfNf+dASA4AYda+hFg2kJxsA2Dx4sVMmDBB6w4RaXMU4DiGdevWMXv2bABuuOGGo+5XVTVkmY6JiTnuMw7dq66u/t6vVV5eTkFBwakOVTqAJ9d8Rr3XQ2x9JDmVyYH2Qc5XCMHDirizqd7roKKiQgsNERER+UEpEdHMPOcaLnn/Weq8bhxeN1f/7yXem/hrUq+bzt5nJnNu3YO8E/UILnM0YMFV15UweyGxsbEUFRVp3SEibZICHN+xb98+br31VrxeL+eeey4XXHDBUX0Olaj9vhweNltDhPvwoy7HkpSURH5+/vf2OWTr1q0/+DxpX3bXHuA/G5cC0K+kMd9LnG87XdxfUBqWzbr6BOx2rzKci4iIyAnrFZ/GM2ddyZRPX8JvGOx1VHHtpy/zxo9uJH7CnTDvYcbVPcJH9v+HYbJgGKG4HF2odnylyioi0mYpwHGYmpoarr/+evbs2UN+fj4PP/zwMfuFhoZSX1+Px+M57rPcbjdwdP6O75o8eTKTJ08+ofFdeuml2u3RwTy2aj4ev4+kumgyahoXEoPrX8GMnwXGQErKSpk4caJ+iyIiIiIn5exOPfjr0In8Zem7AKzet5s/LHqTJy75K66dq8lY8yFD62eyNOJaAPy+KLyuLEaOTta6Q0TaJCUZPaiuro7rrruO9evX061bN1588cWjcm8cEh0dDTQeVTmWQ/cO9RU5WVsqy/jvlhVgQL+9jbs3kr0byPIso8CXyW5/nKqmiIiIyCmb0mskV/cYHrh+e9sqni34itRfvUJIcld6u96lq+uzwP3Y6Hzyup5BeXm5SseKSJujHRxAfX09N954I6tWrSInJ4cZM2YQFxd33P45OTmUlpayY8eOY973eDzs2bMn0FfkVDyy8n/4DYP0mjiSHY35XobUv4TJbKHXDf9mdLdB+g2KiIiInJZ7h01kU2UZX5dsA+Dh5R/TPS6FM25/i533jWC04xkOWDqxP6QrAO/OLaSq7kuqqndht9sZMWIEkydPVhU3EWl1HX4Hh8vl4qabbuKbb74hIyODmTNn/uAPjP379wdg+fLlx7y/Zs0aPB4PoaGh9OzZs6mHLB3A2n3FzNu+tmH3RklOoD3T8y1p3vWUpIyi+8jxCm6IiIjIabOaLfx77M/IsjcchzUwuOXz2eyITCT1l9MIwc25tQ8R5q9suG+YsIcPJScnT6VjRaRN6dABDo/Hw6233srXX39NSkoKL730EmlpaT/4uvPPPx+ApUuXHnMXx6F/4MeMGUNkZGTTDlo6hH+s/ASAnMok4pyNf4eG1P8HDyG8VZ6uLaEiIiLSZOLDIpl+zlVEhjQkyq/1uJgy/2W8/ScSe97t2I19nF33d0yGFwCzKQzD05OkpBRSU1NZvHix1iYi0urafYDjiiuuYNy4ccycOfOIdp/Px+9+9zs+//xzkpKSeOmll+jUqdMJPTM/P5+xY8fi8/n47W9/S1lZGQCGYTBnzhzeeecdzGYzN910U1O/HekAVpXvYsHujZgME31KswLtXdyfk+ArotA+mNI6PxUVFa04ShEREWlvesSl8uSZkzFhAmBHzX5u+uxV4i57kPC80aR51zOi/oVAf7/PjsfZidjYWGpra7U2EZFWFzQ5OPbu3cvFF18cuD5UpWTFihUMGzYs0H7ddddx/fXXB65LS0spLi6mpqbmiOd9+OGHfPzxx0BDSdepU6ce92v/5S9/oVevXke0Pfjgg1xxxRUUFBRw9tln07VrVw4cOMDevXsxmUxMnTr1hMu/ihzuX6s/BaBzRTJR7nAATIaXgfWv4jKHs8jXA7vdrPJsIiIi0uTOy+rFHweex99XNKyTv9q7hb+t+IR7bp5N0d0D6Fn7IfssXdgUei4AXncyTs9elY4VkTYhaAIcPp+PysrKo9q9Xu8R7U6n84SedyhAAlBcXExxcfFx+343OAIQHx/Pm2++ybRp0/joo4/YsmULERERjBkzhmuvvZbhw4cf40ki32/1vt3M37UBs99EflnjjqI89wJi/CV8YR3OjtIDKgsrIiIizeaWvmdReGAv7xatAWB64WJ6xKdy8a2vs+uhsxnleI4DlmzKQ/IAsFny6TmgE0lJSZSXl1NRUUF8fLzWKiLS4kyGYRitPQg5MZdeeikFBQXk5+fz1ltvtfZwpBlMmf8S/9tVSJf9KQwr7gY07N64vPom/N5qXrRdzrBRY5g0aZIylYuIiEizqfe6ufSDf7N2f8MvAa1mC3PGX0/2sjlUvTmVWlMic6Mfw2WOBiA2NpSk9N0sW7aY2tpaVVcRkVbR7nNwiASLtfuK+d+uQsx+E70P273R3T2fKH8ZW1PP5W8P/R9TpkzRQkFERESaVXiIjRfH/YKkcDsAHr+PGxb8B+/YG7EPuQy7sY+xdY+A4QegstLFqm/rsVqt5ObmqrqKiLQKBThE2ohA7o0DKUR6wgAwGx76Od+g2mTnswqdaxUREZGWk26P5YVxv8BmtgCwz1nLrxa+QtzVz2FL60GmdzWDnK8G+kdGZBEX3Q+bzUZycrKqq4hIi1OAQ6QNKNi/h493rj9G7o1PifKXszZ6NNV19cpOLiIiIi1qUHI294+4KHC9snwX967+jLRb38AUZqe/8w2y3MsC9z2udHyeQ8dWVF1FRFqWAhwibcBjqw7fvREKNOze6F//X2pC4ljuzlR2chEREWkVV+YN5cq8oYHrVzYt483aGlKnPI8JgzMd/yLKt/fgXROu+lz8fhuVlZVav4hIi1KAQ6SVFVaU8NHOgqN2b3R3/Q+7sY/F5v7sKS1n5MiRykYuIiIireJvwy9kQFLjOuXur99hS+eRxIz7FaFGHefU/R2L4Wq4aVipq8qipKRM6xcRaVEKcIi0sqfXLgSgS0XqEbs3+jnfZJ8/irX+bCZOnMikSZNab5AiIiLSoYVaQvj32J+TGNaQdNR9MOmo+eK/Epo9gARfEaMdzwb6W8yxDB4wiUmTJlFeXs7GjRuVi0NEml1Iaw9ApCPbUbOfd4tWY/ab6FWeEWg/tHvD+uMHeODsa/WbDxEREWl16ZExPDv2SiZ/9AI+w89eRxU3LXqTl3/1Cnv+Ooxuzs8oDenOhtAfAVBZEc6/n32b9Rs+U+lYEWkR2sEh0or+ve5L/IZBdmVSoHKKyfDSz/kmpb4ovnUkKbghIiIibcaI1M78ZciPA9dLSor4x67NpPxyWsN9xwskeTcF7hfvDMdmi1XpWBFpEScd4Fi2bBlLly49ou2bb745qk1Evl95fQ1zNn+LyYD8ssxAezf3Z9iNfXwbPozFXy/Rdk4RERFpU67tNYpLOvcPXE8r+Ir5Cd2IOftmLHg5u/bvhPprADCbrdjDhmC1hql0rIg0u5MOcLzyyis88MADR7Tdf//9vPrqq8d5hYgcywsFi3D5vGRWJRDtbtimaTJ89HO+SZU1kfKEgSqtJiIiIm2OyWTi/0ZdSq/4tEDbHxa9yf7z7yA0eyB2Yx9jHI8H7hn+CNz1DQlKVTpWRJrTSQc4/vjHP7Jjxw7ef/99AD744AO2b9/On/70pyYfnEh7Ve128vKGr8HgiMopuZ7FxPj3UhAzisqqKpVWExERkTYpPMTGtHE/J8YWDoDT5+GGL94g6vqXMIdHk+35hj7OuYH+Pk8SXneCSseKSLM66QBHRkYG1157LU888QRut5vHH3+ca6+9lvT09OYYn0i79PKGJdR4XKTVxBHvtAfa+zn/S7Ullm/qkikpKVFpNREREWmzsqMSePqsKzBhAmB7zX7u3LSC5F++AMCQ+lkkezcE+rscndi/r17rGxFpNqeUZPSGG27A7XZz44034vF4uPHGG5t6XCLtVr3Xw4vrvzq4e6Mx90Yn9zISfDv4zNkVt9en0rAiIiLS5p2Vkcdv+o8LXH+wYx2vR6QQe84tmPExrvYfgXwcJlMIeZ0v4pJLLlPpWBFpFidcJnbcuHGYTKbAdVVVFUuWLCEiIoIf//jHR/T99NNPm26EIu3Mf7csp7y+lqS6aJIdMYH2/s43qLfGcu6tT3FNVo5+syEiIiJB4Tf9zmZ52U6+2LMZgPu/+YAB5/2axK1LoOhbxjge53/2uwFwuUJ4+omP2L7rE5WOFZEmd8IBjksuueSIAMd7773Hjh07SEpKYsKECc0yOJH2xuf38+91XwBH5t5I86whxbeRd2v7kLBmHf0HDWmtIYqIiIicFIvZzJNnTuL8d56gxFGN1/Dzqy/f5INfvojngdFkOxvycawNuwSAqgPhhIfmkJRUR2VlJfPmzcNkMjFlypRWficiEuxOOMBx6623Bv68detWnnvuOf76179y//3386Mf/YguXbo0ywBF2pOPd65nR00FcY5I0mvjAu39nW9Qb45kR/xQNi5ezIQJE7SDQ0RERIJGQpidZ8+6kp9++Dxew89eRxW/KVzGM1c/Q+m/f8GQ+lmUhvSkLKQHAGHW3oRYCklOtgGwWOsfEWkCp5SD48EHH2Ts2LFMmjSJsWPH8tBDDzX1uETapecLvgSgZ3lj7o0k7ybSvavZEDOcqLhElU4TERGRoDQkJYepg38UuP68eBMzwlOIHn11IB+H7WA+DrDgcnTBMMwqHSsiTeakAxzz589nyZIl3H777QDcdtttLF68WHk3RH7A8rKdfFu2g0h3KFlViYH2vs63cJvD2Bw1SKXTREREJKhdnz+a8Vn5get/rpzPlrNvw5rSDbuxjzMdjwfuGf5w3PWdtP4RkSZz0gGOOXPm8OMf/5iuXbsC0LVrVy688EJmz57d5IMTaU9eKPgKgO770jEfLKcW5dtLtmcp6yMHsWdflUrDioiISFAzmUz8c/RlZEclAGBg8Osl72G95nmwWMn2NOTjOMTnSaKmOoyRI0cCqLKKiJwWk2EYxsm8wOPxUFtbS1xcY/6AyspKIiIisNlsTT5AaXTppZdSUFBAfn4+b731VmsPR07CrpoKRr35DyweMxdvGIrVbwFgpOPfdHV9wqOuC7DYExg5ciSTJk1SFnEREREJagX793Dh+8/g8nkBGJqSw/Pmeipm/x4fIcyLeojykDwAzGY/6dklrF37jSqriMhpOekdHFar9YjgBkBsbKyCGyLfY3rhYvyGQdeK1EBwI9RfTTfXp+xJGsGf7n2IBx98kClTpugbuYiIiAS9/IR07ht2YeB6Wel2novPI7Lvj7DgZWzdP7EaDgD8fjObCy1YrTZyc3OxWq3MmzePOXPmtNbwRSRInVKSURE5cdVuJ69uXIbZb6L7vvRAe0/Xh1hw8/GBVOLj43UsRURERNqVK/OGcFmXgYHr5wq+ZPOPp2KJSSXaX8Iox3OBe+FhKcRG98Nms5GcnExqaiqLFy/WcRUROSkKcIg0s9c2LaPO6ya7MokIbygAZsNDL9f7bA/vwZ46k7KGi4iISLtjMpl4cMTF5MUmB9puW/EpoVc/CyYTXd2f0821IHDP60rD57UDqLKKiJySEw5wTJo0iUcffbQ5xyLS7nj9Pl5cvwgM6LkvI9Dezf0ZEUYVXxs9lTVcRERE2q0Iq41nzrqSUEsIABWuOu4oLSH2R38AYITjeaJ9ew72NuF2dMbwW1RZRUROyQkHOFavXq3EliIn6aMdBeypqyKtNpZYZ2SgvbfzHXaaM1hb5lPVFBEREWnXesSlHpGPY3HJNl7tciZhnYdio56xdf/EbHgAMAwbNZVpqiwnIqdER1REmtGMwsUA9Chv3L3Ryb2MOP9ulprymThxIpMmTWqt4YmIiIi0iCvzhnBhbt/A9aNrP2fvTx7EFGYnybeFwfX/CdwLsaQyeuRPGTdunMrGishJCWntAYi0V+sr9rC0dDsxzgjSahsrD/VxvUOlLYWfTX2WnJyc1hugiIiISAsxmUw8PPJSVu/bzY6aCvyGwc3rvua9y/+P2pdvpo/rHYqt/Sm2DgCgdI+dBx98nOrqvSobKyInTDs4RJrJzMIlAOTtSwu0JXi3keZdx0dVGXz22WetNTQRERGRFhdtC+PpM6/AarYAUOqo5s9eG5GDLsGEwZl1/yLcXwmAYZiwhw0hJ6eLysaKyAlTgEOkGRxwOXhr60qsXgu5Bxozh+e75uGwRFMWP1Clz0RERKTD6Z/UiT8PGh+4/rR4I58MvxpLbBoRRiVj6v4VuGcxR2Hy56psrIicMAU4RJrB65u/xenz0LUilRCj4bcUYf4qOru/YFP0EKLjElT6TERERDqk6/NHc3Zmj8D1feuX4Pjp3wHo5F1Jb+fbgXtedwo+T7TKxorICTmpAMf+/fsZN24ct9xyC8888wwLFy6krKysucYmEpR8fj8vb1iCyYC8/Y3HU7q7PgETbLEPUOkzERER6bBMJhOPnfFTUiOiAfD4ffxqbzER424CYEj9LOK82wP9XfU5VFbWae0kIj/opJOM7tmzh7179/Lpp58G2hISEujZsye9evUiPz+fXr16kZmZ2aQDFQkWnxVvZEdNBZnVCUR6wgAwGT56uT5gS3hvivfXUFJSwsSJE1X6TERERDqk+LBInjpzMpd/NA2/YbCjpoL/yxrCHRlf4C4uYGzdo7wd/U/8JisYNvB2Y8SISAA2btxIfHy81lEicpSTCnBERERwwQUXUFBQwObNm3G73QDs27ePr776iq+++irQNyoqKhD0OPRfly5dmnb0Im3QjMKvAeh+WHLRXM9iIo0KPtw3CG+MR+VhRUREpMMbntqZ3/Y/m3+unA/AWzsLOf/Hd9FtxjXEe3cwpP5llkZcC4A9Mod9ZfuZOnUqtbW1qqwiIsd0UgGO8PBw7rvvPgB8Ph+bN29m/fr1gf82bNiAw+EAoLq6mqVLl7Js2bIjXr9ixYomHL5I27KtqpzPizcRWx9BSl1soD3fOY9CdyKd+o/h+uuv128cRERERIDb+o7jqz1bWFq6HYDfFa3n/Ql/xvf2X+nteo9d1sHssfYDoGxvNDZrNLm5SVRWVjJv3jxMJhNTpkxpxXcgIm3JSR9ROcRisdCjRw969OjBpZdeCoBhGBQVFVFYWEhBQQHr16+nsLCQqqoqAOrr65tm1CJt1EsbDpaG3Z8eaEv0biHZt4HFUT+iqKiotYYmIiIi0uZYzGaeGDOZc9/5F9VuJ7UeF7+zZPJEj7NwbljImXWP82bMk7hNkZjNVqIihmC1biA5uaFK3eLFi5kwYYJ+eSQiwGkEOI7FZDLRuXNnOnfuzAUXXBBoLy4uDuzyEGmv6r1u/rtlOTZvCDkHGr/J5rvmUR2SQFV8H2q3b6eiokLfhEVEREQOyrDH8vCIS7j589cA+Hbfbt4beS3n71hJZP1+Rtc9zQL7HwHw++x4XWlYw/YSGxtLUVGR1lYiEtAiZWIzMjI499xzuf3221viy4m0iveK1lDtdtKlIuWw0rCVdHZ/ycbooVRWVSn7t4iIiMgxXNi5Hz/tOjBw/fdta6m9+K8AdPYsoqvrs8A9jysNnzdCVelE5CgtEuAQ6Qj+s3EZGNCtojG5aA/Xx3hNFpbVp1FSUsLIkSP1GwYRERGRY/jb8IvIjmoIVvgNg19V1xE25DIARjqeJ9JXdrCnmfqaLEpL92ltJSJHOOEAxyWXXELnzp2bcywiQWt9xV5WlO8krTYWu7uxNGwP1yd868mh3osqp4iIiIh8D7s1lCfPnIzF1PAjyu7aSp7odi6WmFRsODjL8RgYfgDMZjuD+v+UcePGsXHjRsrLy1tz6CLSRpxwDo6HHnqoOcchEtRe2bgUgK77G3dvdPJ8S6Sxn4E3zGRCz8H67YKIiIjIDxiYlMUd/c/mHyv/B8Ds4i2c96M7yZn9G9K86+nnfIvV4Q27Oiorwnn4oWlUVm1V2VgRAXREReS0OTxu3tq6kgi3jYzqxjOgPV0fst6TwoqtJQpuiIiIiJygW/qOZWhKTuD6tn37sIz4OQADna+R4NsWuBcZ1p+cnG5YrVbmzZvHnDlzWnq4ItKGKMAhcpreLVpNjcdFl4pUzJgAiPKVkOldxUb7IBYvXqxtkyIiIiInqKF07CSibQ3Hfms9Lqam9CMkIRsLXs6qfRSz4QbAbAoDXxeSk5NJTU3Vukukg1OAQ+Q0/WfjMkyGiS4VKYG2Hq6PqQ2Jozo+n9raWioqKlpxhCIiIiLBJdMex0MjLglcLzpQxpdn3gxAnH8Xg+tfCdzzeRLweuKIjY3Vukukg1OAQ+Q0FOzfw6p9u8iojifCGwqA2fCQ5/6UzVEDVRpWRERE5BRd1Lkfl3VpLB17T0UFntFTAOjtepcU7/rAPXd9FlWVDq27RDo4BThETsN/DiYX7bY/NdCW4/kam1HLMmeGSsOKiIiInIa/Db+QLHtDwMJn+PlNdBdCUrphxs+YusexGK6GjoYVw9eNESO07hLpyBTgEDlFDo+budtWYXeFkVYbF2jv6fqQNb5O1HgtKg0rIiIichqibGE8dsZPMR3Mc1ZYV8V7I68Fk5kYfwnD6mcE+tojsunZfQzl5eUqHSvSQZ1wmVgROdL729dS63HRf39OoC3Wt4tU73rirpzJuMHj9RsEERERkdM0LDWXG3ufwXPrvgDgHxX7OWPM9dg//zc9XR+x3TqCPdZ+ALzzVgEVNf+jpmafSseKdEDawSFyiuZs+Raz30TnA4cnF/2IPb4Ylu/1KLghIiIi0kT+MPA8esQ1Hgm+OTSVkMzemDAYU/cEVuoB8PvN2MMHkpOTq9KxIh1Q0OzgKC8vZ9GiRaxbt461a9dSWFiIy+Vi6NChzJo1q8WfOW7cOIqLi7+3z5o1awgNDT2lsUnbtr16P0tKiuhUnUCYzwqAxXDRzf0ZX4QPYtXXXzNh4kQFOURERESaQKglhCfGXM4F7z2Nx+9jt8vBrEFXcsXe/4fdt48RddP4IvI2AELMSVhMdSQn2wBYvHgxEyZM0LpMpAMImgDH+++/z0MPPdTmnpmXl4fdbj/mPZPJdFrPlrbrv1uWA9ClovE3CbnuxZjwUho/iNodxVRUVOgbqYiIiEgT6RWfzu8GnMvDyz8CYFrlAc4980YSFzxFN/enFFmHs8s2FAB3fSfMIdXExsZSVFSkdZlIBxE0AQ673c7IkSPp06cPffr0Yf369TzzzDOt/sy7776bYcOGndY4JLj4/H5e37ycCHcoabWxgfY893yK7H3ZV60SZSIiIiLN4abeY/h0VyHflO0A4FfmOOZm9ce3cxVnOJ7hjZCeuM1RgAW3I5dqx5dal4l0IEET4Ljsssu47LLLAtelpaVt8pnS/n21dwt7HVX0PtApkNE72reXNO865nt+SklZCRN1PEVERESkyVnMZh4743LOe+dxHF43FR4nz/S+mBuLC4jwHWCU4998Zv89AH5fFPV18fQfmERFRQWA1mci7ZySjIqcpNc3LwcDOlc0JhfNc89niyOSYle4SsOKiIiINKOc6ATuGXpB4HpOXR27R1wNQGfPl+S6vwrcS4wbwto1W7j33nuZOnUq06dPx+FwtPiYRaRlBM0OjrZq9uzZTJ8+HafTSWJiIoMHD2bixInHzcshwa3S5eCjnQWk1MZg94QBYDJ8dHMtYK6rE/1H9WfKlCmtPEoRERGR9u1neUP5385CPt29AYCbrQm8m5GPqbiAUY7n2Gvti9MUjclkIcY+mKTkjVRVVTJv3jxMJpPWayLtlAIcp+mDDz444nrevHk8/vjj/POf/2TUqFE/+PrZs2fz+uuvn9DX2rp16ymNUZrOO9tW4/J5j0gumulZgY1aqtIvZu+6dZSXl2v7o4iIiEgzMplM/GPUTzj77cc44HJQ6/fzWI8L+G3JRsJ8NYyqe4ZP7XcCYDEnYCZDVVVEOgAFOE7R0KFDGT58OH369CE9PR2Px8Py5ct54oknWL9+PTfddBOvvfYa+fn53/uc8vJyCgoKWmjUcrrmbP4WmzeETtUJgbbu7vnsiMwnMjqJMmXpFhEREWkRyRFRPDTyEn712SsAvOc1uGjIZDov+Q+5nq/JdS+iyNbwC0ePMxOLtUpVVUTaOQU4TtHDDz98xHV4eDhjx45lxIgRXHnllRQUFPCPf/yDmTNnfu9zkpKSfjAIcsjWrVtxOp2nOmQ5TYUVJazZX0xeZRoWoyF9TZi/kizPN/wv8WoqKyuVpVtERESkBU3I6cOlXQbw1taVAPwmLI13U7tDyUZGOP5NcUjfxqoq9TlU132l9ZpIO6YARxMLCwvjN7/5Dddffz1Lly6lqqqKmJiY4/afPHkykydPPqFnX3rppdrt0Yre2LoCDOhyWHLRbu7PqAyJp7AyhJJSVU8RERERaWn3DZvIoj1bKK2vodaAx3pO4Lelm4kwqhjpeJ6F9t8B4PdG46iN5syx3bVeE2mnVEWlGQwcOBAAv9/Prl27Wnk00hR8fj9vb1tFXH0kcc7GBLLdXf9jiTMDj9er6ikiIiIirSA2NIK/j7o0cP2e30zR4MsB6OL5giz3ssC91KSRjB9/EeXl5WzcuJHy8vIWH6+INB/t4GgGVqs18Gefz9eKI5GmsrhkK6WOagYd6BxoS/YWEmWUctYts/hZl176TYCIiIhIKzmnU08u6zKwYcctcFt4Ju8ld8VUtoVRjmcpsfXBTTh+v5nnn/2M3Xs/ora2FrvdzogRI5g8eTIRERGt/C5E5HRpB0cz2LRpU+DPqamp39NTgsVbW1di9pvIrmwMYuS5PmWtO4WVhdsU3BARERFpZfcOm0BKRDQAdSYT/+o1AUwmIo0KhtdNC/SrqwklPDSb3NxcrFYr8+bNY86cOa01bBFpQgpwNINp0xr+Ae3atSspKSk/0Fvaunqvm/eL1pJWE0eYr2F3jsVwk+tZzBb7ABYvXqztjSIiIiKtLDY0gv8b2XhU5V3DyvaBPwGgm/tTMj0rA/fCbL2xhkSSnJxMamqq1nMi7US7D3BcccUVjBs37germZyMF198kVmzZnHgwIEj2g8cOMA999zDxx9/DMBtt93WZF9TWs8nOwtx+DzkViYH2rI8y/CYQ6iN70VtbS0VFRWtOEIRERERATi7Uw8u7zoocH17ZDZGYg4mYHTdU1iM+oYbRgju+iwMA2JjY7WeE2kngiYHx969e7n44osD1263G4AVK1YwbNiwQPt1113H9ddfH7guLS2luLiYmpqaJntmSUkJL7/8Mg888AAZGRnEx8fjdDrZtm0bXq8Xs9nMHXfcwfnnn3/a71ta31tbV2L1Wsiobiwn1s39GUX2vlRWVanUmIiIiEgb8v+GTuCLPZspcVRTYzLzTM8J/PrLp7Ab+xjumMmiyJsA8Hnj8HniqKzcqPWcSDsRNAEOn89HZWXlUe1er/eIdqfT2ezPvOCCCwBYs2YNe/bsYcOGDVgsFjIzMxk6dChXXnklPXv2POFxSNu1r76WhcWbyK1KxmI0bHgK81eS6VnJAtdPKSlTaVgRERGRtiQmNJz/G/UTrvrfDADeNIdzUe8fkbnuQ3q4P2arbTQl1j4AuByZlJUt4Ywzhgd2cGhdJxK8TIZhGK09CDkxl156KQUFBeTn5/PWW2+19nA6hOnrF3HP0vc4d0tfkhwNSavyne+SsH82b0b+hDFjxjBp0iRl3RYRERFpY3731X+Zs3k5AHE+D2+sfgVTTTnV5lTeiH4CvykUAKd7BzWOb3E6naqqIhLk2n0ODpHT8dbWVdhdYYHgBjQcT/nWlUn//v2ZMmWKvvmJiIiItEH3DJlA6sGqKgcsVmb2atiFHe0vYUj9fwL9wmzZ2CM6qaqKSDugAIfIcWyrKmfVvl3kHmhMLhrr20msbwdV6SNYt26dsm2LiIiItFGHjqocMis0kbLOIwDId80j0b8tcC8itB9Wa5iqqogEOQU4RI7jrW2rwOCI6indXJ9RHNGd8LgUZdsWERERaePGZXZnUrfBDRcmE79LHQihdsz4OaP2cTB8ABhGKB5nOqCqKiLBTAEOkWMwDIO5W1eR5IjG7g472Oinq/vzhuoplZXKti0iIiISBP7f0AmkHDyqUmyNYG5+w1GVBN92+jnnBvp53Sn4fRFa54kEMQU4RI5hzf5idtTsJ+dAYxbtdO8aTCYnq2uiKCkpYeTIkcqyLSIiItLGRdvCeGjExYHrp+ydqM5oqKIywDkHu2/vwTsm6qozKCkp1TpPJEgpwCFyDO8WrcHsN5FVlRho6+peyEp3Bm6vj4kTJzJp0qRWHKGIiIiInKjzsnpxYW5fAAyTiT91GgkhNkJwM8bxdKCfxRzDyGE/Zdy4cWzcuFF5OESCTEhrD0CkrTEMg/e2rSa1NpZQnxUAi+Eix72ETlfPYEL/sxTRFxEREQky9w27kC/2bKHS5WBjaDSf9fwRY9e+Q7p3LXmu+WwKPQeA8tJIHnzgUaprylQ2ViTIaAeHyHesKN/JHkcV2ZWNQYxOnuXs89lYsbtWwQ0RERGRIJQYbufeoRMC1w/FdsGZ1BmAofUzCKcGAMMwERk+gJwclY0VCTYKcIh8x5z1S7H4zWRWJwTauri/YHNYL5UMExEREQliP+kygLMy8gDwmi3cmzsWTCbCjFqG1z4X6BdiTsRiSlPZWJEgowCHyGF8fj8f7y4kozoeq98CgNVwkOlZTmn8AJUMExEREQliJpOJh0deQmSIDYBl4fGs7HEuAJ09X5Hp/ibQ1+3shOEPUdlYkSCiAIfIYZaVbWe/p57sysbkojnuJVSEpbGnxqeSYSIiIiJBLtMex58H/yhwfXd8T7zRyZiA0Y7nsBjOhhtGCG5nJ5WNFQkiCnCIHOa9ojVYfRbSaxq/gXV2f8Faf7ZKw4qIiIi0E1f1GMaQ5GwA6kNsPNFlHAB2Yx9D618O9PN5EqiuDNEaUCRIKMAhcpDX7+P97WvJrErAYjR8NEL91aR41lHo76TSsCIiIiLthNlk5pHRlxFqaSgqOS8qk51ZgwDo6fqQBO/mQN/sTmdzxhlnqWysSBBQmViRg74u2cZ+Zx19K3MCbbmeReyzd+H3f/wb2dnZrTc4EREREWlSXWKS+G3/s3l4+cdgMvGntEG8unc9Zk89Z9Y9wdyYxzEw43FbePyxueyr+EZlY0XaOO3gEDno3aI1hHqtpNTGBtq6uL9gYbmdBQsWtN7ARERERKRZ3Nh7DPnxaQCUhsXwetexAMT7d9LHOTfQL8zalZzsXiobK9LGKcAhAnj8Pj4oWktWZSJmTABE+veR4NtCRUJflQYTERERaYesZguPjLoMi6nhx6IXEntQmZALwID6OYT7GtZ/JpMZw9uVpCSVjRVpyxTgEAG+3ruNKo/ziOopnd1fUhyRhz0uSaXBRERERNqpPokZXJ8/GgCf2cI9WaMwTCasuDij/rlAP78vCp8nQWVjRdowBThEgA93rCPcYyPZERNo6+L+kh2RvVUaTERERKSdu6P/OXSyxwGwLjqNJbmjAMjyfEuWe0mgn9uZSWVlndaGIm2UAhzS4fn8fj7aWUCnqoRAW5RvL5HGHtbU2FUeVkRERKSdi7DaeGDExYHrB9MG4I5sCGCMcjyPxXA23DCs+D3Z9O7dm4qKCh1TEWljFOCQDm95+U7K62vpVNV4PCXXs5jF++3UOd0qDysiIiLSAYzL7M6FuX0BqAsJ44ncMQBEGvsZXP9KoF+0PY+Ctbu49957mTp1KtOnT8fhcLTKmEXkSApwSIf3wfa1hHmsJNdFB9py3YtZ682kf//+TJkyRWXARERERDqAe4dOJMYWBsAH8V3ZntYbgHzXPOKNnYF+UZGDyMnprKoqIm2MAhzSoRmGwbyiNWRWJ2A6WD3F7isj0tiLKWsw69at09ZDERERkQ4iOSKKPw/+UcOFycTdnYZjhNgw42d0zZNg+AGwmKMwG51ITlZVFZG2RAEO6dDW7i+mpL6GrMOOp+R4FrM7sgcxcfHKkC0iIiLSwVyZN4QhydkA7AmP483ODUdVkn2b6OH6KNDP40rD77epqopIG6IAh3RoH+xYR6g3hJTaxuopue7F7IzopeopIiIiIh2Q2WTm76MuxWq2ADAtpQ9VsZkADHH+h1B/1cGeFtz12VozirQhCnBIh2UYBh9sX0dmVePxlAj/PqKM3RRUh6l6ioiIiEgHlRebws19zgTAYw7hrzmjAQg16hjpmBbo5/fGUFMdqjWjSBuhAId0WJsqy9hWve/I4ynuJRR4UnF7faqeIiIiItKB3dJ3LDlRCQCsiunEt50GAdDZ8yWpnjWBfp3SzmL0qDPZuHGj8nCItLKQ1h6ASGv5cMc6bN89nuJZxKbsMdx9/d1kZ2e34uhEREREpDWFh1h5eOQlTP74BQAezhjK7NINhLjrOMPxDG/FPI0PC16vhScff5fyiqXY7XZGjBjB5MmTVYVPpBVoB4d0WB/uWEdmdTzmgx+DcP8BorxFfLx+HwsWLGjl0YmIiIhIaxud3pXLugwEoCLUzvTskQDE+PfSr76xNGyotTM52fkqGyvSyhTgkA5pR81+Cir20umI4ylfs9fek+TUdJX6EhEREREA7hl6AXGhDbsxXk/rS9nBhKN9nXOJ8JUBYDKZMbxdSEpS2ViR1qQAh3RIn+xcj9VnIa0mNtCW61nMzsheKvUlIiIiIgHxYZHcM+QCAPwmM/fnnAFACG5G1/870M/vi8LniddaUqQVKcAhHdInOwvJOOx4Spi/ilh/EWVhKvUlIiIiIke6rOtAhqfmArAuJpMvMxuOrWR5viXT/W2gn8eZSWVlrdaSIq1EAQ7pcCpdDpaVbiezOiHQluVZxq6wLpSW71N5WBERERE5gslk4sERFxNiavjx6V+dhuOxRQIwqv7fmA0PAIZhw+NKp3fv3lRUVOiYikgLU4BDOpyPt63F8BlHHE/J9ixl0X47Ho9H5WFFRERE5Ch5sSnc0LvheMoBWyTPH0w4GuUvo7/zv4F+sVG9WLtmG/feey9Tp05l+vTpOByOVhmzSEejAId0ODO+nk9qbSxWf0OV5BDDSaxrPTF9z+XBBx9kypQpKuslIiIiIkf5Tb+zSY+MAWBuWl/2xHUCGhKORrEfaEg4GmMfSE5OrqqqiLQwBTikQ9lTWsIGXxUZ1Y1nIjM8Kym2prNt+85WHJmIiIiItHURVhv3DbsQaEg4+mB2Y8LRETVPB/pZzAlYTKkkJ6uqikhLUoBDOpSF2wvxWsxkHhbgyPEspSQ6X9muRUREROQHnZ/Vi7MzewCwPiaDBYcSjnqXk+H+JtDP7czEMMyqqiLSghTgkA5lhaOMhHo74d5QAEyGjzTvStY745XtWkRERER+kMlk4r7hEwm1NBx3frLTCFyhdgBG1z8fSDiKYcPjTFeFPpEWpACHdBiGYfDVviIyqxqrp6R411NqimF36X5VThERERGRE5IdlcBtfccCUGWL4NmsEcDRCUc9rmQq9ju1zhRpIQpwSIdReKCE3bWVR5SHzfEsZROdVDlFRERERE7Kr/qcSW50IgDz0vqyMy4LgL7Ot4jwlQENCUd7dJvA2LFj2bhxo/JwiDSzkNYegEhL+WDraqJcYcS4GiukZHmWMfD388jpNbAVRyYiIiIiwSbUEsIDwy/iyk9exG8y81DOGJ458AoheBjteI5Pou4BwFFn4x9/f4mKyg3Y7XZGjBjB5MmTVbVPpBloB4d0GP9d+/URx1PivNvZ5/by2dLVrTgqEREREQlWYzK6cWFuXwA2RqcxP70/0JBwNNu3ItAvPDSfnJyuKhsr0swU4JAOoWBXEcUm1xHlYXM8S9kVnqeyXSIiIiJyyu4ZOgG7tSGB/bPZI3BZwwEYXvsspoMJR82mMEz+bJWNFWlmCnBIh/BJ0TpCvVaSHNGBtmzPUsrj+qlsl4iIiIicstSIaH4/4FwAKm2RvJg1HDiYcLS+MeGo152M3xeqsrEizUgBDukQVtaVkVEdjwkTAJH+fZgsteyuNVS2S0REREROyzU9R9ArPg2AuekD2BuVAkA/11zC/PsP9jLjdnZS2ViRZqQAh7R7Hr+PZft3klEdF2jLci9jk5FJSUmJynaJiIiIyGkJMVt4aMTFAPjMFh7NGdPQjpuRjhcC/fzeWKorQ7T+FGkmCnBIu/dN6XYcLjdptbGBtizPt2w0VB5WRERERJrGoORsLu86CIDl8TksSeoOQK5nMUme9YF+OZ3GceaZZ6lsrEgzUJlYaff+t72ApLpoQvwNf90thotodnLD3a+Tk5PTuoMTERERkXbjz4PH8+GOddR4XDyZO4bBFdsI8XkYXf8cb1sfx8CE2x3Co4/MYf+B1SobK9LEtIND2r13Cr8lo6bxjGO6Zw0FDjufffZZK45KRERERNqbpPAofncw4eje8FheyxgMQIJvBz3cnwT6hdu6k5OTp7KxIk0saHZwlJeXs2jRItatW8fatWspLCzE5XIxdOhQZs2a1SrP9Hg8vPTSS7z77rvs3LkTq9VKjx49+MUvfsF55513SmOSprV251bKTG6GHZZ/o5PnWzZG9WDL4sVMmDBB5x9FREREpMlc3XMEr236ho2VpbyWNZSJ5YXE1lcyyDGLzSGj8ZojMZms4MslObkhAf5irUtFmkTQBDjef/99HnrooTbzTJfLxZQpU1i+fDkWi4WuXbtSX1/PsmXLWLZsGddffz2///3vm3S8cvI+KSrA7gojyt245S/du5rlKVdSu30XFRUV+kYiIiIiIk3GarZw3/ALmfTRNJwWG0/knME9he8RZtQw1PkfFkfcCIDPk4jPW05sbCxFRUVal4o0gaA5omK32xk5ciQ33ngjTz31FDfffHOrPvMf//gHy5cvJzMzk3nz5vHuu+/yv//9j2eeeQabzca0adNYsGDBaY9RTs+qurIjjqfE+XZQExrF/qpalecSERERkWYxKq0LE3P6ArAwqTvr47IB6OH6iGjfzkA/j8rGijSpoAlwXHbZZcyYMYM77riDc889l4SEhFZ75r59+5g9ezYADzzwAJ07dw7cO/vss7nuuusAeOqpp057jHLqXD4vy/bvJP27x1N8qSoPKyIiIiLN6i9Dfkx4iBVMJh7tfBZ+kxkzfkY7ng/08fvs1NXY6d27NxUVFaqqInKagibA0ZYsWLAAj8dDTk4Ow4cPP+r+5MmTASgoKGDnzp1H3ZeW8eXODbhcXlJqowNtnTzfUuhOVnlYEREREWlW6fZYbus7DoBt9mTmpfVraPeuJcv9daBfUvxQVq9ax7333svUqVOZPn06DoejVcYsEuwU4DgFq1atAmDQoEHHvJ+SkkJmZuYRfaXlPf/Z+6TUxmLGAoDNX4vLUUzXASOZMmWKSnGJiIiISLO6ofcZZEc17BKfnjMKh61h/TmifjoWvACYzWFE23uTm5urqioipylokoy2Jdu3bwcgKyvruH2ysrLYvXs3RUVF3/us2bNn8/rrr5/Q1926desJj7GjKy8vZ3V9Ofk1PQJtmd6VlER0Yd26dZSXl+t4ioiIiIg0q1BLCPcNm8jV82dSbQ3n+ayR/GbLfKL8ZfStf5OV4Q07im0huYRYHCQn2wBVVRE5VQpwnIKqqioAYmJijtvn0L3q6urvfVZ5eTkFBQVNNzgBoHDPTurCQ8iojg20dfIsZ0Nsb2qLa5WlWkRERERaxNmdenB2Zg8+3b2Been9uKR0Hdk1JfR1vsl627m4LPGAGY+zE6GRW1RVReQ0KMBxClwuFwBWq/W4fWy2huir0+n83mclJSWRn59/Ql9369atP/g8abDeU0msM5Jwb1hDg+En0VfI1rpu2O0hylItIiIiIi3m3mET+HLPZtx+eDz3TB5dMwcrLkbWv8hn9j8A4PPG4vNEU1m5RVVVRE6RAhynIDQ0FACPx3PcPm63G4CwsLDvfdbkyZMDSUl/yKWXXqrdHidoZU0J6TWN1VOSfJspJoaS0lImTpyoaLiIiIiItJjc6ERu7D2GJ9d8xqq4LBYldmPUvs109nzFWs8F7LP2AsBRm0ZJySImTtTxFJFToSSjpyA6uqEqx6GjKsdy6N6hvtJyfH4/X+3Z8p3ysMvZQoaqp4iIiIhIq7i171jSIhqOsT/b+Ux8ZgsmYHT982AYAFjMUQwaMIEBAwaoZKzIKVCA4xTk5OQAsGPHjuP2OVQe9lBfaTlr9hdTV+8myREVaEtzryQi/xwmTZqk6ikiIiIi0uIirDbuGXoBAHvC43gzfQAAib4i8ryfB/od2B/N//3foyoZK3IKFOA4Bf379wdgxYoVx7xfWlrK7t27j+grLefLPZtJqY3BdPCvd6i/Gg91LPhqqUpuiYiIiEirmZDThxGpnQGYlT2CGlskAIPqXsJCwxF3symUThmjVDJW5BQowHEKzj77bKxWK9u3b2fJkiVH3Z89ezYAvXr1Ijs7u6WH1+HN376etNrG4ynp3jXsj+lBamoqixcv1nY/EREREWkVJpOJvw6bgNlkoi4kjBeyRwIQaVTQv/6/gX6GN43EhE5av4qcpHYf4LjiiisYN24cM2fObLJnJiYmBvI43HXXXWzbti1wb8GCBbzwwgsA/PrXv26yryknps7jYs2BPWRUN5bwzfSsYG94Z2JjY6mtbSgRKyIiIiLSGnrFp3NFtyEAvJ/Wlx32hmSifZxvE+Y/cLCXGY8zQ+tXkZMUNFVU9u7dy8UXXxy4PlSlZMWKFQwbNizQft1113H99dcHrktLSykuLqampqbJngnwhz/8gYKCAlauXMmECRPo1q0bDocjkHvjl7/8Jeecc86pv2E5JUtKighz2oj0NObZSPRvZrl1BJXl5Sq5JSIiIiKt7g8Dz+PdotXUeFw8lXsW/1j7X0JwM7x+Bgsj7wDA543H4TBp/SpyEoImwOHz+aisrDyq3ev1HtHudDpb5JlhYWG8/PLLzJw5k/fee4/t27djtVoZOnQoP//5zzn//PNPeBzSdD4v3kRqbWzgOta3kwPWaMrKyykpKVGJWBERERFpdYnhdn7b/xzu++Z9lsfn8HVCF0bs30oX9xesCb2QipCuAJiNbuTnJwd2cGgdK/L9TIZxsCaRtHmXXnopBQUF5Ofn89Zbb7X2cNqkM998hPQ1iXSqTgSgt/Ndlm/5jOrM0YwZM0ZVVERERESkTXD7vJzz9r/YVr2PTo4Kpn87A4vhp9TSg/ei/x7oV133DVU1m7Db7YwYMYLJkydrPStyHO0+B4d0HHvqqthWtZ+0msb8GxmeFewwZ9C/f3+mTJmibwYiIiIi0ibYLCGBsrG7IuKZe7BsbIpvA7nexYF+9og+5OR0UVUVkROgAIe0Gx9sXEGiI4oQwwqAxXBjNVeQ3qUX69atU/ZpEREREWlTzs7swZnp3QB4OXsktdaGX8YNrZuByfAAYDaFYTKySE5OVlUVkR+gAIe0G18UbyatJjZwneJdT3l4lrJPi4iIiEibZDKZ+H/DJmAxmam1hjE9ewQAUf4y+jjfCfTzulLw+61a14r8AAU4pF3wG35WVO8l/bAAR6ZnJXvDu1BZWans0yIiIiLSJuXFpnBVj+EAvJfWj52RDbnk+jvfwOavPtjLgseZoXWtyA9QgEPahfUVe6l3eIirjwq0JXsLKKyyUlJSwsiRI5V1WkRERETapDsGnENsaAQ+s4WnO58FgI16hta/HOjj8yRyoMKrda3I91CAQ9qFRXu3klobiwkTABH+Cva563F7fUycOJFJkya18ghFRERERI4tLjSC3/U/B4Bv4nNZFpcLQJ77U2K8OwP98rr8iLFjx7Jx40bl4RA5hpDWHoBIU/hy92ZSamMD1xmeVTjTB3P3zXeTnZ3degMTERERETkBv+gxjFkbl7CpsoznupzF4OXbMRt+Rta/wIdR9wFQ77Dyfw/P4ECVysaKHIt2cEjQ8/p9fL1nKxnVjcdT0r2r+WSLgwULFrTiyERERERETkyI2cK9QycCsD0ykfdT+wCQ4V1Nln9VoF9EWD45OZ1VNlbkGBTgkKD3xZYCQjxWwr2RgbYodhGRkqsyWiIiIiISNMZkdOPcTj0BmJkzCqfFBsDQmufB8AFgNkVgJlNlY0WOQQEOCXpf7Np4xPGUGN9uqkLjVUZLRERERILOX4ZcgNVs4YDNzqudhgAQ6y+mu+vjQB+PKw3DsGi9K/IdCnBI0Cuo30dqTUzgOt2zhpLwXJXREhEREZGg0zkmkWt6jgDgjczB7A9tOIY92Dkbi+Fs6GSE4HGmab0r8h0KcEhQc/u8rKrYQ3ptdKAtzbuW9TURKg8rIiIiIkHptn7jiLGF47TYeDFnFADhRhX9nW8E+nhcSewrr9V6V+QwCnBIUFu1bze2Ois2X1hDg+EH9y5qvWaVhxURERGRoBQXGsFv+58NwCcp+WyNbAhg9HG+Q6j/AAAmk4We3X/EgAEDlIND5CAFOCSofb5zAym1jcdTEnxFuBJyufvuu5kyZYpKZomIiIhIULqqx3ByohLwm8w81/ksAEJwM6x+VqBPfV0Uj/5zGlOnTmX69Ok4HI5WGq1I26AAhwS1d9cuJe3w/BveNXy1y6vysCIiIiIS1GyWEO4a8iMAlsfnsDQuF4Cu7s+I9e8O9EtLHqmSsSIHKcAhQWt3yV52+h2kHpZ/I8VbgDOxp8pliYiIiEjQG5+Vz7CUHAD+3eVM/Jgw42d43QuBPoY/hoS4bioZK4ICHBLEvtq5kRhXFBajoT64yfBisVQTFZeoclkiIiIiEvRMJhP3DJ0AwPbIJD5M7QNApnclaZ41gX5uZyYxMSoZK6IAhwStje5KUmtjA9fJvk3sD8tQuSwRERERaTf6JWZySef+AMzIGYXTbAVgeP10MAwADH84dTVRWgNLh6cAhwSt1dUlpNU0Hk9J96xhfX2sysOKiIiISLty56DxhFpCqAi1M7vTEKAhuX4X98JAnxBTF3r16kNFRYWOqUiHpQCHBKV6r5vVpbtIcjQGOGKd6/issITzzjtP5WFFREREpN3IsMdyQ/4ZALzeaQj7bXYAhtT/B5PhBiAkJIItG+u59957VVVFOiwFOCQorSjbSUxtJGYjBACL4aLeV409KprQ0FCVhxURERGRduXXfc8iMcyO02Jjes4oAOzGPvo63w30iQjrTk5OnqqqSIelAIcEpc+KCkiuaywPm+ItpD6pF9nZ2coeLSIiIiLtjt0ayu8HnAvAx6m92RaZCEA/55tY/TUAmEwhmPzZJCcnq6qKdEgKcEhQWlq6nfQae+A6zbuO0rAcYmOVPVpERERE2qfJeYPpHpuC32Tm353PAsCGg8HO1wJ9vO4k/L4wrYulQ1KAQ4KOx+9jQ/U+4h2NOzjifVuptiaogoqIiIiItFshZgt3D/kxAN/E5bA8NguAHq6PifSVHuxlwuPM1LpYOiQFOCTorN1fTGRtGGYa8294LS7KystVQUVERERE2rWxmd05M70bmEw83/lMACx4GV4/M9DH542l8oChdbF0OApwSNBZWlJ0RP6NZO8mCmtC8Xg8TJw4URVURERERKRdu3vIBZhNJjZHpbIgqQcAOZ7FxHs3B/p0zh5H//79lYNDOhQFOCTofL1n6xH5N1K9BVi7juLuu+9mypQpqqAiIiIiIu1az/hUJnUbDMD03NF4TWZMwIj6GYE+blc4Tzz+ikrGSoeiAIcEFb/hZ8nuLSQeln8j1ruZz9buYMGCBa04MhERERGRlvO7AecSZrGyJzyO99L6AZDmLSDDuyrQJyl+qErGSoeiAIcElSXbNhDmjMBsWAEwGx5MNjepqWkqgyUiIiIiHUZqRDQ35I8GYFb2CBwWGwBDHTPAMBo6GRHEx/ZUyVjpMBTgkKDy5a5NR+TfSPRtYX9YuspgiYiIiEiHc1OfM4kPjaTSFsmczCEAJPi209nzRaCPx5lOTEyc1srSISjAIUFlo+vAEfk30jzrKAvLVhksEREREelwomxh/Kb/OAD+22kwFdZIAIbU/weT4QPAMEJx1MZqrSwdggIcEjQMw2D1gb0k1UUH2hL8W9h8wFB5WBERERHpkH7efRjZUQk4LTZezhkBQJS/jJ6uDwJ9Qky59OrVl4qKCh1TkXZNAQ4JGhvLi3FV+LAYoQCYDB+l+3dQ73SqPKyIiIiIdEg2Swh3DjofgPdT+7IrPA6AAc7/YvY7AbBYwtiyycW9996rqirSrinAIUHj6Xn/Jfmw3RuJvq3s8tnp37+/ysOKiIiISIc1IacP/RIz8ZktvJh7BgDhRhX9XW8F+kSEdiMnJ09VVaRdU4BDgkJ5eTnLynaQXhMVaEv1FuBK7ce6deu01U5EREREOiyTycRdg38EwBeJeRRGpQHQx/kONn/1wT4WTP5skpOTVVVF2i0FOCQoVFRUUBFpIeXw/Bu+zfjiOisjtIiIiIh0eCPTunB2Zg8wmXi+8xgArDgZ5Hwt0MfrTsLvC1UFQmm3FOCQoGCyh2ENicbiD2toMPyYQ+qorKpSRmgREREREeDPg8djNplYHZvFkvjOAPRwfUKkr+xgDxMeV4YqEEq7pQCHBIUdvrojqqfE+3aw0xOh6ikiIiIiIgf1iEvlp10HAfBC7hn4MWHBy5D6WYE+Pk88Byo8WkNLu6QAhwSF5eU7SamzB65TvIXsMBJVPUVERERE5DC/G3AuYRYr2+zJ/C+lFwBdPF8S690e6NM191wGDBigHBzS7ijAIUFh2d4i0mojA9fx3k2k9D6DSZMmqXqKiIiIiMhB6ZExXJc/CoAZOaNxmy2YMBhePzPQx+WM4F+PvaSSsdLuKMAhbZ7H72P9nr2EehuPqJj8+1n4xVcqbyUiIiIi8h039zmLuNAIysKieTt9AAAZ3pWkegsCfZIThqlkrLQ7CnBIm7d4ayGxjsbjKRH+ClxRsSpvJSIiIiJyDNG2MG7vNw6AV7OGUWexYQKGOmY0djLsxMd215pa2hUFOKTN+7p4M0l1UYHrFG8h+0I7qbyViIiIiMhxXNVjONlR8VRbI3g9cwgAyb7NZLu/DvTxuDKIidGaWtoPBTikzdvsqiSzpjHPRrJ3A/tDVd5KREREROR4bJYQ/jjwfADeyBzMAWvDenpw/X/A8ANg+MOoq7FrTS3thgIc0uYVHCjD7ooNXIdRyp59VSoRKyIiIiLyPSbm9qF3fDr1ITZezRoGQJx/N13cCwN9LKbODB+uNbW0DwpwSJu2t64K5z4vJiwAWAwX++oq8Xg8KhErIiIiIvI9zCYzfxrUsIvj3fT+lIY2HPse7HwNk+EFwBpiJzmxLxs3blQeDgl6Ia09AJHv8/XuzSTVNVZPSfJugk79uftXd5Odnd2KIxMRERERafvOyshjeGouS0qKeDl7JH/Y9DFR/jJ6uD+hMPTHAHy+oIjX5rxNZGQ4I0aMYPLkyURERPzAk0XaHu3gkDbttUXzyaht/Mc1xbuBBZsOsGDBglYclYiIiIhIcDCZTPx50HgAPk7tzc7whlwbA+pfx4IHALM5jKyMESobK0EvaHZwlJeXs2jRItatW8fatWspLCzE5XIxdOhQZs2adVrPXrJkCTNmzGD16tU4HA7S09MZP348N9xww3Ejl927d//eZyYmJrJo0aLTGldHV15ezvqacsY7ugTaYoxdRKb0YPHixUyYMEFnBUVEREREfsCg5GzOz+rFxzvXMyN3NP9v/btEGAfId77LmrCfAOD3ZpCU1FBJRWttCVZBE+B4//33eeihh5r8ubNmzeKBBx7AMAxSU1NJS0tjy5YtPPvss3zyySe8+uqrxMbGHvf1vXv3xmazHdX+fa+RE1OyrwzDGoXFH97YGFJPbEwsRUVFVFRU6B9dEREREZET8MeB5/PJzkK+SMxjkz2FvNpS+jrnsj70x3hN4UAIHlcKsbH1WmtL0AqaAIfdbmfkyJH06dOHPn36sH79ep555pnTeua6det48MEHAbjvvvu4/PLLMZlMlJaWctNNN1FQUMBf/vIXnnzyyeM+4/HHHyczM/O0xiHHVmL2kFjfmH8j1reTyrBElYcVERERETlJ3eNSuKzrAP67ZQUv5J7B/619gzCjhr7OuawIvxIAryuFOtd6rbUlaAVNDo7LLruMGTNmcMcdd3DuueeSkJBw2s985pln8Pv9XHTRRUyaNAmTyQRASkoKjz76KGazmU8++YQNGzac9teSk7fVXU1qrT1wneItZGNdpMrDioiIiIicgjv6n4PNbOHbuBxWxXQCoLfzXWz+moM9LDgdSeTm5rbeIEVOQ9AEOJpaXV0dX375JQCXX375UfdzcnIYPnw4AB999FGLjk0aLC/dTtphCUZjXBv5Yn0x5513nsrDioiIiIicpE5R8fyix3AwmXgx9wwAbNQzwPl6oE9cTD5r1mxk6tSpTJ8+HYfD0VrDFTlpHTbAUVhYiNvtxmaz0bdv32P2GTRoEACrV68+7nOeeeYZrrvuOqZMmcKdd97J22+/jdvtbpYxdzTLirYS6o0JXPt9+7FHRRMaGqqyVSIiIiIip+DWvmOJDLFREJPB1/ENyfx7uj4izH8AALM5hOzMM1RRRYJS0OTgaGpFRUUApKenY7Vaj9knKyvriL7H8uabbx5xPXfuXJ544gmefPJJ8vPzf3Acs2fP5vXXX//BfgBbt249oX7tQeGu7YTUhwENx4ZC/TUQG0t2RLayOouIiIiInKLEcDs39D6Dx1Z9you5oxlWsZUQ3Ayqf41FkTcDYPhSSExoOMKitbcEkw4b4KiqqgIgJibmuH0O3TvU93Bnn302F110ET169CA1NZW6ujq+/vprHnvsMXbt2sUvf/lL3n77bdLS0r53HOXl5RQUFJzGO2mfluzeTKIjKnCd5NvM/shMYiNUQUVERERE5HTckH8GLxUuYRvJLEjuyTllhXR3z2dV+E+oM6cAJjyudGJja7T2lqDSYQMcLpcL4Li7N4BA+ddDfQ/33QouoaGhXHDBBYwYMYKf/OQn7Nmzh6eeeooHHnjge8eRlJR0Qjs9oGEHh9PpPKG+wW6Hr47MmrDAdZJ3E1tDO1G5TxVUREREREROR5QtjNv6jeXeZfOYmTOKs8o3EmL4GFz/Cp9H3gGAzxOPo86ntbcElQ4b4AgNDQXA4/Ect8+hXBqH+p6I+Ph4brjhBu69917mz5/P/fffH6jOciyTJ09m8uTJJ/TsSy+9tMPs9thcu5+0w0rEhhsl7NkXTUlJCRMnTlQEWURERETkNPy8+zCmFXxFMfBBah8u3LuaLu4vWRX2U6osnQATfm8WI0f20NpbgkaHTTL6fcdPDjmRYyzHMmDAAAAqKyuprKw8tQF2YIZhsHFPKWajMZFoTX05Ho+HiRMnqoKKiIiIiMhpCgux8rsB5wDwn+wRuMwhmPEzpH5WoI89IptOmb0oLy9vrWGKnJQOG+DIyckBYM+ePcfdxbFz584j+p6ow4+9+Hy+UxpfR1ZYtpvQKlvgOtq3B0taF+6++26mTJmiCioiIiIiIk3gJ10GkhebzL7QKOamN/ySNtuzlER/Y3GDd+euUclYCRodNsDRs2dPrFYrbrebNWvWHLPP8uXLAejfv/9JPXvz5s1Aw9GW2NjY0xlmh/Tv998kubYxiJHk3cSXW6tZsGBBK45KRERERKR9sZjN/GHgeQDMzhqKw2LFBAyueynQJyw0jVBbikrGSlDosAEOu93O6NGjAY5ZpnX79u0sWbIEgPHjx5/wc71eLzNmzABg+PDhhIR02DQnp6S8vJxv9xaRURseaEvwbcWc1JXFixdre5yIiIiISBMan5VP/8ROVFsjeDNjMAAZ3tUke9YH+tjD80lNTdV6XNq8dh/guOKKKxg3bhwzZ8486t7NN9+MyWTinXfeYc6cORiGAUBZWRl33HEHfr+fc845hx49ehzxukceeYS5c+dSW1t7RPvevXu57bbbWLVqFSEhIfz6179utvfVXlVUVHAg3EK4Oy7QZjVXERMXT21tLRUVFa04OhERERGR9sVkMvGnQQ27OF7vNJiakFBMwBDnfwJ9/L4ooqOytR6XNi9othfs3buXiy++OHB9qMLJihUrGDZsWKD9uuuu4/rrrw9cl5aWUlxcTE1NzVHP7Nu3L3feeScPP/ww99xzD88++yxxcXFs2bIFt9tNbm4uf/vb34563bZt25g2bRp33XUXnTp1IiYmhpqahhrRhmEQGhrK/fffT79+/Zrw/4GOISo2BqstDtPBv5pmw4PH1pCwVSWqRERERESa3ui0rgxPzWVJSRH/zRzCL7d/RZq3gFTPWkqsfQDwONOw27doPS5tWtAEOHw+3zErkni93iPanU7nST33mmuuoXv37kyfPp01a9awf/9+0tPTGT9+PDfccAORkZFHveaKK64gMTGRdevWUVZWRnFxMVarlW7dujFixAh+/vOfk5WVdbJvUYB9Fi8JjqjAdYJvG0WuMEr2qTysiIiIiEhzMJlM/HHg+Vz6wXO8mTGIn+xeToy3nsH1/2Ge9e8AWMzxdO0yJLCDQ+tyaYtMxqFzGdLmXXrppRQUFJCfn89bb73V2sNpFtNWf84Xb24grSYDgHznu7xeuIaJk6/hqquuUgUVEREREZFm8vNPprOweBOTdi3jxm2fA/BB5L3ssTVUWPF4KyjZ9yF2u50RI0YwefJkrc+lTWn3OTgkuLyzfBFJDnvgOsK7AyITCA0N1T+eIiIiIiLN6I8HK6q8nT6ACmvD2nuw89XAfWtIPNlZA7FaraqqIm2SAhzSZpSXl7O9tpoQX0ygzWpzkZ2drYzNIiIiIiLNrG9iJuOz8nFZrLySNRyAZN8mMt3fBvoY3iySkpJVVUXaJAU4pM3YXV5KuBEbuA7zV1FniyA2NlYZm0VEREREWsDvB56LCRPz0vtRFtqQG+/wXRyGPxKfN1ZrdGmTFOCQNqPM7CHJ0ZjUNcm7iYqwDFVQERERERFpIT3iUrmocz885hD+c3AXR6JvK1nuJYE+Hme61ujSJinAIW3GLl8dGbWhgesE3zY2VZopKSlh5MiRytQsIiIiItIC7uh/DhaTmY9S+7AnrOH4+CDna4H7hj+CmuowrdGlzVGAQ9qMtfuLiXFGB64tnj04vX4mTpzIpEmTWnFkIiIiIiIdR+eYRH7adSBes4WXs0cCkODbTo57UaBPp/TR9OvXXzk4pE1RgEPaBIfDwdLCTZj9jRVUQu0m7r77bqZMmaIKKiIiIiIiLei3/c/BZrYwP6UXu8LjABhU/xpgAOD12Hj6ydeZOnUq06dPx+FwtOJoRRoowCFtwsuzX8VfbwtcR/j3s77kAAsWLGjFUYmIiIiIdEwZ9liu7D4Uv8nMzJxRAMT5d9HF/UWgT0LcQKxWm0rGSpuhAIe0uvLycuavW06So3GXRqJ3C864rio9JSIiIiLSSm7tO5Ywi5WFST3YFpkIwID6OWD4GzoY4cTH9lDJWGkzFOCQVldRUUF5iI/M7yQY9cXlqvSUiIiIiEgrSYmI5pqeIzBMpsAujlh/MV3dnwf6eFxpxMTEad0ubYICHNLq4uPjcSZEEOWMCbSFmg5woKpapadERERERFrRr/ucid0aylcJ3dhkTwFggHM2JsMHgOEPo64mUut2aRMU4JBWl5SUhDk2AbMRGWhzeCtVHlZEREREpJXFhUVyXf5oMJmYkTMagBh/Cd3cjbnyLKZcRgzXul1anwIc0urqvR5whgWuI/3llPtDVR5WRERERKQNuCH/DGJs4SyNz6UgOh2AAc7XA7s4rCFRRNm7KQeHtDoFOKTVrdpbRGJdY4Aj0buVqLwRTJo0SeVhRURERERaWbQtjJv6nAkmEzOzG3JxRPnL6O7+X6DP14uKmTr1LpWMlValAIe0upf+N4+MmsYEo3G+bXy4tFClpkRERERE2ohf9hxJYpid5XHZrDu4i6Of8w1MhheAEEsk4aG5KhkrrUoBDmlV5eXlrCrdSZTr8ASjlaSkpqnUlIiIiIhIGxFhtXHzoV0cOYd2cZTT3T0/0Cfclkeq1vHSihTgkFZVUVFBvS0c02EJRg2rm9jYWJWaEhERERFpQ37RYxhJ4XZWxGazNjoDgH7ONxsrqhihRNu7aR0vrUYBDmlVkTHRhJvjAtd2Xyk1tlgqKytVakpEREREpA0JD7Hx6z5nfWcXRxl57k8DfbzudOz2KK3jpVUowCGtan+IjxRHeOA60beVTbWhKhErIiIiItIG/az7MFLCo1gZm8Wag7s4+jv/G9jFYTZFkJ46oDWHKB2YAhzSqlbs3U5GbWOC0Sj3Vhat38l5552nErEiIiIiIm1MeIiVX/c9C0wmXjpsF0c394JAn+rKWFVUkVahAIe0qve++ZLIwxKMmvz7iYqKJjQ0VCViRURERETaoCvzhpIaEd2wiyMmE2jYxcHBXRzWkCjCQ7NVUUVanAIc0mrKy8vZcaD6iASjtkgz2dnZyrwsIiIiItJGhYVYuaXv2IZdHNkjAYj2l9LNvTDQJzy0uyqqSItTgENazb79+wkxRQeuI/wV1NmiVUFFRERERKSNuyJvCGkRMayMzWJ1YBfH640VVfxhRNu7al0vLUoBDmk19WEWElyNx1ASfNuoCE1VBRURERERkTYu1BLCbf0O7eJoyMUR4y+hq/vzQB+vSxVVpGUpwCGtpgQXmbXWwHWsbwdbK3yqoCIiIiIiEgQmdRtMRmQsq+KyWBXTCWjYxYHhB8BsjiS/51la10uLUYBDWs36A3uJdkYFrk2eUjxeLxMnTlQFFRERERGRNs5mCeHWfmMBeCmnIRdHjH/vEbs4HLVJFBZuUB4OaREhrT0A6ZgcDgeffLuM/v4+gbawSBN333E32dnZrTgyERERERE5UZd3HcTTaxayGlgZ04kBVbvo7/wvW0PPxMBM5QEXj/zfS5hD9jFixAgmT56saonSbLSDQ1rF7NmzOVDl49BfQatRz8aSUhYsWPD9LxQRERERkTbDZgnhtn7jAHj54C6OWH8xnV1fBPokxA3AarWqbKw0OwU4pMWVl5fzxbIlRPsbj6fE+4pwx+WqjJSIiIiISJC5rOtAsqPiWR2bxcqDuTgGHJaLAyOC+NjupKamar0vzUoBDmlxFRUVlJndZNY2npCK9xbhi8tVGSkRERERkSBjNVsCuzheymmoqBLrL6aL58tAH48rnZiYWK33pVkpwCEtLj4+Hk9CFPH1kYG2cPZRUVWr8rAiIiIiIkHoJ10GkB2VwJrYTqyMzQKgf33jLg7DH05dTbjW+9KsFOCQFpeUlER4ThpWb+M/bF7vAZWHFREREREJUiFmC7/tf3AXR3ZDLo44/246exY1dvJnk5OT2xrDkw5CAQ5pcQ6HgyqniUNFfEyGly0luznvvPNUHlZEREREJEhd3Lk/udGJrIntxIqDuzgG1M8J7OIIC41n08YKpk6dyvTp03E4HK05XGmHFOCQFvfK7NcwHI35N2J9u9lviSM0NFQlo0REREREglSI2cJv+p8NwEvZDbk44vy7yPUsDvRJSRyiiirSbBTgkBZVXl7Op6u+IcNhC7Ql+rZhSctXRmURERERkSB3cW4/usQksTY287BdHK83djAiiY/rpooq0iwU4JAWVVFRQbnFQ5IjPNAWaZQQEZesjMoiIiIiIkHOYjZz+8GKKrOyRwAQ799BtvvrQB+vKqpIM1GAQ1pUfHw87ng7Ye64QFuIuZbKykplVBYRERERaQcuzO1LbnQiq2M6sSYmE4ABzv8G7vt9kdRWh2j9L01OAQ5pUUlJSYQlpwKNOziq3dWqoCIiIiIi0k6EmC3c1ncsmEzMymrYxZHo20qm59vGTv4srf+lySnAIS3ObNgDf47w76PcH8bEiRNVQUVEREREpJ24uEt/sqPiWR6XzfqoNAAG1Dfu4ggPSyUjrZdycEiTUoBDWtTeyv1YK7yB63jfDuJ7DGfSpEmqoCIiIiIi0k5YzRZuObSLI3skACm+DaR51gT6zHt3jUrGSpNSgENa1HNvzSa9zhq4jvbt5uOvV6tElIiIiIhIO3NZ14Fk2mNZGp/LRnsKAAOcjRVVwkLTCLUlqmSsNBkFOKTFlJeXs2RbIdGuyEBbqKmS1NQ0lYgSEREREWlnjtzF0ZCLI827lmTvhkCfqIh8lYyVJqMAh7SYiooKDoQYmH2NFVRMFhexsSoRJSIiIiLSHv206yDSI2NYnNCVrZFJmIAB9Y27OHzeWGKi0/XzgDQJBTikxcTHxxMSEQ+EAGAyfLitJpWIFRERERFpp0ItIfy6z1lH7OLI9C4nwbs10MfpSNHPA9IkFOCQFpOYmEiYJTZwHeMvZkedRSViRURERETasUndBpMSEc2XiXlsj0jABPQ/LBdHiDmVQQPP0M8DctoU4JAWU15fS2Jd41+5eN8O9vqiVSJWRERERKQdCwuxcnOfMzFMJv5zcBdHjmcpsd6dAJhMJvzeTOXgkNOmAIe0mNUlO0h2hAauw7x76N5ngErEioiIiIi0c1fmDSUp3M7CpO7sCo/DhEF/538D94u21nL3XferZKycFgU4pMXMWfgxEe7owLWFaj7//HOVhBIRERERaefCQ6zc1PtM/CYzr2QNB6Cz5yuifHsAMJnMRIR1V8lYOS1BE+AoLy/n7bff5v7772fSpEn07duX7t2784tf/OK0n71kyRJuvPFGhg8fTt++fRk/fjz/+te/fjByWFdXx2OPPcb48ePp27cvw4cP58Ybb2Tp0qWnPab2pry8nMKSPWDEBtrMYagklIiIiIhIB/Hz7sNICIvk0+Se7AmLwYyf/s43AvetlkzSUnP084GcsqAJcLz//vv86U9/YtasWaxatQqXy9Ukz501axbXXHMNCxcuJDQ0lC5dulBcXMyzzz7LZZddRmVl5TFfV1FRwU9+8hOee+45iouL6dKlC6GhoSxcuJCrr76aV155pUnG115UVFRgWOyBa6tRT701VCViRUREREQ6iAirjRt7j8FntvDqwV0cXd2fE+krO9jDjD2ip34+kFMWNAEOu93OyJEjufHGG3nqqae4+eabT/uZ69at48EHHwTgvvvuY+HChcydO5f58+eTn5/P1q1b+ctf/nLM1951110UFRWRn5/P/PnzmTt3LgsXLuS+++7DMAweeOABCgsLT3uM7UVsXByRRAWu43w7qApNVolYEREREZEO5Ooew4kLjeCTlHxKQ6Ox4KWf663Afb83maioBP18IKckaAIcl112GTNmzOCOO+7g3HPPJSEh4bSf+cwzz+D3+7nooouYNGkSJpMJgJSUFB599FHMZjOffPIJGzZsOOJ169evZ8GCBZjNZh577DFSUlKAhuy/kyZN4qKLLsLn8/HMM8+c9hjbC1d4COmOkMB1rG8n2yq8KhErIiIiItKBRFpDuSH/DLxmC69lDQUgzzWfcP8BAEwmCymJA1tziBLEgibA0dTq6ur48ssvAbj88suPup+Tk8Pw4Q3bpj766KMj7n388ccADB8+nOzs7KNee6jk6eeff64MwAetKdlBfH144NpXt4u1Bes577zzVCJWRERERKQDuabnCGJsYXyY2odym50QPPR1Nu7iqK+L466p/08VVeSkddgAR2FhIW63G5vNRt++fY/ZZ9CgQQCsXr36iPZVq1YBMHjw4GO+rm/fvthsNlwul46pHPTGF59i88QFrs0WB1FRUYSGhqpErIiIiIhIBxJlC+O6/NF4zCHM7tSwi6OH62NC/dUAmM1WIsK6qaKKnLSQH+7SPhUVFQGQnp6O1Wo9Zp+srKwj+h6yffv2I+5/l9VqJS0tjR07dlBUVBQIlBzL7Nmzef31109ozFu3bj2hfm1NeXk5m8vKSaZHoC0sJpzssHQWL17MhAkTdERFRERERKQD+WXPUUwr+Ir30/rys51LiPc46ON6h2/DG6pk2kJySU3dpp8X5KR02ABHVVUVADExMcftc+jeob6n8trq6urvHUd5eTkFBQU/POAgVlFRQdaanYTkLsZmswGwlf7Eut0UFRVRUVGhf7BERERERDqQmNBw1v/sXgA2nnED/+/ee8lNzyXC9m2gT4g7iqKiffp5QU5Yhw1wHCoze7zdG0Dgh/HvlqQ9mdc6nc7vHUdSUhL5+fk/PGBg9+7dREREkJube0L924ru3bvz2muvtfYwRERERESkDdLPC9JUOmyAIzQ0FACPx3PcPm63+4i+h7+2vr7+hF4bFhb2veOYPHkykydPPqExi4iIiIiIiMixddgko8c7fnK44x1FiY6OPuHXHuorIiIiIiIiIs2nwwY4cnJyANizZ89xd2Ls3LnziL7ffe2OHTuO+TqPx8OePXuO+VoRERERERERaXodNsDRs2dPrFYrbrebNWvWHLPP8uXLAejfv/8R7YeuD93/rjVr1uDxeAgNDaVnz55NNmYRERERERERObYOG+Cw2+2MHj0a4JhlWrdv386SJUsAGD9+/BH3zj//fACWLl16zF0ch2o1jxkzhsjIyCYdt4iIiIiIiIgcrd0HOK644grGjRvHzJkzj7p38803YzKZeOedd5gzZw6GYQBQVlbGHXfcgd/v55xzzqFHjx5HvC4/P5+xY8fi8/n47W9/S1lZGQCGYTBnzhzeeecdzGYzN910U7O/PxEREREREREBk3Hop/o2bu/evVx88cWBa7fbjcPhICQkBLvdHmi/7rrruP766wPX48aNo7i4mFtuuYVbb731qOfOnDmThx9+GMMwSEtLIy4uji1btuB2u8nNzeXVV18lPj7+qNdVVFRwxRVXsH37dmw2G127duXAgQPs3bsXk8nEXXfdxS9+8Yum/T9BRERERERERI4paMrE+nw+Kisrj2r3er1HtDudzpN67jXXXEP37t2ZPn06a9asYf/+/aSnpzN+/HhuuOGG4x4xiY+P580332TatGl89NFHbNmyhYiICMaMGcO1117L8OHDT2ocIiIiIiIiInLqgmYHh4iIiIiIiIjI8bT7HBwiIiIiIiIi0v4pwCEiIiIiIiIiQS9ocnDIqfvd735HUVFRaw9DREREREREOpjc3Fz++c9/tsjXUoCjA1i+fDl79+5t7WGIiIiIiIhIB1NRUdFiX0sBjg7A4XAAEBYWRpcuXVp5NHK6tm7ditPp1Hy2I5rT9kXz2b5oPtsXzWf7ozltXzSf7cuh+Tz082hLUICjA8jMzKSqqoouXbrw1ltvtfZw5DRdeumlFBQUaD7bEc1p+6L5bF80n+2L5rP90Zy2L5rP9uXQfGZmZrbY11SSUREREREREREJegpwiIiIiIiIiEjQU4BDRERERERERIKeAhwiIiIiIiIiEvQU4BARERERERGRoKcAh4iIiIiIiIgEPQU4RERERERERCToKcAhIiIiIiIiIkFPAQ4RERERERERCXoKcIiIiIiIiIhI0Atp7QFI87v88sspLy8nKSmptYciTUDz2f5oTtsXzWf7ovlsXzSf7Y/mtH3RfLYvrTGfJsMwjBb7aiIiIiIiIiIizUBHVEREREREREQk6CnAISIiIiIiIiJBTwEOEREREREREQl6CnCIiIiIiIiISNBTFZUgs2TJEmbMmMHq1atxOBykp6czfvx4brjhBiIiIk7pmR9//DH/+c9/2LBhAx6Ph+zsbC688EKuuuoqrFZrE78D+a6mnNPdu3fz9ddfs3btWtatW8emTZvweDxccsklPPzww830DuRwTTWfPp+PJUuWsHDhQlauXMn27dtxOp3ExsbSp08fJk2axFlnndV8b0SApv18zpkzh5UrV7J+/Xr27dtHVVUV4eHhdO7cmXPPPZef//znhIeHN9M7EWie76GHe+WVV7jvvvsAGDp0KLNmzTrtZ8r3a8o5vfPOO5k7d+739pk2bRpjxow5nSHL92iOz6hhGLz//vvMnTuXwsJCqquriY2NpUuXLowZM4Zrr722id+FHNJU87l06VKuuuqqE+p76623csstt5zqkOV7NPXnc8+ePUyfPp2vvvqKvXv34vf7SUpKYtiwYVxzzTV07979lMapKipBZNasWTzwwAMYhkFqairx8fFs2bIFt9tNly5dePXVV4mNjT2pZ/79739n+vTpAGRlZREeHs6WLVvw+XwMGTKE6dOnY7PZmuHdCDT9nD7wwAO8/PLLR7UrwNEymnI+//vf/3L33XcDYDabycrKIjIykh07dlBbWwvApEmT+Otf/4rJZGqut9ShNfXnc/DgwdTU1BAWFkZKSgpRUVGUlpZSXl4OQE5ODjNnziQtLa2Z3lHH1hzfQw9XWlrKj3/848DnUwGO5tfUc3oowJGWlnbcz+Gdd95Jv379mugdyOGa4zNaV1fHLbfcwuLFiwHo1KkTsbGx7N+/n9LSUqKioli6dGkzvBtpyvlcv349f/vb3457v7a2lk2bNgEwffp0Ro0a1RRvQQ7T1J/PlStXcu2111JXV4fVaiUzMxOr1crOnTtxOp2EhITwyCOP8KMf/ejkB2tIUFi7dq3Ro0cPo3v37sbs2bMNv99vGIZhlJSUGJdccomRl5dn3HLLLSf1zE8++cTIy8szevfubcyfPz/QvmXLFmPcuHFGXl6e8dBDDzXp+5BGzTGnTz/9tHHDDTcYTz75pLFw4UJj6tSpRl5envGnP/2pOd6CHKap5/P11183Jk6caLz++utGdXV1oN3j8RgvvPCC0b17dyMvL8945ZVXmvy9SPN8PmfMmGGsXr3a8Pl8R7R/++23xujRo428vDzj+uuvb7L3II2aYz6/61e/+pXRs2dP48YbbzTy8vKMn//8500xdDmO5pjTP/3pT0ZeXp7xxBNPNMeQ5Xs0x3z6/X5jypQpRl5ennHttdcaO3bsOOJ+VVXVEetfaTot8W/u4Z588kkjLy/POPPMM4/6Hiunr6nn0+/3G+eee66Rl5dnTJo0ySguLg7cq66uNu644w4jLy/PGDhw4BFr4BOlAEeQuOmmm4y8vDzjj3/841H3ioqKjB49ehh5eXlGYWHhCT/zwgsvNPLy8ozHH3/8qHuLFy8OBD/2799/WmOXY2uOOf2uhx9+WAGOFtLU83ngwIHAN5Bjufvuu428vDzjwgsvPOUxy/G1xOfzcO+//76Rl5dn9OjRw6irq2uSZ0qj5p7PQ/N3//33G0888YQCHC2gOeZUAY7W0xzz+cYbbxh5eXnGT3/6U8Pj8TTlcOUHtOT3UL/fb5x99tlGXl6e8eijj5728+RoTT2fmzZtMvLy8o77GpfLZfTv39/Iy8szFixYcNLjVZLRIFBXV8eXX34JwOWXX37U/ZycHIYPHw7ARx99dELP3L59Oxs2bAAatrl/14gRI8jOzsbtdvPpp5+e6tDlOJpjTqX1NMd8xsbGfu/Rk0NnwIuKik52uPIDWuPz2aVLFwD8fj8ul6tJnikNmns+q6qqeOCBB0hNTeU3v/nNaY1VToy+h7YvzTWfM2fOBOCmm24iJERpB1tKS38+v/nmG3bt2gXApZdeetrPkyM1x3w6nc7Anzt16nTUfZvNRkpKCgBer/ekx6wARxAoLCzE7XZjs9no27fvMfsMGjQIgNWrV5/QM1etWgU0/KU69BfodJ8pJ6455lRaT2vM56FvDkpK2fRaYz6XL18OQEZGBnFxcU3yTGnQ3PP58MMPs2/fPv7yl78QGRl5WmOVE9Pcc7p06VJuu+02rrrqKm655RaeffZZiouLT2vMcnzNMZ87d+5k06ZNmM1mhg0bxurVq7nnnnu45ppruPnmm3n++eepqKhosvcgjVr6e+ihxMCDBg0iOzv7tJ8nR2qO+czNzSUsLAxoyMXxXWVlZezevRuLxUKvXr1OeswKZwaBQ7+hTU9PP25Vk6ysrCP6/pDt27cf8bqmeKacuOaYU2k9rTGf77//PtD4TUWaTkvNp9frpaysjPnz5/PYY49htVqZOnXqKT9Pjq055/Prr7/mrbfeYty4cZxzzjmnN1A5Yc39Gf3mm2+OuP7f//7H008/ze233871119/0s+T79cc87lu3TqgYTfkK6+8wj//+U+Mw+oqfPrpp0ybNo0nn3wy8NtnaRotuSZyOByBXQOXXHLJaT1Ljq055tNut3PzzTfz6KOP8uc//5m77rqLYcOGYbVaWbduHQ8//DAej4ebbrqJjIyMkx6zAhxBoKqqCoCYmJjj9jl071DfpnxmdXX1CT1TTlxzzKm0npaez/nz5/PZZ59hMpm47rrrTvt5cqTmns9jVTsaPXo0t956K/379z/p58n3a675dDqd3HPPPURERHDPPfec3iDlpDTXnGZnZ3PnnXcyfPhwMjIysNlsbNy4kenTp/PRRx/xyCOPEBERwc9+9rPTewNyhOaYz7KyMqBhDfvII49w1lln8Yc//IGsrCyKiop48MEHWbJkCbfeeivvvfceqampp/ku5JCWXBN99NFHOBwOwsPDT63ahvyg5prPG2+8kaSkJF588UVuv/32I+7l5OTw2GOP8eMf//gURqwjKkHh0Hns40XNgEAp1xM9u30yzzz8nJQ0jeaYU2k9LTmfW7du5c477wTg6quvZuDAgaf1PDlac89np06dGDhwIL179yY+Ph6AFStW8O677+J2u09hxPJ9mms+n3jiCXbu3Mntt9+u0r4trLnm9KabbmLKlCn07NmT6OhowsLC6NevH48//jhXXnklAP/617+oq6s7jdHLdzXHfDocDqBhp1xWVhZPPfUUXbt2xWaz0b17d5577jmSkpKorq7mpZdeOs13IIdryTXRoeMp5513Hna7/bSeJcfWXPPp8XjYtWsXVVVVhISEkJOTQ7du3bDZbOzYsYM33niDkpKSUxqzAhxBIDQ0FGj4i3A8hxbFh/o25TMPnZGSptMccyqtp6Xmc+/evVx33XXU1NRw5pln8vvf//6UnyXH19zzedVVV/Haa6/x5ptv8vXXX/PKK6+QmZnJK6+8wm233XZqg5bjao75XL9+PS+99BK9evXiF7/4xekPUk5Ka3wPveOOO7BarVRXV7NkyZImeaY0aM51LsDPfvazo344Cw8PZ/LkyQCBBIrSNFrq87lr167AcTIdT2k+zTWft9xyC8888ww9e/ZkwYIFfPzxx8ybN4+vvvqKiRMnsmjRIiZNmkRtbe1Jj1kBjiBwItt+TmT70OGio6NP+JmH+krTaY45ldbTEvNZXl7ONddcw549exg6dChPPvnk90bT5dS19Odz8ODBPP/881itVj777LNAwlFpGs0xn3fddRd+v5/77rsPi8Vy+oOUk9Ia30OjoqLo1q0bADt27GiSZ0qD5lznQmOVqu861L579+4TeqacmJb6fL799tsYhkFGRobyqDSj5pjPBQsWsHDhQuLi4nj00UePKHgRExPDgw8+SOfOnSkpKeHVV1896TErB0cQyMnJAWDPnj14PJ5j/lCzc+fOI/r+kNzcXOD7v0mf7DPlxDXHnErrae753L9/P1dffTXbt29nwIABPPfcc9rZ04xa4/OZlpZGXl4eBQUFFBQUKHlsE2qO+Vy/fj0Wi4Vf/epXR907tDV+5cqVjBo1CoA33nhDx1iaUGt9Dz30dU6lbKEcX3PMZ+fOnQN/Pt4vAw59H/X7/ScxWvkhLfH5NAyDt99+G4CLL74Yk8l0Ss+RH9Yc8/ntt98C0LdvX6Kioo66b7VaGTZsGNu2bQskDD4Z2sERBHr27InVasXtdrNmzZpj9jn0G78TTVDXr18/oCFqXVpa2iTPlBPXHHMqrac557OyspIpU6awdetW8vPzmTZtmkpRNrPW+nz6fL4j/leaRnPNp8/nY9++fUf9dyjA4fF4Am2a06bVGp9Rr9fLtm3bAJSQsok1x3z26tUrcMR6165dx+xz6IcyzWfTaonP57Jly9i9ezcmk0nHU5pZc8znyeQxOpU8LQpwBAG73c7o0aMBeP3114+6v3379sB50PHjx5/QM3Nzc8nLywNgzpw5R93/+uuv2bFjB1arlbPPPvtUhy7H0RxzKq2nueaztraWX/7yl2zcuJG8vDxefPHFY0a6pWm1xudz+/btbNq0CWhYTEjTaY753Lhx43H/u+WWWwAYOnRooC0zM7OJ3o1A63xG58yZQ01NDSEhIdoO38SaYz7Dw8MZO3YsQOA3/YczDCOQoFLz2bRa4vN5aO4GDx5Mp06dTnGkciKa6+dQgDVr1lBTU3PUfY/Hw9KlS4/oezIU4AgSN998MyaTiXfeeYc5c+YEanmXlZVxxx134Pf7Oeecc+jRo8cRrxs3bhzjxo0L1Ig+3KFF2LRp01iwYEGgfdu2bdx9990AXHnllYEs/9K0mmNOpfU09XzW19dzww03UFBQQOfOnZk5cyZxcXEt9n46uqaezw8//JCXX36Z8vLyo77WkiVLuP766/H7/fTq1YuhQ4c23xvroPTvbfvT1HO6aNEi/vGPf7B9+/Yj2t1uN7NmzeKhhx4CYPLkySQnJzffG+ugmmudGxISwrfffsvTTz8d2Enl9Xr5xz/+wYYNGwgNDeWaa65p9vfX0TTnv7l1dXV8/PHHAFx66aXN9yYkoKnnc/z48dhsNg4cOMAdd9xxxGmCqqoqpk6dyrZt2zCZTFx44YUnPV6TcWiE0ubNnDmThx9+GMMwSEtLIy4uji1btuB2u8nNzeXVV189KhjRvXt3AB566KFj/iPw4IMPBspjZWVlERERwebNm/H5fAwaNIgZM2borH8zauo5Xb58OTfffHPg2ul04nQ6sdlsREREBNrvueceLrjggmZ8Zx1TU87nv//9bx599FGg4SxxbGzscb/uE088QVJSUtO/oQ6uKedz5syZgR+Q0tLSSExMxDAMiouLOXDgAABdu3Zl2rRppKent9A77Fia43vosTz55JM89dRTDB06lFmzZjX5+5BGTTmn8+fP59e//jUAiYmJgaR3RUVFgWNH559/Po888kigJKI0reb4jM6dO5e77roLn89HfHw8mZmZ7Ny5k8rKSqxWKw8//DATJkxokffX0TTXv7lvvfUWf/7zn4mIiOCrr77Ssd0W0tTz+fbbb3PXXXfh9XoJCQkhMzMTq9XKjh07cLvdmEwmfv/733Pddded9FiVZDSIXHPNNXTv3p3p06ezZs0a9u/fT3p6OuPHj+eGG244pQ/41KlTGTBgAK+++iqFhYWUlZXRpUsXLrzwQq655hpVaWhmTT2nXq+XysrKo9rdbneghBOcft1xObamnM/D5+vQue/j0Xw2j6acz3POOQeXy8WyZcsoKipiy5YteL1e4uLiGDNmDOeddx4XXXSRfnBqRs3xPVRaV1POaX5+PjfffDOrVq1ix44dFBUV4fF4iI+PZ/To0VxyySWMGzeuGd+NNMdn9JJLLqFr16688MILfPvttxQWFhIbG8uECRO4/vrrj/qNszSd5vo399DxlPPPP1//bregpp7Piy++mB49evDSSy/x7bffsmfPHgzDICkpiQEDBvCzn/3slBOuaweHiIiIiIiIiAQ95eAQERERERERkaCnAIeIiIiIiIiIBD0FOEREREREREQk6CnAISIiIiIiIiJBTwEOEREREREREQl6CnCIiIiIiIiISNBTgENEREREREREgp4CHCIiIiIiIiIS9BTgEBEREREREZGgpwCHiIiIiIiIiAQ9BThEREREREREJOgpwCEiIiIiIiIiQU8BDhEREZHT9OSTTzJu3LjWHoaIiEiHpgCHyP9v7+5BqmwbOID/fTCj/KgGIdDAqCXboy2iISzLgtCWGqIxtaChL2hpqa2zBMFTWwhBtfQxVFSTDdWSgWJJhYQZJSQkGvkOL8rz0MdLH+p7PL/fdMN9nXP+93Qf/vd13RcAAABFT8EBAPATxsfHs3///ty+ffu7YwYHB9PR0ZHu7u5ZTAYApU3BAQDwE0ZHR7N06dK0t7dn3759ef78+fS5T58+pVAopKmpKQMDA5mcnJzDpABQWsom3XkBgBI0MTGRS5cu5erVq3n16lXGxsZSU1OTdevW5dChQ1m5cuUPP9/X15ezZ8/m/v37qaury9u3b7NkyZJUVFTkwIEDaW5uzl9/eZYEALNFwQEAlJyBgYF0dnamt7c3SVJVVZXx8fGMj48nSaqrq3P58uX/WXIkSVdXV06ePJkkWb9+fc6fP5+FCxfOXHgA4Js8VgAASsqLFy+ye/fu9Pb2ZvPmzbl161YePXqUJ0+e5PTp01mwYEE+fvyYM2fO/PB7+vv709HRkVOnTqWhoSGLFy/Oy5cvs3379ly/ft3yFACYZQoOAKBkTExMpLOzMyMjI2lra0uhUJiepVFeXp4dO3Zkz549SZIHDx5kbGzsq+/48OFDjhw5km3btmV0dDTXrl1Lc3Nzli1blps3b2bLli05evRoWlpa8vDhw1m9PgAoZQoOAKBkXLlyJX19famrq8uJEye+OWbjxo1Jks+fP2dwcPCr85WVlRkeHk6hUMiFCxeyevXq6XOLFi1KZ2dnbty4kYaGhnz58mVmLgQA+Er5XAcAAJgtXV1dSZK9e/emoqLim2Oqqqqmj7+1zKSioiJ///33D3+nvr4+hULhN5ICAD/LDA4AoCQMDQ3l2bNnSZJNmzZ9d9zw8PD08fLly2c8FwDwZyg4AICS8Pjx4yTJ0qVLs2LFiu+Oe/r0aZKkoaHhX7M5fqS9vT137979/ZAAwC9TcAAAJaGnpydJUltb+8Nxd+7cSZJs2LBhxjMBAH+OggMAKAlTy1NGR0e/O6a7uzs9PT0pKytLa2vrbEUDAP4ABQcAUBKmZnC8efMmfX19X51///799M4qO3fu/NfuKADA/z8FBwAw7w0ODmZkZCRJUl1dncOHD6e/vz/Jf7eDvXfvXtra2vL69eusWrUqx44dm8O0AMCvsE0sADDvTS1Pqa2tzcGDB3P8+PFs3bo1NTU1GRsby/j4eJJk7dq1OXfuXKqrq+cyLgDwCxQcAMC8N7UzSmNjY3bt2pXKyspcvHgx/f39KS8vT2NjY1paWtLa2prycn+PAKAYuYMDAPPe1AyONWvWJEmamprS1NQ0l5EAgD/MOzgAgHlvquBobGyc4yQAwExRcAAA89rQ0FDevXuXRMEBAPOZggMAmNemtoetrq5OfX39HKcBAGaKggMAmNf++f6NsrKyOU4DAMyUssnJycm5DgEAAADwO8zgAAAAAIqeggMAAAAoegoOAAAAoOgpOAAAAICip+AAAAAAip6CAwAAACh6Cg4AAACg6Ck4AAAAgKKn4AAAAACKnoIDAAAAKHr/AVh09nUWfKGqAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -505,7 +553,7 @@ } ], "source": [ - "s3 = NAV * sigma_a**3\n", + "s3 = NAV * sigma_a**3 # factor to calculate dimensionless density \n", "colors = sns.color_palette(\"Dark2\", n_colors = 6)\n", "plt.figure(figsize=(12, 6))\n", "\n", @@ -529,12 +577,214 @@ "sns.despine(offset=10);" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Calculate Errors compared to NIST data (MC)**\n", + "- dimensionless vapor density $\\rho^{v*}$\n", + "- dimensionless liquid density $\\rho^{l*}$\n", + "- dimensionless vapor pressure $p^{v*}$" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 80, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "def plot_vle_errors():\n", + " nist_data_subset = nist_data.loc[nist_data['t']< 1.30977] #use only data with temperatures where all EoS are subcritical\n", + "\n", + " fig, axs = plt.subplots(3, 1, sharex=True, sharey=True)\n", + "\n", + " for i, row in nist_data_subset.iterrows():\n", + " temp = row['t']\n", + " rhov = row['rhov']\n", + " rhol = row['rhol']\n", + " psat = row['p']\n", + "\n", + " vle_uvb3 = PhaseEquilibrium.pure(uvtheory_b3, temp * eps_k_k)\n", + " rhov_uvb3 = vle_uvb3.vapor.density * NAV * (sigma * ANGSTROM)**3\n", + " rhol_uvb3 = vle_uvb3.liquid.density * NAV * (sigma * ANGSTROM)**3\n", + " ps_uvb3 = vle_uvb3.vapor.pressure() / (KB * eps_k_k ) * (sigma * ANGSTROM)**3\n", + " err_uvb3_rhov = (rhov - rhov_uvb3) / rhov * 100\n", + " err_uvb3_rhol = (rhol - rhol_uvb3) / rhol * 100\n", + " err_uvb3_ps = (psat - ps_uvb3) / psat * 100\n", + "\n", + " vle_uvwca = PhaseEquilibrium.pure(uvtheory_wca, temp * eps_k_k)\n", + " rhov_uvwca = vle_uvwca.vapor.density * NAV * (sigma * ANGSTROM)**3\n", + " rhol_uvwca = vle_uvwca.liquid.density * NAV * (sigma * ANGSTROM)**3\n", + " ps_uvwca = vle_uvwca.vapor.pressure() / (KB * eps_k_k ) * (sigma * ANGSTROM)**3\n", + " err_uvwca_rhov = (rhov - rhov_uvwca) / rhov * 100\n", + " err_uvwca_rhol = (rhol - rhol_uvwca) / rhol * 100\n", + " err_uvwca_ps = (psat - ps_uvwca) / psat * 100\n", + "\n", + "\n", + " vle_uvbh = PhaseEquilibrium.pure(uvtheory_bh, temp * eps_k_k)\n", + " rhov_uvbh = vle_uvbh.vapor.density * NAV * (sigma * ANGSTROM)**3\n", + " rhol_uvbh = vle_uvbh.liquid.density * NAV * (sigma * ANGSTROM)**3\n", + " ps_uvbh = vle_uvbh.vapor.pressure() / (KB * eps_k_k ) * (sigma * ANGSTROM)**3\n", + " err_uvbh_rhov = (rhov - rhov_uvbh) / rhov * 100\n", + " err_uvbh_rhol = (rhol - rhol_uvbh) / rhol * 100\n", + " err_uvbh_ps = (psat - ps_uvbh) / psat * 100\n", + "\n", + "\n", + " axs[0].plot(temp, err_uvb3_rhov, 'r.')\n", + " axs[0].plot(temp, err_uvwca_rhov, 'g.')\n", + " axs[0].plot(temp, err_uvbh_rhov, 'b.')\n", + "\n", + " axs[1].plot(temp, err_uvb3_rhol, 'r.')\n", + " axs[1].plot(temp, err_uvwca_rhol, 'g.')\n", + " axs[1].plot(temp, err_uvbh_rhol, 'b.')\n", + " \n", + " axs[2].plot(temp, err_uvb3_ps, 'r.')\n", + " axs[2].plot(temp, err_uvwca_ps, 'g.')\n", + " axs[2].plot(temp, err_uvbh_ps, 'b.')\n", + " \n", + " \n", + " \n", + " \n", + " axs[0].plot(temp, err_uvb3_rhov, 'r.', label='uv-B3')\n", + " axs[0].plot(temp, err_uvwca_rhov, 'g.', label='uv-WCA')\n", + " axs[0].plot(temp, err_uvbh_rhov, 'b.', label='uv-BH')\n", + "\n", + "\n", + " axs[0].text(0.7, 2.1, '$Y=\\\\rho^{v*}$')\n", + " axs[1].text(0.7, 2, '$Y=\\\\rho^{l*}$')\n", + " axs[2].text(0.7, 2, '$Y=p^{v*}$')\n", + "\n", + " axs[0].legend(frameon=False, bbox_to_anchor=(1.01, 1.05))\n", + " axs[1].set_ylabel('100$(Y^{MC}-Y^{EoS}) / Y^{EoS}$')\n", + "\n", + " plt.xlabel('$T^*$') \n", + " return\n", + "\n", + "plot_vle_errors() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compare Third Virial Coefficients" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_third_virial_coeff():\n", + " tvec = np.linspace(0.5, 20, 800)\n", + " \n", + " b3_uv_wca = []\n", + " b3_uv_b3 = []\n", + " b3_thol = []\n", + " for temp in tvec:\n", + " b3_uv_wca.append(uvtheory_wca.third_virial_coefficient(temp * eps_k_k) / (sigma * ANGSTROM)**6 / NAV**2)\n", + " b3_uv_b3.append(uvtheory_b3.third_virial_coefficient(temp * eps_k_k) / (sigma * ANGSTROM)**6 / NAV**2)\n", + " b3_thol.append(thol.third_virial_coefficient(temp * eps_k_k) / (sigma * ANGSTROM)**6 / NAV**2)\n", + "\n", + " plt.plot(1/tvec, b3_uv_wca, '-', label='uv-WCA')\n", + " plt.plot(1/tvec, b3_uv_b3, label='uv-$B_3$')\n", + " plt.plot(1/tvec, b3_thol, '-', label='Thol')\n", + " plt.ylim(-10, 10)\n", + " plt.ylabel('$B_3 / \\\\sigma^6$')\n", + " plt.xlabel('$\\\\varepsilon/(k_BT)$')\n", + " plt.legend(frameon=False)\n", + " return\n", + "plot_third_virial_coeff()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compare isochoric heat capacity isotherms" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_heat_capcities(temp):\n", + " dimensionless_density = np.linspace(0.01, 1.0, 100)\n", + " cv_thol = []\n", + " cv_uv_b3 = []\n", + " cv_uv_wca = []\n", + " cv_uv_bh = []\n", + " for rho in dimensionless_density:\n", + " density = rho / (sigma * ANGSTROM)**3 / NAV\n", + " temperature = temp * eps_k_k\n", + " s_thol = State(thol, density = density, temperature = temperature)\n", + " cv_thol.append(s_thol.c_v(Contributions.ResidualNvt) / (RGAS) + 3.0 / 2.0)\n", + " s_uv_b3 = State(uvtheory_b3, density = density, temperature = temperature)\n", + " cv_uv_b3.append(s_uv_b3.c_v(Contributions.ResidualNvt) / (RGAS) + 3.0 / 2.0)\n", + " s_uv_wca = State(uvtheory_wca, density = density, temperature = temperature)\n", + " cv_uv_wca.append(s_uv_wca.c_v(Contributions.ResidualNvt) / (RGAS) + 3.0 / 2.0)\n", + " s_uv_bh = State(uvtheory_bh, density = density, temperature = temperature)\n", + " cv_uv_bh.append(s_uv_bh.c_v(Contributions.ResidualNvt) / (RGAS) + 3.0 / 2.0)\n", + " \n", + " \n", + " plt.plot(dimensionless_density, cv_thol, '-', label='Thol')\n", + " plt.plot(dimensionless_density, cv_uv_b3, '-', label='uv-$B_3$')\n", + " plt.plot(dimensionless_density, cv_uv_wca, '-', label='uv-WCA')\n", + " plt.plot(dimensionless_density, cv_uv_bh, '-', label='uv-BH')\n", + " \n", + " plt.xlabel('$\\\\rho^*$')\n", + " plt.ylabel('$C_v/Nk_B$')\n", + " plt.title('$T^*={}$'.format(temp))\n", + " plt.legend(frameon=False)\n", + " return\n", + "plot_heat_capcities(1.5)\n", + " " + ] } ], "metadata": { diff --git a/examples/uvtheory.ipynb b/examples/uvtheory.ipynb deleted file mode 100644 index 80bfcf264..000000000 --- a/examples/uvtheory.ipynb +++ /dev/null @@ -1,390 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from feos.si import *\n", - "from feos.uvtheory import UVParameters, Perturbation\n", - "from feos.pets import PetsParameters\n", - "from feos.eos import State, PhaseEquilibrium, PhaseDiagram, EquationOfState, Contributions\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Parameters for Thol EoS:\n", - "A = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0,\n", - " 2.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0])\n", - "N = np.array([0.005208073, 2.186252000, -2.161016000, 1.452700000, -2.041792000, 0.186952860, -0.090988445, \n", - " -0.497456100, 0.109014310, -0.800559220, -0.568839000, -0.620862500, -1.466717700, 1.891469000, \n", - " -0.138370100, -0.386964500, 0.126570200, 0.605781000, 1.179189000, -0.477326790, -9.921857500, -0.574793200, 0.003772923])\n", - "T = np.array([1.000, 0.320, 0.505, 0.672, 0.843, 0.898, 1.294, 2.590, 1.786, 2.770, 1.786,\n", - " 1.205, 2.830, 2.548, 4.650, 1.385, 1.460, 1.351, 0.660, 1.496, 1.830, 1.616, 4.970])\n", - "D = np.array([4.0, 1.0, 1.0, 2.0, 2.0, 3.0, 5.0, 2.0, 2.0, 3.0, 1.0,\n", - " 1.0, 1.0, 1.0, 2.0, 3.0, 3.0, 2.0, 1.0, 2.0, 3.0, 1.0, 1.0])\n", - "L = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 1.0, 2.0, 2.0,\n", - " 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])\n", - "ETA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2.067, 1.522,\n", - " 8.82, 1.722, 0.679, 1.883, 3.925, 2.461, 28.2, 0.753, 0.82])\n", - "BETA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.625,\n", - " 0.638, 3.91, 0.156, 0.157, 0.153, 1.16, 1.73, 383, 0.112, 0.119])\n", - "GAMMA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.71,\n", - " 0.86, 1.94, 1.48, 1.49, 1.945, 3.02, 1.11, 1.17, 1.33, 0.24])\n", - "EPSILON = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.2053,\n", - " 0.409, 0.6, 1.203, 1.829, 1.397, 1.39, 0.539, 0.934, 2.369, 2.43])\n", - "\n", - "class Thol:\n", - " def __init__(self):\n", - " self.sigma = 3.7039 * ANGSTROM\n", - " self.eps_k = 150.03 * KELVIN\n", - " self.tc = 1.32 * self.eps_k / KELVIN\n", - " self.rhoc = 0.31 / self.sigma**3 * ANGSTROM**3\n", - " \n", - " def components(self): \n", - " return 1\n", - " \n", - " def subset(self, components):\n", - " return self\n", - " \n", - " def molar_weight(self):\n", - " return np.array([1.0])\n", - " \n", - " def max_density(self, moles):\n", - " return 0.04\n", - " \n", - " def helmholtz_energy(self, state):\n", - " \"\"\"\n", - " state (StateHD):\n", - " temperature in Kelvin als Float, Dual oder HD oder HD3, HDD, HDD3,\n", - " partial_density in # / Angstrom^3\n", - " volume in Angstrom^3\n", - " moles in mol\n", - " \"\"\"\n", - " tau = self.tc / state.temperature\n", - " delta = np.sum(state.partial_density) / self.rhoc\n", - " a = 0.0 #zero(state)\n", - " \n", - " # print(\"v\", state.volume)\n", - " # print(\"n\", state.moles)\n", - " #print(\"partial density\", state.partial_density)\n", - " #print(\"1\")\n", - " # print(\"delta: {}\".format(delta))\n", - " # print(\"tau: {}\".format(tau))\n", - " \n", - " for i in range(6):\n", - " a = a + N[i] * delta**D[i] * tau**T[i]\n", - " \n", - " # print(\"2\")\n", - " for i in range(6, 12):\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", - " # print(\"3\")\n", - " for i in range(12, 23):\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n", - " return a * np.sum(state.moles)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "sigma = 3.7039\n", - "sigma_a = sigma * ANGSTROM\n", - "eps_k = 150.03\n", - "eps_k_k = eps_k * KELVIN\n", - "\n", - "parameters = UVParameters.from_lists([12.0], [6.0], [sigma], [eps_k])\n", - "uvtheory_wca = EquationOfState.uvtheory(parameters)\n", - "uvtheory_bh = EquationOfState.uvtheory(parameters, perturbation=Perturbation.BarkerHenderson)\n", - "\n", - "parameters = PetsParameters.from_values(sigma, eps_k)\n", - "pets = EquationOfState.pets(parameters)\n", - "\n", - "thol = EquationOfState.python(Thol())\n", - "s3 = State(thol, temperature=300*KELVIN, pressure=1*BAR)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "s1 = State(uvtheory_wca, temperature=300*KELVIN, pressure=1*BAR)\n", - "s2 = State(pets, temperature=300*KELVIN, pressure=1*BAR)\n", - "s3 = State(thol, temperature=300*KELVIN, pressure=1*BAR)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-0.0016213224956115704" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s1.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-0.0009407040108813868" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s2.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-0.0016144150962601586" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s3.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(1.3200003469821506, 1.3097658041494302, 1.3208296613277393)" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "State.critical_point(thol).temperature / eps_k_k, State.critical_point(uvtheory_wca).temperature / eps_k_k, State.critical_point(uvtheory_bh).temperature / eps_k_k" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 52.5 ms, sys: 1.45 ms, total: 54 ms\n", - "Wall time: 54.2 ms\n" - ] - } - ], - "source": [ - "%%time\n", - "vle_uv = PhaseDiagram.pure(uvtheory_wca, 150*KELVIN, 500)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "vle_uv.liquid" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 49 ms, sys: 1.77 ms, total: 50.7 ms\n", - "Wall time: 52.6 ms\n" - ] - } - ], - "source": [ - "%%time\n", - "vle_uv_bh = PhaseDiagram.pure(uvtheory_bh, 150*KELVIN, 500)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:65: RuntimeWarning: overflow encountered in exp\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:65: RuntimeWarning: invalid value encountered in exp\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:68: RuntimeWarning: overflow encountered in exp\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n", - "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:68: RuntimeWarning: invalid value encountered in exp\n", - " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 1.9 s, sys: 16.4 ms, total: 1.92 s\n", - "Wall time: 1.93 s\n" - ] - } - ], - "source": [ - "%%time\n", - "vle_thol = PhaseDiagram.pure(thol, 150*KELVIN, 500)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 27 ms, sys: 1.68 ms, total: 28.7 ms\n", - "Wall time: 32.6 ms\n" - ] - } - ], - "source": [ - "%%time\n", - "vle_pets = PhaseDiagram.pure(pets, 150*KELVIN, 500)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "s3 = NAV * sigma_a**3\n", - "plt.plot(vle_uv.vapor.density * s3 , vle_uv.vapor.temperature / eps_k_k, color='black')\n", - "plt.plot(vle_uv.liquid.density * s3, vle_uv.vapor.temperature / eps_k_k, color='black')\n", - "\n", - "plt.plot(vle_uv_bh.vapor.density * s3 , vle_uv_bh.vapor.temperature / eps_k_k, color='black', linestyle='dashed')\n", - "plt.plot(vle_uv_bh.liquid.density * s3, vle_uv_bh.vapor.temperature / eps_k_k, color='black', linestyle='dashed')\n", - "\n", - "plt.plot(vle_thol.vapor.density * s3, vle_thol.vapor.temperature / eps_k_k, color='red')\n", - "plt.plot(vle_thol.liquid.density * s3, vle_thol.vapor.temperature / eps_k_k, color='red')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "vle_thol = PhaseDiagram.pure(thol, 150*KELVIN, 500)\n", - "s3 = NAV * sigma_a**3\n", - "plt.plot(vle_uv.vapor.density * s3 , vle_uv.vapor.temperature / eps_k_k, color='black')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/uvtheory_versions.ipynb b/examples/uvtheory_versions.ipynb deleted file mode 100644 index 6a7291d5d..000000000 --- a/examples/uvtheory_versions.ipynb +++ /dev/null @@ -1,572 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from feos.si import *\n", - "from feos.uvtheory import UVParameters, Perturbation, VirialOrder\n", - "from feos.eos import State, PhaseEquilibrium, PhaseDiagram, EquationOfState, Contributions\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# **Comparison of differrent versions of the uv-theory for Mie fluids**" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- WCA uv-theory [J. Chem. Phys. 155, 244501 (2021)]\n", - "- BH uv-theory [J. Chem. Phys. 155, 244501 (2021)]\n", - "- uv-$B_3$-theory [to be published]\n", - " - highly accurate\n", - " - only for attractive exponents of 6\n", - " - based on WCA divison of the potential" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Class for dimensionless evaluation of LJ / Mie EoS**" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "class EOS_PROPERTIES():\n", - " def __init__(self, eos, sigma=3.7039, eps_k=150.03, rep=12, att=6.0):\n", - " \"\"\"Python class for the dimensionless evaluation of pure Mie-nu-6 EoS\n", - " Input: EquationOfState from feos,\n", - " Optional: diameter sigma, eps / kB, repulsive exponent rep, attractive exponent att\n", - " \"\"\"\n", - " self.sigma = sigma\n", - " self.nu = rep\n", - " self.eps_k = eps_k\n", - " self.eos = eos \n", - " \n", - " def eos_state(self, temp, rho): \n", - " temperature = temp * self.eps_k * KELVIN\n", - " density = rho / (self.sigma**3 * ANGSTROM**3 * NAV)\n", - " return State(self.eos, temperature=temperature, density=density) \n", - " \n", - " ##### dimensionless quantities ###########\n", - " def res_helmholtz_energy(self, rho, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " return self.eos_state(temp, rho).helmholtz_energy(Contributions.ResidualNvt) / (KB * temperature)\n", - " \n", - " def tot_helmholtz_energy(self, rho, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " return self.eos_state(temp, rho).helmholtz_energy() / (KB * temperature)\n", - " \n", - " def internal_energy(self, rho, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " return self.eos_state(temp, rho).internal_energy(Contributions.ResidualNvt) / (KB * temperature) * temp\n", - " \n", - " def chemical_potential(self, rho, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " return (self.eos_state(temp, rho).chemical_potential(Contributions.ResidualNvt) / RGAS / temperature)[0] * temp\n", - " \n", - " def total_pressure(self, rho, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " p_vec = self.eos_state(temp, rho).pressure() * (self.sigma)**3 * ANGSTROM**3 /(KB * temperature) * temp\n", - " return p_vec\n", - " \n", - " def residual_pressure(self, rho, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " p_vec = self.eos_state(temp, rho).pressure(Contributions.ResidualNvt) * (self.sigma)**3 * ANGSTROM**3 /(KB * temperature) * temp\n", - " return p_vec\n", - " \n", - " def heat_capacity_cv(self, rho, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " return self.eos_state(temp, rho).c_v(Contributions.ResidualNvt) / (RGAS) + 3.0 / 2.0 ## total\n", - " \n", - " def heat_capacity_cp(self, rho, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " return self.eos_state(temp, rho).c_p(Contributions.ResidualNvt) / (RGAS) + 5.0 / 2.0\n", - " \n", - " def compressibility(self, rho, temp):\n", - " return self.eos_state(temp, rho).compressibility()\n", - " \n", - " def isothermal_compressibility(self, rho, temp): # beta_t = 1 / rho*(dp/drho)\n", - " return -1.0 / (self.eos_state(temp, rho).dp_dv() / self.eos_state(temp, rho).density) * KB * self.eps_k * KELVIN * NAV / (self.sigma**3 * ANGSTROM**3)\n", - " \n", - " def thermal_pressure_coefficient(self, rho, temp):\n", - " return self.eos_state(temp, rho).dp_dt() / KB * self.sigma**3 * ANGSTROM**3\n", - " \n", - " def thermal_expansion_coefficient(self, rho, temp):\n", - " return self.thermal_pressure_coefficient(rho, temp) * self.isothermal_compressibility(rho, temp)\n", - " \n", - " def isotropic_compressibility(self, rho, temp):\n", - " return self.eos_state(temp, rho).isentropic_compressibility() * self.eps_k * KELVIN * KB / (self.sigma**3 * ANGSTROM**3)\n", - " \n", - " def speed_of_sound(self, rho, temp): \n", - " return (self.heat_capacity_cp(rho, temp) / self.heat_capacity_cv(rho, temp) / rho / self.isothermal_compressibility(rho, temp))**0.5\n", - " \n", - " \n", - " def joule_thomson(self, rho, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " return (self.isothermal_compressibility(rho, temp) * self.thermal_pressure_coefficient(rho, temp) * temp - 1.0) / (rho * self.heat_capacity_cp(rho, temp))\n", - " \n", - " def grueneisen_parameter(self, rho, temp):\n", - " return self.eos_state(temp, rho).dp_dt() / (rho * self.heat_capacity_cv(rho, temp)) / KB * self.sigma**3 * ANGSTROM**3\n", - " \n", - " def enthalpy(self, rho, temp):\n", - " return self.eos_state(temp, rho).enthalpy() / (KB * self.eps_k * KELVIN) \n", - " \n", - " ############ Virial coefficients ###############################\n", - " def second_virial_coefficient(self, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " return self.eos.second_virial_coefficient(temperature) / (self.sigma**3 * ANGSTROM**3 * NAV)\n", - " \n", - " def third_virial_coefficient(self, temp): # Recheck!\n", - " temperature = temp * self.eps_k * KELVIN\n", - " return self.eos.third_virial_coefficient(temperature) / (self.sigma**3 * ANGSTROM**3 * NAV)**2 \n", - " \n", - " ##### VLE #####\n", - " def vapor_pressure(self, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " vle = PhaseEquilibrium.pure(self.eos, temperature)\n", - " return vle.vapor_pressure(self.eos, temperature)[0] * self.sigma**3 * ANGSTROM**3 / (self.eps_k * KELVIN * KB)\n", - " \n", - " def critical_point(self, initial_temp = 340*KELVIN ):\n", - " return State.critical_point(self.eos, initial_temperature=initial_temp)\n", - " \n", - " def critical_pressure(self):\n", - " return State.critical_point(self.eos, initial_temperature=100*KELVIN).pressure() * self.sigma**3 * ANGSTROM**3 / (self.eps_k * KELVIN * KB)\n", - " \n", - " def critical_density(self):\n", - " return self.critical_point().density * (self.sigma**3 * ANGSTROM**3 * NAV)\n", - " \n", - " def critical_temperature(self):\n", - " return self.critical_point().temperature / (self.eps_k * KELVIN)\n", - " \n", - " def vle_pressure(self, p):\n", - " return PhaseEquilibrium.pure_p(self.eos, p * BAR)\n", - " \n", - " def vle_pressure_temperature(self, p):\n", - " return PhaseEquilibrium.pure_p(self.eos, p * BAR).temperature / (self.eps_k * KELVIN)\n", - " \n", - " def vle_pressure_density(self, p):\n", - " return PhaseEquilibrium.pure_p(self.eos, p * BAR).vapor.density * (self.sigma**3 * ANGSTROM**3 * NAV), VLEState.pure_p(self.eos, p * BAR).liquid.density * (self.sigma**3 * ANGSTROM**3 * NAV)\n", - " \n", - " def vle_temperature(self, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " return PhaseEquilibrium.pure_t(self.eos, temperature)\n", - " \n", - " def vle_temperature_dimensionless(self, temp):\n", - " vle = self.vle_temperature(temp)\n", - " return vle.vapor.density * (self.sigma**3 * ANGSTROM**3 * NAV), vle.liquid.density * (self.sigma**3 * ANGSTROM**3 * NAV)\n", - " \n", - " def vapor_density(self, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " vle = PhaseEquilibrium.pure(self.eos, temperature)\n", - " return vle.vapor.density * (self.sigma**3 * ANGSTROM**3 * NAV)\n", - " \n", - " def liquid_density(self, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " vle = PhaseEquilibrium.pure(self.eos, temperature)\n", - " return vle.liquid.density * (self.sigma**3 * ANGSTROM**3 * NAV)\n", - " \n", - " def enthalpy_of_vaporization(self, temp):\n", - " temperature = temp * self.eps_k * KELVIN\n", - " hv = self.enthalpy(self.vapor_density(temp), temp)\n", - " hl = self.enthalpy(self.liquid_density(temp), temp)\n", - " dhv = hv - hl\n", - " return dhv\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def get_eos(name, rep, sigma = 3.7039, eps_k = 150.03, att=6.0):\n", - " nu = rep\n", - " \n", - " if name == 'thol':\n", - " eos = EquationOfState.python(Thol(sigma, eps_k))\n", - " \n", - " if name == 'uv_wca':\n", - " parameters = UVParameters.from_lists([rep], [att], [sigma], [eps_k])\n", - " eos = EquationOfState.uvtheory(parameters, perturbation=Perturbation.WeeksChandlerAndersen, virial_order=VirialOrder.Second)\n", - " \n", - " if name == 'uv_bh':\n", - " parameters = UVParameters.from_lists([rep], [att], [sigma], [eps_k])\n", - " eos = EquationOfState.uvtheory(parameters, perturbation=Perturbation.BarkerHenderson, virial_order=VirialOrder.Second) \n", - "\n", - " if name == 'uv_b3':\n", - " parameters = UVParameters.from_lists([rep], [att], [sigma], [eps_k])\n", - " eos = EquationOfState.uvtheory(parameters, perturbation=Perturbation.WeeksChandlerAndersen, virial_order=VirialOrder.Third)\n", - " \n", - " \n", - " return EOS_PROPERTIES(eos, sigma=sigma, eps_k=eps_k, rep=rep, att=att)\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## **Examples**" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "rep = 12\n", - "att = 6.0\n", - "sigma = 3.7039 # in Angstrom\n", - "eps_k = 150.03 # eps / kB in K\n", - "uv_bh = get_eos('uv_bh', rep, sigma, eps_k, att)\n", - "uv_wca = get_eos('uv_wca', rep, sigma, eps_k, att)\n", - "uv_b3 = get_eos('uv_b3', rep, sigma, eps_k, att)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Lennard-Jones (LJ) Virial coefficients**" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def plot_second_virial_coeff():\n", - " tvec = np.linspace(0.5, 20, 500)\n", - " b2_thol = []\n", - " b2_uv_wca = []\n", - " b2_uv_bh = []\n", - " b2_uv_b3 = []\n", - " for temp in tvec:\n", - " b2_uv_wca.append(uv_wca.second_virial_coefficient(temp))\n", - " b2_uv_bh.append(uv_bh.second_virial_coefficient(temp))\n", - " b2_uv_b3.append(uv_b3.second_virial_coefficient(temp))\n", - "\n", - " plt.plot(1/tvec, b2_uv_bh, ':', label='uv-BH')\n", - " plt.plot(1/tvec, b2_uv_wca, '--', label='uv-WCA')\n", - " plt.plot(1/tvec, b2_uv_b3, label='uv-$B_3$')\n", - " plt.ylim(-20, 2)\n", - " plt.ylabel('$B_2 / \\\\sigma^3$')\n", - " plt.xlabel('$\\\\varepsilon/(k_BT)$')\n", - " plt.legend(frameon=False)\n", - " return\n", - "plot_second_virial_coeff()" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "jupyter": { - "source_hidden": true - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def plot_third_virial_coeff():\n", - " tvec = np.linspace(0.5, 20, 800)\n", - " \n", - " b2_uv_wca = []\n", - " b2_uv_bh = []\n", - " b2_uv_b3 = []\n", - " for temp in tvec:\n", - " b2_uv_wca.append(uv_wca.third_virial_coefficient(temp))\n", - " b2_uv_bh.append(uv_bh.third_virial_coefficient(temp))\n", - " b2_uv_b3.append(uv_b3.third_virial_coefficient(temp))\n", - "\n", - " #plt.plot(1/tvec, b2_uv_bh, ':', label='uv-BH')\n", - " plt.plot(1/tvec, b2_uv_wca, '--', label='uv-WCA')\n", - " plt.plot(1/tvec, b2_uv_b3, label='uv-$B_3$')\n", - " plt.ylim(-10, 10)\n", - " plt.ylabel('$B_3 / \\\\sigma^6$')\n", - " plt.xlabel('$\\\\varepsilon/(k_BT)$')\n", - " plt.legend(frameon=False)\n", - " return\n", - "plot_third_virial_coeff()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**LJ Isotherms**" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def plot_helmholtz_energy(temperature, dimensionless_density = np.linspace(0.01, 1.1, 100)):\n", - "\n", - " a_uv_bh = []\n", - " a_uv_wca = []\n", - " a_uv_b3 = []\n", - " for rho in dimensionless_density:\n", - " a_uv_bh.append(uv_bh.res_helmholtz_energy(rho, temperature))\n", - " a_uv_wca.append(uv_bh.res_helmholtz_energy(rho, temperature))\n", - " a_uv_b3.append(uv_b3.res_helmholtz_energy(rho, temperature))\n", - " \n", - " plt.plot(dimensionless_density, a_uv_bh, '--', label='uv-BH')\n", - " plt.plot(dimensionless_density, a_uv_wca, ':', label='uv-WCA')\n", - " plt.plot(dimensionless_density, a_uv_bh, label='uv-$B_3$')\n", - " plt.xlabel('$\\\\rho^*$')\n", - " plt.ylabel('$A/(Nk_BT)$')\n", - " plt.title('$T^*={}$'.format(temperature))\n", - " plt.legend(frameon=False)\n", - " return\n", - "plot_helmholtz_energy(temperature=0.5, dimensionless_density=np.linspace(0.01, 1.0, 100))" - ] - }, - { - "cell_type": "code", - "execution_count": 193, - "metadata": { - "jupyter": { - "source_hidden": true - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def plot_heat_capcities(temperature):\n", - " dimensionless_density = np.linspace(0.01, 1.0, 100)\n", - " a_thol = []\n", - " a_uv_bh = []\n", - " a_uv_wca = []\n", - " a_uv_b3 = []\n", - " for rho in dimensionless_density:\n", - " a_thol.append(thol.heat_capacity_cv(rho, temperature))\n", - " a_uv_bh.append(uv_bh.heat_capacity_cv(rho, temperature))\n", - " a_uv_wca.append(uv_bh.heat_capacity_cv(rho, temperature))\n", - " a_uv_b3.append(uv_b3.heat_capacity_cv(rho, temperature))\n", - " \n", - " plt.plot(dimensionless_density, a_thol, '--', label='Thol')\n", - " plt.plot(dimensionless_density, a_uv_bh, ':', label='uv-BH')\n", - " plt.plot(dimensionless_density, a_uv_wca, '.', label='uv-WCA')\n", - " plt.plot(dimensionless_density, a_uv_bh, label='uv-$B_3$')\n", - " plt.xlabel('$\\\\rho^*$')\n", - " plt.ylabel('$C_v/Nk_B$')\n", - " plt.title('$T^*={}$'.format(temperature))\n", - " plt.legend(frameon=False)\n", - " return\n", - "plot_heat_capcities(1.4)\n", - " \n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Critical Point**" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Critical point LJ Fluid\n", - "Reference: Potoff and Panagiotopoulos (MC) Tc*=1.3120, rhoc*=0.316, pc*=0.1279\n", - "uv_b3\n", - "Tc*=1.31329, ADD: 0.099%\n", - "pc*=0.1286, ADD: 0.548%\n", - "rhoc*=0.31425, ADD: 0.553%\n", - "uv_wca\n", - "Tc*=1.30977, ADD: 0.17%\n", - "pc*=0.12448, ADD: 2.674%\n", - "rhoc*=0.30233, ADD: 4.327%\n", - "uv_bh\n", - "Tc*=1.32083, ADD: 0.673%\n", - "pc*=0.13486, ADD: 5.442%\n", - "rhoc*=0.31865, ADD: 0.838%\n" - ] - } - ], - "source": [ - "def evaluate_critical_points():\n", - " print('Critical point LJ Fluid')\n", - " print('Reference: Potoff and Panagiotopoulos (MC) Tc*=1.3120, rhoc*=0.316, pc*=0.1279')\n", - " for name in ['uv_b3', 'uv_wca', 'uv_bh']:\n", - " rep = 12\n", - " att = 6.0\n", - " sigma = 3.7039 # in Angstrom\n", - " eps_k = 150.03 # eps / kB in K\n", - " eos = get_eos(name, rep, sigma, eps_k, att)\n", - " print(name)\n", - " print('Tc*={}, ADD: {}%'.format(np.round(eos.critical_temperature(), 5), np.round(np.abs(eos.critical_temperature() - 1.3120 ) / 1.3120 * 100 ,3)))\n", - " print('pc*={}, ADD: {}%'.format(np.round(eos.critical_pressure(), 5), np.round(np.abs(eos.critical_pressure() - 0.1279 ) / 0.1279 * 100 ,3)))\n", - " print('rhoc*={}, ADD: {}%'.format(np.round(eos.critical_density(), 5), np.round(np.abs(eos.critical_density() - 0.316) / 0.316 * 100 ,3)))\n", - " return\n", - "\n", - "evaluate_critical_points()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**VLE**" - ] - }, - { - "cell_type": "code", - "execution_count": 225, - "metadata": { - "jupyter": { - "source_hidden": true - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def plot_vle():\n", - " names = ['uv_wca', 'uv_bh', 'uv_b3']\n", - " for name in names:\n", - " axes = plt.gca()\n", - " color = next(axes._get_lines.prop_cycler)['color']\n", - " rep = 12\n", - " att = 6.0\n", - " sigma = 3.7039 # in Angstrom\n", - " eps_k = 150.03 # eps / kB in K\n", - " eos = get_eos(name, rep, sigma, eps_k, att)\n", - " tc = eos.critical_temperature()\n", - " eos_rhol = []\n", - " eos_rhov = []\n", - " temperatures = np.linspace(0.7, 0.99999 *tc, 100)\n", - " for temp in temperatures:\n", - " eos_rhol.append(eos.liquid_density(temp))\n", - " eos_rhov.append(eos.vapor_density(temp))\n", - " plt.plot(eos.critical_density(), eos.critical_temperature(), 'x', color=color)\n", - " plt.plot( eos_rhov, temperatures, color=color)\n", - " plt.plot( eos_rhol, temperatures, color=color, label='{}'.format(name))\n", - " plt.legend(frameon=False)\n", - " plt.xlabel('$\\\\rho^*$')\n", - " plt.ylabel('$T^*$')\n", - " return\n", - "plot_vle()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "venv_feos05", - "language": "python", - "name": "venv_feos05" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} From 98c2c17bb7d9773b1bccb833b761d0c4ca0cd089 Mon Sep 17 00:00:00 2001 From: Anja Reimer Date: Thu, 12 Jan 2023 12:32:31 +0100 Subject: [PATCH 13/14] cleanup mod --- src/uvtheory/eos/mod.rs | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/src/uvtheory/eos/mod.rs b/src/uvtheory/eos/mod.rs index 2ff548491..143b859c0 100644 --- a/src/uvtheory/eos/mod.rs +++ b/src/uvtheory/eos/mod.rs @@ -204,11 +204,9 @@ mod test { fn helmholtz_energy_pure_bh() -> EosResult<()> { let eps_k = 150.03; let sig = 3.7039; - let r = UVRecord::new(24.0, 6.0, sig, eps_k); - let i = Identifier::new(None, None, None, None, None, None); - let pr = PureRecord::new(i, 1.0, r, None); - let parameters = UVParameters::new_pure(pr); - + let rep = 24.0; + let att = 6.0; + let parameters = UVParameters::new_simple(rep, att, sig, eps_k); let options = UVTheoryOptions { max_eta: 0.5, perturbation: Perturbation::BarkerHenderson, @@ -222,6 +220,7 @@ mod test { let moles = arr1(&[2.0]) * MOL; let volume = (sig * ANGSTROM).powi(3) / reduced_density * NAV * 2.0 * MOL; let s = State::new_nvt(&eos, temperature, volume, &moles).unwrap(); + let a = s .molar_helmholtz_energy(Contributions::ResidualNvt) .to_reduced(RGAS * temperature) @@ -235,11 +234,9 @@ mod test { fn helmholtz_energy_pure_uvb3() -> EosResult<()> { let eps_k = 150.03; let sig = 3.7039; - let r = UVRecord::new(12.0, 6.0, sig, eps_k); - let i = Identifier::new(None, None, None, None, None, None); - let pr = PureRecord::new(i, 1.0, r, None); - let parameters = UVParameters::new_pure(pr); - + let rep = 12.0; + let att = 6.0; + let parameters = UVParameters::new_simple(rep, att, sig, eps_k); let options = UVTheoryOptions { max_eta: 0.5, perturbation: Perturbation::WeeksChandlerAndersen, @@ -264,7 +261,7 @@ mod test { #[test] fn helmholtz_energy_mixtures_bh() -> EosResult<()> { - // Mixture of equal components --> result must be the same as fpr pure fluid /// + // Mixture of equal components --> result must be the same as for pure fluid /// // component 1 let rep1 = 24.0; let eps_k1 = 150.03; From e2e28897d28b7ccc3dcec5b3e7e3b7c066b61e11 Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Thu, 19 Jan 2023 14:48:08 +0100 Subject: [PATCH 14/14] update changelogs --- CHANGELOG.md | 1 + feos-core/CHANGELOG.md | 1 + 2 files changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index fea4211a6..ab92152c9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Added `estimator` module to documentation. [#86](https://github.com/feos-org/feos/pull/86) - Added benchmarks for the evaluation of the Helmholtz energy and some properties of the `State` object for PC-SAFT. [#89](https://github.com/feos-org/feos/pull/89) - The Python class `StateVec` is exposed in both the `feos.eos` and `feos.dft` module. [#113](https://github.com/feos-org/feos/pull/113) +- Added uv-B3-theory and additional optional argument `virial_order` to uvtheory constructor to enable uv-B3. [#98](https://github.com/feos-org/feos/pull/98) ### Changed - Export `EosVariant` and `FunctionalVariant` directly in the crate root instead of their own modules. [#62](https://github.com/feos-org/feos/pull/62) diff --git a/feos-core/CHANGELOG.md b/feos-core/CHANGELOG.md index 75dd1b99c..1741b4d10 100644 --- a/feos-core/CHANGELOG.md +++ b/feos-core/CHANGELOG.md @@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Added `PhaseDiagram::par_pure` that uses rayon to calculate phase diagrams in parallel. [#57](https://github.com/feos-org/feos/pull/57) - Added `StateVec::moles` getter. [#113](https://github.com/feos-org/feos/pull/113) - Added public constructors `PhaseDiagram::new` and `StateVec::new` that allow the creation of the respective structs from a list of `PhaseEquilibrium`s or `State`s in Rust and Python. [#113](https://github.com/feos-org/feos/pull/113) +- Added new variant `EosError::Error` which allows dispatching generic errors that are not covered by the existing variants. [#98](https://github.com/feos-org/feos/pull/98) ### Changed - Added `Sync` and `Send` as supertraits to `EquationOfState`. [#57](https://github.com/feos-org/feos/pull/57)