PySDM 3.0.0rc8__tar.gz → 3.0.0rc10__tar.gz

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/.github/workflows/precommit.yml

@@ -76,7 +76,7 @@ jobs:
           exclude_urls: https://www.gnu.org/licenses/gpl-3.0.html,https://open-atmos.github.io/PySDM/\2/\3.html
 
           # A comma separated patterns to exclude during URL checks
-          exclude_patterns: http://purl.org,http://www.w3.org
+          exclude_patterns: http://purl.org,http://www.w3.org,https://doi.org/10.1175/
 
           # A comma separated list of file patterns (direct paths work as well) to exclude
           exclude_files: docs/generate_html.py,.github/workflows/precommit.yml

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdm
-Version: 3.0.0rc8
+Version: 3.0.0rc10
 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

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PySDM/attributes/physics/relative_fall_velocity.py

@@ -1,5 +1,5 @@
 """
-Attributes for tracking droplet velocity
+Attributes for tracking particle velocity
 """
 
 from PySDM.attributes.impl import (
@@ -29,13 +29,13 @@ class RelativeFallMomentum(ExtensiveAttribute):
 class RelativeFallVelocity(DerivedAttribute):
     def __init__(self, builder):
         self.momentum = builder.get_attribute("relative fall momentum")
-        self.water_mass = builder.get_attribute("water mass")
+        self.signed_water_mass = builder.get_attribute("signed water mass")
 
         super().__init__(
             builder,
             name="relative fall velocity",
-            dependencies=(self.momentum, self.water_mass),
+            dependencies=(self.momentum, self.signed_water_mass),
         )
 
     def recalculate(self):
-        self.data.ratio(self.momentum.get(), self.water_mass.get())
+        self.data.ratio(self.momentum.get(), self.signed_water_mass.get())

pysdm-3.0.0rc10/PySDM/attributes/physics/terminal_velocity.py

@@ -0,0 +1,39 @@
+"""
+particle terminal velocity (used for collision probability and particle displacement)
+"""
+
+from PySDM.attributes.impl import DerivedAttribute, register_attribute
+
+
+@register_attribute(
+    name="relative fall velocity",
+    variant=lambda dynamics, _: "RelaxedVelocity" not in dynamics,
+)
+@register_attribute()
+class TerminalVelocity(DerivedAttribute):
+    def __init__(self, builder):
+        self.radius = builder.get_attribute("radius")
+        self.signed_water_mass = builder.get_attribute("signed water mass")
+        self.cell_id = builder.get_attribute("cell id")
+        dependencies = [self.radius, self.signed_water_mass, self.cell_id]
+        super().__init__(builder, name="terminal velocity", dependencies=dependencies)
+
+        self.approximation_liquid = builder.formulae.terminal_velocity_class(
+            builder.particulator
+        )
+        self.approximation_ice = builder.formulae.terminal_velocity_ice_class(
+            builder.particulator
+        )
+
+    def recalculate(self):
+        self.approximation_liquid(self.data, self.radius.get())
+        # TODO #1605 order of functions calls changes result. approximation_liquid will override
+        #  approximation_ice when mixed-phase spheres shape active
+        if self.formulae.particle_shape_and_density.supports_mixed_phase():
+            self.approximation_ice(
+                self.data,
+                self.signed_water_mass.get(),
+                self.cell_id.get(),
+                self.particulator.environment["T"],
+                self.particulator.environment["p"],
+            )

pysdm-3.0.0rc10/PySDM/backends/impl_numba/methods/terminal_velocity_methods.py

@@ -0,0 +1,127 @@
+"""
+CPU implementation of backend methods for terminal velocities
+"""
+
+from functools import cached_property
+
+import numba
+
+from PySDM.backends.impl_common.backend_methods import BackendMethods
+
+
+class TerminalVelocityMethods(BackendMethods):
+
+    @cached_property
+    def _gunn_and_kinzer_interpolation_body(self):
+        @numba.njit(**self.default_jit_flags)
+        def body(output, radius, factor, b, c):
+            for i in numba.prange(len(radius)):  # pylint: disable=not-an-iterable
+                if radius[i] > 0:
+                    r_id = int(factor * radius[i])
+                    r_rest = ((factor * radius[i]) % 1) / factor
+                    output[i] = b[r_id] + r_rest * c[r_id]
+                elif radius[i] == 0:
+                    output[i] = 0
+
+        return body
+
+    def gunn_and_kinzer_interpolation(self, *, output, radius, factor, b, c):
+        return self._gunn_and_kinzer_interpolation_body(
+            output.data, radius.data, factor, b.data, c.data
+        )
+
+    @cached_property
+    def _rogers_and_yau_terminal_velocity_body(self):
+        v_term = self.formulae.terminal_velocity.v_term
+
+        @numba.njit(**self.default_jit_flags)
+        def body(*, values, radius):
+            for i in numba.prange(len(values)):  # pylint: disable=not-an-iterable
+                if radius[i] >= 0.0:
+                    values[i] = v_term(radius[i])
+
+        return body
+
+    def rogers_and_yau_terminal_velocity(self, *, values, radius):
+        self._rogers_and_yau_terminal_velocity_body(values=values, radius=radius)
+
+    @cached_property
+    def _power_series_body(self):
+        @numba.njit(**self.default_jit_flags)
+        def body(*, values, radius, num_terms, prefactors, powers):
+            for i in numba.prange(len(values)):  # pylint: disable=not-an-iterable
+                values[i] = 0.0
+                for j in range(num_terms):
+                    values[i] = values[i] + prefactors[j] * radius[i] ** (powers[j] * 3)
+
+        return body
+
+    def power_series(self, *, values, radius, num_terms, prefactors, powers):
+        self._power_series_body(
+            values=values,
+            radius=radius,
+            num_terms=num_terms,
+            prefactors=prefactors,
+            powers=powers,
+        )
+
+    def terminal_velocity_columnar_ice_crystals(
+        self, *, values, signed_water_mass, cell_id, temperature, pressure
+    ):
+        self._terminal_velocity_columnar_ice_crystals_body(
+            values=values,
+            signed_water_mass=signed_water_mass,
+            cell_id=cell_id,
+            temperature=temperature,
+            pressure=pressure,
+        )
+
+    @cached_property
+    def _terminal_velocity_columnar_ice_crystals_body(self):
+        v_base_term = self.formulae.terminal_velocity_ice.v_base_term
+        atmospheric_correction_factor = (
+            self.formulae.terminal_velocity_ice.atmospheric_correction_factor
+        )
+
+        @numba.njit(**self.default_jit_flags)
+        def body(*, values, signed_water_mass, cell_id, temperature, pressure):
+            for i in numba.prange(len(values)):  # pylint: disable=not-an-iterable
+                if signed_water_mass[i] < 0:
+                    cid = cell_id[i]
+                    correction = atmospheric_correction_factor(
+                        temperature[cid], pressure[cid]
+                    )
+                    values[i] = v_base_term(-signed_water_mass[i]) * correction
+
+        return body
+
+    def terminal_velocity_ice_spheres(
+        self, *, values, signed_water_mass, cell_id, temperature, pressure
+    ):  # pylint: disable=unused-argument
+        self._terminal_velocity_ice_spheres_body(
+            values=values,
+            signed_water_mass=signed_water_mass,
+            cell_id=cell_id,
+            temperature=temperature,
+        )
+
+    @cached_property
+    def _terminal_velocity_ice_spheres_body(self):
+        v_base_term = self.formulae.terminal_velocity_ice.v_base_term
+        stokes_prefactor = self.formulae.terminal_velocity_ice.stokes_regime
+        formulae = self.formulae_flattened
+
+        def body(*, values, signed_water_mass, cell_id, temperature):
+            for i in numba.prange(len(values)):  # pylint: disable=not-an-iterable
+                if signed_water_mass[i] < 0:
+                    cid = cell_id[i]
+                    radius = formulae.particle_shape_and_density__mass_to_radius(
+                        signed_water_mass[i]
+                    )
+                    dynamic_viscosity = formulae.air_dynamic_viscosity__eta_air(
+                        temperature[cid]
+                    )
+                    prefactor = stokes_prefactor(radius, dynamic_viscosity)
+                    values[i] = v_base_term(prefactor, radius)
+
+        return body

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PySDM/backends/impl_thrust_rtc/methods/terminal_velocity_methods.py

@@ -69,7 +69,7 @@ class TerminalVelocityMethods(ThrustRTCBackendMethods):
         )
 
     @cached_property
