PySDM 2.129__tar.gz → 2.131__tar.gz

{pysdm-2.129 → pysdm-2.131}/.github/workflows/readme_snippets.yml

@@ -26,6 +26,7 @@ jobs:
       - run: python -m pip install $PIP_INSTALL_ARGS -e .
       - run: python -m pip install $PIP_INSTALL_ARGS pytest-codeblocks pytest
       - run: python -m pip install $PIP_INSTALL_ARGS "pyparsing<3.0.0"  # https://github.com/matplotlib/matplotlib/issues/25204
+      - run: python -m pip install $PIP_INSTALL_ARGS "pillow<11.3.0"  # matplotlib triggers deprecation warnings in 11.3.0
       - run: |
           python -c "import os,pytest_codeblocks; code=pytest_codeblocks.extract_from_file('docs/markdown/pysdm_landing.md'); f=open('readme.py', 'w', encoding='utf-8'); f.write('# coding: utf-8'+os.linesep); f.writelines(block.code for block in code if block.syntax=='Python'); f.close()"
       - run: cat -n readme.py

{pysdm-2.129 → pysdm-2.131}/.github/workflows/tests.yml

@@ -17,6 +17,7 @@ on:
     paths-ignore: ['docs/**', '**.md']
   pull_request:
     branches: [ main ]
+    paths-ignore: ['docs/**', '**.md']
   schedule:
     - cron: '0 13 * * 4'
 
@@ -169,6 +170,7 @@ jobs:
         run: |
           python -m pip uninstall -y jupyterlab-server # https://github.com/pypa/pip/issues/6275
           python -m pip install -e . -e ./examples
+          python -m pip install pytest-timeout
           python -m pip install -r tests/devops_tests/requirements.txt
       - if: steps.cache.outputs.cache-hit != 'true'
         uses: actions/cache/save@v4
@@ -185,7 +187,7 @@ jobs:
         test-suite: [ "chemistry_extraterrestrial", "freezing", "isotopes", "condensation_a", "condensation_b", "condensation_c", "coagulation", "breakup", "multi-process_a", "multi-process_b", "multi-process_c", "multi-process_d", "multi-process_e"]
       fail-fast: false
     runs-on: ${{ matrix.platform }}
-    timeout-minutes: 35
+    timeout-minutes: ${{ startsWith(matrix.platform, 'windows-') && 40 || 30 }}
     steps:
       - uses: actions/checkout@v4.1.6
         with:
@@ -244,7 +246,7 @@ jobs:
         run: python -m pytest --basetemp=/tmp/pytest ${{ env.pytest_options }} tests/examples_tests/test_run* -k "not Rozanski_and_Sonntag_1982" --suite ${{ matrix.test-suite }}
 
       - if: ( ! startsWith(matrix.platform, 'macos-13') )
-        run: python -m pytest ${{ env.pytest_options }} --basetemp=/tmp/pytest tests/examples_tests/test_run* --suite ${{ matrix.test-suite }}
+        run: python -m pytest ${{ env.pytest_options }} --basetemp=/tmp/pytest --timeout_method=thread --timeout=${{ startsWith(matrix.platform, 'windows-') && 1000 || 900 }} tests/examples_tests/test_run* --suite ${{ matrix.test-suite }}
         
       - if: ( ! startsWith(matrix.platform, 'windows-') ) && matrix.test-suite == env.anim_test-suite && matrix.python-version == env.anim_python-version
         run: |

{pysdm-2.129/pysdm.egg-info → pysdm-2.131}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdm
-Version: 2.129
+Version: 2.131
 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
 Author-email: "https://github.com/open-atmos/PySDM/graphs/contributors" <sylwester.arabas@agh.edu.pl>
 License-Expression: GPL-3.0-only
@@ -30,6 +30,7 @@ Requires-Dist: scipy
 Requires-Dist: pyevtk
 Provides-Extra: tests
 Requires-Dist: matplotlib; extra == "tests"
