PySDM 2.74__tar.gz → 2.77__tar.gz

{PySDM-2.74 → PySDM-2.77}/.pre-commit-config.yaml

@@ -18,4 +18,4 @@ repos:
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
-      - id: debug-statements
+      - id: debug-statements

{PySDM-2.74 → PySDM-2.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.74
+Version: 2.77
 Summary: Pythonic particle-based (super-droplet) warm-rain/aqueous-chemistry cloud microphysics package with box, parcel & 1D/2D prescribed-flow examples in Python, Julia and Matlab
 Home-page: https://github.com/open-atmos/PySDM
 Author: https://github.com/open-atmos/PySDM/graphs/contributors

{PySDM-2.74 → PySDM-2.77}/PySDM/backends/impl_numba/methods/__init__.py

@@ -12,3 +12,4 @@ from .moments_methods import MomentsMethods
 from .pair_methods import PairMethods
 from .physics_methods import PhysicsMethods
 from .terminal_velocity_methods import TerminalVelocityMethods
+from .seeding_methods import SeedingMethods

{PySDM-2.74 → PySDM-2.77}/PySDM/backends/impl_numba/methods/condensation_methods.py

@@ -291,9 +291,7 @@ class CondensationMethods(BackendMethods):
                 )
                 pv = formulae.state_variable_triplet__pv(p, water_vapour_mixing_ratio)
                 lv = formulae.latent_heat__lv(T)
-                pvs = formulae.saturation_vapour_pressure__pvs_Celsius(
-                    T - formulae.constants.T0
-                )
+                pvs = formulae.saturation_vapour_pressure__pvs_water(T)
                 DTp = formulae.diffusion_thermics__D(T, p)
                 RH = pv / pvs
                 Sc = formulae.trivia__air_schmidt_number(
@@ -445,7 +443,7 @@ class CondensationMethods(BackendMethods):
                 v_drop = formulae.particle_shape_and_density__mass_to_volume(
                     attributes.water_mass[drop]
                 )
-                if v_drop < 0:
+                if v_drop <= 0:
                     continue
                 x_old = formulae.condensation_coordinate__x(v_drop)
                 r_old = formulae.trivia__radius(v_drop)

{PySDM-2.74 → PySDM-2.77}/PySDM/backends/impl_numba/methods/physics_methods.py

@@ -59,7 +59,7 @@ class PhysicsMethods(BackendMethods):
                 )
                 RH[i] = ff.state_variable_triplet__pv(
                     p[i], water_vapour_mixing_ratio[i]
-                ) / ff.saturation_vapour_pressure__pvs_Celsius(T[i] - ff.constants.T0)
+                ) / ff.saturation_vapour_pressure__pvs_water(T[i])
 
         return body
 
@@ -82,9 +82,7 @@ class PhysicsMethods(BackendMethods):
         @numba.njit(**self.default_jit_flags)
         def body(*, T_in, p_in, RH_in, water_vapour_mixing_ratio_in, a_w_ice_out):
             for i in prange(T_in.shape[0]):  # pylint: disable=not-an-iterable
-                pvi = ff.saturation_vapour_pressure__ice_Celsius(
-                    T_in[i] - ff.constants.T0
-                )
+                pvi = ff.saturation_vapour_pressure__pvs_ice(T_in[i])
                 pv = ff.state_variable_triplet__pv(
                     p_in[i], water_vapour_mixing_ratio_in[i]
                 )

PySDM-2.77/PySDM/backends/impl_numba/methods/seeding_methods.py