-    def __interpolation_body(self):
+    def __gunn_and_kinzer_interpolation_body(self):
         # TODO #599 r<0
         return trtc.For(
             ("output", "radius", "factor", "a", "b"),
@@ -126,9 +126,9 @@ class TerminalVelocityMethods(ThrustRTCBackendMethods):
         )
 
     @nice_thrust(**NICE_THRUST_FLAGS)
-    def interpolation(self, *, output, radius, factor, b, c):
+    def gunn_and_kinzer_interpolation(self, *, output, radius, factor, b, c):
         factor_device = trtc.DVInt64(factor)
-        self.__interpolation_body.launch_n(
+        self.__gunn_and_kinzer_interpolation_body.launch_n(
             len(radius), (output.data, radius.data, factor_device, b.data, c.data)
         )
 
@@ -157,7 +157,7 @@ class TerminalVelocityMethods(ThrustRTCBackendMethods):
         )
 
     @cached_property
-    def __terminal_velocity_body(self):
+    def __rogers_and_yau_terminal_velocity_body(self):
         return trtc.For(
             param_names=("values", "radius"),
             name_iter="i",
@@ -171,5 +171,7 @@ class TerminalVelocityMethods(ThrustRTCBackendMethods):
         )
 
     @nice_thrust(**NICE_THRUST_FLAGS)
