PySDM 2.70__tar.gz → 2.71__tar.gz

{PySDM-2.70 → PySDM-2.71}/PKG-INFO

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

@@ -121,8 +121,8 @@ class Builder:
             self._resolve_attribute(attr_name)
         self.req_attr_names = None
 
-        for dynamic in self.particulator.dynamics.values():
-            dynamic.register(self)
+        for key, dynamic in self.particulator.dynamics.items():
+            self.particulator.dynamics[key] = dynamic.instantiate(builder=self)
 
         single_buffer_for_all_products = np.empty(self.particulator.mesh.grid)
         for product in products:

{PySDM-2.70 → PySDM-2.71}/PySDM/dynamics/ambient_thermodynamics.py

@@ -2,7 +2,10 @@
 environment-sync triggering class
 """
 
+from PySDM.dynamics.impl import register_dynamic
 
+
+@register_dynamic()
 class AmbientThermodynamics:
     def __init__(self):
         self.particulator = None

{PySDM-2.70 → PySDM-2.71}/PySDM/dynamics/aqueous_chemistry.py

@@ -13,12 +13,14 @@ from PySDM.dynamics.impl.chemistry_utils import (
     M,
     SpecificGravities,
 )
+from PySDM.dynamics.impl import register_dynamic
 
 DEFAULTS = namedtuple("_", ("pH_min", "pH_max", "pH_rtol", "ionic_strength_threshold"))(
     pH_min=-1.0, pH_max=14.0, pH_rtol=1e-6, ionic_strength_threshold=0.02 * M
 )
 
 
+@register_dynamic()
 class AqueousChemistry:  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,

{PySDM-2.70 → PySDM-2.71}/PySDM/dynamics/collisions/collision.py

@@ -23,6 +23,7 @@ from PySDM.dynamics.impl.random_generator_optimizer_nopair import (
     RandomGeneratorOptimizerNoPair,
 )
 from PySDM.physics import si
+from PySDM.dynamics.impl import register_dynamic
 
 # pylint: disable=too-many-lines
 
@@ -36,6 +37,7 @@ DEFAULTS = namedtuple(
 )
 
 
+@register_dynamic()
 class Collision:  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,
@@ -288,6 +290,7 @@ class Collision:  # pylint: disable=too-many-instance-attributes
         )
 
 
+@register_dynamic()
 class Coalescence(Collision):
     def __init__(
         self,
@@ -316,6 +319,7 @@ class Coalescence(Collision):
         )
 
 
+@register_dynamic()
 class Breakup(Collision):
     def __init__(
         self,

{PySDM-2.70 → PySDM-2.71}/PySDM/dynamics/condensation.py

@@ -7,7 +7,8 @@ from collections import namedtuple
 
 import numpy as np
 
-from ..physics import si
+from PySDM.physics import si
+from PySDM.dynamics.impl import register_dynamic
 
 DEFAULTS = namedtuple("_", ("rtol_x", "rtol_thd", "cond_range", "schedule"))(
     rtol_x=1e-6,
@@ -17,6 +18,7 @@ DEFAULTS = namedtuple("_", ("rtol_x", "rtol_thd", "cond_range", "schedule"))(
 )
 
 
+@register_dynamic()
 class Condensation:  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,

{PySDM-2.70 → PySDM-2.71}/PySDM/dynamics/displacement.py

@@ -11,9 +11,12 @@ from collections import namedtuple
 
 import numpy as np
 
+from PySDM.dynamics.impl import register_dynamic
+
 DEFAULTS = namedtuple("_", ("rtol", "adaptive"))(rtol=1e-2, adaptive=True)
 
 
+@register_dynamic()
 class Displacement:  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,

PySDM-2.71/PySDM/dynamics/eulerian_advection.py

@@ -0,0 +1,22 @@
+"""
+wrapper class for triggering integration in the Eulerian advection solver
+"""
+
+from PySDM.dynamics.impl import register_dynamic
+
+
+@register_dynamic()
+class EulerianAdvection:
+    def __init__(self, solvers):
+        self.solvers = solvers
+        self.particulator = None
+
+    def register(self, builder):
+        self.particulator = builder.particulator
+
+    def __call__(self):
+        for field in ("water_vapour_mixing_ratio", "thd"):
+            self.particulator.environment.get_predicted(field).download(
+                getattr(self.particulator.environment, f"get_{field}")(), reshape=True
+            )
+        self.solvers(self.particulator.dynamics["Displacement"])

{PySDM-2.70 → PySDM-2.71}/PySDM/dynamics/freezing.py

@@ -7,8 +7,10 @@ from PySDM.backends.impl_common.freezing_attributes import (
     TimeDependentAttributes,
 )
 from PySDM.physics.heterogeneous_ice_nucleation_rate import Null
+from PySDM.dynamics.impl import register_dynamic
 
 
+@register_dynamic()
 class Freezing:
     def __init__(self, *, singular=True, record_freezing_temperature=False, thaw=False):
         assert not (record_freezing_temperature and singular)

{PySDM-2.70 → PySDM-2.71}/PySDM/dynamics/impl/__init__.py

@@ -1 +1,3 @@
 """ stuff not intended to be imported from user code """
+
+from .register_dynamic import register_dynamic

PySDM-2.71/PySDM/dynamics/impl/register_dynamic.py

@@ -0,0 +1,21 @@
+""" decorator for dynamics classes
+ensuring that their instances can be re-used with multiple builders """
+
+from copy import deepcopy
+
+
+def _instantiate(self, *, builder):
+    copy = deepcopy(self)
+    copy.register(builder=builder)
+    return copy
+
+
+def register_dynamic():
+    def decorator(cls):
+        if hasattr(cls, "instantiate"):
+            assert cls.instantiate is _instantiate
+        else:
+            setattr(cls, "instantiate", _instantiate)
+        return cls
+
+    return decorator

{PySDM-2.70 → PySDM-2.71}/PySDM/dynamics/isotopic_fractionation.py

@@ -4,11 +4,13 @@ requires condensation dynamic to be registered (and run beforehand)
 """
 
 from PySDM.dynamics.condensation import Condensation
