PySDM 2.108__tar.gz → 2.110__tar.gz

{pysdm-2.108 → pysdm-2.110}/.github/workflows/tests.yml

@@ -271,8 +271,8 @@ jobs:
           python -m pytest --durations=10 -v -p no:unraisableexception -We tests/examples_tests/test_tests_completeness.py
 
        # TODO #1207
-      - if: startsWith(matrix.platform, 'windows-')
+      - if: startsWith(matrix.platform, 'macos-13')
         run: python -m pytest --durations=10 -v -p no:unraisableexception -We tests/examples_tests/test_run* -k "not Rozanski_and_Sonntag_1982" --suite ${{ matrix.test-suite }}
 
-      - if: ( ! startsWith(matrix.platform, 'windows-') )
+      - if: ( ! startsWith(matrix.platform, 'macos-13') )
         run: python -m pytest --durations=10 -v -p no:unraisableexception -We tests/examples_tests/test_run* --suite ${{ matrix.test-suite }}

{pysdm-2.108 → pysdm-2.110}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pysdm
-Version: 2.108
+Version: 2.110
 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.108 → pysdm-2.110}/PySDM/backends/impl_numba/methods/__init__.py

@@ -13,3 +13,4 @@ from .pair_methods import PairMethods
 from .physics_methods import PhysicsMethods
 from .terminal_velocity_methods import TerminalVelocityMethods
 from .seeding_methods import SeedingMethods
+from .deposition_methods import DepositionMethods

{pysdm-2.108 → pysdm-2.110}/PySDM/backends/impl_numba/methods/condensation_methods.py

@@ -290,7 +290,7 @@ class CondensationMethods(BackendMethods):
                     rhod, T, water_vapour_mixing_ratio
                 )
                 pv = formulae.state_variable_triplet__pv(p, water_vapour_mixing_ratio)
-                lv = formulae.latent_heat__lv(T)
+                lv = formulae.latent_heat_vapourisation__lv(T)
                 pvs = formulae.saturation_vapour_pressure__pvs_water(T)
                 DTp = formulae.diffusion_thermics__D(T, p)
                 RH = pv / pvs
@@ -390,14 +390,18 @@ class CondensationMethods(BackendMethods):
             K,
             ventilation_factor,
         ):
-            volume = formulae.condensation_coordinate__volume(x_new)
+            if x_new > formulae.diffusion_coordinate__x_max():
+                return x_old - x_new
+            mass_new = formulae.diffusion_coordinate__mass(x_new)
+            volume_new = formulae.particle_shape_and_density__mass_to_volume(mass_new)
+            r_new = formulae.trivia__radius(volume_new)
             RH_eq = formulae.hygroscopicity__RH_eq(
-                formulae.trivia__radius(volume),
+                r_new,
                 temperature,
                 kappa,
                 rd3,
                 formulae.surface_tension__sigma(
-                    temperature, volume, formulae.constants.PI_4_3 * rd3, f_org
+                    temperature, volume_new, formulae.constants.PI_4_3 * rd3, f_org
                 ),
             )
             r_dr_dt = formulae.drop_growth__r_dr_dt(
@@ -410,10 +414,11 @@ class CondensationMethods(BackendMethods):
                 K,
                 ventilation_factor,
             )
+            dm_dt = formulae.particle_shape_and_density__dm_dt(r=r_new, r_dr_dt=r_dr_dt)
             return (
                 x_old
                 - x_new
-                + timestep * formulae.condensation_coordinate__dx_dt(x_new, r_dr_dt)
+                + timestep * formulae.diffusion_coordinate__dx_dt(mass_new, dm_dt)
             )
 
         @numba.njit(**jit_flags)
@@ -440,15 +445,17 @@ class CondensationMethods(BackendMethods):
             lambdaK = formulae.diffusion_kinetics__lambdaK(T, p)
             lambdaD = formulae.diffusion_kinetics__lambdaD(DTp, T)
             for drop in cell_idx:
+                if attributes.water_mass[drop] <= 0:
+                    continue
                 v_drop = formulae.particle_shape_and_density__mass_to_volume(
                     attributes.water_mass[drop]
                 )
