PySDM 3.0.0rc41__tar.gz → 3.0.0rc43__tar.gz

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/.github/dependabot.yml

@@ -4,10 +4,21 @@ updates:
   directory: "/"
   schedule:
     interval: daily
+  ignore:
+  - dependency-name: "setuptools-scm"
+    update-types:
+      - "version-update:semver-patch" 
+  - dependency-name: "setuptools"
+    update-types:
+      - "version-update:semver-patch" 
 - package-ecosystem: pip
   directory: "/examples"
   schedule:
     interval: daily
+  ignore:
+  - dependency-name: "*"
+    update-types:
+      - "version-update:semver-patch" 
 - package-ecosystem: "github-actions"
   directory: "/"
   schedule:

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/.github/workflows/docs_code_snippets.yml

@@ -91,11 +91,11 @@ jobs:
         with:
           release: R2024b
           cache: true
-      - uses: matlab-actions/run-command@v3.2
+      - uses: matlab-actions/run-command@v3.3
         with:
           command: docs_code
       - run: sed -i -e 's/CPU/GPU/g' docs_code.m
-      - uses: matlab-actions/run-command@v3.2
+      - uses: matlab-actions/run-command@v3.3
         with:
           command: docs_code
 

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/.github/workflows/precommit.yml

@@ -24,7 +24,7 @@ jobs:
       - uses: actions/checkout@v4.1.6
       - uses: actions/setup-python@v7.0.0
         with:
-          python-version: "3.11"
+          python-version: "3.13"
       - run: |
           pip install pre-commit
           pre-commit run --all-files --show-diff-on-failure

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/.pre-commit-config.yaml

@@ -23,7 +23,7 @@ repos:
         files: '.json'
 
   - repo: https://github.com/lk16/detect-missing-init
-    rev: v0.1.6
+    rev: v0.1.9
     hooks:
     - id: detect-missing-init
       args: ['--create', "--track", "--python-folders", "tests,PySDM,examples/PySDM_examples"]

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdm
-Version: 3.0.0rc41
+Version: 3.0.0rc43
 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
@@ -39,7 +39,7 @@ Requires-Dist: pytest; extra == "nonunit-tests"
 Requires-Dist: PySDM-examples; extra == "nonunit-tests"
 Requires-Dist: PyPartMC; extra == "nonunit-tests"
 Provides-Extra: ci-version-pins
-Requires-Dist: PyPartMC==2.1.0; extra == "ci-version-pins"
+Requires-Dist: PyPartMC==2.1.2; extra == "ci-version-pins"
 Requires-Dist: numba==0.60.0; extra == "ci-version-pins"
 Requires-Dist: numpy==2.0.2; extra == "ci-version-pins"
 Requires-Dist: scipy==1.15.3; extra == "ci-version-pins"
@@ -47,9 +47,9 @@ Requires-Dist: ThrustRTC==0.3.20; extra == "ci-version-pins"
 Requires-Dist: CURandRTC==0.1.7; extra == "ci-version-pins"
 Requires-Dist: jax==0.8.0; extra == "ci-version-pins"
 Requires-Dist: Pint==0.24.4; extra == "ci-version-pins"
-Requires-Dist: chempy==0.10.1; extra == "ci-version-pins"
+Requires-Dist: chempy==0.10.2; extra == "ci-version-pins"
 Requires-Dist: pyevtk==1.7.0; extra == "ci-version-pins"
-Requires-Dist: pyparsing==3.2.5; extra == "ci-version-pins"
+Requires-Dist: pyparsing==3.3.3; extra == "ci-version-pins"
 Dynamic: license-file
 
 # <img src="https://raw.githubusercontent.com/open-atmos/PySDM/main/docs/logos/pysdm_logo.svg" width=100 height=146 alt="pysdm logo">

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/attributes/impl/temperature_variation_option_attribute.py

@@ -7,7 +7,7 @@ class TemperatureVariationOptionAttribute:  # pylint: disable=too-few-public-met
 
     def __init__(self, particulator, neglect_temperature_variations: bool):
         if neglect_temperature_variations:
-            assert particulator.environment.mesh.dimension == 0
+            assert particulator.environment.mesh.n_dims == 0
         self.neglect_temperature_variations = neglect_temperature_variations
         self.initial_temperature = (
             particulator.Storage.from_ndarray(

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/attributes/numerics/cell_origin.py

@@ -12,5 +12,5 @@ class CellOrigin(CellAttribute):
             particulator,
             name="cell origin",
             dtype=int,
-            n_vector_components=particulator.mesh.dim,
+            n_vector_components=particulator.mesh.n_dims,
         )

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/attributes/numerics/position_in_cell.py

@@ -11,5 +11,5 @@ class PositionInCell(CellAttribute):
         super().__init__(
             particulator,
             name="position in cell",
-            n_vector_components=particulator.mesh.dim,
+            n_vector_components=particulator.mesh.n_dims,
         )

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/attributes/physics/critical_saturation.py

@@ -12,7 +12,7 @@ from PySDM.attributes.impl import (
 @register_attribute()
 class CriticalSaturation(DerivedAttribute, TemperatureVariationOptionAttribute):
     def __init__(self, particulator, neglect_temperature_variations=False):
-        assert particulator.mesh.dimension == 0
+        assert particulator.mesh.n_dims == 0
 
         self.v_crit = particulator.get_attribute("critical volume")
         self.v_dry = particulator.get_attribute("dry volume")

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/attributes/physics/terminal_velocity.py

@@ -21,10 +21,10 @@ class TerminalVelocity(DerivedAttribute):
         )
 
         self.approximation_liquid = particulator.formulae.terminal_velocity_class(
-            particulator
+            particulator.backend
         )
         self.approximation_ice = particulator.formulae.terminal_velocity_ice_class(
-            particulator
+            particulator.backend
         )
 
     def recalculate(self):

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/backends/__init__.py

@@ -84,10 +84,18 @@ else:
 _BACKEND_CACHE = {}
 
 
-def _cached_backend(formulae=None, backend_class=None, **kwargs):
-    key = backend_class.__name__ + ":" + str(formulae) + ":" + str(kwargs)
+def _cached_backend(formulae=None, n_dims=0, backend_class=None, **kwargs):
+    key = (
+        backend_class.__name__
+        + ":"
+        + str(n_dims)
+        + ":"
+        + str(formulae)
+        + ":"
+        + str(kwargs)
+    )
     if key not in _BACKEND_CACHE:
-        _BACKEND_CACHE[key] = backend_class(formulae=formulae, **kwargs)
+        _BACKEND_CACHE[key] = backend_class(formulae=formulae, n_dims=n_dims, **kwargs)
     return _BACKEND_CACHE[key]
 
 

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/backends/impl_common/backend_methods.py

@@ -17,3 +17,5 @@ class BackendMethods:
             self.default_jit_flags = {}
         if not hasattr(self, "block_until_ready"):
             self.block_until_ready = False
+        if not hasattr(self, "n_dims"):
+            self.n_dims = None

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/backends/impl_numba/methods/displacement_methods.py

@@ -107,9 +107,8 @@ class DisplacementMethods(BackendMethods):
     def calculate_displacement(
         self, *, dim, displacement, courant, cell_origin, position_in_cell, n_substeps
     ):
-        n_dims = len(courant.shape)
         scheme = self.formulae.particle_advection.displacement
-        if n_dims == 1:
+        if self.n_dims == 1:
             DisplacementMethods.calculate_displacement_body_1d(
                 dim,
                 scheme,
@@ -119,7 +118,7 @@ class DisplacementMethods(BackendMethods):
                 position_in_cell.data,
                 n_substeps,
             )
-        elif n_dims == 2:
+        elif self.n_dims == 2:
             DisplacementMethods.calculate_displacement_body_2d(
                 dim,
                 scheme,
@@ -129,7 +128,7 @@ class DisplacementMethods(BackendMethods):
                 position_in_cell.data,
                 n_substeps,
             )
-        elif n_dims == 3:
+        elif self.n_dims == 3:
             DisplacementMethods.calculate_displacement_body_3d(
                 dim,
                 scheme,

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/backends/jax.py

@@ -26,23 +26,23 @@ class Jax(
         self,
         formulae=None,
         *,
+        n_dims=0,
         double_precision=True,
         override_jit_flags=None,  # pylint: disable=unused-argument
         # TODO #1913: investigate if there are any jit/jax flags we can add configuration for
         block_until_ready=False,
     ):
         jax.config.update("jax_enable_x64", True)
-        if not double_precision:
+        if not double_precision or n_dims > 0:
             raise NotImplementedError()
 
+        self.n_dims = n_dims
         self.block_until_ready = (
             block_until_ready  # TODO #1913: implement switch in jit code
         )
         self.formulae = formulae or Formulae()
         self.formulae_flattened = self.formulae.flatten
 
-        self.default_jit_flags = {"parallel": False}
-
         methods.CollisionsMethods.__init__(self)
         methods.PairMethods.__init__(self)
         methods.IndexMethods.__init__(self)

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/backends/numba.py

@@ -1,5 +1,6 @@
 """
-Multi-threaded CPU backend using LLVM-powered just-in-time compilation
+CPU backend using LLVM-powered just-in-time compilation
+with multi-threading for multi-cell simulations (i.e., if n_dims>0)
 """
 
 import os
@@ -40,17 +41,24 @@ class Numba(  # pylint: disable=too-many-ancestors,duplicate-code
     default_croupier = "local"
 
     def __init__(
-        self, formulae=None, *, double_precision=True, override_jit_flags=None
+        self,
+        formulae=None,
+        *,
+        n_dims=0,
+        double_precision=True,
+        override_jit_flags=None,
     ):
         if not double_precision:
             raise NotImplementedError()
+
         self.formulae = formulae or Formulae()
         self.formulae_flattened = self.formulae.flatten
+        self.n_dims = n_dims
 
-        parallel_default = True
-
+        parallel_default = n_dims > 0
         if override_jit_flags is not None and "parallel" in override_jit_flags:
             parallel_default = override_jit_flags["parallel"]
+            del override_jit_flags["parallel"]
 
         if parallel_default:
             if platform.machine() == "arm64":

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/backends/thrust_rtc.py

@@ -47,10 +47,16 @@ class ThrustRTC(  # pylint: disable=duplicate-code,too-many-ancestors
     default_croupier = "global"
 
     def __init__(
-        self, formulae=None, *, double_precision=False, debug=False, verbose=False
+        self,
+        formulae=None,
+        *,
+        n_dims=0,
+        double_precision=False,
+        debug=False,
+        verbose=False,
     ):
         self.formulae = formulae or Formulae()
-
+        self.n_dims = n_dims
         self._conv_function = trtc.DVDouble if double_precision else trtc.DVFloat
         self._real_type = "double" if double_precision else "float"
         self._np_dtype = np.float64 if double_precision else np.float32

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/dynamics/freezing.py

@@ -4,7 +4,7 @@ time-dependent formulation for immersion freezing
 and homogeneous freezing and thaw
 """
 
-from typing import Optional
+from typing import Literal, Optional
 from PySDM.dynamics.impl import register_dynamic
 
 
@@ -13,9 +13,9 @@ class Freezing:  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,
         *,
-        homogeneous_freezing: Optional[str] = None,
-        immersion_freezing: Optional[str] = None,
-        thaw: Optional[str] = None,
+        homogeneous_freezing: Optional[Literal["threshold", "time-dependent"]] = None,
+        immersion_freezing: Optional[Literal["singular", "time-dependent"]] = None,
+        thaw: Optional[Literal["instantaneous"]] = None,
     ):
         assert (
             homogeneous_freezing or immersion_freezing or thaw

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/dynamics/terminal_velocity/columnar_ice_crystal.py

@@ -7,11 +7,11 @@ Eq. (18) .Assumed shape is columnar based on empirical parameterizations of
 
 
 class ColumnarIceCrystal:  # pylint: disable=too-few-public-methods,too-many-arguments
-    def __init__(self, particulator):
-        self.particulator = particulator
+    def __init__(self, backend):
+        self.backend = backend
 
     def __call__(self, output, signed_water_mass, cell_id, temperature, pressure):
-        self.particulator.backend.terminal_velocity_columnar_ice_crystals(
+        self.backend.terminal_velocity_columnar_ice_crystals(
             values=output.data,
             signed_water_mass=signed_water_mass.data,
             cell_id=cell_id.data,

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/dynamics/terminal_velocity/gunn_and_kinzer.py

@@ -13,8 +13,8 @@ from PySDM.physics import constants as const
 
 
 class GunnKinzer1949:  # pylint: disable=too-few-public-methods
-    def __init__(self, particulator, small_r_limit=None):
-        self.particulator = particulator
+    def __init__(self, backend, small_r_limit=None):
+        self.backend = backend
 
         """
         Table 2 in
@@ -121,9 +121,9 @@ class GunnKinzer1949:  # pylint: disable=too-few-public-methods
         approximation_small = TpDependent.make(only_small=True)
         small_r_limit = small_r_limit or 40 * const.si.um
         approximation_small(u[1:], space[1:], small_r_limit)
-        self.a = particulator.backend.Storage.from_ndarray(u)
+        self.a = backend.Storage.from_ndarray(u)
         b = np.append(np.diff(u), [u[-1] - u[-2]]) / step
-        self.b = particulator.backend.Storage.from_ndarray(b)
+        self.b = backend.Storage.from_ndarray(b)
 
     def __call__(self, output, radius):
         r_max = radius.amax()
@@ -132,7 +132,7 @@ class GunnKinzer1949:  # pylint: disable=too-few-public-methods
                 f"Radii can be interpolated up to {self.maximum_radius} m"
                 + f" (max value of {r_max} m within input data)"
             )
-        self.particulator.backend.gunn_and_kinzer_interpolation(
+        self.backend.gunn_and_kinzer_interpolation(
             output=output, radius=radius, factor=self.factor, b=self.a, c=self.b
         )
 

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/dynamics/terminal_velocity/power_series.py

@@ -16,8 +16,8 @@ from PySDM.physics import si, constants as const
 
 
 class PowerSeries:  # pylint: disable=too-few-public-methods
-    def __init__(self, particulator, *, prefactors=None, powers=None):
-        self.particulator = particulator
+    def __init__(self, backend, *, prefactors=None, powers=None):
+        self.backend = backend
         self.prefactors = np.array(prefactors or [2.0e-1 * si.m / si.s / np.sqrt(si.m)])
         self.powers = np.array(powers or [1 / 6])
         assert len(self.prefactors) == len(self.powers)
@@ -25,7 +25,7 @@ class PowerSeries:  # pylint: disable=too-few-public-methods
             self.prefactors[i] *= const.PI_4_3**p / si.um ** (3 * p)
 
     def __call__(self, output, radius):
-        self.particulator.backend.power_series(
+        self.backend.power_series(
             values=output.data,
             radius=radius.data,
             num_terms=len(self.powers),

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/dynamics/terminal_velocity/rogers_and_yau.py

@@ -5,11 +5,11 @@ equations: (8.5), (8.6), (8.8)
 
 
 class RogersYau:  # pylint: disable=too-few-public-methods
-    def __init__(self, particulator):
-        self.particulator = particulator
+    def __init__(self, backend):
+        self.backend = backend
 
     def __call__(self, output, radius):
-        self.particulator.backend.rogers_and_yau_terminal_velocity(
+        self.backend.rogers_and_yau_terminal_velocity(
             values=output.data,
             radius=radius.data,
         )

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/dynamics/terminal_velocity/spheres_ice.py

@@ -4,11 +4,11 @@ terminal velocity of solid ice spheres
 
 
 class IceSphere:  # pylint: disable=too-few-public-methods,too-many-arguments
-    def __init__(self, particulator):
-        self.particulator = particulator
+    def __init__(self, backend):
+        self.backend = backend
 
     def __call__(self, output, signed_water_mass, cell_id, temperature, pressure):
-        self.particulator.backend.terminal_velocity_ice_spheres(
+        self.backend.terminal_velocity_ice_spheres(
             values=output.data,
             signed_water_mass=signed_water_mass.data,
             cell_id=cell_id.data,

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/environments/box.py

@@ -16,6 +16,8 @@ class Box:
         self.particulator = None
         self._ambient_air = {}
         self.backend = backend
+        if backend is not None:
+            assert backend.n_dims == self.mesh.n_dims
 
     def __getitem__(self, item):
         return self._ambient_air[item]

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/environments/impl/moist.py

@@ -18,6 +18,7 @@ class Moist:  # pylint: disable=too-many-instance-attributes
         self.dt = dt
         self.mesh = mesh
         self.variables = variables
+        assert backend.n_dims == self.mesh.n_dims
 
         if backend.formulae.ventilation.__name__ != "Neglect":
             for var in ("air density", "air dynamic viscosity"):

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/environments/impl/register_environment.py

@@ -5,8 +5,8 @@ from copy import deepcopy
 
 
 def _instantiate(self, particulator):
-    """Creating a copy without backend as a workaround
-    for long execution times: see PR #1885"""  # to be addressed in TODO #1179
+    """Creating a deep copy to facilitate environment reuse in user code,
+    but exluding backend (and the formulae within) to avoid re-JIT-compilations"""
     backend = self.backend
     self.backend = None
     copy = deepcopy(self)

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/environments/parcel.py

@@ -39,7 +39,7 @@ class Parcel(Moist):  # pylint: disable=too-many-instance-attributes
         super().__init__(
             dt, Mesh.mesh_0d(), variables, mixed_phase=mixed_phase, backend=backend
         )
-
+        assert backend.n_dims == self.mesh.n_dims
         self.mass_of_dry_air = mass_of_dry_air
         self.w = w if callable(w) else lambda _: w
         self.delta_liquid_water_mixing_ratio = np.nan

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/exporters/vtk_exporter.py

@@ -89,7 +89,7 @@ class VTKExporter:
             }
         )
 
-        if particulator.mesh.dimension == 2:
+        if particulator.mesh.n_dims == 2:
             y = (
                 particulator.mesh.size[0]
                 / particulator.mesh.grid[0]
@@ -122,7 +122,7 @@ class VTKExporter:
                 print("Exporting Products to vtk, path: " + path)
             payload = {}
 
-            if particulator.mesh.dimension != 2:
+            if particulator.mesh.n_dims != 2:
                 raise NotImplementedError(
                     "Only 2 dimensions data is supported at the moment."
                 )

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/impl/mesh.py

@@ -21,14 +21,6 @@ class Mesh:
     def dz(self):
         return self.size[-1] / self.grid[-1]
 
-    @property
-    def dimension(self):
-        return self.n_dims
-
-    @property
-    def dim(self):
-        return self.n_dims
-
     @property
     def domain_bottom_surface_area(self):
         assert self.n_dims > 0

pysdm-3.0.0rc43/PySDM/initialisation/init_fall_momenta.py

@@ -0,0 +1,41 @@
+"""
+Initialize the `PySDM.attributes.physics.relative_fall_velocity.RelativeFallMomentum`
+of droplets
+"""
+
+import numpy as np
+
+
+def init_fall_momenta(
+    *,
+    terminal_velocity_approx,
+    backend,
+    water_mass: np.ndarray,
+    zero: bool = False,
+):
+    """
+    Calculate default values of the
+    `PySDM.attributes.physics.relative_fall_velocity.RelativeFallMomentum` attribute
+    (needed when using
+    `PySDM.attributes.physics.relative_fall_velocity.RelativeFallVelocity` attribute)
+
+    Parameters:
+        - water_mass: a numpy array of superdroplet water masses
+
+    Returns:
+        - a numpy array of initial momentum values
+    """
+    if zero:
+        return np.zeros_like(water_mass)
+
+    approximation = terminal_velocity_approx(backend=backend)
+
+    volume_arr = backend.formulae.particle_shape_and_density.mass_to_volume(water_mass)
+    radii_arr = backend.formulae.trivia.radius(volume=volume_arr)
+    radii = backend.Storage.from_ndarray(radii_arr)
+
+    output = backend.Storage.empty((len(water_mass),), dtype=float)
+
+    approximation(output=output, radius=radii)
+
+    return output.to_ndarray() * water_mass

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/initialisation/sampling/spatial_sampling.py

@@ -2,9 +2,6 @@
 spatial sampling logic (i.e., physical x-y-z coordinates)
 """
 
-# TODO #305 QUASIRANDOM & GRID
-#  https://slayoo.github.io/workshop_2019/files/talk_Shima.pdf
-
 
 class Pseudorandom:  # pylint: disable=too-few-public-methods
     @staticmethod

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/PySDM/particulator.py

@@ -725,7 +725,7 @@ class Particulator:  # pylint: disable=too-many-public-methods,too-many-instance
                 **self.condensation_params,
             )
         attributes["multiplicity"] = int_caster(attributes["multiplicity"])
-        if self.mesh.dimension == 0:
+        if self.mesh.n_dims == 0:
             attributes["cell id"] = np.zeros_like(
                 attributes["multiplicity"], dtype=np.int64
             )

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/examples/PySDM_examples/Abade_and_Albuquerque_2024/fig_2.ipynb

@@ -87,7 +87,6 @@
     "        freezing_temperature_spectrum=\"Niemand_et_al_2012\",\n",
     "        heterogeneous_ice_nucleation_rate=\"ABIFM\",\n",
     "    ),\n",
-    "    override_jit_flags={\"parallel\": False}\n",
     ")"
    ]
   },

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/examples/PySDM_examples/Arabas_and_Shima_2017/simulation.py

@@ -30,14 +30,7 @@ class Simulation:
             initial_water_vapour_mixing_ratio=settings.initial_water_vapour_mixing_ratio,
             T0=settings.T0,
             w=settings.w,
-            backend=backend(
-                formulae=settings.formulae,
-                **(
-                    {"override_jit_flags": {"parallel": False}}
-                    if backend is Numba
-                    else {}
-                ),
-            ),
+            backend=backend(formulae=settings.formulae),
         )
         r_wet = equilibrate_wet_radii(
             r_dry=r_dry,

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/examples/PySDM_examples/Arabas_et_al_2015/example_benchmark.py

@@ -54,7 +54,7 @@ def main():
         for sd in n_sd:
             settings.n_sd_per_gridbox = sd
             storage = Storage()
-            simulation = Simulation(settings, storage, None, backend())
+            simulation = Simulation(settings, storage, None, backend(n_dims=2))
             simulation.reinit(products=[WallTime()])
             simulation.run()
             times[key].append(storage.load("wall time")[-1])

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/examples/PySDM_examples/Arabas_et_al_2025/aida.ipynb

@@ -206,7 +206,7 @@
     "                T0 = settings.T0,\n",
     "                initial_water_vapour_mixing_ratio = settings.initial_water_vapour_mixing_ratio,\n",
     "                w = vertical_velocity,\n",
-    "                backend=CPU(settings.formulae, override_jit_flags={\"parallel\": False}),\n",
+    "                backend=CPU(settings.formulae),\n",
     "                mixed_phase = True\n",
     "            )\n",
     "        dry_radius = settings.formulae.trivia.radius(volume=settings.attributes['dry volume'])\n",

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/examples/PySDM_examples/Arabas_et_al_2025/make_particulator.py

@@ -35,7 +35,7 @@ def make_particulator(
         "particle_shape_and_density": "MixedPhaseSpheres",
     }
     formulae = Formulae(**formulae_ctor_args)
-    backend = CPU(formulae, override_jit_flags={"parallel": False})
+    backend = CPU(formulae)
 
     attributes = {
         "signed water mass": np.ones(n_sd) * droplet_volume * formulae.constants.rho_w

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/examples/PySDM_examples/Grabowski_and_Pawlowska_2023/simulation.py

@@ -26,9 +26,7 @@ class Simulation(BasicSimulation):
             T0=settings.initial_temperature,
             w=settings.vertical_velocity,
             mass_of_dry_air=44 * si.kg,
-            backend=CPU(
-                formulae=settings.formulae, override_jit_flags={"parallel": False}
-            ),
+            backend=CPU(formulae=settings.formulae),
         )
         volume = environment.mass_of_dry_air / settings.initial_air_density
         attributes = {

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/examples/PySDM_examples/Jensen_and_Nugent_2017/simulation.py

@@ -38,10 +38,7 @@ class Simulation(BasicSimulation):
             T0=settings.T0,
             w=settings.vertical_velocity,
             z0=settings.z0,
-            backend=CPU(
-                formulae=settings.formulae,
-                override_jit_flags={"parallel": False},
-            ),
+            backend=CPU(formulae=settings.formulae),
         )
 
         self.r_dry, n_in_unit_volume = Logarithmic(

{pysdm-3.0.0rc41 → pysdm-3.0.0rc43}/examples/PySDM_examples/Kreidenweis_et_al_2003/simulation.py

@@ -19,9 +19,7 @@ class Simulation(BasicSimulation):
             initial_water_vapour_mixing_ratio=settings.initial_water_vapour_mixing_ratio,
             T0=settings.T0,
             w=settings.w,
-            backend=CPU(
-                formulae=settings.formulae, override_jit_flags={"parallel": False}
-            ),
+            backend=CPU(formulae=settings.formulae),
         )
         attributes = environment.init_attributes(
             n_in_dv=settings.n_in_dv,