+Requires-Dist: Pillow; extra == "tests"
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-timeout; extra == "tests"
 Requires-Dist: PySDM-examples; extra == "tests"

{pysdm-2.129 → pysdm-2.131}/PySDM/backends/impl_common/freezing_attributes.py

@@ -25,3 +25,14 @@ class TimeDependentAttributes(
     """groups attributes required in time-dependent regime"""
 
     __slots__ = ()
+
+
+class TimeDependentHomogeneousAttributes(
+    namedtuple(
+        typename="TimeDependentHomogeneousAttributes",
+        field_names=("volume", "signed_water_mass"),
+    )
+):
+    """groups attributes required in time-dependent regime for homogeneous freezing"""
+
+    __slots__ = ()

{pysdm-2.129 → pysdm-2.131}/PySDM/backends/impl_numba/methods/deposition_methods.py

@@ -16,7 +16,7 @@ class DepositionMethods(BackendMethods):  # pylint:disable=too-few-public-method
         formulae = self.formulae_flattened
 
         @numba.njit(**{**self.default_jit_flags, **{"parallel": False}})
-        def body(  # pylint: disable=too-many-arguments
+        def body(  # pylint: disable=too-many-arguments,unused-argument
             *,
             multiplicity,
             signed_water_mass,
@@ -47,22 +47,15 @@ class DepositionMethods(BackendMethods):  # pylint:disable=too-few-public-method
                         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)
+                    capacity = formulae.diffusion_ice_capacity__capacity(ice_mass)
 
-                    mass_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],
-                        )
-                    )
+                    mass_ventilation_factor = 1  # TODO #1655
                     heat_ventilation_factor = mass_ventilation_factor  # TODO #1588
 
                     Dv_const = formulae.diffusion_thermics__D(temperature, pressure)
@@ -95,6 +88,7 @@ class DepositionMethods(BackendMethods):  # pylint:disable=too-few-public-method
                         D=diffusion_coefficient * mass_ventilation_factor,
                         pvs=pvs_ice,
                     )
