PySDM 2.67__tar.gz → 2.68__tar.gz

{PySDM-2.67 → PySDM-2.68}/.github/workflows/tests+artifacts+pypi.yml

@@ -31,6 +31,7 @@ jobs:
         run: git diff
 
   nojit_and_codecov:
+    needs: [precommit, pylint]
     runs-on: ubuntu-latest
     env:
       NUMBA_DISABLE_JIT: 1
@@ -120,7 +121,7 @@ jobs:
           prop_path: 'creators'
 
   tests:
-    needs: [pylint, pdoc, nojit_and_codecov, precommit, zenodo_json]
+    needs: [pdoc, nojit_and_codecov, zenodo_json]
     strategy:
       matrix:
         platform: [ubuntu-latest, macos-12, windows-latest]
@@ -173,6 +174,7 @@ jobs:
 #           limit-access-to-actor: true
 
   examples-setup:
+    needs: [nojit_and_codecov]
     strategy:
       matrix:
         platform: [ubuntu-22.04, macos-12, windows-latest]
@@ -208,7 +210,7 @@ jobs:
           key: examples_pip_cache-${{ matrix.platform }}-${{ matrix.python-version }}-${{ env.toml_ci_md5 }}
 
   examples:
-    needs: [pylint, precommit, examples-setup]
+    needs: [examples-setup]
     strategy:
       matrix:
         platform: [ubuntu-22.04, macos-12, windows-latest]

{PySDM-2.67 → PySDM-2.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.67
+Version: 2.68
 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.67 → PySDM-2.68}/PySDM/builder.py

@@ -29,11 +29,8 @@ class Builder:
         assert not inspect.isclass(backend)
         self.formulae = backend.formulae
         self.particulator = Particulator(n_sd, backend)
-        self.req_attr = {
-            "multiplicity": get_attribute_class("multiplicity")(self),
-            "water mass": get_attribute_class("water mass")(self),
-            "cell id": get_attribute_class("cell id")(self),
-        }
+        self.req_attr_names = ["multiplicity", "water mass", "cell id"]
+        self.req_attr = None
         self.aerosol_radius_threshold = 0
         self.condensation_params = None
 
@@ -57,34 +54,38 @@ class Builder:
 
     def add_dynamic(self, dynamic):
         assert self.particulator.environment is not None
-        key = get_key(dynamic)
+        key = inspect.getmro(type(dynamic))[-2].__name__
         assert key not in self.particulator.dynamics
         self.particulator.dynamics[key] = dynamic
 
-    def replace_dynamic(self, dynamic):
-        key = get_key(dynamic)
-        assert key in self.particulator.dynamics
-        self.particulator.dynamics.pop(key)
-        self.add_dynamic(dynamic)
-
-    def register_product(self, product, buffer):
+    def _register_product(self, product, buffer):
         if product.name in self.particulator.products:
             raise ValueError(f'product name "{product.name}" already registered')
         product.set_buffer(buffer)
         product.register(self)
         self.particulator.products[product.name] = product
 
+    def _resolve_attribute(self, attr_name):
+        if attr_name not in self.req_attr:
+            self.req_attr[attr_name] = get_attribute_class(
+                attr_name,
+                self.particulator.dynamics.keys(),
+                self.formulae,
+            )(self)
+            assert self.req_attr is not None
+
     def get_attribute(self, attribute_name):
-        self.request_attribute(attribute_name)
+        """intended for obtaining attribute instances during build() logic,
+        from within register() methods"""
+        self._resolve_attribute(attribute_name)
         return self.req_attr[attribute_name]
 