-    def terminal_velocity(self, *, values, radius):
-        self.__terminal_velocity_body.launch_n(n=values.size(), args=[values, radius])
+    def rogers_and_yau_terminal_velocity(self, *, values, radius):
+        self.__rogers_and_yau_terminal_velocity_body.launch_n(
+            n=values.size(), args=[values, radius]
+        )

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PySDM/dynamics/relaxed_velocity.py

@@ -63,7 +63,7 @@ class RelaxedVelocity:  # pylint: disable=too-many-instance-attributes
             "relative fall momentum"
         )
         self.terminal_vel_attr: Attribute = builder.get_attribute("terminal velocity")
-        self.water_mass_attr: Attribute = builder.get_attribute("water mass")
+        self.water_mass_attr: Attribute = builder.get_attribute("signed water mass")
         self.sqrt_radius_attr: Attribute = builder.get_attribute(
             "square root of radius"
         )

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PySDM/dynamics/terminal_velocity/__init__.py

@@ -5,3 +5,5 @@ particle terminal velocity formulae
 from PySDM.dynamics.terminal_velocity.gunn_and_kinzer import GunnKinzer1949
 from PySDM.dynamics.terminal_velocity.power_series import PowerSeries
 from PySDM.dynamics.terminal_velocity.rogers_and_yau import RogersYau
+from PySDM.dynamics.terminal_velocity.columnar_ice_crystal import ColumnarIceCrystal
+from PySDM.dynamics.terminal_velocity.spheres_ice import IceSphere

pysdm-3.0.0rc10/PySDM/dynamics/terminal_velocity/columnar_ice_crystal.py

@@ -0,0 +1,20 @@
+"""
+[Spichtinger & Gierens 2009](https://doi.org/10.5194/acp-9-685-2009)
+Eq. (18) .Assumed shape is columnar based on empirical parameterizations of
+[Heymsfield & Iaquinta (2000)](https://doi.org/10.1175/1520-0469(2000)057%3C0916:CCTV%3E2.0.CO;2)
+[Barthazy & Schefold (2006)](https://doi.org/10.1016/j.atmosres.2005.12.009)
+"""
+
+
+class ColumnarIceCrystal:  # pylint: disable=too-few-public-methods,too-many-arguments
+    def __init__(self, particulator):
+        self.particulator = particulator
+
+    def __call__(self, output, signed_water_mass, cell_id, temperature, pressure):
+        self.particulator.backend.terminal_velocity_columnar_ice_crystals(
+            values=output.data,
+            signed_water_mass=signed_water_mass.data,
+            cell_id=cell_id.data,
+            temperature=temperature.data,
+            pressure=pressure.data,
+        )

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PySDM/dynamics/terminal_velocity/gunn_and_kinzer.py

@@ -131,7 +131,7 @@ class GunnKinzer1949:  # pylint: disable=too-few-public-methods
                 f"Radii can be interpolated up to {self.maximum_radius} m"
                 + f" (max value of {r_max} m within input data)"
             )
