From 6bb1b4a82e063f5af9482f70296549f2da954551 Mon Sep 17 00:00:00 2001 From: Paul Bowen <48794746+pb475@users.noreply.github.com> Date: Sat, 23 Nov 2024 19:05:00 +0100 Subject: [PATCH 1/5] Barahona and Nenes 2007 entraining example --- .../Barahona_and_Nenes_2007/fig_1.ipynb | 613 ++++++++++++++++++ 1 file changed, 613 insertions(+) create mode 100644 examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb diff --git a/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb new file mode 100644 index 000000000..3f1de0ecc --- /dev/null +++ b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb @@ -0,0 +1,613 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "nS021k0eQ5K7", + "outputId": "578a2bd3-5783-4710-a7c0-742504462c6c", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/302.0 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m \u001b[32m297.0/302.0 kB\u001b[0m \u001b[31m20.7 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m302.0/302.0 kB\u001b[0m \u001b[31m5.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.4/1.4 MB\u001b[0m \u001b[31m28.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m865.8/865.8 kB\u001b[0m \u001b[31m18.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + } + ], + "source": [ + "!pip install --quiet pint mendeleev" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "_KYH2YCDF4CF" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pint\n", + "from matplotlib import pyplot\n", + "import scipy\n", + "\n", + "si = pint.UnitRegistry()\n", + "si.setup_matplotlib()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "3Gd21_5yF4CG" + }, + "outputs": [], + "source": [ + "class Constants:\n", + " from scipy import constants\n", + " import mendeleev as pt\n", + "\n", + " # polynomial fot to equilibrium vapour pressure wrt water (coefficients from Flatau et al. 1992)\n", + " # doi:10.1175/1520-0450(1992)031<1507%3APFTSVP>2.0.CO%3B2\n", + " c_w = (6.115836990e000, 0.444606896e000, 0.143177157e-01, 0.264224321e-03, 0.299291081e-05,\n", + " 0.203154182e-07, 0.702620698e-10, 0.379534310e-13, -.321582393e-15)\n", + "\n", + " T0 = T0 = constants.zero_Celsius * si.kelvin\n", + "\n", + " def __molar_mass(x):\n", + " return x.atomic_weight * si.gram / si.mole\n", + "\n", + " M_a = (\n", + " 0.78 * __molar_mass(pt.N) * 2 +\n", + " 0.21 * __molar_mass(pt.O) * 2 +\n", + " 0.01 * __molar_mass(pt.Ar)\n", + " )\n", + " M_v = __molar_mass(pt.O) + __molar_mass(pt.H) * 2\n", + "\n", + " R_str = constants.R * si.joule / si.kelvin / si.mole\n", + "\n", + " R_a = R_str / M_a\n", + " R_v = R_str / M_v\n", + "\n", + " g = constants.g * si.metre / si.second**2\n", + "\n", + " l_v = 2.5e6 * si.joule / si.kilogram\n", + " c_p = 1000 * si.joule / si.kilogram / si.kelvin\n", + "\n", + " D = 2.26e-5 * si.metre ** 2 / si.second\n", + " K = 2.4e-2 * si.joules / si.metres / si.seconds / si.kelvins\n", + " rho_w = 1 * si.kilogram / si.litre\n", + " sigma_w = 0.072 * si.joule / si.metre**2\n", + "\n", + " epsilon = R_a/R_v" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "vlM1J4LZF4CG" + }, + "outputs": [], + "source": [ + "class Formulae:\n", + " @staticmethod\n", + " def rho(p, R, T):\n", + " return p / (R * T)\n", + "\n", + " @staticmethod\n", + " def __p_sat(temperature, coefficients, valid_range):\n", + " from numpy.polynomial.polynomial import polyval\n", + "\n", + " value = polyval(temperature.to(si.celsius).magnitude, coefficients)\n", + "\n", + " if isinstance(temperature.magnitude, np.ndarray):\n", + " value[np.logical_or(temperature < valid_range[0], temperature > valid_range[1])] = np.nan\n", + " else:\n", + " value = np.nan if not valid_range[0] < temperature <= valid_range[1] else value\n", + "\n", + " return value * si.hectopascals\n", + "\n", + " @staticmethod\n", + " def p_eq(T):\n", + " # TODO! kappa Koehler\n", + " return Formulae.__p_sat(T, Constants.c_w, (Constants.T0-85 * si.kelvin, np.inf * si.kelvin))\n", + "\n", + " @staticmethod\n", + " def r_dr_dt(S_eq, T, S, rho_eq):\n", + " return (\n", + " (S - S_eq)\n", + " / Constants.rho_w\n", + " / (1/rho_eq / Constants.D + Constants.l_v**2 / Constants.K / T**2 / Constants.R_v)\n", + " )\n", + " # TODO: something wrong in this one, units aren't working out as expected, expecting r*dr_dt to work out as [length]*[length / time].\n", + " # perhaps there is something fishy with the Constants.l_v**2 / Constants.K / T**2 / Constants.R_v term...\n", + "\n", + " # def S_eq(a, kappa, a_dry_3, T): # adapted from https://github.com/open-atmos/PySDM/blob/83b1edd16dbcb8e97a7a4beaf77822fac7016e94/PySDM/physics/hygroscopicity/kappa_koehler_leading_terms.py#L16\n", + " # print( \"s_eq, dimension of first part: \", (2 * Constants.sigma_w / Constants.R_v / T / Constants.rho_w) / a )\n", + " # print( \"s_eq, dimension of second part: \", (kappa * a_dry_3 / a**3).dimensionality )\n", + " # return (\n", + " # (2 * Constants.sigma_w / Constants.R_v / T / Constants.rho_w) / a - kappa * a_dry_3 / a**3\n", + " # )\n", + "\n", + " @staticmethod\n", + " def RH_eq(r, T, kp, a_dry_3, sgm): # from https://github.com/open-atmos/PySDM/blob/main/PySDM/physics/hygroscopicity/kappa_koehler.py\n", + " return (\n", + " np.exp((2 * sgm / Constants.R_v / T / Constants.rho_w) / r)\n", + " * (r**3 - a_dry_3)\n", + " / (r**3 - a_dry_3 * (1 - kp))\n", + " )\n", + "\n", + " @staticmethod\n", + " def S_eq(a, kappa, a_dry_3, T): # adapted from RH_eq above\n", + " return (\n", + " np.exp((2 * Constants.sigma_w / Constants.R_v / T / Constants.rho_w) / a)\n", + " * (a**3 - a_dry_3)\n", + " / (a**3 - a_dry_3 * (1 - kappa))\n", + " ) - 1\n", + "\n", + "\n", + "\n", + " @staticmethod\n", + " def r_cr(kp, a_dry_3, T, sgm): # from https://github.com/open-atmos/PySDM/blob/main/PySDM/physics/hygroscopicity/kappa_koehler.py\n", + " return np.sqrt(3 * kp * a_dry_3 / (2 * sgm / Constants.R_v / T / Constants.rho_w))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "EaiiPI4TF4CH" + }, + "outputs": [], + "source": [ + "class Storage:\n", + " \"\"\" utility class to make pint and scipy.odeint integration seamless \"\"\"\n", + " class __Impl(np.ndarray):\n", + " p_idx, p_unit = 0, si.hectopascals\n", + " T_idx, T_unit = 1, si.kelvins\n", + " w_v_idx, w_v_unit = 2, si.kilogram/si.kilogram\n", + " s_idx, s_unit = 3, si.dimensionless\n", + " R_idx, R_unit = 4, si.meter\n", + " n_unit = si.dimensionless\n", + " m_unit = si.grams\n", + " z_unit = si.metres\n", + " n_scalar_vars = 5\n", + "\n", + " # def __init__():\n", + " # for idx, var in enumerate('p', 'T'):\n", + " # setattr(self, var) = property(...)\n", + "\n", + "\n", + " @property\n", + " def m_idx(self):\n", + " n_part = (self.shape[0] - self.n_scalar_vars ) // 2\n", + " start = self.n_scalar_vars\n", + " return slice(start, start + n_part)\n", + "\n", + " @property\n", + " def p(self):\n", + " return self[self.p_idx] * self.p_unit\n", + "\n", + " @p.setter\n", + " def p(self, value):\n", + " self[self.p_idx] = (value.to(self.p_unit) / self.p_unit).magnitude\n", + "\n", + " @property\n", + " def T(self):\n", + " return self[self.T_idx] * self.T_unit\n", + "\n", + " @T.setter\n", + " def T(self, value):\n", + " self[self.T_idx] = (value.to(self.T_unit) / self.T_unit).magnitude\n", + "\n", + " @property\n", + " def m(self):\n", + " return self[self.m_idx] * self.m_unit\n", + "\n", + " @m.setter\n", + " def m(self, value):\n", + " self[self.m_idx] = (value.to(self.m_unit) / self.m_unit).magnitude\n", + "\n", + " @property\n", + " def n(self):\n", + " return self[self.n_idx] * self.n_unit\n", + "\n", + " @n.setter\n", + " def n(self, value):\n", + " self[self.n_idx] = (value.to(self.n_unit) / self.n_unit).magnitude\n", + "\n", + " @property\n", + " def w_v(self):\n", + " return self[self.w_v_idx] * self.w_v_unit\n", + "\n", + " @w_v.setter\n", + " def w_v(self, value):\n", + " self[self.w_v_idx] = (value.to(self.w_v_unit) / self.w_v_unit).magnitude\n", + "\n", + " @property\n", + " def n_idx(self):\n", + " n_part = (self.shape[0] - self.n_scalar_vars ) // 2\n", + " start = self.n_scalar_vars + n_part\n", + " return slice(start, start + n_part)\n", + "\n", + " @property\n", + " def s(self):\n", + " return self[self.s_idx] * self.s_unit\n", + "\n", + " @s.setter\n", + " def s(self, value):\n", + " self[self.s_idx] = (value.to(self.s_unit) / self.s_unit).magnitude\n", + "\n", + " @property\n", + " def R(self):\n", + " return self[self.R_idx] * self.R_unit\n", + "\n", + " @R.setter\n", + " def R(self, value):\n", + " self[self.R_idx] = (value.to(self.R_unit) / self.R_unit).magnitude\n", + "\n", + "\n", + " @staticmethod\n", + " def __make_storage(shape):\n", + " storage = Storage.__Impl(shape)\n", + " return storage\n", + "\n", + " @staticmethod\n", + " def make_state(n_particles):\n", + " return Storage.__make_storage((Storage.__Impl.n_scalar_vars + 2 * n_particles,))\n", + "\n", + " @staticmethod\n", + " def make_deriv(state):\n", + " storage = Storage.__make_storage(state.shape)\n", + " storage.p_unit /= storage.z_unit\n", + " storage.T_unit /= storage.z_unit\n", + " storage.m_unit /= storage.z_unit\n", + " storage.w_v_unit /= storage.z_unit\n", + " storage.s_unit /= storage.z_unit\n", + " storage.n_unit /= storage.z_unit\n", + " storage.R_unit /= storage.z_unit\n", + " return storage\n", + "\n", + " @staticmethod\n", + " def view_state(array):\n", + " storage = Storage.__make_storage(array.shape)\n", + " storage[:] = array[:]\n", + " return storage" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-aahyi9NF4CH" + }, + "source": [ + "### the new ODE system we will solve ..." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3Sp4KUcgF4CI" + }, + "source": [ + "\n", + "
this week (particles):
\n", + "$$\n", + "\\begin{eqnarray}\n", + " \\frac{dp}{dz} &=& - \\rho g \\\\\n", + " \\frac{dm_i}{dz} &=& \\frac{\\xi_i}{w} \\max\\!\\!\\left[0,\\,\\,\\frac{4\\pi r_i^2}{r_i} D (\\rho_v - \\rho_{eq})\\right]\\\\ &=& \\frac{\\xi_i}{w}\\max\\!\\!\\left[0,\\,\\,(4 \\pi)^{2/3} \\sqrt[3]{\\frac{3m_i}{\\xi_i\\rho_w}}\\,D \\left(\\rho_v - \\frac{p_{eq}(T)}{R_v T}\\right)\\right]\\\\\n", + " \\vdots\\\\\n", + " \\frac{dT}{dz} &=& \\frac{1}{c_p} \\left(\\frac{1}{\\rho}\\frac{dp}{dz} + \\frac{l_v}{m_a} \\sum_i \\frac{dm_i}{dz} \\right)\n", + "\\end{eqnarray}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "nLBfqaJ8F4CI" + }, + "outputs": [], + "source": [ + "class System:\n", + " def __init__(self, *, w, ent_Tdiff, ent_RH, ent_mu, r_dry, kappa):\n", + " self.w = w\n", + " self.ent_mu = ent_mu\n", + " self.ent_Tdiff = ent_Tdiff\n", + " self.ent_RH = ent_RH\n", + " self.a_dry_3 = r_dry**3\n", + " self.kappa = kappa\n", + "\n", + " def __call__(self, _, state):\n", + " state = Storage.view_state(state)\n", + " deriv = Storage.make_deriv(state)\n", + "\n", + " #(8)\n", + " deriv.R = state.R * self.ent_mu #rough appox of eq.8 to get things working (assumes constant updraft and negligible variability in dry air density)\n", + "\n", + " rho = Formulae.rho(state.p, Constants.R_a, state.T) # TODO: total pressure, but dry air R. (a good approximation)\n", + " # volume = self.m_a / rho\n", + " volume = (4/3)*np.pi*state.R**3 # new total volume, as we are evolving R with bubble expansion\n", + " total_mass = rho * volume\n", + " rho_eq = Formulae.p_eq(state.T) / Constants.R_v / state.T\n", + " m_v = state.w_v*rho*volume #m_v is the total vapour mass\n", + " m_l = np.sum(state.m * state.n) # m_l is the total liquid water mass\n", + " m_w = m_l + m_v # m_w is the total water mass\n", + " rho_v = m_v / volume #m_w undefined\n", + "\n", + " # eq. (4)\n", + " deriv.p = -Formulae.rho(state.p, Constants.R_a, state.T) * Constants.g\n", + "\n", + " # eq. (12) PER DROPLET (implied loop)\n", + " a = (3*state.m/4/np.pi/Constants.rho_w)**(1/3)\n", + "\n", + " deriv.m = 4 * np.pi * Constants.rho_w * a * Formulae.r_dr_dt(\n", + " Formulae.S_eq(a,self.kappa,self.a_dry_3,state.T), state.T, state.s, rho_eq\n", + " ) / self.w\n", + " # TODO: switch from integration in mass \"m\" to integration in \"ln(r)\" or alike ... or to \"r\" to be closer to the paper\n", + "\n", + " # eq. (5) - assuming self.xi constant\n", + " # dwl_dz = np.sum(deriv.m)/self.m_a\n", + " dwl_dz = np.sum(deriv.m * state.n)/total_mass\n", + "\n", + " env_T = state.T - self.ent_Tdiff\n", + " env_pv = self.ent_RH * Formulae.p_eq(env_T)\n", + " env_w_v = Formulae.rho(env_pv, Constants.R_v, env_T) / rho # to keep a constant relative humidity following conditions of BN07\n", + "\n", + " # eq. (2)\n", + " deriv.w_v = - dwl_dz - self.ent_mu * (state.w_v - env_w_v + np.sum(state.m * state.n)/rho/volume)\n", + "\n", + " # eq. (1)\n", + " deriv.T = (deriv.p/rho - deriv.w_v * Constants.l_v) / Constants.c_p + \\\n", + " - self.ent_mu * ( (Constants.l_v/Constants.c_p)*(state.w_v-env_w_v) + (state.T-env_T) )\n", + "\n", + " #(3)\n", + " deriv.s = state.p/(Constants.epsilon*Formulae.p_eq(state.T)) * deriv.w_v \\\n", + " - (1+state.s)*(\n", + " (Constants.epsilon*Constants.l_v/(Constants.R_a*state.T**2))*deriv.T +\n", + " (Constants.g/(Constants.R_a*state.T))\n", + " )\n", + "\n", + " #(6)\n", + " env_n = 0 # environemntal n=0 for dry air entrainment\n", + " deriv.n = 0 / si.metres #-Constants.mu * (state.n - env_n)\n", + "\n", + " return deriv" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nGVe3eDLF4CI" + }, + "source": [ + "$p$: pressure \n", + "$z$: vertical displacement \n", + "$\\rho$: air density \n", + "$g$: gravitational acceleration \n", + "$r_i$: radius of size category $i$\n", + "$m_i$: mass of liquid water in size category $i$ (i.e., sum of masses of particles of radius $r_i$) \n", + "$\\xi_i$: multiplicity of size category $i$ (i.e., number of particles of radius $r_i$) \n", + "$\\rho_v$: density of water vapour\n", + "$\\rho_{eq}$: density of water vapour at saturation (in phase equilibrium wrt water surface) \n", + "$T$: temperature \n", + "$c_p$: specific heat of air \n", + "$l_v$: latent heat of vapourisation \n", + "$m_a$: mass of air \\\\\n", + "$R$: radius of parcel \\\\\n", + "$w_v$: water vapour mixing ratio\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2xFm959hF4CI" + }, + "source": [ + "### ... implemented according to SciPy API" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YAOzAcfWF4CI" + }, + "source": [ + "### instead of a simplest ODE solver (last week), let's now use a more sophisticated one from SciPy" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "g4iCJUjOF4CI" + }, + "outputs": [], + "source": [ + "from scipy import integrate\n", + "def solve(system, state, displacement):\n", + " integ = integrate.solve_ivp(\n", + " system,\n", + " [0, displacement / state.z_unit],\n", + " state,\n", + " max_step=(.1 * si.metre / state.z_unit).magnitude,\n", + " method='LSODA'\n", + " )\n", + " assert integ.success, integ.message\n", + " return Storage.view_state(integ.y), integ.t * state.z_unit" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qBOq7bpcF4CI" + }, + "source": [ + "### and let's finally do the calculations ..." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "LFFo1xrUF4CI" + }, + "outputs": [], + "source": [ + "n_size_sections = 10\n", + "T0 = 300 * si.kelvins\n", + "p0 = 1000 * si.hectopascals\n", + "s0 = -0.01 * si.dimensionless\n", + "\n", + "pv0 = (1 + s0) * Formulae.p_eq(T0)\n", + "displacement = 250 * si.metres\n", + "R0 = 350 * si.metres\n", + "volume = 4/3 * np.pi * R0**3\n", + "w_v0 = Constants.epsilon / (p0/pv0 - 1)\n", + "\n", + "# entrainment parameters\n", + "ent_mu = 0 / si.meter\n", + "ent_Tdiff = 0.3 * si.kelvin # T-T'\n", + "ent_RH = 0.9 * si.dimensionless #relative humidity\n", + "\n", + "kappa = 1.2\n", + "geometric_stdev = 1.3\n", + "median_dry_radius = 1 * si.um\n", + "aerosol_concentration = 50 / si.centimetre**3\n", + "\n", + "dry_radii_quantiles = scipy.stats.lognorm(\n", + " np.log(geometric_stdev),\n", + " 0,\n", + " median_dry_radius.to(si.m).magnitude\n", + ").ppf(\n", + " np.linspace(0, 1, 2 * n_size_sections + 1)[1:-1:2]\n", + ") * si.m\n", + "\n", + "wet_radii_quantiles = np.asarray([scipy.optimize.root_scalar(\n", + " f=lambda r: s0 - Formulae.S_eq(r*si.m, kappa, r_dry**3, T0),\n", + " bracket=(\n", + " r_dry.to(si.m).magnitude,\n", + " Formulae.r_cr(kappa, r_dry**3, T0, Constants.sigma_w).to(si.m).magnitude\n", + " )\n", + ").root for r_dry in dry_radii_quantiles]) * si.m\n", + "\n", + "systems = {}\n", + "solutions = {}\n", + "zsteps = {}\n", + "for w in [.1, 1] * si.metre / si.second:\n", + " state = Storage.make_state(n_size_sections)\n", + " state.p = p0\n", + " state.T = T0\n", + " state.n = aerosol_concentration * volume / n_size_sections\n", + " state.m = 4/3 * np.pi * Constants.rho_w * wet_radii_quantiles**3\n", + " state.s = s0\n", + " state.R = R0\n", + " state.w_v = w_v0\n", + "\n", + " systems[w] = System(w=w, ent_mu=ent_mu, ent_Tdiff=ent_Tdiff, ent_RH=ent_RH, r_dry=dry_radii_quantiles, kappa=kappa)\n", + " solutions[w], zsteps[w] = solve(systems[w], state, displacement)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uzWyPPO0F4CK" + }, + "source": [ + "### ... and plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 410 + }, + "id": "T1lffCOOF4CK", + "outputId": "ebaa1541-d4bc-4312-e7bb-c8052a74a60e" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "fig, axs = pyplot.subplots(1, 3, sharey=True, figsize=(15, 4))\n", + "\n", + "for w in solutions.keys():\n", + " sys = systems[w]\n", + " sol = solutions[w]\n", + " z = zsteps[w]\n", + "\n", + " axs[0].plot(sol.s, z, label=w)\n", + " axs[1].plot(np.mean(sol.m, axis=0), z, label=w)\n", + " axs[1].xaxis.set_units(si.micrograms)\n", + "\n", + " axs[2].plot(sol.w_v, z, label=w)\n", + " axs[2].xaxis.set_units(si.grams / si.kilogram)\n", + "\n", + "for i in range(len(axs)):\n", + " axs[i].legend(loc='upper left')\n", + " axs[i].grid()\n", + "\n", + "_ = axs[0].set_title('Supersaturation [%]')\n", + "_ = axs[1].set_title('Average drop mass')\n", + "_ = axs[2].set_title('vapour mixing ratio [g/kg]')" + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 3e4eac350a6fe6188735e8a608df41056c14acee Mon Sep 17 00:00:00 2001 From: Paul Bowen <48794746+pb475@users.noreply.github.com> Date: Tue, 26 Nov 2024 09:35:13 +0000 Subject: [PATCH 2/5] Update fig_1.ipynb Oops, previous commit was and older version. This is the most up-to-date code for the Barahone-Nenes2007 replication. --- .../Barahona_and_Nenes_2007/fig_1.ipynb | 273 ++++++------------ 1 file changed, 90 insertions(+), 183 deletions(-) diff --git a/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb index 3f1de0ecc..95e6d62cc 100644 --- a/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb +++ b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb @@ -14,24 +14,9 @@ "cell_type": "code", "execution_count": 1, "metadata": { - "id": "nS021k0eQ5K7", - "outputId": "578a2bd3-5783-4710-a7c0-742504462c6c", - "colab": { - "base_uri": "https://localhost:8080/" - } + "id": "nS021k0eQ5K7" }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/302.0 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m \u001b[32m297.0/302.0 kB\u001b[0m \u001b[31m20.7 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m302.0/302.0 kB\u001b[0m \u001b[31m5.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.4/1.4 MB\u001b[0m \u001b[31m28.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m865.8/865.8 kB\u001b[0m \u001b[31m18.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h" - ] - } - ], + "outputs": [], "source": [ "!pip install --quiet pint mendeleev" ] @@ -48,6 +33,7 @@ "import pint\n", "from matplotlib import pyplot\n", "import scipy\n", + "import functools\n", "\n", "si = pint.UnitRegistry()\n", "si.setup_matplotlib()" @@ -128,7 +114,6 @@ "\n", " @staticmethod\n", " def p_eq(T):\n", - " # TODO! kappa Koehler\n", " return Formulae.__p_sat(T, Constants.c_w, (Constants.T0-85 * si.kelvin, np.inf * si.kelvin))\n", "\n", " @staticmethod\n", @@ -136,36 +121,16 @@ " return (\n", " (S - S_eq)\n", " / Constants.rho_w\n", - " / (1/rho_eq / Constants.D + Constants.l_v**2 / Constants.K / T**2 / Constants.R_v)\n", + " / (1 / rho_eq / Constants.D + Constants.l_v**2 / Constants.K / T**2 / Constants.R_v)\n", " )\n", - " # TODO: something wrong in this one, units aren't working out as expected, expecting r*dr_dt to work out as [length]*[length / time].\n", - " # perhaps there is something fishy with the Constants.l_v**2 / Constants.K / T**2 / Constants.R_v term...\n", "\n", - " # def S_eq(a, kappa, a_dry_3, T): # adapted from https://github.com/open-atmos/PySDM/blob/83b1edd16dbcb8e97a7a4beaf77822fac7016e94/PySDM/physics/hygroscopicity/kappa_koehler_leading_terms.py#L16\n", - " # print( \"s_eq, dimension of first part: \", (2 * Constants.sigma_w / Constants.R_v / T / Constants.rho_w) / a )\n", - " # print( \"s_eq, dimension of second part: \", (kappa * a_dry_3 / a**3).dimensionality )\n", - " # return (\n", - " # (2 * Constants.sigma_w / Constants.R_v / T / Constants.rho_w) / a - kappa * a_dry_3 / a**3\n", - " # )\n", - "\n", - " @staticmethod\n", - " def RH_eq(r, T, kp, a_dry_3, sgm): # from https://github.com/open-atmos/PySDM/blob/main/PySDM/physics/hygroscopicity/kappa_koehler.py\n", - " return (\n", - " np.exp((2 * sgm / Constants.R_v / T / Constants.rho_w) / r)\n", - " * (r**3 - a_dry_3)\n", - " / (r**3 - a_dry_3 * (1 - kp))\n", - " )\n", - "\n", - " @staticmethod\n", - " def S_eq(a, kappa, a_dry_3, T): # adapted from RH_eq above\n", + " def S_eq(a, kappa, a_dry_3, T):\n", " return (\n", " np.exp((2 * Constants.sigma_w / Constants.R_v / T / Constants.rho_w) / a)\n", " * (a**3 - a_dry_3)\n", " / (a**3 - a_dry_3 * (1 - kappa))\n", " ) - 1\n", "\n", - "\n", - "\n", " @staticmethod\n", " def r_cr(kp, a_dry_3, T, sgm): # from https://github.com/open-atmos/PySDM/blob/main/PySDM/physics/hygroscopicity/kappa_koehler.py\n", " return np.sqrt(3 * kp * a_dry_3 / (2 * sgm / Constants.R_v / T / Constants.rho_w))\n" @@ -180,115 +145,60 @@ "outputs": [], "source": [ "class Storage:\n", - " \"\"\" utility class to make pint and scipy.odeint integration seamless \"\"\"\n", - " class __Impl(np.ndarray):\n", - " p_idx, p_unit = 0, si.hectopascals\n", - " T_idx, T_unit = 1, si.kelvins\n", - " w_v_idx, w_v_unit = 2, si.kilogram/si.kilogram\n", - " s_idx, s_unit = 3, si.dimensionless\n", - " R_idx, R_unit = 4, si.meter\n", - " n_unit = si.dimensionless\n", - " m_unit = si.grams\n", - " z_unit = si.metres\n", - " n_scalar_vars = 5\n", - "\n", - " # def __init__():\n", - " # for idx, var in enumerate('p', 'T'):\n", - " # setattr(self, var) = property(...)\n", - "\n", - "\n", - " @property\n", - " def m_idx(self):\n", - " n_part = (self.shape[0] - self.n_scalar_vars ) // 2\n", - " start = self.n_scalar_vars\n", - " return slice(start, start + n_part)\n", - "\n", - " @property\n", - " def p(self):\n", - " return self[self.p_idx] * self.p_unit\n", - "\n", - " @p.setter\n", - " def p(self, value):\n", - " self[self.p_idx] = (value.to(self.p_unit) / self.p_unit).magnitude\n", - "\n", - " @property\n", - " def T(self):\n", - " return self[self.T_idx] * self.T_unit\n", - "\n", - " @T.setter\n", - " def T(self, value):\n", - " self[self.T_idx] = (value.to(self.T_unit) / self.T_unit).magnitude\n", - "\n", - " @property\n", - " def m(self):\n", - " return self[self.m_idx] * self.m_unit\n", - "\n", - " @m.setter\n", - " def m(self, value):\n", - " self[self.m_idx] = (value.to(self.m_unit) / self.m_unit).magnitude\n", - "\n", - " @property\n", - " def n(self):\n", - " return self[self.n_idx] * self.n_unit\n", - "\n", - " @n.setter\n", - " def n(self, value):\n", - " self[self.n_idx] = (value.to(self.n_unit) / self.n_unit).magnitude\n", - "\n", - " @property\n", - " def w_v(self):\n", - " return self[self.w_v_idx] * self.w_v_unit\n", - "\n", - " @w_v.setter\n", - " def w_v(self, value):\n", - " self[self.w_v_idx] = (value.to(self.w_v_unit) / self.w_v_unit).magnitude\n", - "\n", - " @property\n", - " def n_idx(self):\n", - " n_part = (self.shape[0] - self.n_scalar_vars ) // 2\n", - " start = self.n_scalar_vars + n_part\n", - " return slice(start, start + n_part)\n", - "\n", - " @property\n", - " def s(self):\n", - " return self[self.s_idx] * self.s_unit\n", - "\n", - " @s.setter\n", - " def s(self, value):\n", - " self[self.s_idx] = (value.to(self.s_unit) / self.s_unit).magnitude\n", - "\n", - " @property\n", - " def R(self):\n", - " return self[self.R_idx] * self.R_unit\n", - "\n", - " @R.setter\n", - " def R(self, value):\n", - " self[self.R_idx] = (value.to(self.R_unit) / self.R_unit).magnitude\n", - "\n", + " \"\"\" state vector representation with each element having its own Pint-compatible\n", + " physical dimension, thus allowing to seamlessly couple Pint and scipy.odeint\n", + " (assumes the last variable extends till the end of the state vector;\n", + " all methods return objects that inherit from `numpy.ndarray` but are additionally\n", + " equipped with .VAR unit-aware setters and getters, allowing both unit-anaware\n", + " whole-array expressions (e.g., `state += dt * deriv`) as well as unit-aware\n", + " operations on state vars (e.g., `state.T = 300 * si.K` or `state.m[:] = ...`) \"\"\"\n", + "\n", + " var_units = {\n", + " 'p': si.Pa,\n", + " 'T': si.K,\n", + " 'R': si.m,\n", + " 's': si.dimensionless,\n", + " 'w_v': si.dimensionless,\n", + " 'n': si.dimensionless,\n", + " 'm': si.kg\n", + " }\n", + "\n", + " der_unit = si.metre\n", "\n", " @staticmethod\n", - " def __make_storage(shape):\n", - " storage = Storage.__Impl(shape)\n", - " return storage\n", + " def __make_storage(shape, deriv=False):\n", + " def getter(self, idx, unit):\n", + " return self[idx] * unit\n", + "\n", + " def setter(self, value, idx, unit):\n", + " self[idx] = (value.to(unit) / unit).magnitude\n", + "\n", + " properties = {'z_unit': Storage.der_unit}\n", + " for i, key in enumerate(Storage.var_units.keys()):\n", + " kwargs = {\n", + " 'unit': Storage.var_units[key] / (Storage.der_unit if deriv else 1),\n", + " 'idx': i if i + 1 != len(Storage.var_units) else slice(i, None)\n", + " }\n", + " properties[key] = property(\n", + " functools.partial(getter, **kwargs),\n", + " functools.partial(setter, **kwargs),\n", + " )\n", + "\n", + " return type(\"StorageImpl\", (np.ndarray,), properties)(shape)\n", "\n", " @staticmethod\n", " def make_state(n_particles):\n", - " return Storage.__make_storage((Storage.__Impl.n_scalar_vars + 2 * n_particles,))\n", + " \"\"\" returns a newly allocated unit-aware storage of size relevant for `n_particles` simulation \"\"\"\n", + " return Storage.__make_storage((len(Storage.var_units) - 1 + n_particles,))\n", "\n", " @staticmethod\n", " def make_deriv(state):\n", - " storage = Storage.__make_storage(state.shape)\n", - " storage.p_unit /= storage.z_unit\n", - " storage.T_unit /= storage.z_unit\n", - " storage.m_unit /= storage.z_unit\n", - " storage.w_v_unit /= storage.z_unit\n", - " storage.s_unit /= storage.z_unit\n", - " storage.n_unit /= storage.z_unit\n", - " storage.R_unit /= storage.z_unit\n", - " return storage\n", + " \"\"\" returns a newly allocated unit-aware storage with size of `state` and derivative dimensions \"\"\"\n", + " return Storage.__make_storage(state.shape, deriv=True)\n", "\n", " @staticmethod\n", " def view_state(array):\n", + " \"\"\" returns a newly allocated unit-aware storage with size and data from unit-unaware `array` \"\"\"\n", " storage = Storage.__make_storage(array.shape)\n", " storage[:] = array[:]\n", " return storage" @@ -318,7 +228,25 @@ " \\vdots\\\\\n", " \\frac{dT}{dz} &=& \\frac{1}{c_p} \\left(\\frac{1}{\\rho}\\frac{dp}{dz} + \\frac{l_v}{m_a} \\sum_i \\frac{dm_i}{dz} \\right)\n", "\\end{eqnarray}\n", - "$$" + "$$\n", + "\n", + "$p$: pressure \n", + "$z$: vertical displacement \n", + "$\\rho$: air density \n", + "$g$: gravitational acceleration \n", + "$r_i$: radius of size category $i$ \\\\\n", + "$m_i$: mass of liquid water in size category $i$ (i.e., sum of masses of particles of radius $r_i$) \n", + "$\\xi_i$: multiplicity of size category $i$ (i.e., number of particles of radius $r_i$) \n", + "$\\rho_v$: density of water vapour \\\\\n", + "$\\rho_{eq}$: density of water vapour at saturation (in phase equilibrium wrt water surface) \n", + "$T$: temperature \n", + "$c_p$: specific heat of air \n", + "$l_v$: latent heat of vapourisation \n", + "$m_a$: mass of air \\\\\n", + "$R$: radius of parcel \\\\\n", + "$w_v$: water vapour mixing ratio\n", + "\n", + "TODO: This system needs to be updated to match the system we are actually solving from Lee and Pruppacher. Variables need to be updated as well.\n" ] }, { @@ -330,13 +258,14 @@ "outputs": [], "source": [ "class System:\n", - " def __init__(self, *, w, ent_Tdiff, ent_RH, ent_mu, r_dry, kappa):\n", + " def __init__(self, *, w, ent_Tdiff, ent_RH, ent_mu, ent_n, r_dry, kappa):\n", " self.w = w\n", " self.ent_mu = ent_mu\n", " self.ent_Tdiff = ent_Tdiff\n", " self.ent_RH = ent_RH\n", " self.a_dry_3 = r_dry**3\n", " self.kappa = kappa\n", + " self.ent_n = ent_n\n", "\n", " def __call__(self, _, state):\n", " state = Storage.view_state(state)\n", @@ -346,14 +275,13 @@ " deriv.R = state.R * self.ent_mu #rough appox of eq.8 to get things working (assumes constant updraft and negligible variability in dry air density)\n", "\n", " rho = Formulae.rho(state.p, Constants.R_a, state.T) # TODO: total pressure, but dry air R. (a good approximation)\n", - " # volume = self.m_a / rho\n", " volume = (4/3)*np.pi*state.R**3 # new total volume, as we are evolving R with bubble expansion\n", " total_mass = rho * volume\n", " rho_eq = Formulae.p_eq(state.T) / Constants.R_v / state.T\n", " m_v = state.w_v*rho*volume #m_v is the total vapour mass\n", " m_l = np.sum(state.m * state.n) # m_l is the total liquid water mass\n", " m_w = m_l + m_v # m_w is the total water mass\n", - " rho_v = m_v / volume #m_w undefined\n", + " rho_v = m_v / volume\n", "\n", " # eq. (4)\n", " deriv.p = -Formulae.rho(state.p, Constants.R_a, state.T) * Constants.g\n", @@ -366,13 +294,12 @@ " ) / self.w\n", " # TODO: switch from integration in mass \"m\" to integration in \"ln(r)\" or alike ... or to \"r\" to be closer to the paper\n", "\n", - " # eq. (5) - assuming self.xi constant\n", - " # dwl_dz = np.sum(deriv.m)/self.m_a\n", + " # eq. (5)\n", " dwl_dz = np.sum(deriv.m * state.n)/total_mass\n", "\n", " env_T = state.T - self.ent_Tdiff\n", " env_pv = self.ent_RH * Formulae.p_eq(env_T)\n", - " env_w_v = Formulae.rho(env_pv, Constants.R_v, env_T) / rho # to keep a constant relative humidity following conditions of BN07\n", + " env_w_v = Formulae.rho(env_pv, Constants.R_v, env_T) / rho # to keep a constant relative humidity following conditions of BarahonaNenes2007\n", "\n", " # eq. (2)\n", " deriv.w_v = - dwl_dz - self.ent_mu * (state.w_v - env_w_v + np.sum(state.m * state.n)/rho/volume)\n", @@ -389,8 +316,7 @@ " )\n", "\n", " #(6)\n", - " env_n = 0 # environemntal n=0 for dry air entrainment\n", - " deriv.n = 0 / si.metres #-Constants.mu * (state.n - env_n)\n", + " deriv.n = -self.ent_mu * (state.n - self.ent_n)\n", "\n", " return deriv" ] @@ -401,21 +327,7 @@ "id": "nGVe3eDLF4CI" }, "source": [ - "$p$: pressure \n", - "$z$: vertical displacement \n", - "$\\rho$: air density \n", - "$g$: gravitational acceleration \n", - "$r_i$: radius of size category $i$\n", - "$m_i$: mass of liquid water in size category $i$ (i.e., sum of masses of particles of radius $r_i$) \n", - "$\\xi_i$: multiplicity of size category $i$ (i.e., number of particles of radius $r_i$) \n", - "$\\rho_v$: density of water vapour\n", - "$\\rho_{eq}$: density of water vapour at saturation (in phase equilibrium wrt water surface) \n", - "$T$: temperature \n", - "$c_p$: specific heat of air \n", - "$l_v$: latent heat of vapourisation \n", - "$m_a$: mass of air \\\\\n", - "$R$: radius of parcel \\\\\n", - "$w_v$: water vapour mixing ratio\n" + "\n" ] }, { @@ -427,15 +339,6 @@ "### ... implemented according to SciPy API" ] }, - { - "cell_type": "markdown", - "metadata": { - "id": "YAOzAcfWF4CI" - }, - "source": [ - "### instead of a simplest ODE solver (last week), let's now use a more sophisticated one from SciPy" - ] - }, { "cell_type": "code", "execution_count": 7, @@ -478,6 +381,7 @@ "T0 = 300 * si.kelvins\n", "p0 = 1000 * si.hectopascals\n", "s0 = -0.01 * si.dimensionless\n", + "w = 0.3 * si.meter / si.second\n", "\n", "pv0 = (1 + s0) * Formulae.p_eq(T0)\n", "displacement = 250 * si.metres\n", @@ -489,6 +393,7 @@ "ent_mu = 0 / si.meter\n", "ent_Tdiff = 0.3 * si.kelvin # T-T'\n", "ent_RH = 0.9 * si.dimensionless #relative humidity\n", + "ent_n = 0.0 * si.dimensionless\n", "\n", "kappa = 1.2\n", "geometric_stdev = 1.3\n", @@ -514,7 +419,7 @@ "systems = {}\n", "solutions = {}\n", "zsteps = {}\n", - "for w in [.1, 1] * si.metre / si.second:\n", + "for mu in [0.0, 0.01] * si.metre**-1:\n", " state = Storage.make_state(n_size_sections)\n", " state.p = p0\n", " state.T = T0\n", @@ -524,8 +429,8 @@ " state.R = R0\n", " state.w_v = w_v0\n", "\n", - " systems[w] = System(w=w, ent_mu=ent_mu, ent_Tdiff=ent_Tdiff, ent_RH=ent_RH, r_dry=dry_radii_quantiles, kappa=kappa)\n", - " solutions[w], zsteps[w] = solve(systems[w], state, displacement)" + " systems[mu] = System(w=w, ent_mu=mu, ent_Tdiff=ent_Tdiff, ent_RH=ent_RH, ent_n=ent_n, r_dry=dry_radii_quantiles, kappa=kappa)\n", + " solutions[mu], zsteps[mu] = solve(systems[mu], state, displacement)" ] }, { @@ -546,7 +451,7 @@ "height": 410 }, "id": "T1lffCOOF4CK", - "outputId": "ebaa1541-d4bc-4312-e7bb-c8052a74a60e" + "outputId": "29fd460d-a17a-4a2d-9a6d-d515fc1ac6cb" }, "outputs": [ { @@ -555,7 +460,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } @@ -563,16 +468,18 @@ "source": [ "fig, axs = pyplot.subplots(1, 3, sharey=True, figsize=(15, 4))\n", "\n", - "for w in solutions.keys():\n", - " sys = systems[w]\n", - " sol = solutions[w]\n", - " z = zsteps[w]\n", + "for mu in solutions.keys():\n", + " sys = systems[mu]\n", + " sol = solutions[mu]\n", + " z = zsteps[mu]\n", + "\n", + " axs[0].plot(sol.s, z, label=mu)\n", "\n", - " axs[0].plot(sol.s, z, label=w)\n", - " axs[1].plot(np.mean(sol.m, axis=0), z, label=w)\n", + " drops_mass = sol.m * sol.n\n", + " axs[1].plot(np.mean(drops_mass, axis=0), z, label=mu)\n", " axs[1].xaxis.set_units(si.micrograms)\n", "\n", - " axs[2].plot(sol.w_v, z, label=w)\n", + " axs[2].plot(sol.w_v, z, label=mu)\n", " axs[2].xaxis.set_units(si.grams / si.kilogram)\n", "\n", "for i in range(len(axs)):\n", From 583206386cc7f89e182c89928808b8852be84f36 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Agnieszka=20=C5=BBaba?= Date: Wed, 27 Nov 2024 22:06:02 +0100 Subject: [PATCH 3/5] add notebook badges and description cell with todo annotation to Barahona&Nenes example --- .../Barahona_and_Nenes_2007/fig_1.ipynb | 1038 +++++++++-------- 1 file changed, 525 insertions(+), 513 deletions(-) diff --git a/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb index 95e6d62cc..4f98669ec 100644 --- a/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb +++ b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb @@ -1,520 +1,532 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "nS021k0eQ5K7" - }, - "outputs": [], - "source": [ - "!pip install --quiet pint mendeleev" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "_KYH2YCDF4CF" - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pint\n", - "from matplotlib import pyplot\n", - "import scipy\n", - "import functools\n", - "\n", - "si = pint.UnitRegistry()\n", - "si.setup_matplotlib()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "3Gd21_5yF4CG" - }, - "outputs": [], - "source": [ - "class Constants:\n", - " from scipy import constants\n", - " import mendeleev as pt\n", - "\n", - " # polynomial fot to equilibrium vapour pressure wrt water (coefficients from Flatau et al. 1992)\n", - " # doi:10.1175/1520-0450(1992)031<1507%3APFTSVP>2.0.CO%3B2\n", - " c_w = (6.115836990e000, 0.444606896e000, 0.143177157e-01, 0.264224321e-03, 0.299291081e-05,\n", - " 0.203154182e-07, 0.702620698e-10, 0.379534310e-13, -.321582393e-15)\n", - "\n", - " T0 = T0 = constants.zero_Celsius * si.kelvin\n", - "\n", - " def __molar_mass(x):\n", - " return x.atomic_weight * si.gram / si.mole\n", - "\n", - " M_a = (\n", - " 0.78 * __molar_mass(pt.N) * 2 +\n", - " 0.21 * __molar_mass(pt.O) * 2 +\n", - " 0.01 * __molar_mass(pt.Ar)\n", - " )\n", - " M_v = __molar_mass(pt.O) + __molar_mass(pt.H) * 2\n", - "\n", - " R_str = constants.R * si.joule / si.kelvin / si.mole\n", - "\n", - " R_a = R_str / M_a\n", - " R_v = R_str / M_v\n", - "\n", - " g = constants.g * si.metre / si.second**2\n", - "\n", - " l_v = 2.5e6 * si.joule / si.kilogram\n", - " c_p = 1000 * si.joule / si.kilogram / si.kelvin\n", - "\n", - " D = 2.26e-5 * si.metre ** 2 / si.second\n", - " K = 2.4e-2 * si.joules / si.metres / si.seconds / si.kelvins\n", - " rho_w = 1 * si.kilogram / si.litre\n", - " sigma_w = 0.072 * si.joule / si.metre**2\n", - "\n", - " epsilon = R_a/R_v" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "id": "vlM1J4LZF4CG" - }, - "outputs": [], - "source": [ - "class Formulae:\n", - " @staticmethod\n", - " def rho(p, R, T):\n", - " return p / (R * T)\n", - "\n", - " @staticmethod\n", - " def __p_sat(temperature, coefficients, valid_range):\n", - " from numpy.polynomial.polynomial import polyval\n", - "\n", - " value = polyval(temperature.to(si.celsius).magnitude, coefficients)\n", - "\n", - " if isinstance(temperature.magnitude, np.ndarray):\n", - " value[np.logical_or(temperature < valid_range[0], temperature > valid_range[1])] = np.nan\n", - " else:\n", - " value = np.nan if not valid_range[0] < temperature <= valid_range[1] else value\n", - "\n", - " return value * si.hectopascals\n", - "\n", - " @staticmethod\n", - " def p_eq(T):\n", - " return Formulae.__p_sat(T, Constants.c_w, (Constants.T0-85 * si.kelvin, np.inf * si.kelvin))\n", - "\n", - " @staticmethod\n", - " def r_dr_dt(S_eq, T, S, rho_eq):\n", - " return (\n", - " (S - S_eq)\n", - " / Constants.rho_w\n", - " / (1 / rho_eq / Constants.D + Constants.l_v**2 / Constants.K / T**2 / Constants.R_v)\n", - " )\n", - "\n", - " def S_eq(a, kappa, a_dry_3, T):\n", - " return (\n", - " np.exp((2 * Constants.sigma_w / Constants.R_v / T / Constants.rho_w) / a)\n", - " * (a**3 - a_dry_3)\n", - " / (a**3 - a_dry_3 * (1 - kappa))\n", - " ) - 1\n", - "\n", - " @staticmethod\n", - " def r_cr(kp, a_dry_3, T, sgm): # from https://github.com/open-atmos/PySDM/blob/main/PySDM/physics/hygroscopicity/kappa_koehler.py\n", - " return np.sqrt(3 * kp * a_dry_3 / (2 * sgm / Constants.R_v / T / Constants.rho_w))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "id": "EaiiPI4TF4CH" - }, - "outputs": [], - "source": [ - "class Storage:\n", - " \"\"\" state vector representation with each element having its own Pint-compatible\n", - " physical dimension, thus allowing to seamlessly couple Pint and scipy.odeint\n", - " (assumes the last variable extends till the end of the state vector;\n", - " all methods return objects that inherit from `numpy.ndarray` but are additionally\n", - " equipped with .VAR unit-aware setters and getters, allowing both unit-anaware\n", - " whole-array expressions (e.g., `state += dt * deriv`) as well as unit-aware\n", - " operations on state vars (e.g., `state.T = 300 * si.K` or `state.m[:] = ...`) \"\"\"\n", - "\n", - " var_units = {\n", - " 'p': si.Pa,\n", - " 'T': si.K,\n", - " 'R': si.m,\n", - " 's': si.dimensionless,\n", - " 'w_v': si.dimensionless,\n", - " 'n': si.dimensionless,\n", - " 'm': si.kg\n", - " }\n", - "\n", - " der_unit = si.metre\n", - "\n", - " @staticmethod\n", - " def __make_storage(shape, deriv=False):\n", - " def getter(self, idx, unit):\n", - " return self[idx] * unit\n", - "\n", - " def setter(self, value, idx, unit):\n", - " self[idx] = (value.to(unit) / unit).magnitude\n", - "\n", - " properties = {'z_unit': Storage.der_unit}\n", - " for i, key in enumerate(Storage.var_units.keys()):\n", - " kwargs = {\n", - " 'unit': Storage.var_units[key] / (Storage.der_unit if deriv else 1),\n", - " 'idx': i if i + 1 != len(Storage.var_units) else slice(i, None)\n", - " }\n", - " properties[key] = property(\n", - " functools.partial(getter, **kwargs),\n", - " functools.partial(setter, **kwargs),\n", - " )\n", - "\n", - " return type(\"StorageImpl\", (np.ndarray,), properties)(shape)\n", - "\n", - " @staticmethod\n", - " def make_state(n_particles):\n", - " \"\"\" returns a newly allocated unit-aware storage of size relevant for `n_particles` simulation \"\"\"\n", - " return Storage.__make_storage((len(Storage.var_units) - 1 + n_particles,))\n", - "\n", - " @staticmethod\n", - " def make_deriv(state):\n", - " \"\"\" returns a newly allocated unit-aware storage with size of `state` and derivative dimensions \"\"\"\n", - " return Storage.__make_storage(state.shape, deriv=True)\n", - "\n", - " @staticmethod\n", - " def view_state(array):\n", - " \"\"\" returns a newly allocated unit-aware storage with size and data from unit-unaware `array` \"\"\"\n", - " storage = Storage.__make_storage(array.shape)\n", - " storage[:] = array[:]\n", - " return storage" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "-aahyi9NF4CH" - }, - "source": [ - "### the new ODE system we will solve ..." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "3Sp4KUcgF4CI" - }, - "source": [ - "\n", - "
this week (particles):
\n", - "$$\n", - "\\begin{eqnarray}\n", - " \\frac{dp}{dz} &=& - \\rho g \\\\\n", - " \\frac{dm_i}{dz} &=& \\frac{\\xi_i}{w} \\max\\!\\!\\left[0,\\,\\,\\frac{4\\pi r_i^2}{r_i} D (\\rho_v - \\rho_{eq})\\right]\\\\ &=& \\frac{\\xi_i}{w}\\max\\!\\!\\left[0,\\,\\,(4 \\pi)^{2/3} \\sqrt[3]{\\frac{3m_i}{\\xi_i\\rho_w}}\\,D \\left(\\rho_v - \\frac{p_{eq}(T)}{R_v T}\\right)\\right]\\\\\n", - " \\vdots\\\\\n", - " \\frac{dT}{dz} &=& \\frac{1}{c_p} \\left(\\frac{1}{\\rho}\\frac{dp}{dz} + \\frac{l_v}{m_a} \\sum_i \\frac{dm_i}{dz} \\right)\n", - "\\end{eqnarray}\n", - "$$\n", - "\n", - "$p$: pressure \n", - "$z$: vertical displacement \n", - "$\\rho$: air density \n", - "$g$: gravitational acceleration \n", - "$r_i$: radius of size category $i$ \\\\\n", - "$m_i$: mass of liquid water in size category $i$ (i.e., sum of masses of particles of radius $r_i$) \n", - "$\\xi_i$: multiplicity of size category $i$ (i.e., number of particles of radius $r_i$) \n", - "$\\rho_v$: density of water vapour \\\\\n", - "$\\rho_{eq}$: density of water vapour at saturation (in phase equilibrium wrt water surface) \n", - "$T$: temperature \n", - "$c_p$: specific heat of air \n", - "$l_v$: latent heat of vapourisation \n", - "$m_a$: mass of air \\\\\n", - "$R$: radius of parcel \\\\\n", - "$w_v$: water vapour mixing ratio\n", - "\n", - "TODO: This system needs to be updated to match the system we are actually solving from Lee and Pruppacher. Variables need to be updated as well.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "nLBfqaJ8F4CI" - }, - "outputs": [], - "source": [ - "class System:\n", - " def __init__(self, *, w, ent_Tdiff, ent_RH, ent_mu, ent_n, r_dry, kappa):\n", - " self.w = w\n", - " self.ent_mu = ent_mu\n", - " self.ent_Tdiff = ent_Tdiff\n", - " self.ent_RH = ent_RH\n", - " self.a_dry_3 = r_dry**3\n", - " self.kappa = kappa\n", - " self.ent_n = ent_n\n", - "\n", - " def __call__(self, _, state):\n", - " state = Storage.view_state(state)\n", - " deriv = Storage.make_deriv(state)\n", - "\n", - " #(8)\n", - " deriv.R = state.R * self.ent_mu #rough appox of eq.8 to get things working (assumes constant updraft and negligible variability in dry air density)\n", - "\n", - " rho = Formulae.rho(state.p, Constants.R_a, state.T) # TODO: total pressure, but dry air R. (a good approximation)\n", - " volume = (4/3)*np.pi*state.R**3 # new total volume, as we are evolving R with bubble expansion\n", - " total_mass = rho * volume\n", - " rho_eq = Formulae.p_eq(state.T) / Constants.R_v / state.T\n", - " m_v = state.w_v*rho*volume #m_v is the total vapour mass\n", - " m_l = np.sum(state.m * state.n) # m_l is the total liquid water mass\n", - " m_w = m_l + m_v # m_w is the total water mass\n", - " rho_v = m_v / volume\n", - "\n", - " # eq. (4)\n", - " deriv.p = -Formulae.rho(state.p, Constants.R_a, state.T) * Constants.g\n", - "\n", - " # eq. (12) PER DROPLET (implied loop)\n", - " a = (3*state.m/4/np.pi/Constants.rho_w)**(1/3)\n", - "\n", - " deriv.m = 4 * np.pi * Constants.rho_w * a * Formulae.r_dr_dt(\n", - " Formulae.S_eq(a,self.kappa,self.a_dry_3,state.T), state.T, state.s, rho_eq\n", - " ) / self.w\n", - " # TODO: switch from integration in mass \"m\" to integration in \"ln(r)\" or alike ... or to \"r\" to be closer to the paper\n", - "\n", - " # eq. (5)\n", - " dwl_dz = np.sum(deriv.m * state.n)/total_mass\n", - "\n", - " env_T = state.T - self.ent_Tdiff\n", - " env_pv = self.ent_RH * Formulae.p_eq(env_T)\n", - " env_w_v = Formulae.rho(env_pv, Constants.R_v, env_T) / rho # to keep a constant relative humidity following conditions of BarahonaNenes2007\n", - "\n", - " # eq. (2)\n", - " deriv.w_v = - dwl_dz - self.ent_mu * (state.w_v - env_w_v + np.sum(state.m * state.n)/rho/volume)\n", - "\n", - " # eq. (1)\n", - " deriv.T = (deriv.p/rho - deriv.w_v * Constants.l_v) / Constants.c_p + \\\n", - " - self.ent_mu * ( (Constants.l_v/Constants.c_p)*(state.w_v-env_w_v) + (state.T-env_T) )\n", - "\n", - " #(3)\n", - " deriv.s = state.p/(Constants.epsilon*Formulae.p_eq(state.T)) * deriv.w_v \\\n", - " - (1+state.s)*(\n", - " (Constants.epsilon*Constants.l_v/(Constants.R_a*state.T**2))*deriv.T +\n", - " (Constants.g/(Constants.R_a*state.T))\n", - " )\n", - "\n", - " #(6)\n", - " deriv.n = -self.ent_mu * (state.n - self.ent_n)\n", - "\n", - " return deriv" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "nGVe3eDLF4CI" - }, - "source": [ - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2xFm959hF4CI" - }, - "source": [ - "### ... implemented according to SciPy API" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "g4iCJUjOF4CI" - }, - "outputs": [], - "source": [ - "from scipy import integrate\n", - "def solve(system, state, displacement):\n", - " integ = integrate.solve_ivp(\n", - " system,\n", - " [0, displacement / state.z_unit],\n", - " state,\n", - " max_step=(.1 * si.metre / state.z_unit).magnitude,\n", - " method='LSODA'\n", - " )\n", - " assert integ.success, integ.message\n", - " return Storage.view_state(integ.y), integ.t * state.z_unit" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "qBOq7bpcF4CI" - }, - "source": [ - "### and let's finally do the calculations ..." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "LFFo1xrUF4CI" - }, - "outputs": [], - "source": [ - "n_size_sections = 10\n", - "T0 = 300 * si.kelvins\n", - "p0 = 1000 * si.hectopascals\n", - "s0 = -0.01 * si.dimensionless\n", - "w = 0.3 * si.meter / si.second\n", - "\n", - "pv0 = (1 + s0) * Formulae.p_eq(T0)\n", - "displacement = 250 * si.metres\n", - "R0 = 350 * si.metres\n", - "volume = 4/3 * np.pi * R0**3\n", - "w_v0 = Constants.epsilon / (p0/pv0 - 1)\n", - "\n", - "# entrainment parameters\n", - "ent_mu = 0 / si.meter\n", - "ent_Tdiff = 0.3 * si.kelvin # T-T'\n", - "ent_RH = 0.9 * si.dimensionless #relative humidity\n", - "ent_n = 0.0 * si.dimensionless\n", - "\n", - "kappa = 1.2\n", - "geometric_stdev = 1.3\n", - "median_dry_radius = 1 * si.um\n", - "aerosol_concentration = 50 / si.centimetre**3\n", - "\n", - "dry_radii_quantiles = scipy.stats.lognorm(\n", - " np.log(geometric_stdev),\n", - " 0,\n", - " median_dry_radius.to(si.m).magnitude\n", - ").ppf(\n", - " np.linspace(0, 1, 2 * n_size_sections + 1)[1:-1:2]\n", - ") * si.m\n", - "\n", - "wet_radii_quantiles = np.asarray([scipy.optimize.root_scalar(\n", - " f=lambda r: s0 - Formulae.S_eq(r*si.m, kappa, r_dry**3, T0),\n", - " bracket=(\n", - " r_dry.to(si.m).magnitude,\n", - " Formulae.r_cr(kappa, r_dry**3, T0, Constants.sigma_w).to(si.m).magnitude\n", - " )\n", - ").root for r_dry in dry_radii_quantiles]) * si.m\n", - "\n", - "systems = {}\n", - "solutions = {}\n", - "zsteps = {}\n", - "for mu in [0.0, 0.01] * si.metre**-1:\n", - " state = Storage.make_state(n_size_sections)\n", - " state.p = p0\n", - " state.T = T0\n", - " state.n = aerosol_concentration * volume / n_size_sections\n", - " state.m = 4/3 * np.pi * Constants.rho_w * wet_radii_quantiles**3\n", - " state.s = s0\n", - " state.R = R0\n", - " state.w_v = w_v0\n", - "\n", - " systems[mu] = System(w=w, ent_mu=mu, ent_Tdiff=ent_Tdiff, ent_RH=ent_RH, ent_n=ent_n, r_dry=dry_radii_quantiles, kappa=kappa)\n", - " solutions[mu], zsteps[mu] = solve(systems[mu], state, displacement)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "uzWyPPO0F4CK" - }, - "source": [ - "### ... and plotting" - ] + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "[![preview notebook](https://img.shields.io/static/v1?label=render%20on&logo=github&color=87ce3e&message=GitHub)](https://github.com/open-atmos/PySDM/blob/main/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb)\n", + "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PySDM.git/main?urlpath=lab/tree/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb)\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PySDM/blob/main/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb)" + ] + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "TODO #1417 Provide notebook description" + }, + { + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "cell_type": "markdown", + "source": "\"Open\n" + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "nS021k0eQ5K7" + }, + "outputs": [], + "source": [ + "!pip install --quiet pint mendeleev" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "_KYH2YCDF4CF" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pint\n", + "from matplotlib import pyplot\n", + "import scipy\n", + "import functools\n", + "\n", + "si = pint.UnitRegistry()\n", + "si.setup_matplotlib()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "3Gd21_5yF4CG" + }, + "outputs": [], + "source": [ + "class Constants:\n", + " from scipy import constants\n", + " import mendeleev as pt\n", + "\n", + " # polynomial fot to equilibrium vapour pressure wrt water (coefficients from Flatau et al. 1992)\n", + " # doi:10.1175/1520-0450(1992)031<1507%3APFTSVP>2.0.CO%3B2\n", + " c_w = (6.115836990e000, 0.444606896e000, 0.143177157e-01, 0.264224321e-03, 0.299291081e-05,\n", + " 0.203154182e-07, 0.702620698e-10, 0.379534310e-13, -.321582393e-15)\n", + "\n", + " T0 = T0 = constants.zero_Celsius * si.kelvin\n", + "\n", + " def __molar_mass(x):\n", + " return x.atomic_weight * si.gram / si.mole\n", + "\n", + " M_a = (\n", + " 0.78 * __molar_mass(pt.N) * 2 +\n", + " 0.21 * __molar_mass(pt.O) * 2 +\n", + " 0.01 * __molar_mass(pt.Ar)\n", + " )\n", + " M_v = __molar_mass(pt.O) + __molar_mass(pt.H) * 2\n", + "\n", + " R_str = constants.R * si.joule / si.kelvin / si.mole\n", + "\n", + " R_a = R_str / M_a\n", + " R_v = R_str / M_v\n", + "\n", + " g = constants.g * si.metre / si.second**2\n", + "\n", + " l_v = 2.5e6 * si.joule / si.kilogram\n", + " c_p = 1000 * si.joule / si.kilogram / si.kelvin\n", + "\n", + " D = 2.26e-5 * si.metre ** 2 / si.second\n", + " K = 2.4e-2 * si.joules / si.metres / si.seconds / si.kelvins\n", + " rho_w = 1 * si.kilogram / si.litre\n", + " sigma_w = 0.072 * si.joule / si.metre**2\n", + "\n", + " epsilon = R_a/R_v" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "vlM1J4LZF4CG" + }, + "outputs": [], + "source": [ + "class Formulae:\n", + " @staticmethod\n", + " def rho(p, R, T):\n", + " return p / (R * T)\n", + "\n", + " @staticmethod\n", + " def __p_sat(temperature, coefficients, valid_range):\n", + " from numpy.polynomial.polynomial import polyval\n", + "\n", + " value = polyval(temperature.to(si.celsius).magnitude, coefficients)\n", + "\n", + " if isinstance(temperature.magnitude, np.ndarray):\n", + " value[np.logical_or(temperature < valid_range[0], temperature > valid_range[1])] = np.nan\n", + " else:\n", + " value = np.nan if not valid_range[0] < temperature <= valid_range[1] else value\n", + "\n", + " return value * si.hectopascals\n", + "\n", + " @staticmethod\n", + " def p_eq(T):\n", + " return Formulae.__p_sat(T, Constants.c_w, (Constants.T0-85 * si.kelvin, np.inf * si.kelvin))\n", + "\n", + " @staticmethod\n", + " def r_dr_dt(S_eq, T, S, rho_eq):\n", + " return (\n", + " (S - S_eq)\n", + " / Constants.rho_w\n", + " / (1 / rho_eq / Constants.D + Constants.l_v**2 / Constants.K / T**2 / Constants.R_v)\n", + " )\n", + "\n", + " def S_eq(a, kappa, a_dry_3, T):\n", + " return (\n", + " np.exp((2 * Constants.sigma_w / Constants.R_v / T / Constants.rho_w) / a)\n", + " * (a**3 - a_dry_3)\n", + " / (a**3 - a_dry_3 * (1 - kappa))\n", + " ) - 1\n", + "\n", + " @staticmethod\n", + " def r_cr(kp, a_dry_3, T, sgm): # from https://github.com/open-atmos/PySDM/blob/main/PySDM/physics/hygroscopicity/kappa_koehler.py\n", + " return np.sqrt(3 * kp * a_dry_3 / (2 * sgm / Constants.R_v / T / Constants.rho_w))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "EaiiPI4TF4CH" + }, + "outputs": [], + "source": [ + "class Storage:\n", + " \"\"\" state vector representation with each element having its own Pint-compatible\n", + " physical dimension, thus allowing to seamlessly couple Pint and scipy.odeint\n", + " (assumes the last variable extends till the end of the state vector;\n", + " all methods return objects that inherit from `numpy.ndarray` but are additionally\n", + " equipped with .VAR unit-aware setters and getters, allowing both unit-anaware\n", + " whole-array expressions (e.g., `state += dt * deriv`) as well as unit-aware\n", + " operations on state vars (e.g., `state.T = 300 * si.K` or `state.m[:] = ...`) \"\"\"\n", + "\n", + " var_units = {\n", + " 'p': si.Pa,\n", + " 'T': si.K,\n", + " 'R': si.m,\n", + " 's': si.dimensionless,\n", + " 'w_v': si.dimensionless,\n", + " 'n': si.dimensionless,\n", + " 'm': si.kg\n", + " }\n", + "\n", + " der_unit = si.metre\n", + "\n", + " @staticmethod\n", + " def __make_storage(shape, deriv=False):\n", + " def getter(self, idx, unit):\n", + " return self[idx] * unit\n", + "\n", + " def setter(self, value, idx, unit):\n", + " self[idx] = (value.to(unit) / unit).magnitude\n", + "\n", + " properties = {'z_unit': Storage.der_unit}\n", + " for i, key in enumerate(Storage.var_units.keys()):\n", + " kwargs = {\n", + " 'unit': Storage.var_units[key] / (Storage.der_unit if deriv else 1),\n", + " 'idx': i if i + 1 != len(Storage.var_units) else slice(i, None)\n", + " }\n", + " properties[key] = property(\n", + " functools.partial(getter, **kwargs),\n", + " functools.partial(setter, **kwargs),\n", + " )\n", + "\n", + " return type(\"StorageImpl\", (np.ndarray,), properties)(shape)\n", + "\n", + " @staticmethod\n", + " def make_state(n_particles):\n", + " \"\"\" returns a newly allocated unit-aware storage of size relevant for `n_particles` simulation \"\"\"\n", + " return Storage.__make_storage((len(Storage.var_units) - 1 + n_particles,))\n", + "\n", + " @staticmethod\n", + " def make_deriv(state):\n", + " \"\"\" returns a newly allocated unit-aware storage with size of `state` and derivative dimensions \"\"\"\n", + " return Storage.__make_storage(state.shape, deriv=True)\n", + "\n", + " @staticmethod\n", + " def view_state(array):\n", + " \"\"\" returns a newly allocated unit-aware storage with size and data from unit-unaware `array` \"\"\"\n", + " storage = Storage.__make_storage(array.shape)\n", + " storage[:] = array[:]\n", + " return storage" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-aahyi9NF4CH" + }, + "source": [ + "### the new ODE system we will solve ..." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3Sp4KUcgF4CI" + }, + "source": [ + "\n", + "
this week (particles):
\n", + "$$\n", + "\\begin{eqnarray}\n", + " \\frac{dp}{dz} &=& - \\rho g \\\\\n", + " \\frac{dm_i}{dz} &=& \\frac{\\xi_i}{w} \\max\\!\\!\\left[0,\\,\\,\\frac{4\\pi r_i^2}{r_i} D (\\rho_v - \\rho_{eq})\\right]\\\\ &=& \\frac{\\xi_i}{w}\\max\\!\\!\\left[0,\\,\\,(4 \\pi)^{2/3} \\sqrt[3]{\\frac{3m_i}{\\xi_i\\rho_w}}\\,D \\left(\\rho_v - \\frac{p_{eq}(T)}{R_v T}\\right)\\right]\\\\\n", + " \\vdots\\\\\n", + " \\frac{dT}{dz} &=& \\frac{1}{c_p} \\left(\\frac{1}{\\rho}\\frac{dp}{dz} + \\frac{l_v}{m_a} \\sum_i \\frac{dm_i}{dz} \\right)\n", + "\\end{eqnarray}\n", + "$$\n", + "\n", + "$p$: pressure \n", + "$z$: vertical displacement \n", + "$\\rho$: air density \n", + "$g$: gravitational acceleration \n", + "$r_i$: radius of size category $i$ \\\\\n", + "$m_i$: mass of liquid water in size category $i$ (i.e., sum of masses of particles of radius $r_i$) \n", + "$\\xi_i$: multiplicity of size category $i$ (i.e., number of particles of radius $r_i$) \n", + "$\\rho_v$: density of water vapour \\\\\n", + "$\\rho_{eq}$: density of water vapour at saturation (in phase equilibrium wrt water surface) \n", + "$T$: temperature \n", + "$c_p$: specific heat of air \n", + "$l_v$: latent heat of vapourisation \n", + "$m_a$: mass of air \\\\\n", + "$R$: radius of parcel \\\\\n", + "$w_v$: water vapour mixing ratio\n", + "\n", + "TODO: This system needs to be updated to match the system we are actually solving from Lee and Pruppacher. Variables need to be updated as well.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "nLBfqaJ8F4CI" + }, + "outputs": [], + "source": [ + "class System:\n", + " def __init__(self, *, w, ent_Tdiff, ent_RH, ent_mu, ent_n, r_dry, kappa):\n", + " self.w = w\n", + " self.ent_mu = ent_mu\n", + " self.ent_Tdiff = ent_Tdiff\n", + " self.ent_RH = ent_RH\n", + " self.a_dry_3 = r_dry**3\n", + " self.kappa = kappa\n", + " self.ent_n = ent_n\n", + "\n", + " def __call__(self, _, state):\n", + " state = Storage.view_state(state)\n", + " deriv = Storage.make_deriv(state)\n", + "\n", + " #(8)\n", + " deriv.R = state.R * self.ent_mu #rough appox of eq.8 to get things working (assumes constant updraft and negligible variability in dry air density)\n", + "\n", + " rho = Formulae.rho(state.p, Constants.R_a, state.T) # TODO: total pressure, but dry air R. (a good approximation)\n", + " volume = (4/3)*np.pi*state.R**3 # new total volume, as we are evolving R with bubble expansion\n", + " total_mass = rho * volume\n", + " rho_eq = Formulae.p_eq(state.T) / Constants.R_v / state.T\n", + " m_v = state.w_v*rho*volume #m_v is the total vapour mass\n", + " m_l = np.sum(state.m * state.n) # m_l is the total liquid water mass\n", + " m_w = m_l + m_v # m_w is the total water mass\n", + " rho_v = m_v / volume\n", + "\n", + " # eq. (4)\n", + " deriv.p = -Formulae.rho(state.p, Constants.R_a, state.T) * Constants.g\n", + "\n", + " # eq. (12) PER DROPLET (implied loop)\n", + " a = (3*state.m/4/np.pi/Constants.rho_w)**(1/3)\n", + "\n", + " deriv.m = 4 * np.pi * Constants.rho_w * a * Formulae.r_dr_dt(\n", + " Formulae.S_eq(a,self.kappa,self.a_dry_3,state.T), state.T, state.s, rho_eq\n", + " ) / self.w\n", + " # TODO: switch from integration in mass \"m\" to integration in \"ln(r)\" or alike ... or to \"r\" to be closer to the paper\n", + "\n", + " # eq. (5)\n", + " dwl_dz = np.sum(deriv.m * state.n)/total_mass\n", + "\n", + " env_T = state.T - self.ent_Tdiff\n", + " env_pv = self.ent_RH * Formulae.p_eq(env_T)\n", + " env_w_v = Formulae.rho(env_pv, Constants.R_v, env_T) / rho # to keep a constant relative humidity following conditions of BarahonaNenes2007\n", + "\n", + " # eq. (2)\n", + " deriv.w_v = - dwl_dz - self.ent_mu * (state.w_v - env_w_v + np.sum(state.m * state.n)/rho/volume)\n", + "\n", + " # eq. (1)\n", + " deriv.T = (deriv.p/rho - deriv.w_v * Constants.l_v) / Constants.c_p + \\\n", + " - self.ent_mu * ( (Constants.l_v/Constants.c_p)*(state.w_v-env_w_v) + (state.T-env_T) )\n", + "\n", + " #(3)\n", + " deriv.s = state.p/(Constants.epsilon*Formulae.p_eq(state.T)) * deriv.w_v \\\n", + " - (1+state.s)*(\n", + " (Constants.epsilon*Constants.l_v/(Constants.R_a*state.T**2))*deriv.T +\n", + " (Constants.g/(Constants.R_a*state.T))\n", + " )\n", + "\n", + " #(6)\n", + " deriv.n = -self.ent_mu * (state.n - self.ent_n)\n", + "\n", + " return deriv" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nGVe3eDLF4CI" + }, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2xFm959hF4CI" + }, + "source": [ + "### ... implemented according to SciPy API" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "g4iCJUjOF4CI" + }, + "outputs": [], + "source": [ + "from scipy import integrate\n", + "def solve(system, state, displacement):\n", + " integ = integrate.solve_ivp(\n", + " system,\n", + " [0, displacement / state.z_unit],\n", + " state,\n", + " max_step=(.1 * si.metre / state.z_unit).magnitude,\n", + " method='LSODA'\n", + " )\n", + " assert integ.success, integ.message\n", + " return Storage.view_state(integ.y), integ.t * state.z_unit" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qBOq7bpcF4CI" + }, + "source": [ + "### and let's finally do the calculations ..." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "LFFo1xrUF4CI" + }, + "outputs": [], + "source": [ + "n_size_sections = 10\n", + "T0 = 300 * si.kelvins\n", + "p0 = 1000 * si.hectopascals\n", + "s0 = -0.01 * si.dimensionless\n", + "w = 0.3 * si.meter / si.second\n", + "\n", + "pv0 = (1 + s0) * Formulae.p_eq(T0)\n", + "displacement = 250 * si.metres\n", + "R0 = 350 * si.metres\n", + "volume = 4/3 * np.pi * R0**3\n", + "w_v0 = Constants.epsilon / (p0/pv0 - 1)\n", + "\n", + "# entrainment parameters\n", + "ent_mu = 0 / si.meter\n", + "ent_Tdiff = 0.3 * si.kelvin # T-T'\n", + "ent_RH = 0.9 * si.dimensionless #relative humidity\n", + "ent_n = 0.0 * si.dimensionless\n", + "\n", + "kappa = 1.2\n", + "geometric_stdev = 1.3\n", + "median_dry_radius = 1 * si.um\n", + "aerosol_concentration = 50 / si.centimetre**3\n", + "\n", + "dry_radii_quantiles = scipy.stats.lognorm(\n", + " np.log(geometric_stdev),\n", + " 0,\n", + " median_dry_radius.to(si.m).magnitude\n", + ").ppf(\n", + " np.linspace(0, 1, 2 * n_size_sections + 1)[1:-1:2]\n", + ") * si.m\n", + "\n", + "wet_radii_quantiles = np.asarray([scipy.optimize.root_scalar(\n", + " f=lambda r: s0 - Formulae.S_eq(r*si.m, kappa, r_dry**3, T0),\n", + " bracket=(\n", + " r_dry.to(si.m).magnitude,\n", + " Formulae.r_cr(kappa, r_dry**3, T0, Constants.sigma_w).to(si.m).magnitude\n", + " )\n", + ").root for r_dry in dry_radii_quantiles]) * si.m\n", + "\n", + "systems = {}\n", + "solutions = {}\n", + "zsteps = {}\n", + "for mu in [0.0, 0.01] * si.metre**-1:\n", + " state = Storage.make_state(n_size_sections)\n", + " state.p = p0\n", + " state.T = T0\n", + " state.n = aerosol_concentration * volume / n_size_sections\n", + " state.m = 4/3 * np.pi * Constants.rho_w * wet_radii_quantiles**3\n", + " state.s = s0\n", + " state.R = R0\n", + " state.w_v = w_v0\n", + "\n", + " systems[mu] = System(w=w, ent_mu=mu, ent_Tdiff=ent_Tdiff, ent_RH=ent_RH, ent_n=ent_n, r_dry=dry_radii_quantiles, kappa=kappa)\n", + " solutions[mu], zsteps[mu] = solve(systems[mu], state, displacement)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uzWyPPO0F4CK" + }, + "source": [ + "### ... and plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 410 }, + "id": "T1lffCOOF4CK", + "outputId": "29fd460d-a17a-4a2d-9a6d-d515fc1ac6cb" + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 410 - }, - "id": "T1lffCOOF4CK", - "outputId": "29fd460d-a17a-4a2d-9a6d-d515fc1ac6cb" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } + "output_type": "display_data", + "data": { + "text/plain": [ + "
" ], - "source": [ - "fig, axs = pyplot.subplots(1, 3, sharey=True, figsize=(15, 4))\n", - "\n", - "for mu in solutions.keys():\n", - " sys = systems[mu]\n", - " sol = solutions[mu]\n", - " z = zsteps[mu]\n", - "\n", - " axs[0].plot(sol.s, z, label=mu)\n", - "\n", - " drops_mass = sol.m * sol.n\n", - " axs[1].plot(np.mean(drops_mass, axis=0), z, label=mu)\n", - " axs[1].xaxis.set_units(si.micrograms)\n", - "\n", - " axs[2].plot(sol.w_v, z, label=mu)\n", - " axs[2].xaxis.set_units(si.grams / si.kilogram)\n", - "\n", - "for i in range(len(axs)):\n", - " axs[i].legend(loc='upper left')\n", - " axs[i].grid()\n", - "\n", - "_ = axs[0].set_title('Supersaturation [%]')\n", - "_ = axs[1].set_title('Average drop mass')\n", - "_ = axs[2].set_title('vapour mixing ratio [g/kg]')" - ] - } - ], - "metadata": { - "colab": { - "provenance": [], - "include_colab_link": true - }, - "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.2" + "image/png": "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\n" + }, + "metadata": {} } + ], + "source": [ + "fig, axs = pyplot.subplots(1, 3, sharey=True, figsize=(15, 4))\n", + "\n", + "for mu in solutions.keys():\n", + " sys = systems[mu]\n", + " sol = solutions[mu]\n", + " z = zsteps[mu]\n", + "\n", + " axs[0].plot(sol.s, z, label=mu)\n", + "\n", + " drops_mass = sol.m * sol.n\n", + " axs[1].plot(np.mean(drops_mass, axis=0), z, label=mu)\n", + " axs[1].xaxis.set_units(si.micrograms)\n", + "\n", + " axs[2].plot(sol.w_v, z, label=mu)\n", + " axs[2].xaxis.set_units(si.grams / si.kilogram)\n", + "\n", + "for i in range(len(axs)):\n", + " axs[i].legend(loc='upper left')\n", + " axs[i].grid()\n", + "\n", + "_ = axs[0].set_title('Supersaturation [%]')\n", + "_ = axs[1].set_title('Average drop mass')\n", + "_ = axs[2].set_title('vapour mixing ratio [g/kg]')" + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 0 + "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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 } From 3d5cc629db469eee272ced0aa62ccbc6454e51b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Agnieszka=20=C5=BBaba?= Date: Thu, 28 Nov 2024 14:26:49 +0100 Subject: [PATCH 4/5] add colab header to Barahona&Nenes example --- .../Barahona_and_Nenes_2007/fig_1.ipynb | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb index 4f98669ec..d19455db6 100644 --- a/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb +++ b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb @@ -14,6 +14,19 @@ "cell_type": "markdown", "source": "TODO #1417 Provide notebook description" }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "import sys\n", + "if 'google.colab' in sys.modules:\n", + " !pip --quiet install open-atmos-jupyter-utils\n", + " from open_atmos_jupyter_utils import pip_install_on_colab\n", + " pip_install_on_colab('PySDM-examples')" + ] + }, { "metadata": { "id": "view-in-github", From 28086ee77c17fe6c9bf6f03aae0135e6b7475bab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Agnieszka=20=C5=BBaba?= Date: Tue, 3 Dec 2024 14:47:30 +0100 Subject: [PATCH 5/5] cleanup and plot closer to Barahona_and_Nenes --- .../Barahona_and_Nenes_2007/fig_1.ipynb | 357 ++++++++---------- 1 file changed, 158 insertions(+), 199 deletions(-) diff --git a/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb index d19455db6..5d1007c6c 100644 --- a/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb +++ b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb @@ -12,86 +12,86 @@ { "metadata": {}, "cell_type": "markdown", - "source": "TODO #1417 Provide notebook description" + "source": [ + "Fig. 1 from [Barahona and Nenes 2007](https://doi.org/10.1029/2007JD008473) using [Lee & Pruppacher 1977](https://doi.org/10.1007/BF00876119) entraining parcel model implemented without dependence on PySDM, and with Pint dimensional analysis checks.\n", + "\n", + "TODO #1433:\n", + "- use DimensionalAnalysis context manager to check units only once, and skip units checks for integration\n", + "- switch from integration in mass \"m\" to integration in \"ln(r)\" or alike ... or to \"r\" to be closer to the paper\n", + "- rho in System: total pressure, but dry air R. (a good approximation)\n" + ] }, { - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T13:46:36.127318Z", + "start_time": "2024-12-03T13:46:36.097786Z" + } + }, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": [ "import sys\n", "if 'google.colab' in sys.modules:\n", " !pip --quiet install open-atmos-jupyter-utils\n", " from open_atmos_jupyter_utils import pip_install_on_colab\n", " pip_install_on_colab('PySDM-examples')" - ] - }, - { - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "cell_type": "markdown", - "source": "\"Open\n" - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "nS021k0eQ5K7" - }, + ], "outputs": [], - "source": [ - "!pip install --quiet pint mendeleev" - ] + "execution_count": 10 }, { "cell_type": "code", - "execution_count": 2, "metadata": { - "id": "_KYH2YCDF4CF" + "id": "_KYH2YCDF4CF", + "ExecuteTime": { + "end_time": "2024-12-03T13:46:36.588674Z", + "start_time": "2024-12-03T13:46:36.132140Z" + } }, - "outputs": [], "source": [ "import numpy as np\n", "import pint\n", "from matplotlib import pyplot\n", "import scipy\n", "import functools\n", - "\n", + "from scipy import constants\n", + "from chempy import Substance\n", + " \n", "si = pint.UnitRegistry()\n", - "si.setup_matplotlib()" - ] + "si.setup_matplotlib()\n", + "si.define('fraction = [] = frac')\n", + "si.define('percent = 1e-2 frac = pct')" + ], + "outputs": [], + "execution_count": 11 }, { "cell_type": "code", - "execution_count": 3, "metadata": { - "id": "3Gd21_5yF4CG" + "id": "3Gd21_5yF4CG", + "ExecuteTime": { + "end_time": "2024-12-03T13:46:36.608277Z", + "start_time": "2024-12-03T13:46:36.601776Z" + } }, - "outputs": [], "source": [ "class Constants:\n", - " from scipy import constants\n", - " import mendeleev as pt\n", - "\n", " # polynomial fot to equilibrium vapour pressure wrt water (coefficients from Flatau et al. 1992)\n", " # doi:10.1175/1520-0450(1992)031<1507%3APFTSVP>2.0.CO%3B2\n", " c_w = (6.115836990e000, 0.444606896e000, 0.143177157e-01, 0.264224321e-03, 0.299291081e-05,\n", " 0.203154182e-07, 0.702620698e-10, 0.379534310e-13, -.321582393e-15)\n", "\n", - " T0 = T0 = constants.zero_Celsius * si.kelvin\n", + " T0 = constants.zero_Celsius * si.kelvin\n", "\n", " def __molar_mass(x):\n", - " return x.atomic_weight * si.gram / si.mole\n", + " return Substance.from_formula(x).mass * si.gram / si.mole\n", "\n", " M_a = (\n", - " 0.78 * __molar_mass(pt.N) * 2 +\n", - " 0.21 * __molar_mass(pt.O) * 2 +\n", - " 0.01 * __molar_mass(pt.Ar)\n", + " 0.78 * __molar_mass(\"N2\") +\n", + " 0.21 * __molar_mass(\"O2\") +\n", + " 0.01 * __molar_mass(\"Ar\")\n", " )\n", - " M_v = __molar_mass(pt.O) + __molar_mass(pt.H) * 2\n", + " M_v = __molar_mass(\"O\") + __molar_mass(\"H\") * 2\n", "\n", " R_str = constants.R * si.joule / si.kelvin / si.mole\n", "\n", @@ -109,15 +109,19 @@ " sigma_w = 0.072 * si.joule / si.metre**2\n", "\n", " epsilon = R_a/R_v" - ] + ], + "outputs": [], + "execution_count": 12 }, { "cell_type": "code", - "execution_count": 4, "metadata": { - "id": "vlM1J4LZF4CG" + "id": "vlM1J4LZF4CG", + "ExecuteTime": { + "end_time": "2024-12-03T13:46:36.619675Z", + "start_time": "2024-12-03T13:46:36.615186Z" + } }, - "outputs": [], "source": [ "class Formulae:\n", " @staticmethod\n", @@ -148,26 +152,31 @@ " / Constants.rho_w\n", " / (1 / rho_eq / Constants.D + Constants.l_v**2 / Constants.K / T**2 / Constants.R_v)\n", " )\n", - "\n", - " def S_eq(a, kappa, a_dry_3, T):\n", + " \n", + " @staticmethod\n", + " def S_eq(drop_radius, kappa, a_dry_3, T):\n", " return (\n", - " np.exp((2 * Constants.sigma_w / Constants.R_v / T / Constants.rho_w) / a)\n", - " * (a**3 - a_dry_3)\n", - " / (a**3 - a_dry_3 * (1 - kappa))\n", + " np.exp((2 * Constants.sigma_w / Constants.R_v / T / Constants.rho_w) / drop_radius)\n", + " * (drop_radius**3 - a_dry_3)\n", + " / (drop_radius**3 - a_dry_3 * (1 - kappa))\n", " ) - 1\n", "\n", " @staticmethod\n", " def r_cr(kp, a_dry_3, T, sgm): # from https://github.com/open-atmos/PySDM/blob/main/PySDM/physics/hygroscopicity/kappa_koehler.py\n", " return np.sqrt(3 * kp * a_dry_3 / (2 * sgm / Constants.R_v / T / Constants.rho_w))\n" - ] + ], + "outputs": [], + "execution_count": 13 }, { "cell_type": "code", - "execution_count": 5, "metadata": { - "id": "EaiiPI4TF4CH" + "id": "EaiiPI4TF4CH", + "ExecuteTime": { + "end_time": "2024-12-03T13:46:36.630871Z", + "start_time": "2024-12-03T13:46:36.625974Z" + } }, - "outputs": [], "source": [ "class Storage:\n", " \"\"\" state vector representation with each element having its own Pint-compatible\n", @@ -181,8 +190,8 @@ " var_units = {\n", " 'p': si.Pa,\n", " 'T': si.K,\n", - " 'R': si.m,\n", - " 's': si.dimensionless,\n", + " 'parcel_radius': si.m,\n", + " 'supersaturation': si.dimensionless,\n", " 'w_v': si.dimensionless,\n", " 'n': si.dimensionless,\n", " 'm': si.kg\n", @@ -227,60 +236,19 @@ " storage = Storage.__make_storage(array.shape)\n", " storage[:] = array[:]\n", " return storage" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "-aahyi9NF4CH" - }, - "source": [ - "### the new ODE system we will solve ..." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "3Sp4KUcgF4CI" - }, - "source": [ - "\n", - "
this week (particles):
\n", - "$$\n", - "\\begin{eqnarray}\n", - " \\frac{dp}{dz} &=& - \\rho g \\\\\n", - " \\frac{dm_i}{dz} &=& \\frac{\\xi_i}{w} \\max\\!\\!\\left[0,\\,\\,\\frac{4\\pi r_i^2}{r_i} D (\\rho_v - \\rho_{eq})\\right]\\\\ &=& \\frac{\\xi_i}{w}\\max\\!\\!\\left[0,\\,\\,(4 \\pi)^{2/3} \\sqrt[3]{\\frac{3m_i}{\\xi_i\\rho_w}}\\,D \\left(\\rho_v - \\frac{p_{eq}(T)}{R_v T}\\right)\\right]\\\\\n", - " \\vdots\\\\\n", - " \\frac{dT}{dz} &=& \\frac{1}{c_p} \\left(\\frac{1}{\\rho}\\frac{dp}{dz} + \\frac{l_v}{m_a} \\sum_i \\frac{dm_i}{dz} \\right)\n", - "\\end{eqnarray}\n", - "$$\n", - "\n", - "$p$: pressure \n", - "$z$: vertical displacement \n", - "$\\rho$: air density \n", - "$g$: gravitational acceleration \n", - "$r_i$: radius of size category $i$ \\\\\n", - "$m_i$: mass of liquid water in size category $i$ (i.e., sum of masses of particles of radius $r_i$) \n", - "$\\xi_i$: multiplicity of size category $i$ (i.e., number of particles of radius $r_i$) \n", - "$\\rho_v$: density of water vapour \\\\\n", - "$\\rho_{eq}$: density of water vapour at saturation (in phase equilibrium wrt water surface) \n", - "$T$: temperature \n", - "$c_p$: specific heat of air \n", - "$l_v$: latent heat of vapourisation \n", - "$m_a$: mass of air \\\\\n", - "$R$: radius of parcel \\\\\n", - "$w_v$: water vapour mixing ratio\n", - "\n", - "TODO: This system needs to be updated to match the system we are actually solving from Lee and Pruppacher. Variables need to be updated as well.\n" - ] + ], + "outputs": [], + "execution_count": 14 }, { "cell_type": "code", - "execution_count": 6, "metadata": { - "id": "nLBfqaJ8F4CI" + "id": "nLBfqaJ8F4CI", + "ExecuteTime": { + "end_time": "2024-12-03T13:46:36.645769Z", + "start_time": "2024-12-03T13:46:36.638213Z" + } }, - "outputs": [], "source": [ "class System:\n", " def __init__(self, *, w, ent_Tdiff, ent_RH, ent_mu, ent_n, r_dry, kappa):\n", @@ -297,29 +265,23 @@ " deriv = Storage.make_deriv(state)\n", "\n", " #(8)\n", - " deriv.R = state.R * self.ent_mu #rough appox of eq.8 to get things working (assumes constant updraft and negligible variability in dry air density)\n", + " deriv.parcel_radius = state.parcel_radius * self.ent_mu / 2 #rough appox of eq.8 to get things working (assumes constant updraft and negligible variability in dry air density)\n", "\n", - " rho = Formulae.rho(state.p, Constants.R_a, state.T) # TODO: total pressure, but dry air R. (a good approximation)\n", - " volume = (4/3)*np.pi*state.R**3 # new total volume, as we are evolving R with bubble expansion\n", - " total_mass = rho * volume\n", - " rho_eq = Formulae.p_eq(state.T) / Constants.R_v / state.T\n", - " m_v = state.w_v*rho*volume #m_v is the total vapour mass\n", - " m_l = np.sum(state.m * state.n) # m_l is the total liquid water mass\n", - " m_w = m_l + m_v # m_w is the total water mass\n", - " rho_v = m_v / volume\n", + " rho = Formulae.rho(state.p, Constants.R_a, state.T) \n", "\n", " # eq. (4)\n", - " deriv.p = -Formulae.rho(state.p, Constants.R_a, state.T) * Constants.g\n", + " deriv.p = -rho * Constants.g\n", "\n", " # eq. (12) PER DROPLET (implied loop)\n", - " a = (3*state.m/4/np.pi/Constants.rho_w)**(1/3)\n", - "\n", - " deriv.m = 4 * np.pi * Constants.rho_w * a * Formulae.r_dr_dt(\n", - " Formulae.S_eq(a,self.kappa,self.a_dry_3,state.T), state.T, state.s, rho_eq\n", + " drop_radius = (3*state.m/4/np.pi/Constants.rho_w)**(1/3)\n", + " rho_eq = Formulae.p_eq(state.T) / Constants.R_v / state.T\n", + " deriv.m = 4 * np.pi * Constants.rho_w * drop_radius * Formulae.r_dr_dt(\n", + " Formulae.S_eq(drop_radius,self.kappa,self.a_dry_3,state.T), state.T, state.supersaturation, rho_eq\n", " ) / self.w\n", - " # TODO: switch from integration in mass \"m\" to integration in \"ln(r)\" or alike ... or to \"r\" to be closer to the paper\n", "\n", " # eq. (5)\n", + " volume = (4/3)*np.pi*state.parcel_radius**3 # new total volume, as we are evolving R with bubble expansion\n", + " total_mass = rho * volume\n", " dwl_dz = np.sum(deriv.m * state.n)/total_mass\n", "\n", " env_T = state.T - self.ent_Tdiff\n", @@ -334,8 +296,8 @@ " - self.ent_mu * ( (Constants.l_v/Constants.c_p)*(state.w_v-env_w_v) + (state.T-env_T) )\n", "\n", " #(3)\n", - " deriv.s = state.p/(Constants.epsilon*Formulae.p_eq(state.T)) * deriv.w_v \\\n", - " - (1+state.s)*(\n", + " deriv.supersaturation = state.p/(Constants.epsilon*Formulae.p_eq(state.T)) * deriv.w_v \\\n", + " - (1+state.supersaturation)*(\n", " (Constants.epsilon*Constants.l_v/(Constants.R_a*state.T**2))*deriv.T +\n", " (Constants.g/(Constants.R_a*state.T))\n", " )\n", @@ -344,33 +306,19 @@ " deriv.n = -self.ent_mu * (state.n - self.ent_n)\n", "\n", " return deriv" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "nGVe3eDLF4CI" - }, - "source": [ - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2xFm959hF4CI" - }, - "source": [ - "### ... implemented according to SciPy API" - ] + ], + "outputs": [], + "execution_count": 15 }, { "cell_type": "code", - "execution_count": 7, "metadata": { - "id": "g4iCJUjOF4CI" + "id": "g4iCJUjOF4CI", + "ExecuteTime": { + "end_time": "2024-12-03T13:46:36.656940Z", + "start_time": "2024-12-03T13:46:36.654273Z" + } }, - "outputs": [], "source": [ "from scipy import integrate\n", "def solve(system, state, displacement):\n", @@ -383,30 +331,25 @@ " )\n", " assert integ.success, integ.message\n", " return Storage.view_state(integ.y), integ.t * state.z_unit" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "qBOq7bpcF4CI" - }, - "source": [ - "### and let's finally do the calculations ..." - ] + ], + "outputs": [], + "execution_count": 16 }, { "cell_type": "code", - "execution_count": 8, "metadata": { - "id": "LFFo1xrUF4CI" + "id": "LFFo1xrUF4CI", + "ExecuteTime": { + "end_time": "2024-12-03T13:47:21.983842Z", + "start_time": "2024-12-03T13:46:36.665326Z" + } }, - "outputs": [], "source": [ "n_size_sections = 10\n", "T0 = 300 * si.kelvins\n", "p0 = 1000 * si.hectopascals\n", "s0 = -0.01 * si.dimensionless\n", - "w = 0.3 * si.meter / si.second\n", + "w = 5 * si.meter / si.second\n", "\n", "pv0 = (1 + s0) * Formulae.p_eq(T0)\n", "displacement = 250 * si.metres\n", @@ -444,77 +387,93 @@ "systems = {}\n", "solutions = {}\n", "zsteps = {}\n", - "for mu in [0.0, 0.01] * si.metre**-1:\n", + "\n", + "def e_c(RH, T, Tp):\n", + " \"\"\"Equation 23b from Barahona & Nenes 2007\"\"\"\n", + " alpha = Constants.g * Constants.M_v * Constants.l_v / Constants.c_p / Constants.R_str / (T**2) \\\n", + " - Constants.g * Constants.M_a / Constants.R_str / T\n", + " return alpha / ((1-RH) - Constants.l_v * Constants.M_v / Constants.R_str / (T**2) * (T - Tp))\n", + "\n", + "for mu in [0.0 * si.metre**-1, e_c(RH = 1 + s0, T = T0, Tp = T0 - ent_Tdiff)]:\n", " state = Storage.make_state(n_size_sections)\n", " state.p = p0\n", " state.T = T0\n", " state.n = aerosol_concentration * volume / n_size_sections\n", " state.m = 4/3 * np.pi * Constants.rho_w * wet_radii_quantiles**3\n", - " state.s = s0\n", - " state.R = R0\n", + " state.supersaturation = s0\n", + " state.parcel_radius = R0\n", " state.w_v = w_v0\n", "\n", " systems[mu] = System(w=w, ent_mu=mu, ent_Tdiff=ent_Tdiff, ent_RH=ent_RH, ent_n=ent_n, r_dry=dry_radii_quantiles, kappa=kappa)\n", " solutions[mu], zsteps[mu] = solve(systems[mu], state, displacement)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "uzWyPPO0F4CK" - }, - "source": [ - "### ... and plotting" - ] + ], + "outputs": [], + "execution_count": 17 }, { "cell_type": "code", - "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 410 }, "id": "T1lffCOOF4CK", - "outputId": "29fd460d-a17a-4a2d-9a6d-d515fc1ac6cb" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} + "outputId": "29fd460d-a17a-4a2d-9a6d-d515fc1ac6cb", + "ExecuteTime": { + "end_time": "2024-12-03T13:47:22.266670Z", + "start_time": "2024-12-03T13:47:22.028365Z" } - ], + }, "source": [ - "fig, axs = pyplot.subplots(1, 3, sharey=True, figsize=(15, 4))\n", + "fig, axs = pyplot.subplots(3, 1, sharex=True, figsize=(5, 12))\n", "\n", "for mu in solutions.keys():\n", " sys = systems[mu]\n", " sol = solutions[mu]\n", - " z = zsteps[mu]\n", - "\n", - " axs[0].plot(sol.s, z, label=mu)\n", - "\n", - " drops_mass = sol.m * sol.n\n", - " axs[1].plot(np.mean(drops_mass, axis=0), z, label=mu)\n", - " axs[1].xaxis.set_units(si.micrograms)\n", - "\n", - " axs[2].plot(sol.w_v, z, label=mu)\n", - " axs[2].xaxis.set_units(si.grams / si.kilogram)\n", - "\n", + " t = zsteps[mu] / w\n", + "\n", + " axs[0].plot(t, sol.supersaturation, label=mu)\n", + " axs[0].yaxis.set_units(si.percent)\n", + " \n", + " axs[1].plot(t, np.mean(sol.m, axis=0), label=mu)\n", + " axs[1].yaxis.set_units(si.micrograms)\n", + "\n", + " axs[2].plot(t, sol.w_v, label=mu)\n", + " axs[2].yaxis.set_units(si.grams / si.kilogram)\n", + " break\n", + " \n", "for i in range(len(axs)):\n", " axs[i].legend(loc='upper left')\n", " axs[i].grid()\n", - "\n", "_ = axs[0].set_title('Supersaturation [%]')\n", "_ = axs[1].set_title('Average drop mass')\n", "_ = axs[2].set_title('vapour mixing ratio [g/kg]')" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 18 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T13:47:22.276829Z", + "start_time": "2024-12-03T13:47:22.275583Z" + } + }, + "cell_type": "code", + "source": "", + "outputs": [], + "execution_count": null } ], "metadata": {