@@ -0,0 +1,68 @@
+""" CPU implementation of backend methods for particle injections """
+
+from functools import cached_property
+
+import numba
+
+from PySDM.backends.impl_common.backend_methods import BackendMethods
+
+
+class SeedingMethods(BackendMethods):  # pylint: disable=too-few-public-methods
+    @cached_property
+    def _seeding(self):
+        @numba.njit(**{**self.default_jit_flags, "parallel": False})
+        def body(  # pylint: disable=too-many-arguments
+            idx,
+            multiplicity,
+            extensive_attributes,
+            seeded_particle_index,
+            seeded_particle_multiplicity,
+            seeded_particle_extensive_attributes,
+            number_of_super_particles_to_inject: int,
+        ):
+            number_of_super_particles_already_injected = 0
+            # TODO #1387 start enumerating from the end of valid particle set
+            for i, mult in enumerate(multiplicity):
+                if (
+                    number_of_super_particles_to_inject
+                    == number_of_super_particles_already_injected
+                ):
+                    break
+                if mult == 0:
+                    idx[i] = -1
+                    s = seeded_particle_index[
+                        number_of_super_particles_already_injected
+                    ]
+                    number_of_super_particles_already_injected += 1
+                    multiplicity[i] = seeded_particle_multiplicity[s]
+                    for a in range(len(extensive_attributes)):
+                        extensive_attributes[a, i] = (
+                            seeded_particle_extensive_attributes[a, s]
+                        )
+            assert (
+                number_of_super_particles_to_inject
+                == number_of_super_particles_already_injected
+            )
+
+        return body
+
+    def seeding(
+        self,
+        *,
+        idx,
+        multiplicity,
+        extensive_attributes,
+        seeded_particle_index,
+        seeded_particle_multiplicity,
+        seeded_particle_extensive_attributes,
+        number_of_super_particles_to_inject: int,
+    ):
+        self._seeding(
+            idx=idx.data,
+            multiplicity=multiplicity.data,
+            extensive_attributes=extensive_attributes.data,
+            seeded_particle_index=seeded_particle_index.data,
+            seeded_particle_multiplicity=seeded_particle_multiplicity.data,
+            seeded_particle_extensive_attributes=seeded_particle_extensive_attributes.data,
+            number_of_super_particles_to_inject=number_of_super_particles_to_inject,
+        )

{PySDM-2.74 → PySDM-2.77}/PySDM/backends/impl_numba/test_helpers/scipy_ode_condensation_solver.py

@@ -18,7 +18,7 @@ from PySDM.backends.impl_numba.methods.condensation_methods import (
     _CellData,
     _Counters,
 )
-from PySDM.physics.constants_defaults import PI_4_3, T0
+from PySDM.physics.constants_defaults import PI_4_3
 
 idx_thd = 0
 idx_x = 1
@@ -205,7 +205,7 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
         T = jit_formulae.state_variable_triplet__T(rhod, thd)
         p = jit_formulae.state_variable_triplet__p(rhod, T, water_vapour_mixing_ratio)
         pv = jit_formulae.state_variable_triplet__pv(p, water_vapour_mixing_ratio)
-        pvs = jit_formulae.saturation_vapour_pressure__pvs_Celsius(T - T0)
+        pvs = jit_formulae.saturation_vapour_pressure__pvs_water(T)
         RH = pv / pvs
 
         dy_dt = np.empty_like(y)

{PySDM-2.74 → PySDM-2.77}/PySDM/backends/impl_thrust_rtc/methods/condensation_methods.py

@@ -318,8 +318,8 @@ class CondensationMethods(
                 p='p[i]', water_vapour_mixing_ratio='predicted_water_vapour_mixing_ratio[i]')};
             lv[i] = {phys.latent_heat.lv.c_inline(
                 T='T[i]')};