-                if v_drop <= 0:
-                    continue
-                x_old = formulae.condensation_coordinate__x(v_drop)
+                x_old = formulae.diffusion_coordinate__x(attributes.water_mass[drop])
                 r_old = formulae.trivia__radius(v_drop)
-                x_insane = formulae.condensation_coordinate__x(
-                    attributes.vdry[drop] / 100
+                x_insane = formulae.diffusion_coordinate__x(
+                    formulae.particle_shape_and_density__volume_to_mass(
+                        attributes.vdry[drop] / 100
+                    )
                 )
                 rd3 = attributes.vdry[drop] / formulae.constants.PI_4_3
                 sgm = formulae.surface_tension__sigma(
@@ -492,8 +499,12 @@ class CondensationMethods(BackendMethods):
                         Kr,
                         ventilation_factor,
                     )
-                    dx_old = timestep * formulae.condensation_coordinate__dx_dt(
-                        x_old, r_dr_dt_old
+                    mass_old = formulae.diffusion_coordinate__mass(x_old)
+                    dm_dt_old = formulae.particle_shape_and_density__dm_dt(
+                        r=r_old, r_dr_dt=r_dr_dt_old
+                    )
+                    dx_old = timestep * formulae.diffusion_coordinate__dx_dt(
+                        mass_old, dm_dt_old
                     )
                 else:
                     dx_old = 0.0
@@ -561,9 +572,7 @@ class CondensationMethods(BackendMethods):
                     else:
                         x_new = x_old
 
-                mass_new = formulae.particle_shape_and_density__volume_to_mass(
-                    formulae.condensation_coordinate__volume(x_new)
-                )
+                mass_new = formulae.diffusion_coordinate__mass(x_new)
                 mass_cr = formulae.particle_shape_and_density__volume_to_mass(
                     attributes.v_cr[drop]
                 )

pysdm-2.110/PySDM/backends/impl_numba/methods/deposition_methods.py

@@ -0,0 +1,172 @@
+"""basic water vapor deposition on ice for CPU backend, for Howell factor see:
+[Howell 1949](https://doi.org/10.1175/1520-0469(1949)006%3C0134:TGOCDI%3E2.0.CO;2)
+"""
+
+from functools import cached_property
+import numba
+import numpy as np
+from PySDM.backends.impl_common.backend_methods import BackendMethods
+
+
+class DepositionMethods(BackendMethods):  # pylint:disable=too-few-public-methods
+    @cached_property
+    def _deposition(self):
+        assert self.formulae.particle_shape_and_density.supports_mixed_phase()
+
+        formulae = self.formulae_flattened
+
+        @numba.njit(**{**self.default_jit_flags, **{"parallel": False}})
+        def body(  # pylint: disable=too-many-arguments
+            *,
+            multiplicity,
+            signed_water_mass,
+            current_temperature,
+            current_total_pressure,
+            current_relative_humidity,
+            current_water_activity,
+            current_vapour_mixing_ratio,
+            current_dry_air_density,
+            current_dry_potential_temperature,
+            cell_volume,
+            time_step,
+            cell_id,
+            reynolds_number,
+            schmidt_number,
+            # to be modified
+            predicted_vapour_mixing_ratio,
+            predicted_dry_potential_temperature,
+        ):
+            # pylint: disable=too-many-locals
+            n_sd = len(signed_water_mass)
+            for i in range(n_sd):
+                if not formulae.trivia__unfrozen(signed_water_mass[i]):
+                    ice_mass = -signed_water_mass[i]
+                    cid = cell_id[i]
+
+                    radius = formulae.particle_shape_and_density__mass_to_radius(
+                        signed_water_mass[i]
+                    )
+
+                    diameter = radius * 2.0
+
+                    temperature = current_temperature[cid]
+                    pressure = current_total_pressure[cid]
+                    rho = current_dry_air_density[cid]
+                    pvs_ice = formulae.saturation_vapour_pressure__pvs_ice(temperature)
+                    latent_heat_sub = formulae.latent_heat_sublimation__ls(temperature)
+
+                    capacity = formulae.diffusion_ice_capacity__capacity(diameter)
+
+                    ventilation_factor = formulae.ventilation__ventilation_coefficient(
+                        sqrt_re_times_cbrt_sc=formulae.trivia__sqrt_re_times_cbrt_sc(
+                            Re=reynolds_number[i],
+                            Sc=schmidt_number[cid],
+                        )
+                    )
+
+                    Dv_const = formulae.diffusion_thermics__D(temperature, pressure)
+                    lambdaD = formulae.diffusion_ice_kinetics__lambdaD(
+                        temperature, pressure
+                    )
+                    diffusion_coefficient = formulae.diffusion_ice_kinetics__D(
+                        Dv_const, radius, lambdaD, temperature
+                    )
+
+                    Ka_const = formulae.diffusion_thermics__K(temperature, pressure)
+                    lambdaK = formulae.diffusion_ice_kinetics__lambdaK(
+                        temperature, pressure
+                    )
+                    thermal_conductivity = formulae.diffusion_ice_kinetics__K(
+                        Ka_const, radius, lambdaK, temperature, rho
+                    )
+                    saturation_ratio_ice = (
+                        current_relative_humidity[cid] / current_water_activity[cid]
+                    )
+
+                    if saturation_ratio_ice == 1:
+                        continue
+
+                    howell_factor_x_diffcoef_x_rhovsice_x_icess = (
+                        formulae.drop_growth__r_dr_dt(
+                            RH_eq=1,
+                            T=temperature,
+                            RH=saturation_ratio_ice,
+                            lv=latent_heat_sub,
+                            pvs=pvs_ice,
+                            D=diffusion_coefficient,
+                            K=thermal_conductivity,
+                            ventilation_factor=ventilation_factor,
+                        )
+                        * formulae.constants.rho_w
+                    )
+
+                    dm_dt = (
+                        4
+                        * np.pi
+                        * capacity
+                        * howell_factor_x_diffcoef_x_rhovsice_x_icess
+                    )
+
+                    delta_rv_i = (
+                        -dm_dt * multiplicity[i] * time_step / (cell_volume * rho)
+                    )
+                    if -delta_rv_i > current_vapour_mixing_ratio[cid]:
+                        assert False
+                    predicted_vapour_mixing_ratio[cid] += delta_rv_i
+
+                    predicted_dry_potential_temperature[cid] += (
+                        formulae.state_variable_triplet__dthd_dt(
+                            rhod=current_dry_air_density[cid],
+                            thd=current_dry_potential_temperature[cid],
+                            T=temperature,
+                            d_water_vapour_mixing_ratio__dt=delta_rv_i / time_step,
+                            lv=latent_heat_sub,
+                        )
+                        * time_step
+                    )
+
+                    x_old = formulae.diffusion_coordinate__x(ice_mass)
+                    dx_dt_old = formulae.diffusion_coordinate__dx_dt(ice_mass, dm_dt)
+                    x_new = formulae.trivia__explicit_euler(x_old, time_step, dx_dt_old)
+                    signed_water_mass[i] = -formulae.diffusion_coordinate__mass(x_new)
+
+        return body
+
+    def deposition(  # pylint: disable=too-many-locals
+        self,
+        *,
+        multiplicity,
+        signed_water_mass,
+        current_temperature,
+        current_total_pressure,
+        current_relative_humidity,
+        current_water_activity,
+        current_vapour_mixing_ratio,
+        current_dry_air_density,
+        current_dry_potential_temperature,
+        cell_volume,
+        time_step,
+        cell_id,
+        reynolds_number,
+        schmidt_number,
+        predicted_vapour_mixing_ratio,
+        predicted_dry_potential_temperature,
+    ):
+        self._deposition(
+            multiplicity=multiplicity.data,
+            signed_water_mass=signed_water_mass.data,
+            current_temperature=current_temperature.data,
+            current_total_pressure=current_total_pressure.data,
+            current_relative_humidity=current_relative_humidity.data,
+            current_water_activity=current_water_activity.data,
+            current_vapour_mixing_ratio=current_vapour_mixing_ratio.data,
+            current_dry_air_density=current_dry_air_density.data,
+            current_dry_potential_temperature=current_dry_potential_temperature.data,
+            cell_volume=cell_volume,
+            time_step=time_step,
+            cell_id=cell_id.data,
+            reynolds_number=reynolds_number.data,
+            schmidt_number=schmidt_number.data,
+            predicted_vapour_mixing_ratio=predicted_vapour_mixing_ratio.data,
+            predicted_dry_potential_temperature=predicted_dry_potential_temperature.data,
+        )

{pysdm-2.108 → pysdm-2.110}/PySDM/backends/impl_numba/test_helpers/scipy_ode_condensation_solver.py

@@ -92,15 +92,7 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
 
     @numba.njit(**{**JIT_FLAGS, **{"parallel": False}})
     def _liquid_water_mixing_ratio(n, x, m_d_mean):
-        return (
-            np.sum(
-                n
-                * jit_formulae.particle_shape_and_density__volume_to_mass(
-                    jit_formulae.condensation_coordinate__volume(x)
-                )
-            )
-            / m_d_mean
-        )
+        return np.sum(n * jit_formulae.diffusion_coordinate__mass(x)) / m_d_mean
 
     @numba.njit(**{**JIT_FLAGS, **{"parallel": False}})
     def _impl(  # pylint: disable=too-many-arguments,too-many-locals
@@ -133,8 +125,10 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
             diffusivity=DTp,
             density=air_density,
         )
+        sum_n_dm_dt = 0
         for i, x_i in enumerate(x):
-            v = jit_formulae.condensation_coordinate__volume(x_i)
+            m = jit_formulae.diffusion_coordinate__mass(x_i)
+            v = jit_formulae.particle_shape_and_density__mass_to_volume(m)
             r = jit_formulae.trivia__radius(v)
             Dr = jit_formulae.diffusion_kinetics__D(DTp, r, lambdaD)
             Kr = jit_formulae.diffusion_kinetics__K(KTp, r, lambdaK)
@@ -145,34 +139,23 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
                 )
             )
             sgm = jit_formulae.surface_tension__sigma(T, v, dry_volume[i], f_org[i])
