PySDM-examples 2.70__tar.gz → 2.71__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM-examples
-Version: 2.70
+Version: 2.71
 Summary: PySDM usage examples reproducing results from literature and depicting how to use PySDM from Python Jupyter notebooks
 Home-page: https://github.com/open-atmos/PySDM
 Author: https://github.com/open-atmos/PySDM/graphs/contributors

{PySDM-examples-2.70 → PySDM-examples-2.71}/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-examples-2.70 → PySDM-examples-2.71}/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-examples-2.70 → PySDM-examples-2.71}/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-examples-2.70 → PySDM-examples-2.71}/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-examples-2.70 → PySDM-examples-2.71}/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-examples-2.70 → PySDM-examples-2.71}/PySDM_examples.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM-examples
-Version: 2.70
+Version: 2.71
 Summary: PySDM usage examples reproducing results from literature and depicting how to use PySDM from Python Jupyter notebooks
 Home-page: https://github.com/open-atmos/PySDM
 Author: https://github.com/open-atmos/PySDM/graphs/contributors

{PySDM-examples-2.70 → PySDM-examples-2.71}/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",