+
                     howell_factor_x_diffcoef_x_rhovsice_x_icess = (
                         formulae.drop_growth__r_dr_dt(
                             RH_eq=1,

{pysdm-2.129 → pysdm-2.131}/PySDM/backends/impl_numba/methods/freezing_methods.py

@@ -1,5 +1,6 @@
 """
-CPU implementation of backend methods for freezing (singular and time-dependent immersion freezing)
+CPU implementation of backend methods for homogeneous freezing and
+heterogeneous freezing (singular and time-dependent immersion freezing)
 """
 
 from functools import cached_property
@@ -12,31 +13,40 @@ from PySDM.backends.impl_common.backend_methods import BackendMethods
 from ...impl_common.freezing_attributes import (
     SingularAttributes,
     TimeDependentAttributes,
+    TimeDependentHomogeneousAttributes,
 )
 
 
 class FreezingMethods(BackendMethods):
-    def __init__(self):
-        BackendMethods.__init__(self)
-        unfrozen_and_saturated = self.formulae.trivia.unfrozen_and_saturated
-        frozen_and_above_freezing_point = (
-            self.formulae.trivia.frozen_and_above_freezing_point
-        )
-
-        @numba.njit(**{**self.default_jit_flags, "parallel": False})
-        def _freeze(water_mass, i):
-            water_mass[i] = -1 * water_mass[i]
+    @cached_property
+    def _freeze(self):
+        @numba.njit(**{**self.default_jit_flags, **{"parallel": False}})
+        def body(signed_water_mass, i):
+            signed_water_mass[i] = -1 * signed_water_mass[i]
             # TODO #599: change thd (latent heat)!
 
-        @numba.njit(**{**self.default_jit_flags, "parallel": False})
-        def _thaw(water_mass, i):
-            water_mass[i] = -1 * water_mass[i]
+        return body
+
+    @cached_property
+    def _thaw(self):
+        @numba.njit(**{**self.default_jit_flags, **{"parallel": False}})
+        def body(signed_water_mass, i):
+            signed_water_mass[i] = -1 * signed_water_mass[i]
             # TODO #599: change thd (latent heat)!
 
+        return body
+
+    @cached_property
+    def _freeze_singular_body(self):
+        _thaw = self._thaw
+        _freeze = self._freeze
+        frozen_and_above_freezing_point = (
+            self.formulae.trivia.frozen_and_above_freezing_point
+        )
+        unfrozen_and_saturated = self.formulae.trivia.unfrozen_and_saturated
+
         @numba.njit(**self.default_jit_flags)
-        def freeze_singular_body(
-            attributes, temperature, relative_humidity, cell, thaw
-        ):
+        def body(attributes, temperature, relative_humidity, cell, thaw):
             n_sd = len(attributes.freezing_temperature)
             for i in numba.prange(n_sd):  # pylint: disable=not-an-iterable
                 if attributes.freezing_temperature[i] == 0:
@@ -53,13 +63,21 @@ class FreezingMethods(BackendMethods):
                 ):
                     _freeze(attributes.signed_water_mass, i)
 
-        self.freeze_singular_body = freeze_singular_body
+        return body
 
+    @cached_property
+    def _freeze_time_dependent_body(self):
+        _thaw = self._thaw
+        _freeze = self._freeze
+        frozen_and_above_freezing_point = (
+            self.formulae.trivia.frozen_and_above_freezing_point
+        )
+        unfrozen_and_saturated = self.formulae.trivia.unfrozen_and_saturated
         j_het = self.formulae.heterogeneous_ice_nucleation_rate.j_het
         prob_zero_events = self.formulae.trivia.poissonian_avoidance_function
 
         @numba.njit(**self.default_jit_flags)
-        def freeze_time_dependent_body(  # pylint: disable=too-many-arguments
+        def body(  # pylint: disable=too-many-arguments
             rand,
             attributes,
             timestep,
@@ -90,12 +108,69 @@ class FreezingMethods(BackendMethods):
                     if rand[i] < prob:
                         _freeze(attributes.signed_water_mass, i)
 
-        self.freeze_time_dependent_body = freeze_time_dependent_body
+        return body
+
+    @cached_property
+    def _freeze_time_dependent_homogeneous_body(self):
+        _thaw = self._thaw
+        _freeze = self._freeze
+        frozen_and_above_freezing_point = (
+            self.formulae.trivia.frozen_and_above_freezing_point
+        )
+        unfrozen_and_ice_saturated = self.formulae.trivia.unfrozen_and_ice_saturated
+        j_hom = self.formulae.homogeneous_ice_nucleation_rate.j_hom
+        prob_zero_events = self.formulae.trivia.poissonian_avoidance_function
+        d_a_w_ice_within_range = (
+            self.formulae.homogeneous_ice_nucleation_rate.d_a_w_ice_within_range
+        )
+        d_a_w_ice_maximum = (
+            self.formulae.homogeneous_ice_nucleation_rate.d_a_w_ice_maximum
+        )
+
+        @numba.njit(**self.default_jit_flags)
+        def body(  # pylint: disable=unused-argument,too-many-arguments
+            rand,
+            attributes,
+            timestep,
+            cell,
+            a_w_ice,
+            temperature,
+            relative_humidity_ice,
+            thaw,
+        ):
+
+            n_sd = len(attributes.signed_water_mass)
+            for i in numba.prange(n_sd):  # pylint: disable=not-an-iterable
+                cell_id = cell[i]
+                if thaw and frozen_and_above_freezing_point(
+                    attributes.signed_water_mass[i], temperature[cell_id]
+                ):
+                    _thaw(attributes.signed_water_mass, i)
+                elif unfrozen_and_ice_saturated(
+                    attributes.signed_water_mass[i], relative_humidity_ice[cell_id]
+                ):
+                    d_a_w_ice = (relative_humidity_ice[cell_id] - 1.0) * a_w_ice[
+                        cell_id
+                    ]
+
+                    if d_a_w_ice_within_range(d_a_w_ice):
+                        d_a_w_ice = d_a_w_ice_maximum(d_a_w_ice)
+                        rate_assuming_constant_temperature_within_dt = (
+                            j_hom(temperature[cell_id], d_a_w_ice)
+                            * attributes.volume[i]
+                        )
+                        prob = 1 - prob_zero_events(
+                            r=rate_assuming_constant_temperature_within_dt, dt=timestep
+                        )
+                        if rand[i] < prob:
+                            _freeze(attributes.signed_water_mass, i)
+
+        return body
 
     def freeze_singular(
         self, *, attributes, temperature, relative_humidity, cell, thaw: bool
     ):
-        self.freeze_singular_body(
+        self._freeze_singular_body(
             SingularAttributes(
                 freezing_temperature=attributes.freezing_temperature.data,
                 signed_water_mass=attributes.signed_water_mass.data,
@@ -118,7 +193,7 @@ class FreezingMethods(BackendMethods):
         relative_humidity,
         thaw: bool,
     ):
-        self.freeze_time_dependent_body(
+        self._freeze_time_dependent_body(
             rand.data,
             TimeDependentAttributes(
                 immersed_surface_area=attributes.immersed_surface_area.data,
@@ -132,6 +207,32 @@ class FreezingMethods(BackendMethods):
             thaw=thaw,
         )
 
+    def freeze_time_dependent_homogeneous(
+        self,
+        *,
+        rand,
+        attributes,
+        timestep,
+        cell,
+        a_w_ice,
+        temperature,
+        relative_humidity_ice,
+        thaw: bool,
+    ):
+        self._freeze_time_dependent_homogeneous_body(
+            rand.data,
+            TimeDependentHomogeneousAttributes(
+                volume=attributes.volume.data,
+                signed_water_mass=attributes.signed_water_mass.data,
+            ),
+            timestep,
+            cell.data,
+            a_w_ice.data,
+            temperature.data,
+            relative_humidity_ice.data,
+            thaw=thaw,
+        )
+
     @cached_property
     def _record_freezing_temperatures_body(self):
         ff = self.formulae_flattened

{pysdm-2.129 → pysdm-2.131}/PySDM/dynamics/freezing.py

@@ -1,14 +1,25 @@
 """
-immersion freezing using either singular or time-dependent formulation
+droplet freezing using either singular or
+time-dependent formulation for immersion freezing
+and homogeneous freezing and thaw
 """
 
 from PySDM.dynamics.impl import register_dynamic
 
 
 @register_dynamic()
-class Freezing:
-    def __init__(self, *, singular=True, thaw=False):
+class Freezing:  # pylint: disable=too-many-instance-attributes
+    def __init__(
+        self,
+        *,
+        singular=True,
+        homogeneous_freezing=False,
+        immersion_freezing=True,
+        thaw=False,
+    ):
         self.singular = singular
+        self.homogeneous_freezing = homogeneous_freezing
+        self.immersion_freezing = immersion_freezing
         self.thaw = thaw
         self.enable = True
         self.rand = None
@@ -26,12 +37,21 @@ class Freezing:
         if self.singular:
             builder.request_attribute("freezing temperature")
 
-        if not self.singular:
+        if not self.singular and self.immersion_freezing:
             assert (
                 self.particulator.formulae.heterogeneous_ice_nucleation_rate.__name__
                 != "Null"
             )
             builder.request_attribute("immersed surface area")
+
+        if self.homogeneous_freezing:
+            assert (
+                self.particulator.formulae.homogeneous_ice_nucleation_rate.__name__
+                != "Null"
+            )
+            builder.request_attribute("volume")
+
+        if self.homogeneous_freezing or not self.singular:
             self.rand = self.particulator.Storage.empty(
                 self.particulator.n_sd, dtype=float
             )
@@ -49,11 +69,19 @@ class Freezing:
         if not self.enable:
             return
 
-        if self.singular:
-            self.particulator.immersion_freezing_singular(thaw=self.thaw)
-        else:
+        if self.immersion_freezing:
+            if self.singular:
+                self.particulator.immersion_freezing_singular(thaw=self.thaw)
+            else:
+                self.rand.urand(self.rng)
+                self.particulator.immersion_freezing_time_dependent(
+                    rand=self.rand,
+                    thaw=self.thaw,
+                )
+
+        if self.homogeneous_freezing:
             self.rand.urand(self.rng)
-            self.particulator.immersion_freezing_time_dependent(
+            self.particulator.homogeneous_freezing_time_dependent(
                 rand=self.rand,
                 thaw=self.thaw,
             )

pysdm-2.131/PySDM/dynamics/terminal_velocity/power_series.py

@@ -0,0 +1,33 @@
+"""
+Power series expression - a simple and mutable power-law (where the coefficients are specified
+by the user), which is a form used in many more complex terminal velocity parameterizations
+such as Rogers & Yau. This formulation emerges from balancing drag and gravitational forces on
+a spherical object, and the power depends on the drag coefficient (and thus the Reynolds number
+and flow regime). Rogers and Yau distinguishes different power law parameters for three regimes,
+whereas this much simpler formulation applies across the full range of particle sizes.
+It is introduced it as a simple option for comparison against bulk methods, think of it as the
+terminal-velocity analogue to the Geometric collision kernel.
+"""
+
+import numpy as np
+
+from PySDM.physics import si, constants as const
+
+
+class PowerSeries:  # pylint: disable=too-few-public-methods
+    def __init__(self, particulator, *, prefactors=None, powers=None):
+        self.particulator = particulator
+        self.prefactors = np.array(prefactors or [2.0e-1 * si.m / si.s / np.sqrt(si.m)])
+        self.powers = np.array(powers or [1 / 6])
+        assert len(self.prefactors) == len(self.powers)
+        for i, p in enumerate(self.powers):
+            self.prefactors[i] *= const.PI_4_3**p / si.um ** (3 * p)
+
+    def __call__(self, output, radius):
+        self.particulator.backend.power_series(
+            values=output.data,
+            radius=radius.data,
+            num_terms=len(self.powers),
+            prefactors=self.prefactors,
+            powers=self.powers,
+        )

{pysdm-2.129 → pysdm-2.131}/PySDM/formulae.py

@@ -47,6 +47,7 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
         hydrostatics: str = "ConstantGVapourMixingRatioAndThetaStd",
         freezing_temperature_spectrum: str = "Null",
         heterogeneous_ice_nucleation_rate: str = "Null",
+        homogeneous_ice_nucleation_rate: str = "Null",
         fragmentation_function: str = "AlwaysN",
         isotope_equilibrium_fractionation_factors: str = "Null",
         isotope_kinetic_fractionation_factors: str = "Null",
@@ -86,6 +87,7 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
         self.hydrostatics = hydrostatics
         self.freezing_temperature_spectrum = freezing_temperature_spectrum
         self.heterogeneous_ice_nucleation_rate = heterogeneous_ice_nucleation_rate
+        self.homogeneous_ice_nucleation_rate = homogeneous_ice_nucleation_rate
         self.fragmentation_function = fragmentation_function
         self.isotope_equilibrium_fractionation_factors = (
             isotope_equilibrium_fractionation_factors

{pysdm-2.129 → pysdm-2.131}/PySDM/particulator.py

@@ -8,6 +8,7 @@ from PySDM.backends.impl_common.backend_methods import BackendMethods
 from PySDM.backends.impl_common.freezing_attributes import (
     SingularAttributes,
     TimeDependentAttributes,
+    TimeDependentHomogeneousAttributes,
 )
 from PySDM.backends.impl_common.index import make_Index
 from PySDM.backends.impl_common.indexed_storage import make_IndexedStorage
@@ -537,3 +538,18 @@ class Particulator:  # pylint: disable=too-many-public-methods,too-many-instance
             thaw=thaw,
         )
         self.attributes.mark_updated("signed water mass")
+
+    def homogeneous_freezing_time_dependent(self, *, thaw: bool, rand: Storage):
+        self.backend.freeze_time_dependent_homogeneous(
+            rand=rand,
+            attributes=TimeDependentHomogeneousAttributes(
+                volume=self.attributes["volume"],
+                signed_water_mass=self.attributes["signed water mass"],
+            ),
+            timestep=self.dt,
+            cell=self.attributes["cell id"],
+            a_w_ice=self.environment["a_w_ice"],
+            temperature=self.environment["T"],
+            relative_humidity_ice=self.environment["RH_ice"],
+            thaw=thaw,
+        )

{pysdm-2.129 → pysdm-2.131}/PySDM/physics/__init__.py

@@ -27,6 +27,7 @@ from . import (
     fragmentation_function,
     freezing_temperature_spectrum,
     heterogeneous_ice_nucleation_rate,
+    homogeneous_ice_nucleation_rate,
     hydrostatics,
     hygroscopicity,
     impl,

{pysdm-2.129 → pysdm-2.131}/PySDM/physics/constants_defaults.py

@@ -90,7 +90,6 @@ 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) """
@@ -98,20 +97,16 @@ HAC = 1.0
 """ 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
+HAC_ice = 1.0
 """ 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
+C_cunn = 0.7
+""" Cunningham correction factor as used in
+[Spichtinger & Gierens 2009](https://doi.org/10.5194/acp-9-685-2009) """
 
 ARM_C1 = 6.1094 * si.hectopascal
 """ [August](https://doi.org/10.1002/andp.18280890511) Roche Magnus formula coefficients
@@ -322,8 +317,44 @@ ABIFM_M = np.inf
 ABIFM_C = np.inf
 """ 〃 """
 
+KOOP_2000_C1 = -906.7
+""" homogeneous ice nucleation rate
+([Koop et al. 2000](https://doi.org/10.1038/35020537)) """
+KOOP_2000_C2 = 8502
+""" 〃 """
+KOOP_2000_C3 = -26924
+""" 〃 """
+KOOP_2000_C4 = 29180
+""" 〃 """
+KOOP_UNIT = 1 / si.cm**3 / si.s
+""" 〃 """
+KOOP_MIN_DA_W_ICE = 0.26
+""" 〃 """
+KOOP_MAX_DA_W_ICE = 0.34
+
+KOOP_CORR = -1.522
+""" homogeneous ice nucleation rate correction factor
+([Spichtinger et al. 2023](https://doi.org/10.5194/acp-23-2035-2023)) """
+
+KOOP_MURRAY_C0 = -3020.684
+""" homogeneous ice nucleation rate for pure water droplets
+([Koop & Murray 20016](https://doi.org/10.1063/1.4962355)) """
+KOOP_MURRAY_C1 = -425.921 / si.K
+""" 〃 """
+KOOP_MURRAY_C2 = -25.9779 / si.K**2
+""" 〃 """
+KOOP_MURRAY_C3 = -0.868451 / si.K**3
+""" 〃 """
+KOOP_MURRAY_C4 = -1.66203e-2 / si.K**4
+""" 〃 """
+KOOP_MURRAY_C5 = -1.71736e-4 / si.K**5
+""" 〃 """
+KOOP_MURRAY_C6 = -7.46953e-7 / si.K**6
+""" 〃 """
+
 J_HET = np.nan
-""" constant ice nucleation rate """
+J_HOM = np.nan
+""" constant ice nucleation rates """
 
 STRAUB_E_D1 = 0.04 * si.cm
 """ [Straub et al. 2010](https://doi.org/10.1175/2009JAS3175.1) """
@@ -498,6 +529,28 @@ CRAIG_1961_SLOPE_COEFF = 8
 CRAIG_1961_INTERCEPT_COEFF = 10 * PER_MILLE
 """ 〃 """
 
+capacity_columnar_ice_B1 = 0.3
+""" eq. A11 & A12 in [Spichtinger et al. 2023](https://doi.org/10.5194/acp-23-2035-2023)  """
+capacity_columnar_ice_B2 = 0.43
+""" 〃 """
+capacity_columnar_ice_A1 = 0.015755 * si.m / si.kg**capacity_columnar_ice_B1
+""" 〃 """
+capacity_columnar_ice_A2 = 0.33565 * si.m / si.kg**capacity_columnar_ice_B2
+""" 〃 """
+
+columnar_ice_mass_transition = 2.146e-13 * si.kg
+""" tab. 1 in [Spichtinger & Gierens 2009](https://doi.org/10.5194/acp-9-685-2009) """
+columnar_ice_length_beta_1 = 3.0
+""" 〃 """
+columnar_ice_length_beta_2 = 2.2
+""" 〃 """
+columnar_ice_length_alpha_1 = 526.1 * si.kg / si.m**columnar_ice_length_beta_1
+""" 〃 """
+columnar_ice_length_alpha_2 = 0.04142 * si.kg / si.m**columnar_ice_length_beta_2
+""" 〃 """
+columnar_bulk_ice_density = 0.81e3 * si.kg / si.m**3
+""" 〃 """
+
 asymmetry_g = 0.85  # forward scattering from cloud droplets
 """ [Bohren 1987](https://doi.org/10.1119/1.15109) """
 

{pysdm-2.129 → pysdm-2.131}/PySDM/physics/diffusion_ice_capacity/__init__.py

@@ -3,3 +3,4 @@ Formulae for capacity in diffusional growh/evaporation of ice
 """
 
 from .spherical import Spherical
+from .columnar import Columnar

pysdm-2.131/PySDM/physics/diffusion_ice_capacity/columnar.py

@@ -0,0 +1,29 @@
+"""
+capacity for columnar ice crystals approximated as prolate ellipsoids
+eq. A11 & A12 in Spichtinger et al. 2023 (https://doi.org/10.5194/acp-23-2035-2023)
+"""
+
+import numpy as np
+
+
+class Columnar:  # pylint: disable=too-few-public-methods
+
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def capacity(const, mass):
+        return (
+            const.capacity_columnar_ice_A1 * mass**const.capacity_columnar_ice_B1
+            + const.capacity_columnar_ice_A2 * mass**const.capacity_columnar_ice_B2
+        )
+
+    @staticmethod
+    def reference_capacity(
+        const, polar_diameter, eccentricity
+    ):  # pylint: disable=unused-argument
+        return (
+            polar_diameter
+            * eccentricity
+            / np.log((1 + eccentricity) / (1 - eccentricity))
+        )

{pysdm-2.129 → pysdm-2.131}/PySDM/physics/diffusion_ice_capacity/spherical.py

@@ -2,6 +2,8 @@
 capacity for approximation of ice crystals as spheres
 """
 
+import numpy as np
+
 
 class Spherical:  # pylint: disable=too-few-public-methods
 
@@ -9,5 +11,5 @@ class Spherical:  # pylint: disable=too-few-public-methods
         pass
 
     @staticmethod
-    def capacity(const, diameter):
-        return diameter / const.TWO
+    def capacity(const, mass):
+        return np.power(mass / const.PI_4_3 / const.rho_i, const.ONE_THIRD)

{pysdm-2.129 → pysdm-2.131}/PySDM/physics/diffusion_ice_kinetics/standard.py

@@ -23,7 +23,7 @@ class Standard:
     @staticmethod
     def D(const, D, r, lmbd, T):
         return D / (
-            r / (r + lmbd)
+            r / (r + lmbd * const.C_cunn)
             + 4.0 * D / const.MAC_ice / np.sqrt(8.0 * const.Rv * T / const.PI) / r
         )
 
@@ -31,8 +31,7 @@ class Standard:
     def K(const, K, r, lmbd, T, rho):  # pylint: disable=too-many-arguments
         return K / (
             r / (r + lmbd)
-            + 4.0
-            * K
+            + K
             / const.HAC_ice
             / np.sqrt(8.0 * const.Rd * T / const.PI)
             / const.c_pd