PySDM 2.32__tar.gz → 2.34__tar.gz

{PySDM-2.32 → 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.32 → PySDM-2.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.32
+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
@@ -251,8 +251,8 @@ Description: # PySDM
         
         radius_bins_edges = 10 .^ range(log10(10*si.um), log10(5e3*si.um), length=32) 
         
-        builder = Builder(n_sd=n_sd, backend=CPU())
-        builder.set_environment(Box(dt=1 * si.s, dv=1e6 * si.m^3))
+        env = Box(dt=1 * si.s, dv=1e6 * si.m^3)
+        builder = Builder(n_sd=n_sd, backend=CPU(), environment=env)
         builder.add_dynamic(Coalescence(collision_kernel=Golovin(b=1.5e3 / si.s)))
         products = [ParticleVolumeVersusRadiusLogarithmSpectrum(radius_bins_edges=radius_bins_edges, name="dv/dlnr")] 
         particulator = builder.build(attributes, products)
@@ -271,8 +271,8 @@ Description: # PySDM
         
         radius_bins_edges = logspace(log10(10 * si.um), log10(5e3 * si.um), 32);
         
-        builder = Builder(pyargs('n_sd', int32(n_sd), 'backend', CPU()));
-        builder.set_environment(Box(pyargs('dt', 1 * si.s, 'dv', 1e6 * si.m ^ 3)));
+        env = Box(pyargs('dt', 1 * si.s, 'dv', 1e6 * si.m ^ 3));
+        builder = Builder(pyargs('n_sd', int32(n_sd), 'backend', CPU(), 'environment', env));
         builder.add_dynamic(Coalescence(pyargs('collision_kernel', Golovin(1.5e3 / si.s))));
         products = py.list({ ParticleVolumeVersusRadiusLogarithmSpectrum(pyargs( ...
           'radius_bins_edges', py.numpy.array(radius_bins_edges), ...
@@ -295,8 +295,8 @@ Description: # PySDM
         
         radius_bins_edges = np.logspace(np.log10(10 * si.um), np.log10(5e3 * si.um), num=32)
         
-        builder = Builder(n_sd=n_sd, backend=CPU())
-        builder.set_environment(Box(dt=1 * si.s, dv=1e6 * si.m ** 3))
+        env = Box(dt=1 * si.s, dv=1e6 * si.m ** 3)
+        builder = Builder(n_sd=n_sd, backend=CPU(), environment=env)
         builder.add_dynamic(Coalescence(collision_kernel=Golovin(b=1.5e3 / si.s)))
         products = [ParticleVolumeVersusRadiusLogarithmSpectrum(radius_bins_edges=radius_bins_edges, name='dv/dlnr')]
         particulator = builder.build(attributes, products)
@@ -398,14 +398,13 @@ Description: # PySDM
             COAL[":Coalescence"] --->|passed as arg to| BUILDER_ADD_DYN(["Builder.add_dynamic()"])
             BUILDER_INSTANCE["builder :Builder"] -...-|has a method| BUILDER_BUILD(["Builder.build()"])
             ATTRIBUTES[attributes: dict] -->|passed as arg to| BUILDER_BUILD
-            N_SD["n_sd :int"] -->|passed as arg to| BUILDER_INIT
-            BUILDER_INSTANCE -..-|has a method| BUILDER_SET_ENV(["Builder.set_environment()"])
-            BUILDER_INIT(["Builder.__init__()"]) ----->|instantiates| BUILDER_INSTANCE
+            N_SD["n_sd :int"] ---->|passed as arg to| BUILDER_INIT
+            BUILDER_INIT(["Builder.__init__()"]) --->|instantiates| BUILDER_INSTANCE
             BUILDER_INSTANCE -..-|has a method| BUILDER_ADD_DYN(["Builder.add_dynamic()"])
-            ENV_INIT(["Box.__init__()"]) --->|instantiates| ENV
-            DT[dt :float] ----->|passed as arg to| ENV_INIT
-            DV[dv :float] ----->|passed as arg to| ENV_INIT
-            ENV[":Box"] -->|passed as arg to| BUILDER_SET_ENV
+            ENV_INIT(["Box.__init__()"]) -->|instantiates| ENV
+            DT[dt :float] -->|passed as arg to| ENV_INIT
+            DV[dv :float] -->|passed as arg to| ENV_INIT
+            ENV[":Box"] -->|passed as arg to| BUILDER_INIT
             B["b: float"] --->|passed as arg to| KERNEL_INIT(["Golovin.__init__()"])
             KERNEL_INIT -->|instantiates| KERNEL
             KERNEL[collision_kernel: Golovin] -->|passed as arg to| COAL_INIT(["Coalesncence.__init__()"])
@@ -424,7 +423,7 @@ Description: # PySDM
             volume -->|added as element of| ATTRIBUTES
             BUILDER_BUILD -->|returns| PARTICULATOR_INSTANCE["particulator :Particulator"]
             PARTICULATOR_INSTANCE -.-|has a field| PARTICULATOR_PROD(["Particulator.products:dict"])
-            BACKEND_INSTANCE["backend :CPU"] -->|passed as arg to| BUILDER_INIT
+            BACKEND_INSTANCE["backend :CPU"] ---->|passed as arg to| BUILDER_INIT
             PRODUCTS -.-|accessible via| PARTICULATOR_PROD
             NP_LOGSPACE(["np.logspace()"]) -->|returns| EDGES 
             EDGES[radius_bins_edges: np.ndarray] -->|passed as arg to| SPECTRUM_INIT
@@ -435,7 +434,6 @@ Description: # PySDM
             click BUILDER_INSTANCE "https://open-atmos.github.io/PySDM/PySDM/builder.html"
             click BUILDER_INIT "https://open-atmos.github.io/PySDM/PySDM/builder.html"
             click BUILDER_ADD_DYN "https://open-atmos.github.io/PySDM/PySDM/builder.html"
-            click BUILDER_SET_ENV "https://open-atmos.github.io/PySDM/PySDM/builder.html"
             click ENV_INIT "https://open-atmos.github.io/PySDM/PySDM/environments/index.html"
             click ENV "https://open-atmos.github.io/PySDM/PySDM/environments/index.html"
             click KERNEL_INIT "https://open-atmos.github.io/PySDM/PySDM/dynamics/collisions/collision_kernels/index.html"
@@ -506,8 +504,7 @@ Description: # PySDM
         n_sd = 256
         
         formulae = Formulae()
-        builder = Builder(backend=CPU(formulae), n_sd=n_sd)
-        builder.set_environment(env)
+        builder = Builder(backend=CPU(formulae), n_sd=n_sd, environment=env)
         builder.add_dynamic(AmbientThermodynamics())
         builder.add_dynamic(Condensation())
         
@@ -588,8 +585,7 @@ Description: # PySDM
         n_sd = 256;
         
         formulae = Formulae();
-        builder = Builder(pyargs('backend', CPU(formulae), 'n_sd', int32(n_sd)));
-        builder.set_environment(env);
+        builder = Builder(pyargs('backend', CPU(formulae), 'n_sd', int32(n_sd), 'environment', env));
         builder.add_dynamic(AmbientThermodynamics());
         builder.add_dynamic(Condensation());
         
@@ -689,8 +685,7 @@ Description: # PySDM
         n_sd = 256
         
         formulae = Formulae()
-        builder = Builder(backend=CPU(formulae), n_sd=n_sd)
-        builder.set_environment(env)
+        builder = Builder(backend=CPU(formulae), n_sd=n_sd, environment=env)
         builder.add_dynamic(AmbientThermodynamics())
         builder.add_dynamic(Condensation())
         

{PySDM-2.32 → 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.32 → 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.32 → 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.32 → 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.32 → 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.32 → 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.32 → 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.32 → 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.32 → 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.32 → PySDM-2.34}/PySDM/builder.py

@@ -19,8 +19,15 @@ from PySDM.particulator import Particulator
 from PySDM.physics.particle_shape_and_density import LiquidSpheres, MixedPhaseSpheres
 
 
+def _warn_env_as_ctor_arg():
+    warnings.warn(
+        "PySDM > v2.31 Builder expects environment instance as argument",
+        DeprecationWarning,
+    )
+
+
 class Builder:
-    def __init__(self, n_sd, backend):
+    def __init__(self, n_sd, backend, environment=None):
         assert not inspect.isclass(backend)
         self.formulae = backend.formulae
         self.particulator = Particulator(n_sd, backend)
@@ -32,10 +39,19 @@ class Builder:
         self.aerosol_radius_threshold = 0
         self.condensation_params = None
 
+        if environment is None:
+            _warn_env_as_ctor_arg()
+        else:
+            self._set_environment(environment)
+
     def _set_condensation_parameters(self, **kwargs):
         self.condensation_params = kwargs
 
     def set_environment(self, environment):
+        _warn_env_as_ctor_arg()
+        self._set_environment(environment)
+
+    def _set_environment(self, environment):
         if self.particulator.environment is not None:
             raise AssertionError("environment has already been set")
         self.particulator.environment = environment

{PySDM-2.32 → 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.32 → 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()