-    def request_attribute(self, attribute, variant=None):
-        if attribute not in self.req_attr:
-            self.req_attr[attribute] = get_attribute_class(
-                attribute, self.particulator.dynamics, self.formulae
-            )(self)
-        if variant is not None:
-            assert variant == self.req_attr[attribute]
+    def request_attribute(self, attribute_name):
+        """can be called either before or during build()"""
+        if self.req_attr_names is not None:
+            self.req_attr_names.append(attribute_name)
+        else:
+            self._resolve_attribute(attribute_name)
 
     def build(
         self,
@@ -115,12 +116,17 @@ class Builder:
             del attributes["volume"]
             self.request_attribute("volume")
 
+        self.req_attr = {}
+        for attr_name in self.req_attr_names:
+            self._resolve_attribute(attr_name)
+        self.req_attr_names = None
+
         for dynamic in self.particulator.dynamics.values():
             dynamic.register(self)
 
         single_buffer_for_all_products = np.empty(self.particulator.mesh.grid)
         for product in products:
-            self.register_product(product, single_buffer_for_all_products)
+            self._register_product(product, single_buffer_for_all_products)
 
         for attribute in attributes:
             self.request_attribute(attribute)
@@ -146,7 +152,3 @@ class Builder:
             self.particulator.timers[key] = WallTimer()
 
         return self.particulator
-
-
-def get_key(dynamic):
-    return inspect.getmro(type(dynamic))[-2].__name__

{PySDM-2.67 → PySDM-2.68}/PySDM/dynamics/relaxed_velocity.py

@@ -12,8 +12,6 @@ class RelaxedVelocity:  # pylint: disable=too-many-instance-attributes
     """
     A dynamic which updates the fall momentum according to a relaxation timescale
     proportional to the sqrt of the droplet radius.
-
-    Should be added first in order to ensure the correct attributes are selected.
     """
 
     def __init__(self, c: float = 8, constant: bool = False):

{PySDM-2.67 → PySDM-2.68}/PySDM.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.67
+Version: 2.68
 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.68/tests/unit_tests/attributes/test_fall_velocity.py

@@ -0,0 +1,176 @@
+"""
+Test `PySDM.attributes.physics.relative_fall_velocity.RelativeFallVelocity`
+and `PySDM.attributes.physics.relative_fall_velocity.RelativeFallMomentum` attributes
+"""
+
+import numpy as np
+import pytest
+
+from PySDM.attributes.physics import RelativeFallVelocity, TerminalVelocity
+from PySDM.builder import Builder
+from PySDM.dynamics import Coalescence, RelaxedVelocity
+from PySDM.dynamics.collisions.collision_kernels.constantK import ConstantK
+from PySDM.environments.box import Box
+from PySDM.physics import si
+
+
+def generate_rand_attr_param(n_sd):
+    np.random.seed(12)
+
+    return pytest.param(
+        {
+            "volume": (3 * np.random.random(n_sd) + 1) * si.mm**3,
+            "multiplicity": np.random.randint(100, 1000, n_sd),
+            "relative fall momentum": (5 * np.random.random(n_sd) + 1) * 1e-6,
+        },
+        id=f"random(n_sd={n_sd})",
+    )
+
+
+@pytest.fixture(
+    name="default_attributes",
+    params=(
+        pytest.param(
+            {
+                "volume": np.array([si.mm**3, 2 * si.mm**3]),
+                "multiplicity": np.array([1, 1]),
+                "relative fall momentum": np.array([10e-6, 6e-6]),
+            },
+            id="two_droplets",
+        ),
+        pytest.param(
+            {
+                "volume": np.array([si.mm**3, 2 * si.mm**3, 3 * si.mm**3]),
+                "multiplicity": np.array([2, 1, 4]),
+                "relative fall momentum": np.array([10e-6, 6e-6, 4e-6]),
+            },
+            id="fixed(n_sd=3)",
+        ),
+        generate_rand_attr_param(n_sd=100),
+    ),
+)
+def default_attributes_fixture(request):
+    return request.param
+
+
+class TestFallVelocity:
+    @staticmethod
+    def test_fall_velocity_calculation(default_attributes, backend_instance):
+        """
+        Test that fall velocity is the momentum divided by the mass.
+        """
+        env = Box(dt=1, dv=1)
+        builder = Builder(
+            n_sd=len(default_attributes["multiplicity"]),
+            backend=backend_instance,
+            environment=env,
+        )
+
+        # needed to use relative fall velocity instead of terminal
+        # velocity behind the scenes
+        builder.add_dynamic(RelaxedVelocity())
+
+        builder.request_attribute("relative fall velocity")
+
+        particulator = builder.build(attributes=default_attributes, products=())
+
+        assert np.allclose(
+            particulator.attributes["relative fall velocity"].to_ndarray(),
+            particulator.attributes["relative fall momentum"].to_ndarray()
+            / (particulator.attributes["water mass"].to_ndarray()),
+        )
+
+    @staticmethod
+    def test_conservation_of_momentum(default_attributes, backend_instance):
+        """
+        Test that conservation of momentum holds when many super-droplets coalesce
+        """
+        env = Box(dt=1, dv=1)
+        builder = Builder(
+            n_sd=len(default_attributes["multiplicity"]),
+            backend=backend_instance,
+            environment=env,
+        )
+
+        # add and remove relaxed velocity to prevent warning
+        builder.add_dynamic(RelaxedVelocity())
+
+        builder.request_attribute("relative fall momentum")
+
+        builder.add_dynamic(
+            Coalescence(collision_kernel=ConstantK(a=1), adaptive=False)
+        )
+
+        particulator = builder.build(attributes=default_attributes, products=())
+
+        particulator.dynamics.pop("RelaxedVelocity")
+
+        particulator.run(2)
+
+        total_initial_momentum = (
+            default_attributes["relative fall momentum"]
+            * default_attributes["multiplicity"]
+        ).sum()
+
+        total_final_momentum = (
+            particulator.attributes["relative fall momentum"].to_ndarray()
+            * particulator.attributes["multiplicity"].to_ndarray()
+        ).sum()
+
+        # assert that the total number of droplets changed
+        assert np.sum(particulator.attributes["multiplicity"].to_ndarray()) != np.sum(
+            default_attributes["multiplicity"]
+        )
+
+        # assert that the total momentum is conserved
+        assert np.isclose(total_final_momentum, total_initial_momentum)
+
+    @staticmethod
+    def test_attribute_selection(backend_instance):
+        """
+        Test that the correct velocity attribute is selected by the mapper.
+        `PySDM.attributes.physics.relative_fall_velocity.RelativeFallVelocity`
+        should only be selected when `PySDM.dynamics.RelaxedVelocity` dynamic exists.
+        """
+        env = Box(dt=1, dv=1)
+        builder_no_relax = Builder(n_sd=1, backend=backend_instance, environment=env)
+        builder_no_relax.request_attribute("relative fall velocity")
+        _ = builder_no_relax.build(
+            attributes={"multiplicity": np.ones(1), "water mass": np.zeros(1)},
+            products=(),
+        )
+
+        # with no RelaxedVelocity, the builder should use TerminalVelocity
+        assert isinstance(
+            builder_no_relax.req_attr["relative fall velocity"], TerminalVelocity
+        )
+        env = Box(dt=1, dv=1)
+        builder = Builder(n_sd=1, backend=backend_instance, environment=env)
+        builder.add_dynamic(RelaxedVelocity())
+        builder.request_attribute("relative fall velocity")
+        _ = builder.build(
+            attributes={
+                "multiplicity": np.ones(1),
+                "water mass": np.zeros(1),
+                "relative fall momentum": np.zeros(1),
+            },
+            products=(),
+        )
+
+        # with RelaxedVelocity, the builder should use RelativeFallVelocity
+        assert isinstance(
+            builder.req_attr["relative fall velocity"], RelativeFallVelocity
+        )
+
+        # requesting momentum with no dynamic issues a warning
+        env = Box(dt=1, dv=1)
+        builder = Builder(n_sd=1, backend=backend_instance, environment=env)
+        builder.request_attribute("relative fall momentum")
+        with pytest.warns(UserWarning):
+            _ = builder.build(
+                attributes={
+                    "multiplicity": np.ones(1),
+                    "water mass": np.zeros(1),
+                },
+                products=(),
+            )

{PySDM-2.67 → PySDM-2.68}/tests/unit_tests/dummy_particulator.py

@@ -1,8 +1,6 @@
 # pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring
 from PySDM.builder import Builder
 from PySDM.particulator import Particulator
-from PySDM.attributes.numerics import CellId
-from PySDM.attributes.physics import Multiplicity
 
 from .dummy_environment import DummyEnvironment
 
@@ -15,5 +13,5 @@ class DummyParticulator(Builder, Particulator):
         Particulator.__init__(self, n_sd, backend)
         self.environment = env
         self.particulator = self
-        self.req_attr = {"multiplicity": Multiplicity(self), "cell id": CellId(self)}
+        self.req_attr_names = ["multiplicity", "cell id"]
         self.attributes = None

{PySDM-2.67 → PySDM-2.68}/tests/unit_tests/dynamics/test_relaxed_velocity.py

@@ -167,8 +167,6 @@ def test_timescale(default_attributes, c, constant_timescale, backend_instance):
         environment=env,
     )
 
