PySDM 2.33__tar.gz → 2.34__tar.gz

{PySDM-2.33 → PySDM-2.34}/.github/workflows/tests+artifacts+pypi.yml

@@ -16,9 +16,6 @@ on:
 
 jobs:
   precommit:
-    strategy:
-      matrix:
-        package-dir: [".", "examples"]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -26,11 +23,12 @@ jobs:
         with:
           python-version: 3.8
       - run: |
-          cd ${{ matrix.package-dir }}
           pip install pre-commit
           pre-commit clean
           pre-commit autoupdate
           pre-commit run --all-files
+      - if: ${{ failure() }}
+        run: git diff
 
   nojit_and_codecov:
     runs-on: ubuntu-latest
@@ -127,7 +125,7 @@ jobs:
       matrix:
         platform: [ubuntu-latest, macos-12, windows-latest]
         python-version: ["3.8", "3.10"]
-        test-suite: ["unit_tests", "smoke_tests/box", "smoke_tests/parcel", "smoke_tests/kinematic_1d", "smoke_tests/kinematic_2d"]
+        test-suite: ["unit_tests", "smoke_tests/no_env", "smoke_tests/box", "smoke_tests/parcel", "smoke_tests/kinematic_1d", "smoke_tests/kinematic_2d"]
         exclude:
           - test-suite: "devops_tests"
             python-version: "3.8"
@@ -177,7 +175,7 @@ jobs:
       matrix:
         platform: [ubuntu-22.04, macos-12, windows-latest]
         python-version: ["3.8", "3.10"]
-        test-suite: [ "aqueous_chemistry", "freezing", "condensation", "coagulation", "breakup", "multi-process" ]
+        test-suite: [ "aqueous_chemistry", "freezing", "condensation", "coagulation", "breakup", "multi-process", "isotopes"]
       fail-fast: false
     runs-on: ${{ matrix.platform }}
     steps:

{PySDM-2.33 → PySDM-2.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.33
+Version: 2.34
 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.33 → PySDM-2.34}/PySDM/attributes/chemistry/__init__.py

@@ -4,4 +4,3 @@ attributes used by the `PySDM.dynamics.aqueous_chemistry` dynamic
 from .acidity import Acidity
 from .concentration import make_concentration_factory
 from .hydrogen_ion_concentration import HydrogenIonConcentration
-from .mole_amount import make_mole_amount_factory

{PySDM-2.33 → PySDM-2.34}/PySDM/attributes/impl/mapper.py

@@ -7,10 +7,12 @@ from PySDM.attributes.chemistry import (
     Acidity,
     HydrogenIonConcentration,
     make_concentration_factory,
-    make_mole_amount_factory,
 )
 from PySDM.attributes.ice import CoolingRate, FreezingTemperature, ImmersedSurfaceArea
 from PySDM.attributes.impl.dummy_attribute import make_dummy_attribute_factory