-            pvs[i] = {phys.saturation_vapour_pressure.pvs_Celsius.c_inline(
-                T='T[i] - const.T0')};
+            pvs[i] = {phys.saturation_vapour_pressure.pvs_water.c_inline(
+                T='T[i]')};
             RH[i] = pv[i] / pvs[i];
             RH_max[i] = max(RH_max[i], RH[i]);
             DTp[i] = {phys.diffusion_thermics.D.c_inline(

{PySDM-2.74 → PySDM-2.77}/PySDM/backends/impl_thrust_rtc/methods/physics_methods.py

@@ -27,9 +27,7 @@ class PhysicsMethods(ThrustRTCBackendMethods):
             )};
             RH[i] = {self.formulae.state_variable_triplet.pv.c_inline(
                 p="p[i]", water_vapour_mixing_ratio="water_vapour_mixing_ratio[i]"
-            )} / {self.formulae.saturation_vapour_pressure.pvs_Celsius.c_inline(
-                T="T[i] - const.T0"
-            )};
+            )} / {self.formulae.saturation_vapour_pressure.pvs_water.c_inline(T="T[i]")};
             """.replace(
                 "real_type", self._get_c_type()
             ),

{PySDM-2.74 → PySDM-2.77}/PySDM/backends/numba.py

@@ -28,6 +28,7 @@ class Numba(  # pylint: disable=too-many-ancestors,duplicate-code
     methods.DisplacementMethods,
     methods.TerminalVelocityMethods,
     methods.IsotopeMethods,
+    methods.SeedingMethods,
 ):
     Storage = ImportedStorage
     Random = ImportedRandom
@@ -75,3 +76,4 @@ class Numba(  # pylint: disable=too-many-ancestors,duplicate-code
         methods.DisplacementMethods.__init__(self)
         methods.TerminalVelocityMethods.__init__(self)
         methods.IsotopeMethods.__init__(self)
+        methods.SeedingMethods.__init__(self)

{PySDM-2.74 → PySDM-2.77}/PySDM/builder.py

@@ -150,4 +150,8 @@ class Builder:
         for key in self.particulator.dynamics:
             self.particulator.timers[key] = WallTimer()
 
+        if (attributes["multiplicity"] == 0).any():
+            self.particulator.attributes.healthy = False
+            self.particulator.attributes.sanitize()
+
         return self.particulator

{PySDM-2.74 → PySDM-2.77}/PySDM/dynamics/__init__.py

@@ -15,3 +15,4 @@ from PySDM.dynamics.displacement import Displacement
 from PySDM.dynamics.eulerian_advection import EulerianAdvection
 from PySDM.dynamics.freezing import Freezing
 from PySDM.dynamics.relaxed_velocity import RelaxedVelocity
+from PySDM.dynamics.seeding import Seeding

PySDM-2.77/PySDM/dynamics/seeding.py

@@ -0,0 +1,94 @@
+""" particle injection handling, requires initalising a simulation with
+enough particles flagged with NaN multiplicity (translated to zeros
+at multiplicity discretisation """
+
+from collections.abc import Sized
+
+import numpy as np
+
+from PySDM.dynamics.impl import register_dynamic
+from PySDM.initialisation import discretise_multiplicities
+
+
+@register_dynamic()
+class Seeding:
+    def __init__(
+        self,
+        *,
+        super_droplet_injection_rate: callable,
+        seeded_particle_extensive_attributes: dict,
+        seeded_particle_multiplicity: Sized,
+    ):
+        for attr in seeded_particle_extensive_attributes.values():
+            assert len(seeded_particle_multiplicity) == len(attr)
+        self.particulator = None
+        self.super_droplet_injection_rate = super_droplet_injection_rate
+        self.seeded_particle_extensive_attributes = seeded_particle_extensive_attributes
+        self.seeded_particle_multiplicity = seeded_particle_multiplicity
+        self.rnd = None
+        self.u01 = None
+        self.index = None
+
+    def register(self, builder):
+        self.particulator = builder.particulator
+
+    def post_register_setup_when_attributes_are_known(self):
+        if tuple(self.particulator.attributes.get_extensive_attribute_keys()) != tuple(
+            self.seeded_particle_extensive_attributes.keys()
+        ):
+            raise ValueError(
+                f"extensive attributes ({self.seeded_particle_extensive_attributes.keys()})"
+                " do not match those used in particulator"
+                f" ({self.particulator.attributes.get_extensive_attribute_keys()})"
+            )
+
+        self.index = self.particulator.Index.identity_index(
+            len(self.seeded_particle_multiplicity)
+        )
+        if len(self.seeded_particle_multiplicity) > 1:
+            self.rnd = self.particulator.Random(
+                len(self.seeded_particle_multiplicity), self.particulator.formulae.seed
+            )
+            self.u01 = self.particulator.Storage.empty(
+                len(self.seeded_particle_multiplicity), dtype=float
+            )
+        self.seeded_particle_multiplicity = (
+            self.particulator.IndexedStorage.from_ndarray(
+                self.index,
+                discretise_multiplicities(
+                    np.asarray(self.seeded_particle_multiplicity)
+                ),
+            )
+        )
+        self.seeded_particle_extensive_attributes = (
+            self.particulator.IndexedStorage.from_ndarray(
+                self.index,
+                np.asarray(list(self.seeded_particle_extensive_attributes.values())),
+            )
+        )
+
+    def __call__(self):
+        if self.particulator.n_steps == 0:
+            self.post_register_setup_when_attributes_are_known()
+
+        time = self.particulator.n_steps * self.particulator.dt
+        number_of_super_particles_to_inject = self.super_droplet_injection_rate(time)
+
+        if number_of_super_particles_to_inject > 0:
+            assert number_of_super_particles_to_inject <= len(
+                self.seeded_particle_multiplicity
+            )
+
+            if self.rnd is not None:
+                self.u01.urand(self.rnd)
+                # TODO #1387 make shuffle smarter
+                # e.g. don't need to shuffle if only one type of seed particle
+                # or if the number of super particles to inject
+                # is equal to the number of possible seeds
+                self.index.shuffle(self.u01)
+            self.particulator.seeding(
+                seeded_particle_index=self.index,
+                number_of_super_particles_to_inject=number_of_super_particles_to_inject,
+                seeded_particle_multiplicity=self.seeded_particle_multiplicity,
+                seeded_particle_extensive_attributes=self.seeded_particle_extensive_attributes,
+            )

{PySDM-2.74 → PySDM-2.77}/PySDM/impl/particle_attributes.py

@@ -118,3 +118,8 @@ class ParticleAttributes:  # pylint: disable=too-many-instance-attributes
 
     def has_attribute(self, attr):
         return attr in self.__attributes
+
+    def reset_idx(self):
+        self.__valid_n_sd = self.__idx.shape[0]
+        self.__idx.reset_index()
+        self.healthy = False

{PySDM-2.74 → PySDM-2.77}/PySDM/initialisation/discretise_multiplicities.py

@@ -6,11 +6,22 @@ import numpy as np
 
 
 def discretise_multiplicities(values_arg):
-    values_int = values_arg.round().astype(np.int64)
+    """any NaN values in the input array are ignored and flagged
+    with zero multiplicities in the output array"""
+
+    values_int = np.where(np.isnan(values_arg), 0, values_arg).round().astype(np.int64)
 
     if np.issubdtype(values_arg.dtype, np.floating):
+        if np.isnan(values_arg).all():
+            return values_int
+
+        if not np.logical_or(values_int > 0, np.isnan(values_arg)).all():
+            raise ValueError(
+                f"int-casting resulted in multiplicity of zero (min(y_float)={min(values_arg)})"
+            )
+
         percent_diff = 100 * abs(
-            1 - np.sum(values_arg) / np.sum(values_int.astype(float))
+            1 - np.nansum(values_arg) / np.sum(values_int.astype(float))
         )
         if percent_diff > 1:
             raise ValueError(
@@ -18,9 +29,4 @@ def discretise_multiplicities(values_arg):
                 f" due to casting multiplicities to ints"
             )
 
-        if not (values_int > 0).all():
-            raise ValueError(
-                f"int-casting resulted in multiplicity of zero (min(y_float)={min(values_arg)})"
-            )
-
     return values_int

{PySDM-2.74 → PySDM-2.77}/PySDM/initialisation/init_fall_momenta.py

@@ -5,7 +5,6 @@ of droplets
 
 import numpy as np
 
-from PySDM.backends import CPU
 from PySDM.dynamics.terminal_velocity import GunnKinzer1949
 from PySDM.formulae import Formulae
 from PySDM.particulator import Particulator
@@ -31,6 +30,8 @@ def init_fall_momenta(
     if zero:
         return np.zeros_like(water_mass)
 
+    from PySDM.backends import CPU  # pylint: disable=import-outside-toplevel
+
     particulator = Particulator(0, CPU(Formulae()))  # TODO #1155
 
     approximation = terminal_velocity_approx(particulator=particulator)

{PySDM-2.74 → PySDM-2.77}/PySDM/particulator.py

@@ -13,7 +13,7 @@ from PySDM.impl.particle_attributes import ParticleAttributes
 
 
 class Particulator:  # pylint: disable=too-many-public-methods,too-many-instance-attributes
-    def __init__(self, n_sd, backend: BackendMethods):
+    def __init__(self, n_sd, backend):
         assert isinstance(backend, BackendMethods)
         self.__n_sd = n_sd
 
@@ -438,3 +438,44 @@ class Particulator:  # pylint: disable=too-many-public-methods,too-many-instance
         self.backend.isotopic_fractionation()
         for isotope in heavy_isotopes:
             self.attributes.mark_updated(f"moles_{isotope}")
+
+    def seeding(
+        self,
+        *,
+        seeded_particle_index,
+        seeded_particle_multiplicity,
+        seeded_particle_extensive_attributes,
+        number_of_super_particles_to_inject,
+    ):
+        n_null = self.n_sd - self.attributes.super_droplet_count
+        if n_null == 0:
+            raise ValueError(
+                "No available seeds to inject. Please provide particles with nan filled attributes."
+            )
+
+        if number_of_super_particles_to_inject > n_null:
+            raise ValueError(
+                "Trying to inject more super particles than space available."
+            )
+
+        if number_of_super_particles_to_inject > len(seeded_particle_multiplicity):
+            raise ValueError(
+                "Trying to inject multiple super particles with the same attributes. \
+                Instead increase multiplicity of injected particles."
+            )
+
+        self.backend.seeding(
+            idx=self.attributes._ParticleAttributes__idx,
+            multiplicity=self.attributes["multiplicity"],
+            extensive_attributes=self.attributes.get_extensive_attribute_storage(),
+            seeded_particle_index=seeded_particle_index,
+            seeded_particle_multiplicity=seeded_particle_multiplicity,
+            seeded_particle_extensive_attributes=seeded_particle_extensive_attributes,
+            number_of_super_particles_to_inject=number_of_super_particles_to_inject,
+        )
+        self.attributes.reset_idx()
+        self.attributes.sanitize()
+
+        self.attributes.mark_updated("multiplicity")
+        for key in self.attributes.get_extensive_attribute_keys():
+            self.attributes.mark_updated(key)

{PySDM-2.74 → PySDM-2.77}/PySDM/physics/saturation_vapour_pressure/august_roche_magnus.py

@@ -12,10 +12,12 @@ class AugustRocheMagnus:
         pass
 
     @staticmethod
-    def pvs_Celsius(const, T):
-        return const.ARM_C1 * np.exp((const.ARM_C2 * T) / (T + const.ARM_C3))
+    def pvs_water(const, T):
+        return const.ARM_C1 * np.exp(
+            (const.ARM_C2 * (T - const.T0)) / ((T - const.T0) + const.ARM_C3)
+        )
 
     @staticmethod
-    def ice_Celsius(const, T):
+    def pvs_ice(const, T):
         """NaN with unit of pressure and correct dimension"""
-        return np.nan * T / const.ARM_C3 * const.ARM_C1
+        return np.nan * (T - const.T0) / const.ARM_C3 * const.ARM_C1

PySDM-2.77/PySDM/physics/saturation_vapour_pressure/bolton_1980.py

@@ -0,0 +1,22 @@
+"""
+[Bolton 1980](https://doi.org/10.1175/1520-0493(1980)108<1046:TCOEPT>2.0.CO;2)
+"""
+
+import numpy as np
+
+
+class Bolton1980:
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def pvs_water(const, T):
+        """valid for 243.15(-30) <= T <= 308.15(35) K(C), eq. (10)"""
+        return const.B80W_G0 * np.exp(
+            (const.B80W_G1 * (T - const.T0)) / ((T - const.T0) + const.B80W_G2)
+        )
+
+    @staticmethod
+    def pvs_ice(const, T):
+        """NaN with unit of pressure and correct dimension"""
+        return np.nan * (T - const.T0) / const.B80W_G2 * const.B80W_G0

PySDM-2.77/PySDM/physics/saturation_vapour_pressure/flatau_walko_cotton.py

@@ -0,0 +1,65 @@
+"""
+polynomial fits from
+[Flatau et al. 1992](https://doi.org/10.1175/1520-0450(1992)031%3C1507:PFTSVP%3E2.0.CO;2)
+"""
+
+
+class FlatauWalkoCotton:
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def pvs_water(const, T):
+        return const.FWC_C0 + (T - const.T0) * (
+            const.FWC_C1
+            + (T - const.T0)
+            * (
+                const.FWC_C2
+                + (T - const.T0)
+                * (
+                    const.FWC_C3
+                    + (T - const.T0)
+                    * (
+                        const.FWC_C4
+                        + (T - const.T0)
+                        * (
+                            const.FWC_C5
+                            + (T - const.T0)
+                            * (
+                                const.FWC_C6
+                                + (T - const.T0)
+                                * (const.FWC_C7 + (T - const.T0) * const.FWC_C8)
+                            )
+                        )
+                    )
+                )
+            )
+        )
+
+    @staticmethod
+    def pvs_ice(const, T):
+        return const.FWC_I0 + (T - const.T0) * (
+            const.FWC_I1
+            + (T - const.T0)
+            * (
+                const.FWC_I2
+                + (T - const.T0)
+                * (
+                    const.FWC_I3
+                    + (T - const.T0)
+                    * (
+                        const.FWC_I4
+                        + (T - const.T0)
+                        * (
+                            const.FWC_I5
+                            + (T - const.T0)
+                            * (
+                                const.FWC_I6
+                                + (T - const.T0)
+                                * (const.FWC_I7 + (T - const.T0) * const.FWC_I8)
+                            )
+                        )
+                    )
+                )
+            )
+        )

PySDM-2.77/PySDM/physics/saturation_vapour_pressure/lowe1977.py

@@ -0,0 +1,49 @@
+"""
+polynomial fits from
+[Lowe et al. 1977](https://doi.org/10.1175/1520-0450(1977)016<0100:AAPFTC>2.0.CO;2)
+"""
+
+
+class Lowe1977:
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def pvs_water(const, T):
+        return const.L77W_A0 + (T - const.T0) * (
+            const.L77W_A1
+            + (T - const.T0)
+            * (
+                const.L77W_A2
+                + (T - const.T0)
+                * (
+                    const.L77W_A3
+                    + (T - const.T0)
+                    * (
+                        const.L77W_A4
+                        + (T - const.T0)
+                        * (const.L77W_A5 + (T - const.T0) * (const.L77W_A6))
+                    )
+                )
+            )
+        )
+
+    @staticmethod
+    def pvs_ice(const, T):
+        return const.L77I_A0 + (T - const.T0) * (
+            const.L77I_A1
+            + (T - const.T0)
+            * (
+                const.L77I_A2
+                + (T - const.T0)
+                * (
+                    const.L77I_A3
+                    + (T - const.T0)
+                    * (
+                        const.L77I_A4
+                        + (T - const.T0)
+                        * (const.L77I_A5 + (T - const.T0) * (const.L77I_A6))
+                    )
+                )
+            )
+        )

PySDM-2.77/PySDM/physics/saturation_vapour_pressure/murphy_koop_2005.py

@@ -0,0 +1,37 @@
+"""
+[Murphy and Koop 2005](https://doi.org/10.1256/qj.04.94)
+"""
+
+import numpy as np
+
+
+class MurphyKoop2005:
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def pvs_water(const, T):
+        """valid for 123 < T < 332 K, eq (10)"""
+        return const.MK05_LIQ_C1 * np.exp(
+            const.MK05_LIQ_C2
+            - const.MK05_LIQ_C3 / (T)
+            - const.MK05_LIQ_C4 * np.log(T / const.MK05_LIQ_C5)
+            + const.MK05_LIQ_C6 * (T)
+            + np.tanh(const.MK05_LIQ_C7 * (T - const.MK05_LIQ_C8))
+            * (
+                const.MK05_LIQ_C9
+                - const.MK05_LIQ_C10 / T
+                - const.MK05_LIQ_C11 * np.log(T / const.MK05_LIQ_C12)
+                + const.MK05_LIQ_C13 * T
+            )
+        )
+
+    @staticmethod
+    def pvs_ice(const, T):
+        """valid for T > 110 K, eq (7)"""
+        return const.MK05_ICE_C1 * np.exp(
+            const.MK05_ICE_C2
+            - const.MK05_ICE_C3 / T
+            + const.MK05_ICE_C4 * np.log(T / const.MK05_ICE_C5)
+            - const.MK05_ICE_C6 * T
+        )

PySDM-2.77/PySDM/physics/saturation_vapour_pressure/wexler_1976.py

@@ -0,0 +1,31 @@
+"""
+[Wexler 1976](https://nvlpubs.nist.gov/nistpubs/jres/80A/jresv80An5-6p775_A1b.pdf)
+"""
+
+import numpy as np
+
+
+class Wexler1976:
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def pvs_water(const, T):
+        return (
+            np.exp(
+                const.W76W_G0 / T**2
+                + const.W76W_G1 / T
+                + const.W76W_G2
+                + const.W76W_G3 * T
+                + const.W76W_G4 * T**2
+                + const.W76W_G5 * T**3
+                + const.W76W_G6 * T**4
+                + const.W76W_G7 * np.log(T / const.one_kelvin)
+            )
+            * const.W76W_G8
+        )
+
+    @staticmethod
+    def pvs_ice(const, T):
+        """NaN with unit of pressure and correct dimension"""
+        return np.nan * (T - const.T0) / const.B80W_G2 * const.B80W_G0

{PySDM-2.74 → PySDM-2.77}/PySDM.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.74
+Version: 2.77
 Summary: Pythonic particle-based (super-droplet) warm-rain/aqueous-chemistry cloud microphysics package with box, parcel & 1D/2D prescribed-flow examples in Python, Julia and Matlab
 Home-page: https://github.com/open-atmos/PySDM
 Author: https://github.com/open-atmos/PySDM/graphs/contributors