-    sqrt_radius_attr = builder.get_attribute("square root of radius")
-
     dyn = RelaxedVelocity(c=c, constant=constant_timescale)
     builder.add_dynamic(dyn)
 
@@ -177,6 +175,7 @@ def test_timescale(default_attributes, c, constant_timescale, backend_instance):
     )
 
     particulator = builder.build(attributes=default_attributes, products=())
+    sqrt_radius_attr = builder.get_attribute("square root of radius")
 
     tau_storage = particulator.Storage.empty(
         default_attributes["multiplicity"].shape, dtype=float

{PySDM-2.67 → PySDM-2.68}/tests/unit_tests/test_builder.py

@@ -1,9 +1,10 @@
 # pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring
 import numpy as np
+import pytest
 
 from PySDM import Builder
 from PySDM.backends import CPU
-from PySDM.dynamics import Condensation, Displacement
+from PySDM.dynamics import Condensation, Displacement, RelaxedVelocity
 from PySDM.environments import Box
 
 
@@ -50,20 +51,35 @@ class TestBuilder:
         _ = particulator.attributes["critical supersaturation"].to_ndarray()
 
     @staticmethod
-    def test_replace_dynamic():
+    @pytest.mark.parametrize(
+        "dynamics",
+        (
+            (RelaxedVelocity(), Displacement()),
+            (Displacement(), RelaxedVelocity()),
+        ),
+    )
+    def test_order_of_dynamic_registration_does_not_matter_for_attribute_mappings(
+        dynamics,
+    ):
         # arrange
-        env = Box(dt=-1, dv=np.nan)
-        builder = Builder(backend=CPU(), n_sd=1, environment=env)
-        builder.add_dynamic(Displacement(adaptive=False))
+        builder = Builder(backend=CPU(), n_sd=1, environment=Box(dt=-1, dv=np.nan))
+        for dynamic in dynamics:
+            builder.add_dynamic(dynamic)
 
-        # act
-        builder.replace_dynamic(Displacement(adaptive=True))
+        _ = builder.build(
+            products=(),
+            attributes={
+                k: np.asarray([0])
+                for k in ("multiplicity", "volume", "relative fall momentum")
+            },
+        )
 
-        # assert
+        # act
         assert (
-            "Condensation"
-            not in builder.build(
-                products=(),
-                attributes={k: np.asarray([0]) for k in ("multiplicity", "volume")},
-            ).dynamics
+            builder.get_attribute(
+                attribute_name="relative fall velocity"
+            ).__class__.__name__
+            == "RelativeFallVelocity"
         )
+
+        # assert

PySDM-2.67/tests/unit_tests/attributes/test_fall_velocity.py

@@ -1,151 +0,0 @@
-"""
-Test `PySDM.attributes.physics.relative_fall_velocity.RelativeFallVelocity`
-and `PySDM.attributes.physics.relative_fall_velocity.RelativeFallMomentum` attributes
-"""
-
-import numpy as np
-import pytest
-
-from PySDM.attributes.physics import RelativeFallVelocity, TerminalVelocity
-from PySDM.builder import Builder
-from PySDM.dynamics import Coalescence, RelaxedVelocity
-from PySDM.dynamics.collisions.collision_kernels.constantK import ConstantK
-from PySDM.environments.box import Box
-from PySDM.physics import si
-
-
-def generate_rand_attr_param(n_sd):
-    np.random.seed(12)
-
-    return pytest.param(
-        {
-            "volume": (3 * np.random.random(n_sd) + 1) * si.mm**3,
-            "multiplicity": np.random.randint(100, 1000, n_sd),
-            "relative fall momentum": (5 * np.random.random(n_sd) + 1) * 1e-6,
-        },
-        id=f"random(n_sd={n_sd})",
-    )
-
-
-@pytest.fixture(
-    name="default_attributes",
-    params=(
-        pytest.param(
-            {
-                "volume": np.array([si.mm**3, 2 * si.mm**3]),
-                "multiplicity": np.array([1, 1]),
-                "relative fall momentum": np.array([10e-6, 6e-6]),
-            },
-            id="two_droplets",
-        ),
-        pytest.param(
-            {
-                "volume": np.array([si.mm**3, 2 * si.mm**3, 3 * si.mm**3]),
-                "multiplicity": np.array([2, 1, 4]),
-                "relative fall momentum": np.array([10e-6, 6e-6, 4e-6]),
-            },
-            id="fixed(n_sd=3)",
-        ),
-        generate_rand_attr_param(n_sd=100),
-    ),
-)
-def default_attributes_fixture(request):
-    return request.param
-
-
-def test_fall_velocity_calculation(default_attributes, backend_instance):
-    """
-    Test that fall velocity is the momentum divided by the mass.
-    """
-    env = Box(dt=1, dv=1)
-    builder = Builder(
-        n_sd=len(default_attributes["multiplicity"]),
-        backend=backend_instance,
-        environment=env,
-    )
-
-    # needed to use relative fall velocity instead of terminal
-    # velocity behind the scenes
-    builder.add_dynamic(RelaxedVelocity())
-
-    builder.request_attribute("relative fall velocity")
-
-    particulator = builder.build(attributes=default_attributes, products=())
-
-    assert np.allclose(
-        particulator.attributes["relative fall velocity"].to_ndarray(),
-        particulator.attributes["relative fall momentum"].to_ndarray()
-        / (particulator.attributes["water mass"].to_ndarray()),
-    )
-
-
-def test_conservation_of_momentum(default_attributes, backend_instance):
-    """
-    Test that conservation of momentum holds when many super-droplets coalesce
-    """
-    env = Box(dt=1, dv=1)
-    builder = Builder(
-        n_sd=len(default_attributes["multiplicity"]),
-        backend=backend_instance,
-        environment=env,
-    )
-
-    # add and remove relaxed velocity to prevent warning
-    builder.add_dynamic(RelaxedVelocity())
-
-    builder.request_attribute("relative fall momentum")
-
-    builder.particulator.dynamics.pop("RelaxedVelocity")
-
-    builder.add_dynamic(Coalescence(collision_kernel=ConstantK(a=1), adaptive=False))
-
-    particulator = builder.build(attributes=default_attributes, products=())
-
-    particulator.run(2)
-
-    total_initial_momentum = (
-        default_attributes["relative fall momentum"]
-        * default_attributes["multiplicity"]
-    ).sum()
-
-    total_final_momentum = (
-        particulator.attributes["relative fall momentum"].to_ndarray()
-        * particulator.attributes["multiplicity"].to_ndarray()
-    ).sum()
-
-    # assert that the total number of droplets changed
-    assert np.sum(particulator.attributes["multiplicity"].to_ndarray()) != np.sum(
-        default_attributes["multiplicity"]
-    )
-
-    # assert that the total momentum is conserved
-    assert np.isclose(total_final_momentum, total_initial_momentum)
-
-
-def test_attribute_selection(backend_instance):
-    """
-    Test that the correct velocity attribute is selected by the mapper.
-    `PySDM.attributes.physics.relative_fall_velocity.RelativeFallVelocity`
-    should only be selected when `PySDM.dynamics.RelaxedVelocity` dynamic exists.
-    """
-    env = Box(dt=1, dv=1)
-    builder_no_relax = Builder(n_sd=1, backend=backend_instance, environment=env)
-    builder_no_relax.request_attribute("relative fall velocity")
-
-    # with no RelaxedVelocity, the builder should use TerminalVelocity
-    assert isinstance(
-        builder_no_relax.req_attr["relative fall velocity"], TerminalVelocity
-    )
-    env = Box(dt=1, dv=1)
-    builder = Builder(n_sd=1, backend=backend_instance, environment=env)
-    builder.add_dynamic(RelaxedVelocity())
-    builder.request_attribute("relative fall velocity")
-
-    # with RelaxedVelocity, the builder should use RelativeFallVelocity
-    assert isinstance(builder.req_attr["relative fall velocity"], RelativeFallVelocity)
-
-    # requesting momentum with no dynamic issues a warning
-    env = Box(dt=1, dv=1)
-    builder = Builder(n_sd=1, backend=backend_instance, environment=env)
-    with pytest.warns(UserWarning):
-        builder.request_attribute("relative fall momentum")