-            dy_dt[idx_x + i] = jit_formulae.condensation_coordinate__dx_dt(
-                x_i,
-                jit_formulae.drop_growth__r_dr_dt(
-                    jit_formulae.hygroscopicity__RH_eq(
-                        r, T, kappa[i], dry_volume[i] / PI_4_3, sgm
-                    ),
-                    T,
-                    RH,
-                    lv,
-                    pvs,
-                    Dr,
-                    Kr,
-                    ventilation_factor,
+            r_dr_dt = jit_formulae.drop_growth__r_dr_dt(
+                jit_formulae.hygroscopicity__RH_eq(
+                    r, T, kappa[i], dry_volume[i] / PI_4_3, sgm
                 ),
+                T,
+                RH,
+                lv,
+                pvs,
+                Dr,
+                Kr,
+                ventilation_factor,
             )
-        d_water_vapour_mixing_ratio__dt = (
-            dot_water_vapour_mixing_ratio
-            - np.sum(
-                n
-                * jit_formulae.particle_shape_and_density__volume_to_mass(
-                    jit_formulae.condensation_coordinate__volume(x)
-                )
-                * dy_dt[idx_x:]
-            )
-            / m_d_mean
-        )
+            dm_dt = jit_formulae.particle_shape_and_density__dm_dt(r, r_dr_dt)
+            dy_dt[idx_x + i] = jit_formulae.diffusion_coordinate__dx_dt(m, dm_dt)
+            sum_n_dm_dt += n[i] * dm_dt
         dy_dt[idx_thd] = dot_thd + jit_formulae.state_variable_triplet__dthd_dt(
-            rhod, thd, T, d_water_vapour_mixing_ratio__dt, lv
+            rhod, thd, T, dot_water_vapour_mixing_ratio - sum_n_dm_dt / m_d_mean, lv
         )
 
     @numba.njit(**{**JIT_FLAGS, **{"parallel": False}})
@@ -228,7 +211,7 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
             air_dynamic_viscosity,
             rhod,
             pvs,
-            jit_formulae.latent_heat__lv(T),
+            jit_formulae.latent_heat_vapourisation__lv(T),
         )
         return dy_dt
 
@@ -251,10 +234,8 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
         n_sd_in_cell = len(cell_idx)
         y0 = np.empty(n_sd_in_cell + idx_x)
         y0[idx_thd] = thd
-        y0[idx_x:] = jit_formulae.condensation_coordinate__x(
-            jit_formulae.particle_shape_and_density__mass_to_volume(
-                attributes.water_mass[cell_idx]
-            )
+        y0[idx_x:] = jit_formulae.diffusion_coordinate__x(
+            attributes.water_mass[cell_idx]
         )
         total_water_mixing_ratio = (
             water_vapour_mixing_ratio
@@ -301,9 +282,7 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
         m_new = 0
         for i in range(n_sd_in_cell):
             attributes.water_mass[cell_idx[i]] = (
-                jit_formulae.particle_shape_and_density__volume_to_mass(
-                    jit_formulae.condensation_coordinate__volume(y1[idx_x + i])
-                )
+                jit_formulae.diffusion_coordinate__mass(y1[idx_x + i])
             )
             m_new += (
                 attributes.multiplicity[cell_idx[i]]

{pysdm-2.108 → pysdm-2.110}/PySDM/backends/impl_thrust_rtc/methods/condensation_methods.py

@@ -100,11 +100,15 @@ class CondensationMethods(
             struct Minfun {{
                 static __device__ real_type value(real_type x_new, void* args_p) {{
                     auto args = static_cast<real_type*>(args_p);
-                    auto vol = {phys.condensation_coordinate.volume.c_inline(x="x_new")};
-                    auto r_new = {phys.trivia.radius.c_inline(volume="vol")};
+                    if (x_new > {phys.diffusion_coordinate.x_max.c_inline()}) {{
+                        return {args("x_old")} - x_new;
+                    }}
+                    auto m_new = {phys.diffusion_coordinate.mass.c_inline(x="x_new")};
+                    auto v_new = {phys.particle_shape_and_density.mass_to_volume.c_inline(mass="m_new")};
+                    auto r_new = {phys.trivia.radius.c_inline(volume="v_new")};
                     auto sgm = {phys.surface_tension.sigma.c_inline(
                         T=args('_T'),
-                        v_wet="vol",
+                        v_wet="v_new",
                         v_dry=f"const.PI_4_3 * {args('rd3')}",
                         f_org=args("f_org")
                     )};
@@ -125,8 +129,11 @@ class CondensationMethods(
                         K=args("Kr"),
                         ventilation_factor=args("ventilation_factor"),
                     )};
+                    auto dm_dt = {phys.particle_shape_and_density.dm_dt.c_inline(
+                        r="r_new", r_dr_dt="r_dr_dt"
+                    )};
                     return {args("x_old")} - x_new + {args("dt")} * {
-                        phys.condensation_coordinate.dx_dt.c_inline(x="x_new", r_dr_dt="r_dr_dt")
+                        phys.diffusion_coordinate.dx_dt.c_inline(m="m_new", dm_dt="dm_dt")
                     };
                 }}
             }};
@@ -145,9 +152,10 @@ class CondensationMethods(
             auto v_old = {phys.particle_shape_and_density.mass_to_volume.c_inline(
                 mass="water_mass[i]"
             )};
-            auto x_old = {phys.condensation_coordinate.x.c_inline(volume="v_old")};
+            auto x_old = {phys.diffusion_coordinate.x.c_inline(mass="water_mass[i]")};
             auto r_old = {phys.trivia.radius.c_inline(volume="v_old")};
-            auto x_insane = {phys.condensation_coordinate.x.c_inline(volume="vdry[i]/100")};
+            auto m_insane = {phys.particle_shape_and_density.volume_to_mass.c_inline(volume="vdry[i] / 100")};
+            auto x_insane = {phys.diffusion_coordinate.x.c_inline(mass="m_insane")};
             auto rd3 = vdry[i] / {const.PI_4_3};
             auto sgm = {phys.surface_tension.sigma.c_inline(
                 T="_T", v_wet="v", v_dry="vdry[i]", f_org="_f_org[i]"
@@ -161,6 +169,7 @@ class CondensationMethods(
             real_type qrt_re_times_cbrt_sc=0;
             real_type ventilation_factor=0;
             real_type r_dr_dt_old=0;
+            real_type dm_dt_old=0;
             real_type dx_old=0;
 
             real_type x_new = 0;
@@ -184,8 +193,9 @@ class CondensationMethods(
                     RH_eq="RH_eq", T="_T", RH="_RH", lv="_lv", pvs="_pvs", D="Dr", K="Kr",
                     ventilation_factor="ventilation_factor",
                 )};
-                dx_old = dt * {phys.condensation_coordinate.dx_dt.c_inline(
-                    x="x_old", r_dr_dt="r_dr_dt_old"
+                dm_dt_old = {phys.particle_shape_and_density.dm_dt.c_inline(r="r_old", r_dr_dt="r_dr_dt_old")};
+                dx_old = dt * {phys.diffusion_coordinate.dx_dt.c_inline(
+                    m="water_mass[i]", dm_dt="dm_dt_old"
                 )};
             }}
             else {{
@@ -239,10 +249,7 @@ class CondensationMethods(
                     x_new = x_old;
                 }}
             }}
-            auto v_new = {phys.condensation_coordinate.volume.c_inline(x="x_new")};
-            water_mass[i] = {phys.particle_shape_and_density.volume_to_mass.c_inline(
-                volume="v_new"
-            )};
+            water_mass[i] = {phys.diffusion_coordinate.mass.c_inline(x="x_new")};
         """.replace(
                 "real_type", self._get_c_type()
             ),
@@ -316,7 +323,7 @@ class CondensationMethods(
             )};
             pv[i] = {phys.state_variable_triplet.pv.c_inline(
                 p='p[i]', water_vapour_mixing_ratio='predicted_water_vapour_mixing_ratio[i]')};
-            lv[i] = {phys.latent_heat.lv.c_inline(
+            lv[i] = {phys.latent_heat_vapourisation.lv.c_inline(
                 T='T[i]')};
             pvs[i] = {phys.saturation_vapour_pressure.pvs_water.c_inline(
                 T='T[i]')};

{pysdm-2.108 → pysdm-2.110}/PySDM/backends/numba.py

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

{pysdm-2.108 → pysdm-2.110}/PySDM/dynamics/__init__.py

@@ -16,3 +16,4 @@ 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
+from PySDM.dynamics.vapour_deposition_on_ice import VapourDepositionOnIce

pysdm-2.110/PySDM/dynamics/vapour_deposition_on_ice.py

@@ -0,0 +1,20 @@
+"""basic water vapor deposition on ice"""
+
+from PySDM.dynamics.impl import register_dynamic
+
+
+@register_dynamic()
+class VapourDepositionOnIce:
+    def __init__(self):
+        """called by the user while building a particulator"""
+        self.particulator = None
+
+    def register(self, *, builder):
+        """called by the builder"""
+        self.particulator = builder.particulator
+        assert builder.formulae.particle_shape_and_density.supports_mixed_phase()
+        builder.request_attribute("Reynolds number")
+
+    def __call__(self):
+        """called by the particulator during simulation"""
+        self.particulator.deposition()

{pysdm-2.108 → pysdm-2.110}/PySDM/environments/parcel.py

@@ -117,7 +117,7 @@ class Parcel(Moist):  # pylint: disable=too-many-instance-attributes
             p=p,
             T=T,
             water_vapour_mixing_ratio=water_vapour_mixing_ratio,
-            lv=formulae.latent_heat.lv(T),
+            lv=formulae.latent_heat_vapourisation.lv(T),
             d_liquid_water_mixing_ratio__dz=(
                 self.delta_liquid_water_mixing_ratio / dz_dt / dt
             ),

{pysdm-2.108 → pysdm-2.110}/PySDM/formulae.py

@@ -30,13 +30,16 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
         constants: Optional[dict] = None,
         seed: int = None,
         fastmath: bool = True,
-        condensation_coordinate: str = "VolumeLogarithm",
+        diffusion_coordinate: str = "WaterMassLogarithm",
         saturation_vapour_pressure: str = "FlatauWalkoCotton",
-        latent_heat: str = "Kirchhoff",
+        latent_heat_vapourisation: str = "Kirchhoff",
+        latent_heat_sublimation: str = "MurphyKoop2005",
         hygroscopicity: str = "KappaKoehlerLeadingTerms",
         drop_growth: str = "Mason1971",
         surface_tension: str = "Constant",
         diffusion_kinetics: str = "FuchsSutugin",
+        diffusion_ice_kinetics: str = "Standard",
+        diffusion_ice_capacity: str = "Spherical",
         diffusion_thermics: str = "Neglect",
         ventilation: str = "Neglect",
         state_variable_triplet: str = "LibcloudphPlusPlus",
@@ -63,13 +66,17 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
         # in PyCharm and alike, all these fields are later overwritten within this ctor
         self.optical_albedo = optical_albedo
         self.optical_depth = optical_depth
-        self.condensation_coordinate = condensation_coordinate
+        self.diffusion_coordinate = diffusion_coordinate
+        self.diffusion_coordinate = diffusion_coordinate
         self.saturation_vapour_pressure = saturation_vapour_pressure
         self.hygroscopicity = hygroscopicity
         self.drop_growth = drop_growth
         self.surface_tension = surface_tension
         self.diffusion_kinetics = diffusion_kinetics
-        self.latent_heat = latent_heat
+        self.diffusion_ice_kinetics = diffusion_ice_kinetics
+        self.diffusion_ice_capacity = diffusion_ice_capacity
+        self.latent_heat_vapourisation = latent_heat_vapourisation
+        self.latent_heat_sublimation = latent_heat_sublimation
         self.diffusion_thermics = diffusion_thermics
         self.ventilation = ventilation
         self.state_variable_triplet = state_variable_triplet
@@ -171,7 +178,8 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
     @cached_property
     def flatten(self):
         """returns a "flattened" representation providing access to all formulae from within
-        one Numba-JIT-usable named tuple, e.g. with obj.latent_heat__lv(T)"""
+        one Numba-JIT-usable named tuple, e.g. with obj.latent_heat_vapourisation__lv(T)
+        """
         functions = {}
         for component in ["trivia"] + list(self._components):
             for item in dir(getattr(self, component)):
@@ -203,9 +211,11 @@ def _formula(func, constants, dimensional_analysis, **kw):
     source = re.sub(r"\n\s+\):", "):", source)
     loc = {}
     for arg_name in special_params:
-        source = source.replace(
-            f"def {func.__name__}({arg_name},", f"def {func.__name__}("
-        )
+        for sep in ",", ")":
+            source = source.replace(
+                f"def {func.__name__}({arg_name}{sep}",
+                f"def {func.__name__}({')' if sep == ')' else ''}",
+            )
 
     extras = func.__extras if hasattr(func, "__extras") else {}
     exec(  # pylint:disable=exec-used
@@ -281,7 +291,8 @@ def _c_inline(fun, return_type=None, constants=None, **args):
         if stripped.startswith("//"):
             continue
         if stripped.startswith('"""'):
-            in_docstring = True
+            if not (stripped.endswith('"""') and len(stripped) >= 6):
+                in_docstring = True
             continue
         if stripped.startswith("def "):
             continue

{pysdm-2.108 → pysdm-2.110}/PySDM/particulator.py

@@ -484,6 +484,31 @@ class Particulator:  # pylint: disable=too-many-public-methods,too-many-instance
         for key in self.attributes.get_extensive_attribute_keys():
             self.attributes.mark_updated(key)
 
+    def deposition(self):
+        self.backend.deposition(
+            multiplicity=self.attributes["multiplicity"],
+            signed_water_mass=self.attributes["signed water mass"],
+            current_temperature=self.environment["T"],
+            current_total_pressure=self.environment["p"],
+            current_relative_humidity=self.environment["RH"],
+            current_water_activity=self.environment["a_w_ice"],
+            current_vapour_mixing_ratio=self.environment["water_vapour_mixing_ratio"],
+            current_dry_air_density=self.environment["rhod"],
+            current_dry_potential_temperature=self.environment["thd"],
+            cell_volume=self.environment.mesh.dv,
+            time_step=self.dt,
+            cell_id=self.attributes["cell id"],
+            reynolds_number=self.attributes["Reynolds number"],
+            schmidt_number=self.environment["Schmidt number"],
+            predicted_vapour_mixing_ratio=self.environment.get_predicted(
+                "water_vapour_mixing_ratio"
+            ),
+            predicted_dry_potential_temperature=self.environment.get_predicted("thd"),
+        )
+        self.attributes.mark_updated("signed water mass")
+        # TODO #1389 - should we update here?
+        # self.update_TpRH(only_if_not_last='VapourDepositionOnIce')
+
     def immersion_freezing_time_dependent(
         self, *, thaw: bool, record_freezing_temperature: bool, rand: Storage
     ):