PySDM 2.109__tar.gz → 2.110__tar.gz

{pysdm-2.109/pysdm.egg-info → pysdm-2.110}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pysdm
-Version: 2.109
+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.109 → 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.109 → 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,9 +390,9 @@ class CondensationMethods(BackendMethods):
             K,
             ventilation_factor,
         ):
-            if x_new > formulae.condensation_coordinate__x_max():
+            if x_new > formulae.diffusion_coordinate__x_max():
                 return x_old - x_new
-            mass_new = formulae.condensation_coordinate__mass(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(
@@ -418,7 +418,7 @@ class CondensationMethods(BackendMethods):
             return (
                 x_old
                 - x_new
-                + timestep * formulae.condensation_coordinate__dx_dt(mass_new, dm_dt)
+                + timestep * formulae.diffusion_coordinate__dx_dt(mass_new, dm_dt)
             )
 
         @numba.njit(**jit_flags)
@@ -450,9 +450,9 @@ class CondensationMethods(BackendMethods):
                 v_drop = formulae.particle_shape_and_density__mass_to_volume(
                     attributes.water_mass[drop]
                 )
-                x_old = formulae.condensation_coordinate__x(attributes.water_mass[drop])
+                x_old = formulae.diffusion_coordinate__x(attributes.water_mass[drop])
                 r_old = formulae.trivia__radius(v_drop)
-                x_insane = formulae.condensation_coordinate__x(
+                x_insane = formulae.diffusion_coordinate__x(
                     formulae.particle_shape_and_density__volume_to_mass(
                         attributes.vdry[drop] / 100
                     )
@@ -499,11 +499,11 @@ class CondensationMethods(BackendMethods):
                         Kr,
                         ventilation_factor,
                     )
-                    mass_old = formulae.condensation_coordinate__mass(x_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.condensation_coordinate__dx_dt(
+                    dx_old = timestep * formulae.diffusion_coordinate__dx_dt(
                         mass_old, dm_dt_old
                     )
                 else:
@@ -572,7 +572,7 @@ class CondensationMethods(BackendMethods):
                     else:
                         x_new = x_old
 
-                mass_new = formulae.condensation_coordinate__mass(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.109 → pysdm-2.110}/PySDM/backends/impl_numba/test_helpers/scipy_ode_condensation_solver.py

@@ -92,7 +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.condensation_coordinate__mass(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
@@ -127,7 +127,7 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
         )
         sum_n_dm_dt = 0
         for i, x_i in enumerate(x):
-            m = jit_formulae.condensation_coordinate__mass(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)
@@ -152,7 +152,7 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
                 ventilation_factor,
             )
             dm_dt = jit_formulae.particle_shape_and_density__dm_dt(r, r_dr_dt)
-            dy_dt[idx_x + i] = jit_formulae.condensation_coordinate__dx_dt(m, dm_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, dot_water_vapour_mixing_ratio - sum_n_dm_dt / m_d_mean, lv
@@ -211,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
 
@@ -234,7 +234,7 @@ 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(
+        y0[idx_x:] = jit_formulae.diffusion_coordinate__x(
             attributes.water_mass[cell_idx]
         )
         total_water_mixing_ratio = (
@@ -282,7 +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.condensation_coordinate__mass(y1[idx_x + i])
+                jit_formulae.diffusion_coordinate__mass(y1[idx_x + i])
             )
             m_new += (
                 attributes.multiplicity[cell_idx[i]]

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

@@ -100,10 +100,10 @@ class CondensationMethods(
             struct Minfun {{
                 static __device__ real_type value(real_type x_new, void* args_p) {{
                     auto args = static_cast<real_type*>(args_p);
-                    if (x_new > {phys.condensation_coordinate.x_max.c_inline()}) {{
+                    if (x_new > {phys.diffusion_coordinate.x_max.c_inline()}) {{
                         return {args("x_old")} - x_new;
                     }}
-                    auto m_new = {phys.condensation_coordinate.mass.c_inline(x="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(
@@ -133,7 +133,7 @@ class CondensationMethods(
                         r="r_new", r_dr_dt="r_dr_dt"
                     )};
                     return {args("x_old")} - x_new + {args("dt")} * {
-                        phys.condensation_coordinate.dx_dt.c_inline(m="m_new", dm_dt="dm_dt")
+                        phys.diffusion_coordinate.dx_dt.c_inline(m="m_new", dm_dt="dm_dt")
                     };
                 }}
             }};
@@ -152,10 +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(mass="water_mass[i]")};
+            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 m_insane = {phys.particle_shape_and_density.volume_to_mass.c_inline(volume="vdry[i] / 100")};
-            auto x_insane = {phys.condensation_coordinate.x.c_inline(mass="m_insane")};
+            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]"
@@ -194,7 +194,7 @@ class CondensationMethods(
                     ventilation_factor="ventilation_factor",
                 )};
                 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.condensation_coordinate.dx_dt.c_inline(
+                dx_old = dt * {phys.diffusion_coordinate.dx_dt.c_inline(
                     m="water_mass[i]", dm_dt="dm_dt_old"
                 )};
             }}
@@ -249,7 +249,7 @@ class CondensationMethods(
                     x_new = x_old;
                 }}
             }}
-            water_mass[i] = {phys.condensation_coordinate.mass.c_inline(x="x_new")};
+            water_mass[i] = {phys.diffusion_coordinate.mass.c_inline(x="x_new")};
         """.replace(
                 "real_type", self._get_c_type()
             ),
@@ -323,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.109 → 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.109 → 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.109 → 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.109 → 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 = "WaterMassLogarithm",
+        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)):

{pysdm-2.109 → 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
     ):

{pysdm-2.109 → pysdm-2.110}/PySDM/physics/__init__.py

@@ -17,9 +17,11 @@ Physical constants and formulae (mostly one-liners)
 """
 
 from . import (
-    condensation_coordinate,
+    diffusion_coordinate,
     constants_defaults,
     diffusion_kinetics,
+    diffusion_ice_kinetics,
+    diffusion_ice_capacity,
     diffusion_thermics,
     drop_growth,
     fragmentation_function,
@@ -34,7 +36,8 @@ from . import (
     isotope_diffusivity_ratios,
     isotope_relaxation_timescale,
     isotope_temperature_inference,
-    latent_heat,
+    latent_heat_vapourisation,
+    latent_heat_sublimation,
     optical_albedo,
     optical_depth,
     particle_advection,

{pysdm-2.109 → pysdm-2.110}/PySDM/physics/constants_defaults.py

@@ -90,13 +90,29 @@ R_str = sci.R * si.joule / si.kelvin / si.mole
 N_A = sci.N_A / si.mole
 """ Avogadro constant (value from SciPy) """
 
+# mass and heat accommodation coefficients for condensation
 MAC = 1.0
 """ mass accommodation coefficient of unity as recommended in
 [Laaksonen et al. 2005](https://doi.org/10.5194/acp-5-461-2005) """
 HAC = 1.0
-""" thermal accommodation coefficient of uniy as recommended in
+""" thermal accommodation coefficient of unity as recommended in
 [Laaksonen et al. 2005](https://doi.org/10.5194/acp-5-461-2005) """
 
+# mass and heat accommodation coefficients for vapour deposition on ice
+MAC_ice = 0.5
+""" mass accommodation coefficient for vapour deposition as recommended in
+[Kaercher & Lohmann 2002](https://doi.org/10.1029/2001JD000470) """
+HAC_ice = 0.7
+""" thermal accommodation coefficient for vapour deposition as recommended in
+[Pruppacher & Klett](https://doi.org/10.1007/978-0-306-48100-0) """
+
+p1000 = 1000 * si.hectopascals
+c_pd = 1005 * si.joule / si.kilogram / si.kelvin
+c_pv = 1850 * si.joule / si.kilogram / si.kelvin
+g_std = sci.g * si.metre / si.second**2
+
+c_pw = 4218 * si.joule / si.kilogram / si.kelvin
+
 ARM_C1 = 6.1094 * si.hectopascal
 """ [August](https://doi.org/10.1002/andp.18280890511) Roche Magnus formula coefficients
 (values from [Alduchov & Eskridge 1996](https://doi.org/10.1175%2F1520-0450%281996%29035%3C0601%3AIMFAOS%3E2.0.CO%3B2))
@@ -186,12 +202,12 @@ p1000 = 1000 * si.hectopascals
 """ 1000 hPa reference pressure as in the definition of potential temperature"""
 
 p_tri = 611.657 * si.pascal
-""" water triple point characteristics as recommended in
-[Murphy & Koop 2005](https://doi.org/10.1256/qj.04.94) """
+""" water triple point pressure ([Murphy & Koop 2005](https://doi.org/10.1256/qj.04.94)) """
 T_tri = 273.16 * si.kelvin
-""" 〃 """
+""" water triple point temperature ([Murphy & Koop 2005](https://doi.org/10.1256/qj.04.94)) """
 L_tri = 45051.0 * si.joule / si.mol
-""" 〃 """
+""" latent heat of vaporization of liquid at triple point
+([Murphy & Koop 2005](https://doi.org/10.1256/qj.04.94)) """
 
 l_l19_a = 0.167 * si.dimensionless
 """ [Seinfeld and Pandis](https://archive.org/details/0237-pdf-atmospheric-chemistry-and-physics-2nd-ed-j.-seinfeld-s.-pandis-wiley-2006-ww)
@@ -213,6 +229,10 @@ dv_pk05 = 0.0 * si.metres
 """ Delta v for diffusivity in [Pruppacher & Klett](https://doi.org/10.1007/978-0-306-48100-0)
 eq. 13-14 """
 
+lmbd_w_0 = 6.6e-8 * si.metre
+""" Mean free path of water molecules as in table 13.1 in
+[Pruppacher & Klett](https://doi.org/10.1007/978-0-306-48100-0) """
+
 d_l19_a = 0.211e-4 * si.metre**2 / si.second
 """ [Seinfeld & Pandis](https://archive.org/details/0237-pdf-atmospheric-chemistry-and-physics-2nd-ed-j.-seinfeld-s.-pandis-wiley-2006-ww)
 eq. 15.65
@@ -259,6 +279,16 @@ MK05_LIQ_C12 = 1 * si.K
 """ 〃 """
 MK05_LIQ_C13 = 0.014025 / si.K
 """ 〃 """
+MK05_SUB_C1 = 46782.5 * si.joule / si.mole
+""" 〃 """
+MK05_SUB_C2 = 35.8925 * si.joule / si.mole / si.kelvin
+""" 〃 """
+MK05_SUB_C3 = 0.07414 * si.joule / si.mole / si.kelvin**2
+""" 〃 """
+MK05_SUB_C4 = 541.5 * si.joule / si.mole
+""" 〃 """
+MK05_SUB_C5 = 123.75 * si.kelvin
+""" 〃 """
 
 T_STP = (sci.zero_Celsius + 15) * si.kelvin
 """ standard temperature (ICAO) ... """

{pysdm-2.109/PySDM/physics/condensation_coordinate → pysdm-2.110/PySDM/physics/diffusion_coordinate}/water_mass_logarithm.py

@@ -13,6 +13,7 @@ class WaterMassLogarithm:
     def dx_dt(m, dm_dt):
         """
         x = ln(m/m0)
+        m0 = 1 kg
         dx_dt = 1/m(x) dm_dt
         """
         return dm_dt / m

pysdm-2.110/PySDM/physics/diffusion_ice_capacity/__init__.py

@@ -0,0 +1,5 @@
+"""
+Formulae for capacity in diffusional growh/evaporation of ice
+"""
+
+from .spherical import Spherical

pysdm-2.110/PySDM/physics/diffusion_ice_capacity/spherical.py

@@ -0,0 +1,13 @@
+"""
+capacity for approximation of ice crystals as spheres
+"""
+
+
+class Spherical:  # pylint: disable=too-few-public-methods
+
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def capacity(const, diameter):
+        return diameter / const.TWO

pysdm-2.110/PySDM/physics/diffusion_ice_kinetics/__init__.py

@@ -0,0 +1,6 @@
+"""
+Formulae for handling transition-régime corrections in diffusional growh/evaporation of ice
+"""
+
+from .neglect import Neglect
+from .standard import Standard

pysdm-2.110/PySDM/physics/diffusion_ice_kinetics/neglect.py

@@ -0,0 +1,24 @@
+"""
+no transition-regime corrections formulation
+"""
+
+
+class Neglect:
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def lambdaD(_, T, p):  # pylint: disable=unused-argument
+        return -1
+
+    @staticmethod
+    def lambdaK(_, T, p):  # pylint: disable=unused-argument
+        return -1
+
+    @staticmethod
+    def D(_, D, r, lmbd, T):  # pylint: disable=unused-argument
+        return D
+
+    @staticmethod
+    def K(_, K, r, lmbd, T, rho):  # pylint: disable=unused-argument
+        return K