PySDM 2.104__tar.gz → 2.117__tar.gz

{pysdm-2.104 → pysdm-2.117}/.github/workflows/pdoc.yml

@@ -26,13 +26,11 @@ jobs:
       - uses: actions/setup-python@v5.0.0
         with:
           python-version: "3.12"
-      - run: |
-          pip install pdoc nbformat gitpython
-          pip install -e .
-          pip install -e examples
+      - run: pip install pdoc nbformat gitpython
+      - run: pip install -e .
+      - run: pip install -e examples
+      - run: python -We docs/generate_html.py . .
 
-          python -We docs/generate_html.py . .
-        
       - if: ${{ github.ref == 'refs/heads/main' && matrix.platform == 'ubuntu-latest' }}
         uses: JamesIves/github-pages-deploy-action@4.1.1
         with:

{pysdm-2.104 → pysdm-2.117}/.github/workflows/readme_snippets.yml

@@ -43,7 +43,7 @@ jobs:
             readme.png
 
   julia:
-    runs-on: ubuntu-latest
+    runs-on: macos-latest
     steps:
       - uses: actions/checkout@v4.1.6
       - uses: actions/setup-python@v5.0.0
@@ -52,8 +52,9 @@ jobs:
       - run: pip install -e .
       - run: pip install pytest-codeblocks pytest
       - run: python -c "import pytest_codeblocks; code=pytest_codeblocks.extract_from_file('docs/markdown/pysdm_landing.md'); f=open('readme.jl', 'w'); f.writelines(block.code for block in code if block.syntax=='Julia'); f.close()"
-      - uses: julia-actions/setup-julia@v1.9.6
+      - uses: julia-actions/setup-julia@v2
       - run: cat -n readme.jl
+      - run: echo PYTHON=`which python` >> $GITHUB_ENV
       - run: julia readme.jl
       - run: sed -i -e 's/CPU/GPU/g' readme.jl
       - run: julia readme.jl

{pysdm-2.104 → pysdm-2.117}/.github/workflows/tests.yml

@@ -128,7 +128,7 @@ jobs:
             test-suite: "unit_tests/!(dynamics)"
       fail-fast: false
     runs-on: ${{ matrix.platform }}
-    timeout-minutes: ${{ startsWith(matrix.platform, 'windows-') && 35 || 30 }}
+    timeout-minutes: ${{ startsWith(matrix.platform, 'windows-') && 40 || 30 }}
     steps:
       - uses: actions/checkout@v4.1.6
         with:
@@ -213,7 +213,7 @@ jobs:
       matrix:
         platform: [ubuntu-24.04, macos-13, windows-latest]
         python-version: ["3.9", "3.12"]
-        test-suite: [ "chemistry_freezing_extraterrestrial", "isotopes", "condensation_a", "condensation_b", "condensation_c", "coagulation", "breakup", "multi-process_a", "multi-process_b", "multi-process_c", "multi-process_d", "multi-process_e"]
+        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
@@ -267,8 +267,12 @@ jobs:
           pvpython --version
           pvpython -c "from paraview import simple"
 
-      - env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
+      - run: |
           python -m pytest --durations=10 -v -p no:unraisableexception -We tests/examples_tests/test_tests_completeness.py
-          python -m pytest --durations=10 -v -p no:unraisableexception -We tests/examples_tests/test_run* --suite ${{ matrix.test-suite }}
+
+       # TODO #1207
+      - 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, 'macos-13') )
+        run: python -m pytest --durations=10 -v -p no:unraisableexception -We tests/examples_tests/test_run* --suite ${{ matrix.test-suite }}

{pysdm-2.104 → pysdm-2.117}/.gitignore