+from PySDM.attributes.impl.mole_amount import make_mole_amount_factory
+from PySDM.attributes.isotopes import Moles1H, Moles16O, MolesLightWater
+from PySDM.attributes.isotopes.delta import make_delta_factory
 from PySDM.attributes.numerics import CellID, CellOrigin, PositionInCell
 from PySDM.attributes.physics import (
     Area,
@@ -40,6 +42,7 @@ from PySDM.attributes.physics.equilibrium_supersaturation import (
 from PySDM.attributes.physics.hygroscopicity import Kappa, KappaTimesDryVolume
 from PySDM.attributes.physics.relative_fall_velocity import RelativeFallMomentum
 from PySDM.dynamics.impl.chemistry_utils import AQUEOUS_COMPOUNDS
+from PySDM.dynamics.isotopic_fractionation import HEAVY_ISOTOPES
 from PySDM.physics.surface_tension import Constant
 
 attributes = {
@@ -102,6 +105,18 @@ attributes = {
     "equilibrium supersaturation": lambda _, __: EquilibriumSupersaturation,
     "wet to critical volume ratio": lambda _, __: WetToCriticalVolumeRatio,
     "water mass": lambda _, __: WaterMass,
+    **{
+        "moles_"
+        + isotope: partial(lambda _, __, c: make_mole_amount_factory(c), c=isotope)
+        for isotope in HEAVY_ISOTOPES
+    },
+    **{
+        "delta_" + isotope: partial(lambda _, __, c: make_delta_factory(c), c=isotope)
+        for isotope in HEAVY_ISOTOPES
+    },
+    "moles_1H": lambda _, __: Moles1H,
+    "moles_16O": lambda _, __: Moles16O,
+    "moles light water": lambda _, __: MolesLightWater,
 }
 
 

PySDM-2.34/PySDM/attributes/isotopes/__init__.py

@@ -0,0 +1,4 @@
+"""
+isotopic fractionation related attributes
+"""
+from .moles_light_isotopes import Moles1H, Moles16O, MolesLightWater

PySDM-2.34/PySDM/attributes/isotopes/delta.py

@@ -0,0 +1,44 @@
+"""
+per-droplet isotopic ratio of heavy-to-light isotope number concentrations
+expressed vs the VSMOW reference in SI units (i.e., not per mille)
+"""
+from PySDM.attributes.impl.derived_attribute import DerivedAttribute
+
+
+class DeltaImpl(DerivedAttribute):
+    def __init__(self, builder, *, heavy_isotope):
+        assert heavy_isotope[:-1].isnumeric()
+        if heavy_isotope[-1] == "H":
+            light_isotope = "1H"
+        elif heavy_isotope[-1] == "O":
+            light_isotope = "16O"
+        else:
+            raise NotImplementedError()
+
+        self.heavy_isotope = builder.get_attribute("moles_" + heavy_isotope)
+        self.light_isotope = builder.get_attribute(f"moles_{light_isotope}")
+        super().__init__(
+            builder,
+            name="delta_" + heavy_isotope,
+            dependencies=(
+                self.heavy_isotope,
+                self.light_isotope,
+            ),
+        )
+
+        self.reference_ratio = getattr(
+            self.formulae.constants, f"VSMOW_R_{heavy_isotope}"
+        )
+
+    def recalculate(self):
+        self.data.ratio(self.heavy_isotope.get(), self.light_isotope.get())
+        self.particulator.backend.isotopic_delta(
+            self.data, self.data, self.reference_ratio
+        )
+
+
+def make_delta_factory(what):
+    def _factory(builder):
+        return DeltaImpl(builder, heavy_isotope=what)
+
+    return _factory

PySDM-2.34/PySDM/attributes/isotopes/moles_light_isotopes.py

@@ -0,0 +1,91 @@
+"""
+derived attributes providing amounts of light isotopes in water (1H and 16O)
+
+        (water mass) = (
+            moles_H2O * (2 * molar_mass_1H + molar_mass_16O) +
+            moles_2H *  (molar_mass_1H + molar_mass_2H + molar_mass_16O) +
+            moles_3H *  (molar_mass_1H + molar_mass_3H + molar_mass_16O) +
+            moles_17O * (2 * molar_mass_1H + molar_mass_17O) +
+            moles_18O * (2 * molar_mass_1H + molar_mass_18O)
+        )
+
+        moles_H2O = (
+            water_mass
+            - moles_2H *  (molar_mass_1H + molar_mass_2H + molar_mass_16O)
+            - moles_3H *  (molar_mass_1H + molar_mass_3H + molar_mass_16O)
+            - moles_17O * (2 * molar_mass_1H + molar_mass_17O)
+            - moles_18O * (2 * molar_mass_1H + molar_mass_18O)
+        ) / (2 * molar_mass_1H + molar_mass_16O)
+
+        moles_1H = 2 * (moles_H2O + moles_17O + moles_18O) + moles_2H + moles_3H
+        moles_16O =  .5 * (moles_2H + moles_3H) + moles_H2O
+"""
+from PySDM.attributes.impl import DerivedAttribute
+
+
+class Helper(DerivedAttribute):
+    def __init__(self, builder, name, attrs_to_multiplier):
+        self.attrs_to_multiplier = attrs_to_multiplier
+        super().__init__(
+            builder=builder,
+            name=name,
+            dependencies=attrs_to_multiplier.keys(),
+        )
+
+    def recalculate(self):
+        self.data.fill(0)
+        for attr, mult in self.attrs_to_multiplier.items():
+            self.data += (mult, "*", attr.data)
+
+
+class MolesLightWater(Helper):
+    def __init__(self, builder):
+        const = builder.formulae.constants
+        M_H2O = 2 * const.M_1H + const.M_16O
+        super().__init__(
+            builder=builder,
+            name="moles light water",
+            attrs_to_multiplier={
+                builder.get_attribute("moles_2H"): -(
+                    const.M_1H * const.M_2H + const.M_16O
+                )
+                / M_H2O,
+                builder.get_attribute("moles_3H"): -(
+                    const.M_1H * const.M_3H + const.M_16O
+                )
+                / M_H2O,
+                builder.get_attribute("moles_17O"): -(2 * const.M_1H + const.M_17O)
+                / M_H2O,
+                builder.get_attribute("moles_18O"): -(2 * const.M_1H + const.M_18O)
+                / M_H2O,
+                builder.get_attribute("water mass"): 1 / M_H2O,
+            },
+        )
+
+
+class Moles1H(Helper):
+    def __init__(self, builder):
+        super().__init__(
+            builder=builder,
+            name="moles_1H",
+            attrs_to_multiplier={
+                builder.get_attribute("moles_17O"): 2.0,
+                builder.get_attribute("moles_18O"): 2.0,
+                builder.get_attribute("moles_2H"): 1.0,
+                builder.get_attribute("moles_3H"): 1.0,
+                builder.get_attribute("moles light water"): 2.0,
+            },
+        )
+
+
+class Moles16O(Helper):
+    def __init__(self, builder):
+        super().__init__(
+            builder=builder,
+            name="moles_16O",
+            attrs_to_multiplier={
+                builder.get_attribute("moles_2H"): 0.5,
+                builder.get_attribute("moles_3H"): 0.5,
+                builder.get_attribute("moles light water"): 1.0,
+            },
+        )

PySDM-2.34/PySDM/backends/impl_numba/methods/isotope_methods.py

@@ -0,0 +1,28 @@
+"""
+CPU implementation of isotope-relates backend methods
+"""
+from functools import cached_property
+
+import numba
+
+from PySDM.backends.impl_common.backend_methods import BackendMethods
+from PySDM.backends.impl_numba import conf
+
+
+class IsotopeMethods(BackendMethods):
+    @cached_property
+    def __isotopic_delta_body(self):
+        phys_isotopic_delta = self.formulae.trivia.isotopic_ratio_2_delta
+
+        @numba.njit(**{**conf.JIT_FLAGS, "fastmath": self.formulae.fastmath})
+        def isotopic_delta(output, ratio, reference_ratio):
+            for i in numba.prange(output.shape[0]):  # pylint: disable=not-an-iterable
+                output[i] = phys_isotopic_delta(ratio[i], reference_ratio)
+
+        return isotopic_delta
+
+    def isotopic_delta(self, output, ratio, reference_ratio):
+        self.__isotopic_delta_body(output.data, ratio.data, reference_ratio)
+
+    def isotopic_fractionation(self):
+        pass

{PySDM-2.33 → PySDM-2.34}/PySDM/backends/impl_numba/methods/physics_methods.py

@@ -75,14 +75,14 @@ class PhysicsMethods(BackendMethods):
             for i in prange(volume.shape[0]):  # pylint: disable=not-an-iterable
                 volume[i] = phys_mass_to_volume(mass[i])
 
-        self.volume_of_mass = volume_of_mass
+        self.volume_of_mass_body = volume_of_mass
 
         @numba.njit(**{**conf.JIT_FLAGS, "fastmath": self.formulae.fastmath})
         def mass_of_volume(mass, volume):
             for i in prange(volume.shape[0]):  # pylint: disable=not-an-iterable
                 mass[i] = phys_volume_to_mass(volume[i])
 
-        self.mass_of_volume = mass_of_volume
+        self.mass_of_volume_body = mass_of_volume
 
     def temperature_pressure_RH(
         self, *, rhod, thd, water_vapour_mixing_ratio, T, p, RH
@@ -120,7 +120,7 @@ class PhysicsMethods(BackendMethods):
         )
 
     def volume_of_water_mass(self, volume, mass):
-        self.volume_of_mass(volume.data, mass.data)
+        self.volume_of_mass_body(volume.data, mass.data)
 
     def mass_of_water_volume(self, mass, volume):
-        self.mass_of_volume(mass.data, volume.data)
+        self.mass_of_volume_body(mass.data, volume.data)

{PySDM-2.33 → PySDM-2.34}/PySDM/backends/impl_numba/storage.py

@@ -60,6 +60,14 @@ class Storage(StorageBase):
     def __iadd__(self, other):
         if isinstance(other, Storage):
             impl.add(self.data, other.data)
+        elif (
+            isinstance(other, tuple)
+            and len(other) == 3
+            and isinstance(other[0], float)
+            and other[1] == "*"
+            and isinstance(other[2], Storage)
+        ):
+            impl.add_with_multiplier(self.data, other[2].data, other[0])
         else:
             impl.add(self.data, other)
         return self

{PySDM-2.33 → PySDM-2.34}/PySDM/backends/impl_numba/storage_impl.py

@@ -12,6 +12,11 @@ def add(output, addend):
     output += addend
 
 
+@numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
+def add_with_multiplier(output, addend, multiplier):
+    output += multiplier * addend
+
+
 @numba.njit(**conf.JIT_FLAGS)
 def amin(data):
     return np.amin(data)

PySDM-2.34/PySDM/backends/impl_thrust_rtc/methods/isotope_methods.py

@@ -0,0 +1,38 @@
+"""
+GPU implementation of isotope-relates backend methods
+"""
+from functools import cached_property
+
+from PySDM.backends.impl_thrust_rtc.conf import NICE_THRUST_FLAGS
+from PySDM.backends.impl_thrust_rtc.nice_thrust import nice_thrust
+
+from ..conf import trtc
+from ..methods.thrust_rtc_backend_methods import ThrustRTCBackendMethods
+
+
+class IsotopeMethods(ThrustRTCBackendMethods):
+    @cached_property
+    def __isotopic_delta(self):
+        return trtc.For(
+            param_names=("output", "ratio", "reference_ratio"),
+            name_iter="i",
+            body=f"""
+            output[i] = {self.formulae.trivia.isotopic_ratio_2_delta.c_inline(
+                ratio="ratio[i]",
+                reference_ratio="reference_ratio"
+            )};
+            """.replace(
+                "real_type", self._get_c_type()
+            ),
+        )
+
+    @nice_thrust(**NICE_THRUST_FLAGS)
+    def isotopic_delta(self, output, ratio, reference_ratio):
+        self.__isotopic_delta.launch_n(
+            n=output.shape[0],
+            args=(output.data, ratio.data, self._get_floating_point(reference_ratio)),
+        )
+
+    @nice_thrust(**NICE_THRUST_FLAGS)
+    def isotopic_fractionation(self):
+        pass

{PySDM-2.33 → PySDM-2.34}/PySDM/backends/impl_thrust_rtc/methods/physics_methods.py

@@ -161,8 +161,10 @@ class PhysicsMethods(ThrustRTCBackendMethods):
         dy_dt = self._get_floating_point(dy_dt)
         self.__explicit_euler_body.launch_n(y.shape[0], (y.data, dt, dy_dt))
 
+    @nice_thrust(**NICE_THRUST_FLAGS)
     def volume_of_water_mass(self, volume, mass):
         self.__volume_of_mass_body.launch_n(volume.shape[0], (volume.data, mass.data))
 
+    @nice_thrust(**NICE_THRUST_FLAGS)
     def mass_of_water_volume(self, mass, volume):
         self.__mass_of_volume_body.launch_n(mass.shape[0], (mass.data, volume.data))

{PySDM-2.33 → PySDM-2.34}/PySDM/backends/impl_thrust_rtc/storage.py

@@ -37,6 +37,14 @@ def make_storage_class(BACKEND):  # pylint: disable=too-many-statements
             """,
         )
 
+        __add_elementwise_with_multiplier_body = trtc.For(
+            ("output", "addend", "multiplier"),
+            "i",
+            """
+                output[i] += multiplier * addend[i];
+            """,
+        )
+
         __add_body = trtc.For(
             ["output", "addend"],
             "i",
@@ -48,11 +56,21 @@ def make_storage_class(BACKEND):  # pylint: disable=too-many-statements
         @staticmethod
         @nice_thrust(**NICE_THRUST_FLAGS)
         def add(output, addend):
+            args = (output, addend)
             if hasattr(addend, "data"):
                 loop = Impl.__add_elementwise_body
+            elif (
+                isinstance(addend, tuple)
+                and len(addend) == 3
+                and isinstance(addend[0], float)
+                and addend[1] == "*"
+                and isinstance(addend[2], Storage)
+            ):
+                loop = Impl.__add_elementwise_with_multiplier_body
+                args = (output, addend[2], addend[0])
             else:
                 loop = Impl.__add_body
-            loop.launch_n(output.shape[0], Impl.thrust((output, addend)))
+            loop.launch_n(n=output.shape[0], args=Impl.thrust(args))
 
         @staticmethod
         @nice_thrust(**NICE_THRUST_FLAGS)

{PySDM-2.33 → PySDM-2.34}/PySDM/backends/numba.py

@@ -8,6 +8,7 @@ from PySDM.backends.impl_numba.methods.condensation_methods import CondensationM
 from PySDM.backends.impl_numba.methods.displacement_methods import DisplacementMethods
 from PySDM.backends.impl_numba.methods.freezing_methods import FreezingMethods
 from PySDM.backends.impl_numba.methods.index_methods import IndexMethods
+from PySDM.backends.impl_numba.methods.isotope_methods import IsotopeMethods
 from PySDM.backends.impl_numba.methods.moments_methods import MomentsMethods
 from PySDM.backends.impl_numba.methods.pair_methods import PairMethods
 from PySDM.backends.impl_numba.methods.physics_methods import PhysicsMethods
@@ -30,6 +31,7 @@ class Numba(  # pylint: disable=too-many-ancestors,duplicate-code
     FreezingMethods,
     DisplacementMethods,
     TerminalVelocityMethods,
+    IsotopeMethods,
 ):
     Storage = ImportedStorage
     Random = ImportedRandom

{PySDM-2.33 → PySDM-2.34}/PySDM/backends/thrust_rtc.py

@@ -17,6 +17,7 @@ from PySDM.backends.impl_thrust_rtc.methods.displacement_methods import (
 )
 from PySDM.backends.impl_thrust_rtc.methods.freezing_methods import FreezingMethods
 from PySDM.backends.impl_thrust_rtc.methods.index_methods import IndexMethods
+from PySDM.backends.impl_thrust_rtc.methods.isotope_methods import IsotopeMethods
 from PySDM.backends.impl_thrust_rtc.methods.moments_methods import MomentsMethods
 from PySDM.backends.impl_thrust_rtc.methods.pair_methods import PairMethods
 from PySDM.backends.impl_thrust_rtc.methods.physics_methods import PhysicsMethods
@@ -38,6 +39,7 @@ class ThrustRTC(  # pylint: disable=duplicate-code,too-many-ancestors
     DisplacementMethods,
     TerminalVelocityMethods,
     FreezingMethods,
+    IsotopeMethods,
 ):
     ENABLE = True
     Random = ImportedRandom

{PySDM-2.33 → PySDM-2.34}/PySDM/dynamics/__init__.py

@@ -3,6 +3,9 @@ Classes representing physicochemical processes:
 `PySDM.dynamics.collisions.collision.Collision`,
 `PySDM.dynamics.condensation.Condensation`, ...
 """
+from PySDM.dynamics.isotopic_fractionation import IsotopicFractionation
+
+# isort: split
 from PySDM.dynamics.ambient_thermodynamics import AmbientThermodynamics
 from PySDM.dynamics.aqueous_chemistry import AqueousChemistry
 from PySDM.dynamics.collisions import Breakup, Coalescence, Collision

{PySDM-2.33 → PySDM-2.34}/PySDM/dynamics/impl/chemistry_utils.py

@@ -5,8 +5,7 @@ aqueous chemistry helper utils including specific gravity constants with
 import numpy as np
 from chempy import Substance
 
-from PySDM.physics import si
-from PySDM.physics.constants import K_H2O, M
+from PySDM.physics.constants import K_H2O, M, si
 
 
 class EqConst:  # pylint: disable=too-few-public-methods

PySDM-2.34/PySDM/dynamics/isotopic_fractionation.py

@@ -0,0 +1,38 @@
+"""
+resolves fractionation of water molecules across different isotopologues
+requires condensation dynamic to be registered (and run beforehand)
+"""
+
+from PySDM.dynamics.condensation import Condensation
+
+LIGHT_ISOTOPES = ("1H", "16O")
+HEAVY_ISOTOPES = ("2H", "3H", "17O", "18O")
+
+
+class IsotopicFractionation:
+    def __init__(self, isotopes: tuple = HEAVY_ISOTOPES):
+        self.isotopes = isotopes
+        self.particulator = None
+
+    def register(self, builder):
+        self.particulator = builder.particulator
+
+        try:
+            ix_cond = list(builder.particulator.dynamics.keys()).index(
+                Condensation.__name__
+            )
+        except ValueError:
+            ix_cond = -1
+        ix_self = list(builder.particulator.dynamics.keys()).index(
+            self.__class__.__name__
+        )
+        if ix_cond == -1 or ix_cond > ix_self:
+            raise AssertionError(
+                f"{Condensation.__name__} needs to be registered to run prior to {self.__class__}"
+            )
+
+        for isotope in self.isotopes:
+            builder.request_attribute(f"moles_{isotope}")
+
+    def __call__(self):
+        self.particulator.isotopic_fractionation()

{PySDM-2.33 → PySDM-2.34}/PySDM/formulae.py

@@ -44,6 +44,9 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
         freezing_temperature_spectrum: str = "Null",
         heterogeneous_ice_nucleation_rate: str = "Null",
         fragmentation_function: str = "AlwaysN",
+        isotope_equilibrium_fractionation_factors: str = "Null",
+        isotope_meteoric_water_line_excess: str = "Null",
+        isotope_ratio_evolution: str = "Null",
         particle_shape_and_density: str = "LiquidSpheres",
         terminal_velocity: str = "GunnKinzer1949",
         handle_all_breakups: bool = False,
@@ -65,6 +68,11 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
         self.freezing_temperature_spectrum = freezing_temperature_spectrum
         self.heterogeneous_ice_nucleation_rate = heterogeneous_ice_nucleation_rate
         self.fragmentation_function = fragmentation_function
+        self.isotope_equilibrium_fractionation_factors = (
+            isotope_equilibrium_fractionation_factors
+        )
+        self.isotope_meteoric_water_line_excess = isotope_meteoric_water_line_excess
+        self.isotope_ratio_evolution = isotope_ratio_evolution
         self.particle_shape_and_density = particle_shape_and_density
 
         components = tuple(i for i in dir(self) if not i.startswith("__"))
@@ -73,10 +81,14 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
             k: getattr(defaults, k)
             for defaults in (physics.constants, physics.constants_defaults)
             for k in dir(defaults)
-            if isinstance(getattr(defaults, k), (numbers.Number, pint.Quantity))
+            if isinstance(
+                getattr(defaults, k), (numbers.Number, pint.Quantity, pint.Unit)
+            )
         }
+        constants_defaults = {**constants_defaults, **(constants or {})}
+        physics.constants_defaults.compute_derived_values(constants_defaults)
         constants = namedtuple("Constants", tuple(constants_defaults.keys()))(
-            **{**constants_defaults, **(constants or {})}
+            **constants_defaults
         )
         self.constants = constants
         self.seed = seed or physics.constants.default_random_seed

{PySDM-2.33 → PySDM-2.34}/PySDM/particulator.py

@@ -438,3 +438,8 @@ class Particulator:  # pylint: disable=too-many-public-methods,too-many-instance
                 position_in_cell=position_in_cell,
                 n_substeps=n_substeps,
             )
+
+    def isotopic_fractionation(self, heavy_isotopes: tuple):
+        self.backend.isotopic_fractionation()
+        for isotope in heavy_isotopes:
+            self.attributes.mark_updated(f"moles_{isotope}")

{PySDM-2.33 → PySDM-2.34}/PySDM/physics/__init__.py

@@ -15,6 +15,9 @@ from . import (
     hydrostatics,
     hygroscopicity,
     impl,
+    isotope_equilibrium_fractionation_factors,
+    isotope_meteoric_water_line_excess,
+    isotope_ratio_evolution,
     latent_heat,
     particle_advection,
     particle_shape_and_density,
@@ -24,4 +27,4 @@ from . import (
     trivia,
     ventilation,
 )
-from .constants import si
+from .constants import convert_to, in_unit, si

{PySDM-2.33 → PySDM-2.34}/PySDM/physics/constants.py

@@ -22,6 +22,10 @@ def convert_to(value, unit):
     value /= unit
 
 
+def in_unit(value, unit):
+    return value / unit
+
+
 sqrt_two = np.sqrt(2)
 sqrt_pi = np.sqrt(sci.pi)
 PI = sci.pi
@@ -48,6 +52,10 @@ PPT = 1e-12
 PPB = 1e-9
 PPM = 1e-6
 
+PER_CENT = 1e-2
+PER_MILLE = 1e-3
+PER_MEG = PPM
+
 T0 = sci.zero_Celsius * si.kelvin
 
 # there are so few water ions instead of K we have K [H2O] (see Seinfeld & Pandis p 345)