PySDM-examples 3.0.0rc39__tar.gz → 3.0.0rc41__tar.gz

{pysdm_examples-3.0.0rc39/pysdm_examples.egg-info → pysdm_examples-3.0.0rc41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdm-examples
-Version: 3.0.0rc39
+Version: 3.0.0rc41
 Summary: PySDM usage examples reproducing results from literature and depicting how to use PySDM from Python Jupyter notebooks
 Author-email: "https://github.com/open-atmos/PySDM/graphs/contributors" <sylwester.arabas@agh.edu.pl>
 License-Expression: GPL-3.0-only
@@ -30,13 +30,13 @@ Requires-Dist: PyMPDATA==1.7.3; extra == "ci-version-pins"
 Requires-Dist: open-atmos-jupyter-utils==1.5.0; extra == "ci-version-pins"
 Requires-Dist: pystrict==1.3; extra == "ci-version-pins"
 Requires-Dist: matplotlib!=3.9.1; extra == "ci-version-pins"
-Requires-Dist: joblib==1.5.3; extra == "ci-version-pins"
-Requires-Dist: ipywidgets==8.1.7; extra == "ci-version-pins"
+Requires-Dist: joblib==1.6.0; extra == "ci-version-pins"
+Requires-Dist: ipywidgets==8.1; extra == "ci-version-pins"
 Requires-Dist: seaborn==0.13.2; extra == "ci-version-pins"
-Requires-Dist: numdifftools==0.9.42; extra == "ci-version-pins"
+Requires-Dist: numdifftools==0.11.1; extra == "ci-version-pins"
 Requires-Dist: vtk==9.6.2; extra == "ci-version-pins"
 Requires-Dist: pyrcel==2.0.0; extra == "ci-version-pins"
-Requires-Dist: pyvinecopulib==0.7.6; extra == "ci-version-pins"
+Requires-Dist: pyvinecopulib==1.0.0; extra == "ci-version-pins"
 Requires-Dist: cmcrameri==1.10; extra == "ci-version-pins"
 Requires-Dist: cmap==0.7.2; extra == "ci-version-pins"
 Dynamic: description

{pysdm_examples-3.0.0rc39 → pysdm_examples-3.0.0rc41}/PySDM_examples/Abade_and_Albuquerque_2024/simulation.py

@@ -2,7 +2,7 @@ import numpy as np
 
 from PySDM_examples.utils import BasicSimulation
 
-from PySDM import Builder
+from PySDM.particulator import Particulator
 from PySDM.dynamics import (
     Condensation,
     AmbientThermodynamics,
@@ -40,39 +40,36 @@ class Simulation(BasicSimulation):
         if settings.enable_vapour_deposition_on_ice:
             dynamics.append(VapourDepositionOnIce(adaptive=True))
 
-        builder = Builder(
+        environment = Parcel(
+            dt=settings.timestep,
+            mass_of_dry_air=settings.mass_of_dry_air,
+            p0=settings.initial_total_pressure,
+            initial_water_vapour_mixing_ratio=settings.initial_water_vapour_mixing_ratio,
+            T0=settings.initial_temperature,
+            w=settings.updraft,
+            mixed_phase=True,
             backend=settings.backend,
-            n_sd=settings.n_sd,
-            environment=Parcel(
-                dt=settings.timestep,
-                mass_of_dry_air=settings.mass_of_dry_air,
-                p0=settings.initial_total_pressure,
-                initial_water_vapour_mixing_ratio=settings.initial_water_vapour_mixing_ratio,
-                T0=settings.initial_temperature,
-                w=settings.updraft,
-                mixed_phase=True,
-            ),
-            dynamics=dynamics,
         )
-
         r_dry, n_in_dv = ConstantMultiplicity(
             settings.soluble_aerosol
         ).sample_deterministic(n_sd=settings.n_sd)
-        attributes = builder.particulator.environment.init_attributes(
-            n_in_dv=n_in_dv, kappa=settings.kappa, r_dry=r_dry
+        attributes = environment.init_attributes(
+            n_in_dv=n_in_dv,
+            kappa=settings.kappa,
+            r_dry=r_dry,
         )
         attributes["signed water mass"] = (
-            builder.particulator.formulae.particle_shape_and_density.volume_to_mass(
+            settings.backend.formulae.particle_shape_and_density.volume_to_mass(
                 attributes["volume"]
             )
         )
         del attributes["volume"]
 
         if settings.enable_immersion_freezing:
-            trivia = builder.particulator.formulae.trivia
+            trivia = settings.backend.formulae.trivia
             n_inp = int(settings.n_sd * settings.freezing_inp_frac)
 
-            rng = np.random.default_rng(seed=builder.particulator.formulae.seed)
+            rng = np.random.default_rng(seed=settings.backend.formulae.seed)
             insoluble_surface_area = trivia.sphere_surface(
                 diameter=2 * settings.freezing_inp_dry_radius
             )
@@ -81,7 +78,7 @@ class Simulation(BasicSimulation):
             ] = rng.permutation(
                 np.pad(
                     (
-                        builder.particulator.formulae.freezing_temperature_spectrum.invcdf(
+                        settings.backend.formulae.freezing_temperature_spectrum.invcdf(
                             cdf=rng.uniform(low=0, high=1, size=n_inp),
                             A_insol=insoluble_surface_area,
                         )
@@ -91,7 +88,7 @@ class Simulation(BasicSimulation):
                     (0, settings.n_sd - n_inp),
                     mode="constant",
                     constant_values=(
-                        builder.particulator.formulae.constants.HOMOGENEOUS_FREEZING_THRESHOLD
+                        settings.backend.formulae.constants.HOMOGENEOUS_FREEZING_THRESHOLD
                         if settings.singular
                         else 0
                     ),
@@ -107,9 +104,14 @@ class Simulation(BasicSimulation):
                 name="vapour", var="water_vapour_mixing_ratio"
             ),
         )
-        super().__init__(
-            particulator=builder.build(attributes=attributes, products=self.products)
+        particulator = Particulator(
+            n_sd=settings.n_sd,
+            environment=environment,
+            dynamics=dynamics,
+            attributes=attributes,
+            products=self.products,
         )
+        super().__init__(particulator=particulator)
 
     def run(self, *, nt, steps_per_output_interval):
         return self._run(nt=nt, steps_per_output_interval=steps_per_output_interval)

{pysdm_examples-3.0.0rc39 → pysdm_examples-3.0.0rc41}/PySDM_examples/Abdul_Razzak_Ghan_2000/run_ARG_parcel.py

@@ -3,7 +3,7 @@ from collections import namedtuple
 import numpy as np
 from PySDM_examples.Abdul_Razzak_Ghan_2000.aerosol import CONSTANTS_ARG, AerosolARG
 
-from PySDM import Builder, Formulae
+from PySDM import Particulator, Formulae
 from PySDM import products as PySDM_products
 from PySDM.backends import CPU
 from PySDM.dynamics import AmbientThermodynamics, Condensation
@@ -45,6 +45,7 @@ def run_parcel(
         initial_water_vapour_mixing_ratio=const.eps * pv0 / (p0 - pv0),
         w=w,
         T0=T0,
+        backend=CPU(formulae),
     )
 
     aerosol = AerosolARG(
@@ -52,14 +53,6 @@ def run_parcel(
     )
     n_sd = n_sd_per_mode * len(aerosol.modes)
 
-    builder = Builder(
-        backend=CPU(formulae),
-        n_sd=n_sd,
-        environment=env,
-        dynamics=[AmbientThermodynamics(), Condensation()],
-    )
-    builder.request_attribute("critical saturation")
-
     attributes = {
         k: np.empty(0) for k in ("dry volume", "kappa times dry volume", "multiplicity")
     }
@@ -68,11 +61,11 @@ def run_parcel(
         r_dry, concentration = ConstantMultiplicity(spectrum).sample_deterministic(
             n_sd_per_mode
         )
-        v_dry = builder.formulae.trivia.volume(radius=r_dry)
-        specific_concentration = concentration / builder.formulae.constants.rho_STP
+        v_dry = formulae.trivia.volume(radius=r_dry)
+        specific_concentration = concentration / env.backend.formulae.constants.rho_STP
         attributes["multiplicity"] = np.append(
             attributes["multiplicity"],
-            specific_concentration * builder.particulator.environment.mass_of_dry_air,
+            specific_concentration * env.mass_of_dry_air,
         )
         attributes["dry volume"] = np.append(attributes["dry volume"], v_dry)
         attributes["kappa times dry volume"] = np.append(
@@ -80,13 +73,20 @@ def run_parcel(
         )
 
     r_wet = equilibrate_wet_radii(
-        r_dry=builder.formulae.trivia.radius(volume=attributes["dry volume"]),
-        environment=builder.particulator.environment,
+        r_dry=formulae.trivia.radius(volume=attributes["dry volume"]),
+        environment=env,
         kappa_times_dry_volume=attributes["kappa times dry volume"],
     )
-    attributes["volume"] = builder.formulae.trivia.volume(radius=r_wet)
+    attributes["volume"] = env.backend.formulae.trivia.volume(radius=r_wet)
 
-    particulator = builder.build(attributes, products=products)
+    particulator = Particulator(
+        n_sd=n_sd,
+        environment=env,
+        dynamics=[AmbientThermodynamics(), Condensation()],
+        requested_attributes=("critical saturation",),
+        attributes=attributes,
+        products=products,
+    )
 
     output = {product.name: [] for product in particulator.products.values()}
     output_attributes = {

{pysdm_examples-3.0.0rc39 → pysdm_examples-3.0.0rc41}/PySDM_examples/Alpert_and_Knopf_2016/simulation.py

@@ -5,7 +5,7 @@ import numpy as np
 from matplotlib import pyplot
 from packaging import version
 
-from PySDM import Builder, Formulae
+from PySDM import Particulator, Formulae
 from PySDM.backends import CPU
 from PySDM.dynamics import Freezing
 from PySDM.environments import Box
@@ -52,7 +52,7 @@ class Simulation:
             else:
                 total_time = (
                     np.diff(np.asarray(self.temperature_range)) / case["cooling_rate"]
-                )
+                ).item()
 
             constants = None
             if "J_het" not in case:
@@ -214,13 +214,6 @@ def simulation(
         constants=constants,
         particle_shape_and_density="MixedPhaseSpheres",
     )
-    builder = Builder(
-        n_sd=n_sd,
-        backend=CPU(formulae=formulae),
-        environment=Box(dt=time_step, dv=volume),
-        dynamics=[Freezing(immersion_freezing="time-dependent")],
-    )
-    builder.request_attribute("volume")
 
     if hasattr(spectrum, "s_geom") and spectrum.s_geom == 1:
         _isa, _conc = np.full(n_sd, spectrum.m_mode), np.full(
@@ -240,12 +233,20 @@ def simulation(
         IceWaterContent(name="qi"),
         TotalUnfrozenImmersedSurfaceArea(name="A_tot"),
     )
-    particulator = builder.build(attributes=attributes, products=products)
-    env = particulator.environment
-
+    env = Box(dt=time_step, dv=volume, backend=CPU(formulae=formulae))
     env["T"] = initial_temperature
     env["a_w_ice"] = np.nan
     env["RH"] = 1 + np.finfo(float).eps
+
+    particulator = Particulator(
+        n_sd=n_sd,
+        environment=env,
+        attributes=attributes,
+        products=products,
+        dynamics=[Freezing(immersion_freezing="time-dependent")],
+        requested_attributes=("volume",),
+    )
+
     svp = particulator.formulae.saturation_vapour_pressure
 
     cell_id = 0

{pysdm_examples-3.0.0rc39 → pysdm_examples-3.0.0rc41}/PySDM_examples/Arabas_and_Pawlowska_2011/simulation.py

@@ -2,7 +2,7 @@ import numpy as np
 
 from PySDM_examples.utils.basic_simulation import BasicSimulation
 
-from PySDM import Builder, products
+from PySDM import products, Particulator
 from PySDM.backends import CPU
 from PySDM.dynamics import AmbientThermodynamics, Condensation
 from PySDM.environments import Parcel
@@ -19,29 +19,16 @@ class Simulation(BasicSimulation):
     ):
         self.settings = settings
 
-        environment = Parcel(
+        self.environment = Parcel(
             dt=settings.dt,
             mass_of_dry_air=settings.mass_of_dry_air,
             p0=settings.p0,
             initial_relative_humidity=settings.RH0,
             T0=settings.T0,
             w=settings.w,
-        )
-
-        builder = Builder(
             backend=CPU(settings.formulae),
-            n_sd=settings.n_sd,
-            environment=environment,
-            dynamics=(
-                AmbientThermodynamics(),
-                Condensation(),
-            ),
         )
 
-        builder.request_attribute("radius")
-
-        self.builder = builder
-
         attributes, self.mode_id = self._make_attributes()
 
         if product_list is None:
@@ -51,9 +38,16 @@ class Simulation(BasicSimulation):
                 products.AmbientTemperature(name="T"),
             )
 
-        particulator = builder.build(
+        particulator = Particulator(
+            n_sd=settings.n_sd,
+            environment=self.environment,
+            dynamics=(
+                AmbientThermodynamics(),
+                Condensation(),
+            ),
             attributes=attributes,
             products=product_list,
+            requested_attributes=("radius",),
         )
 
         super().__init__(
@@ -64,7 +58,7 @@ class Simulation(BasicSimulation):
     def _make_attributes(self):
         settings = self.settings
         formulae = settings.formulae
-        environment = self.builder.particulator.environment
+        environment = self.environment
 
         parcel_volume = environment.mass_of_dry_air / settings.initial_air_density
 

{pysdm_examples-3.0.0rc39 → pysdm_examples-3.0.0rc41}/PySDM_examples/Arabas_and_Shima_2017/simulation.py

@@ -1,8 +1,8 @@
 import numpy as np
 
 import PySDM.products as PySDM_products
+from PySDM import Particulator
 from PySDM.backends import Numba
-from PySDM.builder import Builder
 from PySDM.dynamics import AmbientThermodynamics, Condensation
 from PySDM.environments import Parcel
 from PySDM.initialisation.hygroscopic_equilibrium import equilibrate_wet_radii
@@ -18,7 +18,18 @@ class Simulation:
         while dt_output / self.n_substeps >= settings.dt_max:  # TODO #334 dt_max
             self.n_substeps += 1
 
-        builder = Builder(
+        attributes = {}
+        r_dry = np.array([settings.r_dry])
+        attributes["dry volume"] = settings.formulae.trivia.volume(radius=r_dry)
+        attributes["kappa times dry volume"] = attributes["dry volume"] * settings.kappa
+        attributes["multiplicity"] = np.array([settings.n_in_dv], dtype=np.int64)
+        environment = Parcel(
+            dt=dt_output / self.n_substeps,
+            mass_of_dry_air=settings.mass_of_dry_air,
+            p0=settings.p0,
+            initial_water_vapour_mixing_ratio=settings.initial_water_vapour_mixing_ratio,
+            T0=settings.T0,
+            w=settings.w,
             backend=backend(
                 formulae=settings.formulae,
                 **(
@@ -27,31 +38,7 @@ class Simulation:
                     else {}
                 ),
             ),
-            n_sd=1,
-            environment=Parcel(
-                dt=dt_output / self.n_substeps,
-                mass_of_dry_air=settings.mass_of_dry_air,
-                p0=settings.p0,
-                initial_water_vapour_mixing_ratio=settings.initial_water_vapour_mixing_ratio,
-                T0=settings.T0,
-                w=settings.w,
-            ),
-            dynamics=[
-                AmbientThermodynamics(),
-                Condensation(
-                    rtol_x=settings.rtol_x,
-                    rtol_thd=settings.rtol_thd,
-                    dt_cond_range=settings.dt_cond_range,
-                ),
-            ],
         )
-
-        attributes = {}
-        r_dry = np.array([settings.r_dry])
-        attributes["dry volume"] = settings.formulae.trivia.volume(radius=r_dry)
-        attributes["kappa times dry volume"] = attributes["dry volume"] * settings.kappa
-        attributes["multiplicity"] = np.array([settings.n_in_dv], dtype=np.int64)
-        environment = builder.particulator.environment
         r_wet = equilibrate_wet_radii(
             r_dry=r_dry,
             environment=environment,
@@ -72,7 +59,20 @@ class Simulation:
             PySDM_products.RipeningRate(unit="s^-1 mg^-1", name="ripening_rate"),
         ]
 
-        self.particulator = builder.build(attributes, products)
+        self.particulator = Particulator(
+            n_sd=1,
+            dynamics=[
+                AmbientThermodynamics(),
+                Condensation(
+                    rtol_x=settings.rtol_x,
+                    rtol_thd=settings.rtol_thd,
+                    dt_cond_range=settings.dt_cond_range,
+                ),
+            ],
+            attributes=attributes,
+            products=products,
+            environment=environment,
+        )
 
         self.n_output = settings.n_output
 

{pysdm_examples-3.0.0rc39 → pysdm_examples-3.0.0rc41}/PySDM_examples/Arabas_et_al_2025/make_particulator.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from PySDM import Builder, Formulae
+from PySDM import Particulator, Formulae
 from PySDM import products as PySDM_products
 from PySDM.backends import CPU
 from PySDM.dynamics import Freezing
@@ -65,22 +65,17 @@ def make_particulator(
         thaw_flag = None
     attributes["multiplicity"] *= total_particle_number
 
-    builder = Builder(
-        n_sd=n_sd,
-        backend=backend,
-        environment=Box(dt, volume),
-        dynamics=[Freezing(immersion_freezing=immersion_freezing_flag, thaw=thaw_flag)],
-    )
-
-    env = builder.particulator.environment
+    env = Box(dt, volume, backend=backend)
     env["T"] = initial_temperature
     env["RH"] = A_VALUE_LARGER_THAN_ONE
     env["rhod"] = 1.0
 
-    builder.request_attribute("volume")
-
-    return builder.build(
+    return Particulator(
+        n_sd=n_sd,
+        environment=env,
+        dynamics=[Freezing(immersion_freezing=immersion_freezing_flag, thaw=thaw_flag)],
         attributes=attributes,
+        requested_attributes=("volume",),
         products=(
             PySDM_products.Time(name="t"),
             PySDM_products.AmbientTemperature(name="T"),

{pysdm_examples-3.0.0rc39 → pysdm_examples-3.0.0rc41}/PySDM_examples/Arabas_et_al_2025/run_simulation.py

@@ -1,10 +1,8 @@
 import numpy as np
 
 
-def update_thermo(particulator, T):
-    env = particulator.environment
-    svp = particulator.formulae.saturation_vapour_pressure
-
+def update_thermo(env, T):
+    svp = env.backend.formulae.saturation_vapour_pressure
     env["T"] = T
     env["a_w_ice"] = svp.pvs_ice(T) / svp.pvs_water(T)
 
@@ -17,10 +15,13 @@ def run_simulation(particulator, temperature_profile, n_steps):
     for step in range(n_steps + 1):
         if step != 0:
             update_thermo(
-                particulator, T=temperature_profile((step - 0.5) * particulator.dt)
+                particulator.environment,
+                T=temperature_profile((step - 0.5) * particulator.dt),
             )
             particulator.run(step - particulator.n_steps)
-            update_thermo(particulator, T=temperature_profile(step * particulator.dt))
+            update_thermo(
+                particulator.environment, T=temperature_profile(step * particulator.dt)
+            )
             output["frozen"].append(particulator.attributes["volume"].to_ndarray() < 0)
         else:
             output["spectrum"] = {}

{pysdm_examples-3.0.0rc39 → pysdm_examples-3.0.0rc41}/PySDM_examples/Bieli_et_al_2022/simulation.py

@@ -1,6 +1,6 @@
 import PySDM.products.size_spectral.arbitrary_moment as am
 from PySDM.backends import CPU
-from PySDM.builder import Builder
+from PySDM.particulator import Particulator
 from PySDM.dynamics import Collision
 from PySDM.environments import Box
 from PySDM.initialisation.sampling.spectral_sampling import ConstantMultiplicity
@@ -15,13 +15,13 @@ def make_core(settings, coal_eff):
         fragmentation_function=settings.fragmentation,
         adaptive=settings.adaptive,
     )
-    builder = Builder(
-        n_sd=settings.n_sd,
+    environment = Box(
+        dv=settings.dv,
+        dt=settings.dt,
         backend=backend(settings.formulae),
-        environment=Box(dv=settings.dv, dt=settings.dt),
-        dynamics=[collision],
     )
-    builder.particulator.environment["rhod"] = 1.0
+
+    environment["rhod"] = 1.0
     attributes = {}
     attributes["volume"], attributes["multiplicity"] = ConstantMultiplicity(
         settings.spectrum
@@ -36,4 +36,10 @@ def make_core(settings, coal_eff):
         am.make_arbitrary_moment_product(rank=rank, **common_args)(name=f"M{rank}")
         for rank in range(3)
     )
-    return builder.build(attributes, products)
+    return Particulator(
+        n_sd=settings.n_sd,
+        environment=environment,
+        dynamics=[collision],
+        attributes=attributes,
+        products=products,
+    )

{pysdm_examples-3.0.0rc39 → pysdm_examples-3.0.0rc41}/PySDM_examples/Grabowski_and_Pawlowska_2023/simulation.py

@@ -1,7 +1,7 @@
 import numpy as np
 from PySDM_examples.utils import BasicSimulation
 
-from PySDM import Builder
+from PySDM import Particulator
 from PySDM.backends import CPU
 from PySDM.backends.impl_numba.test_helpers import scipy_ode_condensation_solver
 from PySDM.dynamics import AmbientThermodynamics, Condensation
@@ -18,33 +18,19 @@ class Simulation(BasicSimulation):
         products=None,
         scipy_solver=False,
     ):
-        builder = Builder(
-            n_sd=settings.n_sd,
+
+        environment = Parcel(
+            dt=settings.timestep,
+            p0=settings.initial_pressure,
+            initial_relative_humidity=settings.initial_relative_humidity,
+            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}
             ),
-            environment=Parcel(
-                dt=settings.timestep,
-                p0=settings.initial_pressure,
-                initial_relative_humidity=settings.initial_relative_humidity,
-                T0=settings.initial_temperature,
-                w=settings.vertical_velocity,
-                mass_of_dry_air=44 * si.kg,
-            ),
-            dynamics=(
-                AmbientThermodynamics(),
-                Condensation(rtol_thd=settings.rtol_thd, rtol_x=settings.rtol_x),
-            ),
         )
-        for attribute in (
-            "critical saturation",
-            "equilibrium saturation",
-            "critical volume",
-        ):
-            builder.request_attribute(attribute)
-
-        env = builder.particulator.environment
-        volume = env.mass_of_dry_air / settings.initial_air_density
+        volume = environment.mass_of_dry_air / settings.initial_air_density
         attributes = {
             k: np.empty(0)
             for k in ("dry volume", "kappa times dry volume", "multiplicity")
@@ -67,14 +53,28 @@ class Simulation(BasicSimulation):
         )
         r_wet = equilibrate_wet_radii(
             r_dry=settings.formulae.trivia.radius(volume=attributes["dry volume"]),
-            environment=env,
+            environment=environment,
             kappa_times_dry_volume=attributes["kappa times dry volume"],
         )
         attributes["volume"] = settings.formulae.trivia.volume(radius=r_wet)
 
-        super().__init__(
-            particulator=builder.build(attributes=attributes, products=products)
+        particulator = Particulator(
+            n_sd=settings.n_sd,
+            environment=environment,
+            dynamics=(
+                AmbientThermodynamics(),
+                Condensation(rtol_thd=settings.rtol_thd, rtol_x=settings.rtol_x),
+            ),
+            attributes=attributes,
+            products=products,
+            requested_attributes=(
+                "critical saturation",
+                "equilibrium saturation",
+                "critical volume",
+            ),
         )
+
+        super().__init__(particulator=particulator)
         if scipy_solver:
             scipy_ode_condensation_solver.patch_particulator(self.particulator)