@@ -4,6 +4,9 @@ PySDM_examples/utils/temporary_files/*
 *.pkl
 *.vtu
 *.vts
+*.svg
+*.gif
+*.ipynb.badges.md
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

{pysdm-2.104 → pysdm-2.117}/PKG-INFO

@@ -1,10 +1,8 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.104
+Version: 2.117
 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
-Author-email: sylwester.arabas@agh.edu.pl
+Author-email: "https://github.com/open-atmos/PySDM/graphs/contributors" <sylwester.arabas@agh.edu.pl>
 License: GPL-3.0
 Project-URL: Tracker, https://github.com/open-atmos/PySDM/issues
 Project-URL: Documentation, https://open-atmos.github.io/PySDM
@@ -20,6 +18,7 @@ Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ThrustRTC==0.3.20
@@ -40,7 +39,7 @@ Requires-Dist: pyrcel; extra == "tests"
 Requires-Dist: jupyter-core<5.0.0; extra == "tests"
 Requires-Dist: ipywidgets!=8.0.3; extra == "tests"
 
-# <img src="https://raw.githubusercontent.com/open-atmos/PySDM/main/docs/logos/pysdm_logo.png" width=100 height=146 alt="pysdm logo">
+# <img src="https://raw.githubusercontent.com/open-atmos/PySDM/main/docs/logos/pysdm_logo.svg" width=100 height=146 alt="pysdm logo">
 
 [![Python 3](https://img.shields.io/static/v1?label=Python&logo=Python&color=3776AB&message=3)](https://www.python.org/)
 [![LLVM](https://img.shields.io/static/v1?label=LLVM&logo=LLVM&color=gold&message=Numba)](https://numba.pydata.org)
@@ -75,7 +74,7 @@ Currently, the development is focused on atmospheric cloud physics
   to represent aerosol/cloud/rain microphysics.
 The package features a Pythonic high-performance implementation of the 
   Super-Droplet Method (SDM) Monte-Carlo algorithm for representing collisional growth 
-  ([Shima et al. 2009](https://rmets.onlinelibrary.wiley.com/doi/abs/10.1002/qj.441)), hence the name. 
+  ([Shima et al. 2009](https://doi.org/10.1002/qj.441)), hence the name. 
 
 PySDM documentation is maintained at: [https://open-atmos.github.io/PySDM](https://open-atmos.github.io/PySDM) 
 

pysdm-2.117/PySDM/attributes/ice/freezing_temperature.py

@@ -0,0 +1,42 @@
+"""
+particle freezing temperature
+"""
+
+from PySDM.attributes.impl import MaximumAttribute, register_attribute
+from ..impl import DerivedAttribute
+
+
+@register_attribute()
+class FreezingTemperature(MaximumAttribute):
+    """singular variant: assigned at initialisation, modified through collisions only"""
+
+    def __init__(self, builder):
+        super().__init__(builder, name="freezing temperature")
+
+
+@register_attribute()
+class TemperatureOfLastFreezing(DerivedAttribute):
+    """time-dependent variant: assigned upon freezing"""
+
+    def __init__(self, builder):
+        assert "Freezing" in builder.particulator.dynamics
+        assert not builder.particulator.dynamics["Freezing"].singular
+        self.signed_water_mass = builder.get_attribute("signed water mass")
+        self.cell_id = builder.get_attribute("cell id")
+        super().__init__(
+            builder,
+            name="temperature of last freezing",
+            dependencies=(self.signed_water_mass, self.cell_id),
+        )
+        builder.particulator.observers.append(self)
+
+    def notify(self):
+        self.update()
+
+    def recalculate(self):
+        self.particulator.backend.record_freezing_temperatures(
+            data=self.data,
+            cell_id=self.cell_id.data,
+            temperature=self.particulator.environment["T"],
+            signed_water_mass=self.signed_water_mass.data,
+        )

{pysdm-2.104 → pysdm-2.117}/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.104 → pysdm-2.117}/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.117/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.104 → pysdm-2.117}/PySDM/backends/impl_numba/methods/freezing_methods.py

@@ -2,7 +2,10 @@
 CPU implementation of backend methods for freezing (singular and time-dependent immersion freezing)
 """
 
+from functools import cached_property
+
 import numba
+import numpy as np
 
 from PySDM.backends.impl_common.backend_methods import BackendMethods
 
@@ -56,7 +59,7 @@ class FreezingMethods(BackendMethods):
         prob_zero_events = self.formulae.trivia.poissonian_avoidance_function
 
         @numba.njit(**self.default_jit_flags)
-        def freeze_time_dependent_body(  # pylint: disable=unused-argument,too-many-arguments
+        def freeze_time_dependent_body(  # pylint: disable=too-many-arguments
             rand,
             attributes,
             timestep,
@@ -64,8 +67,6 @@ class FreezingMethods(BackendMethods):
             a_w_ice,
             temperature,
             relative_humidity,
-            record_freezing_temperature,
-            freezing_temperature,
             thaw,
         ):
             n_sd = len(attributes.signed_water_mass)
@@ -88,8 +89,6 @@ class FreezingMethods(BackendMethods):
                     )
                     if rand[i] < prob:
                         _freeze(attributes.signed_water_mass, i)
-                        # if record_freezing_temperature:
-                        #     freezing_temperature[i] = temperature[cell_id]
 
         self.freeze_time_dependent_body = freeze_time_dependent_body
 
@@ -117,9 +116,7 @@ class FreezingMethods(BackendMethods):
         a_w_ice,
         temperature,
         relative_humidity,
-        record_freezing_temperature,
-        freezing_temperature,
-        thaw: bool
+        thaw: bool,
     ):
         self.freeze_time_dependent_body(
             rand.data,
@@ -132,9 +129,31 @@ class FreezingMethods(BackendMethods):
             a_w_ice.data,
             temperature.data,
             relative_humidity.data,
-            record_freezing_temperature=record_freezing_temperature,
-            freezing_temperature=(
-                freezing_temperature.data if record_freezing_temperature else None
-            ),
             thaw=thaw,
         )
+
+    @cached_property
+    def _record_freezing_temperatures_body(self):
+        ff = self.formulae_flattened
+
+        @numba.njit(**{**self.default_jit_flags, "fastmath": False})
+        def body(data, cell_id, temperature, signed_water_mass):
+            for drop_id in numba.prange(len(data)):  # pylint: disable=not-an-iterable
+                if ff.trivia__unfrozen(signed_water_mass[drop_id]):
+                    if data[drop_id] > 0:
+                        data[drop_id] = np.nan
+                else:
+                    if np.isnan(data[drop_id]):
+                        data[drop_id] = temperature[cell_id[drop_id]]
+
+        return body
+
+    def record_freezing_temperatures(
+        self, *, data, cell_id, temperature, signed_water_mass
+    ):
+        self._record_freezing_temperatures_body(
+            data=data.data,
+            cell_id=cell_id.data,
+            temperature=temperature.data,
+            signed_water_mass=signed_water_mass.data,
+        )

{pysdm-2.104 → pysdm-2.117}/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]]