-        self.particulator.backend.interpolation(
+        self.particulator.backend.gunn_and_kinzer_interpolation(
             output=output, radius=radius, factor=self.factor, b=self.a, c=self.b
         )
 

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PySDM/dynamics/terminal_velocity/rogers_and_yau.py

@@ -8,7 +8,7 @@ class RogersYau:  # pylint: disable=too-few-public-methods
         self.particulator = particulator
 
     def __call__(self, output, radius):
-        self.particulator.backend.terminal_velocity(
+        self.particulator.backend.rogers_and_yau_terminal_velocity(
             values=output.data,
             radius=radius.data,
         )

pysdm-3.0.0rc10/PySDM/dynamics/terminal_velocity/spheres_ice.py

@@ -0,0 +1,17 @@
+"""
+terminal velocity of solid ice spheres
+"""
+
+
+class IceSphere:  # pylint: disable=too-few-public-methods,too-many-arguments
+    def __init__(self, particulator):
+        self.particulator = particulator
+
+    def __call__(self, output, signed_water_mass, cell_id, temperature, pressure):
+        self.particulator.backend.terminal_velocity_ice_spheres(
+            values=output.data,
+            signed_water_mass=signed_water_mass.data,
+            cell_id=cell_id.data,
+            temperature=temperature.data,
+            pressure=pressure.data,
+        )

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PySDM/formulae.py

@@ -19,7 +19,13 @@ from numba.core.errors import NumbaExperimentalFeatureWarning
 
 from PySDM import physics
 from PySDM.backends.impl_numba import conf
-from PySDM.dynamics.terminal_velocity import GunnKinzer1949, PowerSeries, RogersYau
+from PySDM.dynamics.terminal_velocity import (
+    GunnKinzer1949,
+    PowerSeries,
+    RogersYau,
+    ColumnarIceCrystal,
+    IceSphere,
+)
 from PySDM.dynamics.terminal_velocity.gunn_and_kinzer import TpDependent
 
 
@@ -61,6 +67,7 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
         optical_depth: str = "Null",
         particle_shape_and_density: str = "LiquidSpheres",
         terminal_velocity: str = "GunnKinzer1949",
+        terminal_velocity_ice: str = "ColumnarIceCrystal",
         air_dynamic_viscosity: str = "ZografosEtAl1987",
         bulk_phase_partitioning: str = "Null",
         handle_all_breakups: bool = False,
@@ -104,6 +111,7 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
         self.particle_shape_and_density = particle_shape_and_density
         self.air_dynamic_viscosity = air_dynamic_viscosity
         self.terminal_velocity = terminal_velocity
+        self.terminal_velocity_ice = terminal_velocity_ice
         self.bulk_phase_partitioning = bulk_phase_partitioning
 
         self._components = tuple(
@@ -166,6 +174,10 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
             "TpDependent": TpDependent,
             "PowerSeries": PowerSeries,
         }[terminal_velocity]
+        self.terminal_velocity_ice_class = {
+            "ColumnarIceCrystal": ColumnarIceCrystal,
+            "IceSphere": IceSphere,
+        }[terminal_velocity_ice]
 
     def __str__(self):
         description = []

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PySDM/physics/__init__.py

@@ -52,6 +52,7 @@ from . import (
     ventilation,
     air_dynamic_viscosity,
     terminal_velocity,
+    terminal_velocity_ice,
     bulk_phase_partitioning,
 )
 from .constants import convert_to, in_unit, si

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PySDM/physics/constants.py

@@ -39,6 +39,7 @@ ONE = 1
 TWO = 2
 THREE = 3
 FOUR = 4
+NINE = 9
 TWELVE = 12
 ONE_THIRD = 1 / 3
 ONE_HALF = 1 / 2

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PySDM/physics/constants_defaults.py

@@ -18,11 +18,12 @@ from .constants import (  # pylint: disable=unused-import
     PI_4_3,
     PPM,
     T0,
-    THREE,
     ONE,
-    TWO,
-    TWO_THIRDS,
     ONE_HALF,
+    TWO_THIRDS,
+    TWO,
+    THREE,
+    NINE,
     M,
     si,
 )
@@ -638,6 +639,45 @@ ROGERS_YAU_TERM_VEL_SMALL_R_LIMIT = 35 * si.um
 ROGERS_YAU_TERM_VEL_MEDIUM_R_LIMIT = 600 * si.um
 """ 〃 """
 
+SPICHTINGER_GIERENS_TERM_VEL_LIMIT_0 = 2.146e-13 * si.kg
+""" empirical terminal velocity formulation
+for columnar ice crystals from Table 2. in
+[Spichtinger & Gierens 2009](https://doi.org/10.5194/acp-9-685-2009) """
+SPICHTINGER_GIERENS_TERM_VEL_LIMIT_1 = 2.166e-9 * si.kg
+""" 〃 """
+SPICHTINGER_GIERENS_TERM_VEL_LIMIT_2 = 4.264e-8 * si.kg
+""" 〃 """
+SPICHTINGER_TERM_DELTA_COEFF0 = 0.42
+""" 〃 """
+SPICHTINGER_TERM_DELTA_COEFF1 = 0.57
+""" 〃 """
+SPICHTINGER_TERM_DELTA_COEFF2 = 0.31
+""" 〃 """
+SPICHTINGER_TERM_DELTA_COEFF3 = 0.096
+""" 〃 """
+SPICHTINGER_TERM_GAMMA_COEFF0 = (
+    735.4 * si.m / si.s / si.kg**SPICHTINGER_TERM_DELTA_COEFF0
+)
+""" 〃 """
+SPICHTINGER_TERM_GAMMA_COEFF1 = (
+    63292.4 * si.m / si.s / si.kg**SPICHTINGER_TERM_DELTA_COEFF1
+)
+""" 〃 """
+SPICHTINGER_TERM_GAMMA_COEFF2 = (
+    329.8 * si.m / si.s / si.kg**SPICHTINGER_TERM_DELTA_COEFF2
+)
+""" 〃 """
+SPICHTINGER_TERM_GAMMA_COEFF3 = 8.8 * si.m / si.s / si.kg**SPICHTINGER_TERM_DELTA_COEFF3
+""" 〃 """
+SPICHTINGER_CORRECTION_P0 = 300 * si.hectopascal
+""" 〃 """
+SPICHTINGER_CORRECTION_P_EXPO = -0.178
+""" 〃 """
+SPICHTINGER_CORRECTION_T0 = 233 * si.kelvin
+""" 〃 """
+SPICHTINGER_CORRECTION_T_EXPO = -0.394
+""" 〃 """
+
 W76W_G0 = -2.9912729e3 * si.K**2
 """ [Wexler 1976](https://doi.org/10.6028/jres.080A.071) saturation vapour pressure """
 W76W_G1 = -6.0170128e3 * si.K

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/PySDM/physics/terminal_velocity/__init__.py

@@ -1,4 +1,4 @@
-"""terminal velocity formulae"""
+"""terminal velocity formulae for liquid droplets"""
 
 from .rogers_yau import RogersYau
 from .gunn_kinzer_1949 import GunnKinzer1949

pysdm-3.0.0rc10/PySDM/physics/terminal_velocity_ice/__init__.py

@@ -0,0 +1,4 @@
+"""terminal velocity formulae for ice particles"""
+
+from .columnar_ice_crystal import ColumnarIceCrystal
+from .spheres_ice import IceSphere

pysdm-3.0.0rc10/PySDM/physics/terminal_velocity_ice/columnar_ice_crystal.py

@@ -0,0 +1,41 @@
+"""
+[Spichtinger & Gierens 2009](https://doi.org/10.5194/acp-9-685-2009)
+Eq. (18) and (19) Assumed shape is columnar based on empirical parameterizations of
+[Heymsfield & Iaquinta (2000)](https://doi.org/10.1175/1520-0469(2000)057%3C0916:CCTV%3E2.0.CO;2)
+[Barthazy & Schefold (2006)](https://doi.org/10.1016/j.atmosres.2005.12.009)
+"""
+
+import numpy as np
+
+
+class ColumnarIceCrystal:  # pylint: disable=too-few-public-methods
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def v_base_term(const, mass):
+        return np.where(
+            mass < const.SPICHTINGER_GIERENS_TERM_VEL_LIMIT_0,
+            const.SPICHTINGER_TERM_GAMMA_COEFF0
+            * mass**const.SPICHTINGER_TERM_DELTA_COEFF0,
+            np.where(
+                mass < const.SPICHTINGER_GIERENS_TERM_VEL_LIMIT_1,
+                const.SPICHTINGER_TERM_GAMMA_COEFF1
+                * mass**const.SPICHTINGER_TERM_DELTA_COEFF1,
+                np.where(
+                    mass < const.SPICHTINGER_GIERENS_TERM_VEL_LIMIT_2,
+                    const.SPICHTINGER_TERM_GAMMA_COEFF2
+                    * mass**const.SPICHTINGER_TERM_DELTA_COEFF2,
+                    const.SPICHTINGER_TERM_GAMMA_COEFF3
+                    * mass**const.SPICHTINGER_TERM_DELTA_COEFF3,
+                ),
+            ),
+        )
+
+    @staticmethod
+    def atmospheric_correction_factor(const, temperature, pressure):
+        return (
+            pressure / const.SPICHTINGER_CORRECTION_P0
+        ) ** const.SPICHTINGER_CORRECTION_P_EXPO * (
+            const.SPICHTINGER_CORRECTION_T0 / temperature
+        ) ** const.SPICHTINGER_CORRECTION_T_EXPO

pysdm-3.0.0rc10/PySDM/physics/terminal_velocity_ice/spheres_ice.py

@@ -0,0 +1,21 @@
+"""
+terminal velocity of smooth ice spheres
+"""
+
+
+class IceSphere:  # pylint: disable=too-few-public-methods
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def v_base_term(const, radius, prefactor):
+        return prefactor * const.TWO * radius
+
+    @staticmethod
+    def stokes_regime(const, radius, dynamic_viscosity):
+        return const.g_std * const.rho_i * radius / const.NINE / dynamic_viscosity
+
+    # TODO #1602 general functional relationship between reynolds number and drag coefficient
+    @staticmethod
+    def general_flow_regime(const):
+        pass

{pysdm-3.0.0rc8 → pysdm-3.0.0rc10}/docs/bibliography.json

@@ -851,11 +851,14 @@
   },
   "https://doi.org/10.5194/acp-9-685-2009": {
     "usages": [
+      "PySDM/dynamics/terminal_velocity/columnar_ice_crystal.py",
       "PySDM/physics/constants_defaults.py",
       "PySDM/physics/particle_shape_and_density/columnar_ice.py",
       "PySDM/physics/particle_shape_and_density/porous_spheroids.py",
-      "tests/unit_tests/physics/test_particle_shape_and_density.py",
-      "tests/unit_tests/dynamics/test_vapour_deposition_on_ice.py"
+      "PySDM/physics/terminal_velocity_ice/columnar_ice_crystal.py",
+      "tests/unit_tests/dynamics/test_terminal_velocity.py",
+      "tests/unit_tests/dynamics/test_vapour_deposition_on_ice.py",
+      "tests/unit_tests/physics/test_particle_shape_and_density.py"
     ],
     "title": "Modelling of cirrus clouds – Part 1a: Model description and validation",
     "label": "Spichtinger & Gierens 2009 (Atmos. Chem. Phys. 9)"
@@ -946,5 +949,29 @@
     ],
     "title": "A physically constrained classical description of the homogeneous nucleation of ice in water",
     "label": "Koop and Murray 2016 (J. Chem. Phys. 145)"
+  },
+  "https://doi.org/10.48550/arXiv.2509.05536": {
+    "usages": [
+      "examples/PySDM_examples/Ware_et_al_2025/__init__.py",
+      "examples/PySDM_examples/Ware_et_al_2025/fig_10.ipynb"
+    ],
+    "title": "Adaptive time-stepping for the Super-Droplet Method Monte Carlo collision-coalescence scheme",
+    "label": "Ware et al. 2025 (arXiv)"
+  },
+  "https://doi.org/10.1175/1520-0469(2000)057%3C0916:CCTV%3E2.0.CO;2": {
+    "usages": [
+      "PySDM/dynamics/terminal_velocity/columnar_ice_crystal.py",
+      "PySDM/physics/terminal_velocity_ice/columnar_ice_crystal.py"
+    ],
+    "label": "Heymsfield & Iaquinta 2000 (J. Atmos. Sci. 57)",
+    "title": "Cirrus Crystal Terminal Velocities"
+  },
+  "https://doi.org/10.1016/j.atmosres.2005.12.009": {
+    "usages": [
+      "PySDM/dynamics/terminal_velocity/columnar_ice_crystal.py",
+      "PySDM/physics/terminal_velocity_ice/columnar_ice_crystal.py"
+    ],
+    "label": "Barthazy and Schefold 2006 (Atmos. Res. 82)",
+    "title": "Fall velocity of snowflakes of different riming degree and crystal types"
   }
 }

pysdm-3.0.0rc10/examples/PySDM_examples/Ware_et_al_2025/__init__.py

@@ -0,0 +1,10 @@
+"""
+SDM adaptivity example based on
+[Ware et al. 2025 (arXiv)](https://doi.org/10.48550/arXiv.2509.05536)
+
+fig_10.ipynb:
+.. include:: ./fig_10.ipynb.badges.md
+
+"""
+
+# pylint: disable=invalid-name