PySDM 2.126__tar.gz → 2.128__tar.gz

{pysdm-2.126/pysdm.egg-info → pysdm-2.128}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdm
-Version: 2.126
+Version: 2.128
 Summary: Pythonic particle-based (super-droplet) warm-rain/aqueous-chemistry cloud microphysics package with box, parcel & 1D/2D prescribed-flow examples in Python, Julia and Matlab
 Author-email: "https://github.com/open-atmos/PySDM/graphs/contributors" <sylwester.arabas@agh.edu.pl>
 License-Expression: GPL-3.0-only

{pysdm-2.126 → pysdm-2.128}/PySDM/backends/impl_numba/methods/collisions_methods.py

@@ -344,6 +344,14 @@ class CollisionsMethods(BackendMethods):
             stats_n_substep,
             stats_dt_min,
         ):
+            """Modified parameters are: `dt_left[cell_id]`, `prob[pair_id]`,
+            `stats_n_substep[cell_id]`, `stats_dt_min[cell_id]`;
+            `dt_todo[cell_id]` is a local temporary array of time steps to be taken in each cell,
+            which will be equal to `dt` if no adaptive substepping is needed.
+            `stats_n_substep[cell_id]` gets updated by +1 if a given cell will take another substep.
+            After a full model step is completed, `stats_n_substep[cell_id]` would be 1 if
+            no adaptive substepping was needed.
+            """
             dt_todo = np.empty_like(dt_left)
             for cid in numba.prange(len(dt_todo)):  # pylint: disable=not-an-iterable
                 dt_todo[cid] = min(dt_left[cid], dt_range[1])

{pysdm-2.126 → pysdm-2.128}/docs/bibliography.json

@@ -121,7 +121,8 @@
       "examples/PySDM_examples/Shima_et_al_2009/__init__.py",
       "PySDM/dynamics/collisions/collision.py",
       "tutorials/collisions/collisions_playground.ipynb",
-      "tutorials/wikipedia/sdm.ipynb"
+      "tutorials/wikipedia/sdm.ipynb",
+      "tests/smoke_tests/box/shima_et_al_2009/test_convergence.py"
     ],
     "label": "Shima et al. 2009 (Q. J. R. Meteorol. Soc. 135)",
     "title": "The super-droplet method for the numerical simulation of clouds and precipitation: a particle-based and probabilistic microphysics model coupled with a non-hydrostatic model"

{pysdm-2.126 → pysdm-2.128}/examples/PySDM_examples/Berry_1967/spectrum_plotter.py

@@ -26,6 +26,8 @@ class SpectrumPlotter(SuperSpectrumPlotter):
         self.ticks()
         show_plot()
 
-    def plot(self, spectrum, t):
+    def plot(
+        self, spectrum, t, label=None, color=None, title=None, add_error_to_label=False
+    ):
         settings = self.settings
-        self.plot_data(settings, t, spectrum)
+        self.plot_data(settings, t, spectrum, label, color)

{pysdm-2.126 → pysdm-2.128}/examples/PySDM_examples/Shima_et_al_2009/spectrum_plotter.py

@@ -81,12 +81,16 @@ class SpectrumPlotter:
         self.finish()
         pyplot.savefig(file, format=self.format)
 
-    def plot(self, spectrum, t):
-        error = self.plot_analytic_solution(self.settings, t, spectrum)
-        self.plot_data(self.settings, t, spectrum)
+    def plot(
+        self, spectrum, t, label=None, color=None, title=None, add_error_to_label=False
+    ):
+        error = self.plot_analytic_solution(self.settings, t, spectrum, title)
+        if label is not None and add_error_to_label:
+            label += f" error={error:.4g}"
+        self.plot_data(self.settings, t, spectrum, label, color)
         return error
 
-    def plot_analytic_solution(self, settings, t, spectrum=None):
+    def plot_analytic_solution(self, settings, t, spectrum, title):
         if t == 0:
             analytic_solution = settings.spectrum.size_distribution
         else:
@@ -123,11 +127,13 @@ class SpectrumPlotter:
         if spectrum is not None:
             y = spectrum * si.kilograms / si.grams
             error = error_measure(y, y_true, x)
-            self.title = f"error measure: {error:.2f}"  # TODO #327 relative error
+            self.title = (
+                title or f"error measure: {error:.2f}"
+            )  # TODO #327 relative error
             return error
         return None
 
-    def plot_data(self, settings, t, spectrum):
+    def plot_data(self, settings, t, spectrum, label, color):
         if self.smooth:
             scope = self.smooth_scope
             if t != 0:
@@ -144,18 +150,16 @@ class SpectrumPlotter:
             self.ax.plot(
                 (x[:-1] + dx / 2) * si.metres / si.micrometres,
                 spectrum[:-scope] * si.kilograms / si.grams,
-                label=f"t = {t}s",
-                color=self.colors(
-                    t / (self.settings.output_steps[-1] * self.settings.dt)
-                ),
+                label=label or f"t = {t}s",
+                color=color
+                or self.colors(t / (self.settings.output_steps[-1] * self.settings.dt)),
             )
         else:
             self.ax.step(
                 settings.radius_bins_edges[:-1] * si.metres / si.micrometres,
                 spectrum * si.kilograms / si.grams,
                 where="post",
-                label=f"t = {t}s",
-                color=self.colors(
-                    t / (self.settings.output_steps[-1] * self.settings.dt)
-                ),
+                label=label or f"t = {t}s",
+                color=color
+                or self.colors(t / (self.settings.output_steps[-1] * self.settings.dt)),
             )

{pysdm-2.126 → pysdm-2.128/pysdm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdm
-Version: 2.126
+Version: 2.128
 Summary: Pythonic particle-based (super-droplet) warm-rain/aqueous-chemistry cloud microphysics package with box, parcel & 1D/2D prescribed-flow examples in Python, Julia and Matlab
 Author-email: "https://github.com/open-atmos/PySDM/graphs/contributors" <sylwester.arabas@agh.edu.pl>
 License-Expression: GPL-3.0-only

{pysdm-2.126 → pysdm-2.128}/pysdm.egg-info/SOURCES.txt

@@ -717,6 +717,7 @@ tests/smoke_tests/box/dejong_azimi/test_box.py
 tests/smoke_tests/box/partmc/__init__.py
 tests/smoke_tests/box/partmc/test_dry_wet_equilibration.py
 tests/smoke_tests/box/shima_et_al_2009/__init__.py
+tests/smoke_tests/box/shima_et_al_2009/test_convergence.py
 tests/smoke_tests/box/shima_et_al_2009/test_lwc_constant.py
 tests/smoke_tests/box/srivastava_1982/__init__.py
 tests/smoke_tests/box/srivastava_1982/test_eq_10.py

pysdm-2.128/tests/smoke_tests/box/shima_et_al_2009/test_convergence.py

@@ -0,0 +1,85 @@
+"""
+Tests checking if, for the example case from Fig 4 in
+[Shima et al. 2009](https://doi.org/10.1002/qj.441),
+the simulations converge towards analytic solution.
+"""
+
+from inspect import signature
+from itertools import islice
+
+import pytest
+from matplotlib import pyplot
+from PySDM_examples.Shima_et_al_2009.example import run
+from PySDM_examples.Shima_et_al_2009.settings import Settings
+from PySDM_examples.Shima_et_al_2009.spectrum_plotter import SpectrumPlotter
+
+from PySDM.physics import si
+
+COLORS = ("red", "green", "blue")
+
+
+class TestConvergence:  # pylint: disable=missing-class-docstring
+    @staticmethod
+    @pytest.mark.parametrize(
+        "adaptive, dt",
+        (
+            pytest.param(False, 100 * si.s, marks=pytest.mark.xfail(strict=True)),
+            (True, 100 * si.s),
+            pytest.param(False, 50 * si.s, marks=pytest.mark.xfail(strict=True)),
+            (True, 50 * si.s),
+        ),
+    )
+    def test_convergence_with_sd_count(dt, adaptive, plot=False):
+        """check if increasing the number of super particles indeed
+        reduces the error of the simulation (vs. analytic solution)"""
+        # arrange
+        settings = Settings(steps=[3600])
+        settings.adaptive = adaptive
+        plotter = SpectrumPlotter(settings)
+        errors = {}
+
+        # act
+        for i, ln2_nsd in enumerate((11, 15, 19)):
+            settings.dt = dt
+            settings.n_sd = 2**ln2_nsd
+            values, _ = run(settings)
+
+            title = (
+                ""
+                if i != 0
+                else (
+                    f"{settings.dt=}  settings.times={settings.steps}  {settings.adaptive=}"
+                )
+            )
+            errors[ln2_nsd] = plotter.plot(
+                **dict(
+                    islice(
+                        {  # supporting older versions of PySDM-examples
+                            "t": settings.steps[-1],
+                            "spectrum": values[tuple(values.keys())[-1]],
+                            "label": f"{ln2_nsd=}",
+                            "color": COLORS[i],
+                            "title": title,
+                            "add_error_to_label": True,
+                        }.items(),
+                        len(signature(plotter.plot).parameters),
+                    )
+                )
+            )
+
+        # plot
+        if plot:
+            plotter.show()
+        else:
+            # https://github.com/matplotlib/matplotlib/issues/9970
+            pyplot.xscale("linear")
+            pyplot.clf()
+
+        # assert monotonicity (i.e., the larger the sd count, the smaller the error)
+        assert tuple(errors.keys()) == tuple(sorted(errors.keys()))
+        assert tuple(errors.values()) == tuple(reversed(sorted(errors.values())))
+
+    @staticmethod
+    def test_convergence_with_timestep():
+        """ditto for timestep"""
+        pytest.skip("# TODO #1189")

{pysdm-2.126 → pysdm-2.128}/tests/unit_tests/backends/test_collisions_methods.py

@@ -8,7 +8,7 @@ from PySDM.backends import CPU, GPU
 from PySDM.backends.impl_common.index import make_Index
 from PySDM.backends.impl_common.indexed_storage import make_IndexedStorage
 from PySDM.backends.impl_common.pair_indicator import make_PairIndicator
-from PySDM.backends.impl_numba.methods.collisions_methods import pair_indices
+from PySDM.backends.impl_numba.methods.collisions_methods import pair_indices, coalesce
 
 NONZERO = 44
 
@@ -148,7 +148,7 @@ class TestCollisionMethods:
         ),
     )
     # pylint: disable=too-many-locals