+from PySDM.dynamics.impl import register_dynamic
 
 LIGHT_ISOTOPES = ("1H", "16O")
 HEAVY_ISOTOPES = ("2H", "3H", "17O", "18O")
 
 
+@register_dynamic()
 class IsotopicFractionation:
     def __init__(self, isotopes: tuple = HEAVY_ISOTOPES):
         self.isotopes = isotopes

{PySDM-2.70 → PySDM-2.71}/PySDM/dynamics/relaxed_velocity.py

@@ -6,8 +6,10 @@ towards the terminal velocity
 
 from PySDM.attributes.impl.attribute import Attribute
 from PySDM.particulator import Particulator
+from PySDM.dynamics.impl import register_dynamic
 
 
+@register_dynamic()
 class RelaxedVelocity:  # pylint: disable=too-many-instance-attributes
     """
     A dynamic which updates the fall momentum according to a relaxation timescale

{PySDM-2.70 → PySDM-2.71}/PySDM/environments/impl/moist.py

@@ -44,21 +44,21 @@ class Moist:
             result[var] = self.particulator.Storage.empty((self.mesh.n_cell,), float)
         return result
 
-    def __getitem__(self, index):
-        """returns a Storage representing the variable (field) at a given index or
-        otherwise a NaN-filled Storage if the index is not found (in order to simplify
+    def __getitem__(self, key: str):
+        """returns a Storage representing the variable (field) at a given key or
+        otherwise a NaN-filled Storage if the key is not found (in order to simplify
         generic code which uses optional variables, e.g. air viscosity, etc.)"""
-        if index in self._values["current"]:
-            return self._values["current"][index]
+        if key in self._values["current"]:
+            return self._values["current"][key]
         return self._nan_field
 
-    def get_predicted(self, index):
+    def get_predicted(self, key: str):
         if self._values["predicted"] is None:
             raise AssertionError(
                 "It seems the AmbientThermodynamics dynamic was not added"
                 " when building particulator"
             )
-        return self._values["predicted"][index]
+        return self._values["predicted"][key]
 
     def _recalculate_temperature_pressure_relative_humidity(self, target):
         self.particulator.backend.temperature_pressure_rh(

{PySDM-2.70 → PySDM-2.71}/PySDM/environments/kinematic_1d.py

@@ -26,7 +26,7 @@ class Kinematic1D(Moist):
         self._tmp["rhod"] = rhod
 
     def get_water_vapour_mixing_ratio(self) -> np.ndarray:
-        return self.particulator.dynamics["EulerianAdvection"].solvers.advectee.get()
+        return self.particulator.dynamics["EulerianAdvection"].solvers.advectee
 
     def get_thd(self) -> np.ndarray:
         return self.thd0
@@ -61,9 +61,7 @@ class Kinematic1D(Moist):
                 v_wet, n_per_kg = spectral_discretisation.sample(
                     backend=self.particulator.backend, n_sd=self.particulator.n_sd
                 )
-                # attributes["dry volume"] = v_wet
                 attributes["volume"] = v_wet
-                # attributes["kappa times dry volume"] = attributes["dry volume"] * kappa
             else:
                 r_dry, n_per_kg = spectral_discretisation.sample(
                     backend=self.particulator.backend, n_sd=self.particulator.n_sd

{PySDM-2.70 → PySDM-2.71}/PySDM/environments/kinematic_2d.py

@@ -85,16 +85,12 @@ class Kinematic2D(Moist):
         return attributes
 
     def get_thd(self):
-        return (
-            self.particulator.dynamics["EulerianAdvection"].solvers["th"].advectee.get()
-        )
+        return self.particulator.dynamics["EulerianAdvection"].solvers["th"]
 
     def get_water_vapour_mixing_ratio(self):
-        return (
-            self.particulator.dynamics["EulerianAdvection"]
-            .solvers["water_vapour_mixing_ratio"]
-            .advectee.get()
-        )
+        return self.particulator.dynamics["EulerianAdvection"].solvers[
+            "water_vapour_mixing_ratio"
+        ]
 
     def sync(self):
         self.particulator.dynamics["EulerianAdvection"].solvers.wait()

{PySDM-2.70 → PySDM-2.71}/PySDM.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.70
+Version: 2.71
 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.70 → PySDM-2.71}/PySDM.egg-info/SOURCES.txt

@@ -177,6 +177,7 @@ PySDM/dynamics/impl/__init__.py
 PySDM/dynamics/impl/chemistry_utils.py
 PySDM/dynamics/impl/random_generator_optimizer.py
 PySDM/dynamics/impl/random_generator_optimizer_nopair.py
+PySDM/dynamics/impl/register_dynamic.py
 PySDM/dynamics/terminal_velocity/__init__.py
 PySDM/dynamics/terminal_velocity/gunn_and_kinzer.py
 PySDM/dynamics/terminal_velocity/power_series.py
@@ -776,6 +777,7 @@ tests/unit_tests/backends/storage/test_index.py
 tests/unit_tests/backends/storage/test_setitem.py
 tests/unit_tests/dynamics/__init__.py
 tests/unit_tests/dynamics/test_eulerian_advection.py
+tests/unit_tests/dynamics/test_impl_register_dynamic.py
 tests/unit_tests/dynamics/test_isotopic_fractionation.py
 tests/unit_tests/dynamics/test_relaxed_velocity.py
 tests/unit_tests/dynamics/test_terminal_velocity.py

{PySDM-2.70 → PySDM-2.71}/examples/PySDM_examples/Shipway_and_Hill_2012/mpdata_1d.py

@@ -1,4 +1,7 @@
+from functools import cached_property
+
 import numpy as np
+
 from PyMPDATA import Options, ScalarField, Solver, Stepper, VectorField
 from PyMPDATA.boundary_conditions import Extrapolated
 
@@ -19,41 +22,55 @@ class MPDATA_1D:
         self.dt = dt
         self.advector_of_t = advector_of_t
 
-        grid = (nz,)
-        options = Options(
+        self._grid = (nz,)
+        self._options = Options(
             n_iters=mpdata_settings["n_iters"],
             infinite_gauge=mpdata_settings["iga"],
             nonoscillatory=mpdata_settings["fct"],
             third_order_terms=mpdata_settings["tot"],
         )
-        stepper = Stepper(options=options, grid=grid, non_unit_g_factor=True)
         bcs = (Extrapolated(),)
-        zZ_scalar = arakawa_c.z_scalar_coord(grid) / nz
-        g_factor = ScalarField(
+        zZ_scalar = arakawa_c.z_scalar_coord(self._grid) / nz
+        self._g_factor = ScalarField(
             data=g_factor_of_zZ(zZ_scalar),
-            halo=options.n_halo,
+            halo=self._options.n_halo,
             boundary_conditions=bcs,
         )
-        advector = VectorField(
+        self._advector = VectorField(
             data=(np.full(nz + 1, advector_of_t(0)),),
-            halo=options.n_halo,
+            halo=self._options.n_halo,
             boundary_conditions=bcs,
         )
-        self.advectee = ScalarField(
+        self._advectee = ScalarField(
             data=advectee_of_zZ_at_t0(zZ_scalar),
-            halo=options.n_halo,
+            halo=self._options.n_halo,
             boundary_conditions=bcs,
         )
-        self.solver = Solver(
-            stepper=stepper,
-            advectee=self.advectee,
-            advector=advector,
-            g_factor=g_factor,
+
+    @cached_property
+    def solver(self):
+        return Solver(
+            stepper=Stepper(
+                options=self._options, grid=self._grid, non_unit_g_factor=True
+            ),
+            advectee=self._advectee,
+            advector=self._advector,
+            g_factor=self._g_factor,
         )
 
+    @property
+    def solver_cached(self):
+        return "solver" in self.__dict__
+
+    @property
+    def advectee(self):
+        return (self.solver.advectee if self.solver_cached else self._advectee).get()
+
     @property
     def advector(self):
-        return self.solver.advector.get_component(0)
+        return (
+            self.solver.advector if self.solver_cached else self._advector
+        ).get_component(0)
 
     def update_advector_field(self):
         self.__t += 0.5 * self.dt
@@ -61,5 +78,5 @@ class MPDATA_1D:
         np.testing.assert_array_less(np.abs(self.advector), 1)
         self.__t += 0.5 * self.dt
 
-    def __call__(self):
+    def __call__(self, _):
         self.solver.advance(1)

{PySDM-2.70 → PySDM-2.71}/examples/PySDM_examples/Shipway_and_Hill_2012/simulation.py

@@ -46,7 +46,7 @@ class Simulation:
             z_above_reservoir = zZ * (settings.nz * settings.dz) + self.z0
             return z_above_reservoir
 
-        self.mpdata = MPDATA_1D(
+        mpdata = MPDATA_1D(
             nz=settings.nz,
             dt=settings.dt,
             mpdata_settings=settings.mpdata_settings,
@@ -79,7 +79,7 @@ class Simulation:
                     update_thd=settings.condensation_update_thd,
                 )
             )
-        self.builder.add_dynamic(EulerianAdvection(self.mpdata))
+        self.builder.add_dynamic(EulerianAdvection(mpdata))
 
         self.products = []
         if settings.precip:
@@ -257,10 +257,11 @@ class Simulation:
 
         self.save(0)
         for step in range(self.nt):
-            self.mpdata.update_advector_field()
+            mpdata = self.particulator.dynamics["EulerianAdvection"].solvers
+            mpdata.update_advector_field()
             if "Displacement" in self.particulator.dynamics:
                 self.particulator.dynamics["Displacement"].upload_courant_field(
-                    (self.mpdata.advector / self.g_factor_vec,)
+                    (mpdata.advector / self.g_factor_vec,)
                 )
             self.particulator.run(steps=1)
             self.save(step + 1)

{PySDM-2.70 → PySDM-2.71}/examples/PySDM_examples/Szumowski_et_al_1998/gui_settings.py

@@ -348,10 +348,15 @@ class GUISettings:
                 return widget.value
         raise NotImplementedError()
 
-    def stream_function(self, xX, zZ, _):
+    @property
+    def stream_function(self):
         assert hasattr(self.__settings, "rhod_w_max")
         self.__settings.rhod_w_max = self.ui_rhod_w_max.value
-        return self.__settings.stream_function(xX, zZ, _)
+
+        def fun(xX, zZ, _):
+            return self.__settings.stream_function(xX, zZ, _)
+
+        return fun
 
     @property
     def freezing_inp_spec(self):

{PySDM-2.70 → PySDM-2.71}/examples/PySDM_examples/Szumowski_et_al_1998/mpdata_2d.py

@@ -1,4 +1,5 @@
 import inspect
+from functools import cached_property
 from threading import Thread
 
 import numpy as np
@@ -24,13 +25,12 @@ class MPDATA_2D:
         dt,
         grid,
         size,
-        displacement,
         n_iters=2,
         infinite_gauge=True,
         nonoscillatory=True,
         third_order_terms=False
     ):
-        self.grid = grid
+        self._grid = grid
         self.size = size
         self.dt = dt
         self.stream_function = stream_function
@@ -39,96 +39,103 @@ class MPDATA_2D:
         )
         self.asynchronous = False
         self.thread: (Thread, None) = None
-        self.displacement = displacement
         self.t = 0
+        self.advectees = advectees
 
-        options = Options(
+        self._options = Options(
             n_iters=n_iters,
             infinite_gauge=infinite_gauge,
             nonoscillatory=nonoscillatory,
             third_order_terms=third_order_terms,
         )
+
+        self.g_factor = make_rhod(grid, rhod_of_zZ)
+        self.g_factor_vec = (
+            rhod_of_zZ(zZ=x_vec_coord(grid)[-1]),
+            rhod_of_zZ(zZ=z_vec_coord(grid)[-1]),
+        )
+
+    @cached_property
+    def mpdatas(self):
         disable_threads_if_needed = {}
         if not conf.JIT_FLAGS["parallel"]:
             disable_threads_if_needed["n_threads"] = 1
 
         stepper = Stepper(
-            options=options,
-            grid=self.grid,
+            options=self._options,
+            grid=self._grid,
             non_unit_g_factor=True,
             **disable_threads_if_needed
         )
 
         advector_impl = VectorField(
             (
-                np.full((grid[0] + 1, grid[1]), np.nan),
-                np.full((grid[0], grid[1] + 1), np.nan),
+                np.full((self._grid[0] + 1, self._grid[1]), np.nan),
+                np.full((self._grid[0], self._grid[1] + 1), np.nan),
             ),
-            halo=options.n_halo,
+            halo=self._options.n_halo,
             boundary_conditions=(Periodic(), Periodic()),
         )
 
-        g_factor = make_rhod(self.grid, rhod_of_zZ)
         g_factor_impl = ScalarField(
-            g_factor.astype(dtype=options.dtype),
-            halo=options.n_halo,
+            self.g_factor.astype(dtype=self._options.dtype),
+            halo=self._options.n_halo,
             boundary_conditions=(Periodic(), Periodic()),
         )
 
-        self.g_factor_vec = (
-            rhod_of_zZ(zZ=x_vec_coord(self.grid)[-1]),
-            rhod_of_zZ(zZ=z_vec_coord(self.grid)[-1]),
-        )
-        self.mpdatas = {}
-        for k, v in advectees.items():
+        mpdatas = {}
+        for k, v in self.advectees.items():
             advectee_impl = ScalarField(
-                np.asarray(v, dtype=options.dtype),
-                halo=options.n_halo,
+                np.asarray(v, dtype=self._options.dtype),
+                halo=self._options.n_halo,
                 boundary_conditions=(Periodic(), Periodic()),
             )
-            self.mpdatas[k] = Solver(
+            mpdatas[k] = Solver(
                 stepper=stepper,
                 advectee=advectee_impl,
                 advector=advector_impl,
                 g_factor=g_factor_impl,
             )
+        return mpdatas
 
-    def __getitem__(self, item):
-        return self.mpdatas[item]
+    def __getitem__(self, key: str):
+        if "mpdatas" in self.__dict__:
+            return self.mpdatas[key].advectee.get()
+        return self.advectees[key]
 
-    def __call__(self):
+    def __call__(self, displacement):
         if self.asynchronous:
             self.thread = Thread(target=self.step, args=())
             self.thread.start()
         else:
-            self.step()
+            self.step(displacement)
 
     def wait(self):
         if self.asynchronous:
             if self.thread is not None:
                 self.thread.join()
 
-    def refresh_advector(self):
+    def refresh_advector(self, displacement):
         for mpdata in self.mpdatas.values():
             advector = nondivergent_vector_field_2d(
-                self.grid, self.size, self.dt, self.stream_function, t=self.t
+                self._grid, self.size, self.dt, self.stream_function, t=self.t
             )
-            for d in range(len(self.grid)):
+            for d in range(len(self._grid)):
                 np.testing.assert_array_less(np.abs(advector[d]), 1)
                 mpdata.advector.get_component(d)[:] = advector[d]
-            if self.displacement is not None:
-                for d in range(len(self.grid)):
+            if displacement is not None:
+                for d in range(len(self._grid)):
                     advector[d] /= self.g_factor_vec[d]
-                self.displacement.upload_courant_field(advector)
+                displacement.upload_courant_field(advector)
             break  # the advector field is shared
 
-    def step(self):
+    def step(self, displacement):
         if not self.stream_function_time_dependent and self.t == 0:
-            self.refresh_advector()
+            self.refresh_advector(displacement)
 
         self.t += 0.5 * self.dt
         if self.stream_function_time_dependent:
-            self.refresh_advector()
+            self.refresh_advector(displacement)
         for mpdata in self.mpdatas.values():
             mpdata.advance(1)
         self.t += 0.5 * self.dt

{PySDM-2.70 → PySDM-2.71}/examples/PySDM_examples/Szumowski_et_al_1998/simulation.py

@@ -66,13 +66,6 @@ class Simulation:
                 **kwargs,
             )
             builder.add_dynamic(condensation)
-        displacement = None
-        if self.settings.processes["particle advection"]:
-            displacement = Displacement(
-                enable_sedimentation=self.settings.processes["sedimentation"],
-                adaptive=self.settings.displacement_adaptive,
-                rtol=self.settings.displacement_rtol,
-            )
         if self.settings.processes["fluid advection"]:
             initial_profiles = {
                 "th": self.settings.initial_dry_potential_temperature_profile,
@@ -92,7 +85,6 @@ class Simulation:
                 dt=self.settings.dt,
                 grid=self.settings.grid,
                 size=self.settings.size,
-                displacement=displacement,
                 n_iters=self.settings.mpdata_iters,
                 infinite_gauge=self.settings.mpdata_iga,
                 nonoscillatory=self.settings.mpdata_fct,
@@ -100,7 +92,13 @@ class Simulation:
             )
             builder.add_dynamic(EulerianAdvection(solver))
         if self.settings.processes["particle advection"]:
-            builder.add_dynamic(displacement)
+            builder.add_dynamic(
+                Displacement(
+                    enable_sedimentation=self.settings.processes["sedimentation"],
+                    adaptive=self.settings.displacement_adaptive,
+                    rtol=self.settings.displacement_rtol,
+                )
+            )
         if (
             self.settings.processes["coalescence"]
             and self.settings.processes["breakup"]

{PySDM-2.70 → PySDM-2.71}/examples/setup.py

@@ -26,7 +26,8 @@ setup(
         "PyMPDATA" + (">=1.0.15" if CI else ""),
         "open-atmos-jupyter-utils",
         "pystrict",
-        "matplotlib",
+        # https://github.com/matplotlib/matplotlib/issues/28551
+        "matplotlib" + ("!=3.9.1" if CI else ""),
         "joblib",
         "ipywidgets",
         "seaborn",

{PySDM-2.70 → PySDM-2.71}/tests/smoke_tests/kinematic_2d/arabas_et_al_2015/test_adaptive_displacement.py

@@ -64,6 +64,8 @@ def test_adaptive_displacement(rtol, plot=False):
     pyplot.yticks(np.arange(settings.grid[1] + 1))
     if plot:
         pyplot.show()
+    else:
+        pyplot.clf()
 
     # Assert
     if rtol is not None:

{PySDM-2.70 → PySDM-2.71}/tests/unit_tests/dynamics/test_eulerian_advection.py

@@ -21,8 +21,9 @@ class TestEulerianAdvection:  # pylint: disable=too-few-public-methods
         env.pred["water_vapour_mixing_ratio"][:] = 3.7
         env.pred["thd"][:] = 5.59
         particulator.environment = env
+        particulator.dynamics["Displacement"] = None
 
-        sut = EulerianAdvection(lambda: None)
+        sut = EulerianAdvection(lambda _: None)
         sut.register(particulator)
 
         # Act