-    def test_scale_prob_for_adaptive_sdm_gamma(
+    def test_scale_prob_for_adaptive_sdm_gamma_including_multi_cell_cases(
         *,
         backend_instance,
         gamma,
@@ -235,3 +235,102 @@ class TestCollisionMethods:
 
         # Assert
         assert all(cell_start.to_ndarray()[:] == np.array([0, 3]))
+
+    @staticmethod
+    @pytest.mark.parametrize(
+        "gamma, permutation, multiplicity, cell_id, dt_left, dt, dt_max, is_first_in_pair, ",
+        (
+            (  # pylint: disable=undefined-variable,unused-variable
+                [2, 2, 2] + [3, 3] + [1, 1, 1],
+                tuple(range(n_part := 16)),
+                [1] * 2 + [100] * (n_part - 2),
+                [0] * (n_in_cell_0 := 6)
+                + [1] * (n_in_cell_1 := 4)
+                + [2] * (n_in_cell_2 := 6),
+                [dt := 12.0] * (n_cell := 3),
+                dt,
+                dt,
+                [True, False] * (n_part // 2),
+            ),
+        ),
+    )
+    # pylint: disable=too-many-locals
+    def test_adaptivity_paper_diagram_scenario(
+        *,
+        gamma,
+        permutation,
+        multiplicity,
+        cell_id,
+        dt_left,
+        dt,
+        dt_max,
+        is_first_in_pair,
+    ):
+        # Arrange
+        backend = CPU()
+        _permutation = make_Index(backend).from_ndarray(np.asarray(permutation))
+        _multiplicity = make_IndexedStorage(backend).from_ndarray(
+            _permutation, np.asarray(multiplicity)
+        )
+        _cell_id = backend.Storage.from_ndarray(np.asarray(cell_id))
+        _dt_left = backend.Storage.from_ndarray(np.asarray(dt_left))
+        _is_first_in_pair = make_PairIndicator(backend)(len(multiplicity))
+        _is_first_in_pair.indicator[:] = np.asarray(is_first_in_pair)
+        _n_substep = backend.Storage.from_ndarray(np.zeros_like(dt_left, dtype=int))
+        _dt_min = backend.Storage.from_ndarray(np.asarray(dt_left))
+        dt_range = (np.nan, dt_max)
+
+        # Act
+        while any(_dt_left.data > 0):
+            _gamma = backend.Storage.from_ndarray(np.asarray(gamma))
+            backend.scale_prob_for_adaptive_sdm_gamma(
+                prob=_gamma,
+                multiplicity=_multiplicity,
+                cell_id=_cell_id,
+                dt_left=_dt_left,
+                dt=dt,
+                dt_range=dt_range,
+                is_first_in_pair=_is_first_in_pair,
+                stats_n_substep=_n_substep,
+                stats_dt_min=_dt_min,
+            )
+            assert all(_gamma.data == _gamma.data.astype(int))
+            n_pair = len(gamma)
+            n_cell = len(dt_left)
+            for i in range(n_pair):
+                j, k, skip_pair = pair_indices(
+                    i=i,
+                    idx=_permutation.data,
+                    is_first_in_pair=_is_first_in_pair.indicator.data,
+                    prob_like=_gamma.data,
+                )
+                if not skip_pair:
+                    coalesce(
+                        i=i,
+                        j=j,
+                        k=k,
+                        cid=cell_id[j],
+                        multiplicity=_multiplicity.data,
+                        gamma=_gamma.data,
+                        attributes=np.empty(
+                            shape=(
+                                0,
+                                0,
+                            )
+                        ),
+                        coalescence_rate=np.empty(n_cell),
+                    )
+                    if _multiplicity.data[j] == 0:
+                        _is_first_in_pair.indicator.data[j] = False
+                        gamma[i] = 0.0
+
+        # Assert
+        assert _n_substep[0] == 2
+        assert _n_substep[1] == 3
+        assert _n_substep[2] == 1
+        assert (_dt_left.to_ndarray() == 0.0).all()
+        assert all(_dt_min.data == dt / _n_substep.data)
+        assert all(
+            _multiplicity.data
+            == (0, 1, 25, 25, 25, 25, 12, 13, 12, 13, 50, 50, 50, 50, 50, 50)
+        )