PySDM-examples 3.0.0rc29__tar.gz → 3.0.0rc31__tar.gz

{pysdm_examples-3.0.0rc29 → pysdm_examples-3.0.0rc31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdm-examples
-Version: 3.0.0rc29
+Version: 3.0.0rc31
 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
@@ -34,7 +34,7 @@ Requires-Dist: joblib==1.5.3; extra == "ci-version-pins"
 Requires-Dist: ipywidgets==8.1.7; 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: vtk==9.6.1; extra == "ci-version-pins"
+Requires-Dist: vtk==9.6.2; extra == "ci-version-pins"
 Requires-Dist: pyrcel==1.3.4; extra == "ci-version-pins"
 Requires-Dist: pyvinecopulib==0.7.6; extra == "ci-version-pins"
 Dynamic: author

pysdm_examples-3.0.0rc31/PySDM_examples/Arabas_and_Pawlowska_2011/__init__.py

@@ -0,0 +1,14 @@
+# pylint: disable=invalid-name
+"""
+condensation example using parcel environment based on
+[Arabas Pawlowska 2011 (GMD)](https://doi.org/10.5194/gmd-4-15-2011)
+
+fig_1.ipynb:
+.. include:: ./fig_1.ipynb.badges.md
+
+fig_2.ipynb:
+.. include:: ./fig_2.ipynb.badges.md
+"""
+
+from .simulation import Simulation
+from .settings import Settings

pysdm_examples-3.0.0rc31/PySDM_examples/Arabas_and_Pawlowska_2011/settings.py

@@ -0,0 +1,66 @@
+from PySDM import Formulae
+from PySDM.physics import si
+from PySDM.initialisation.spectra import Lognormal, Sum
+
+
+class Settings:
+    def __init__(self):
+        self.dt = 0.25 * si.s
+        self.mass_of_dry_air = 1000 * si.kg
+        self.p0 = 1000 * si.hPa
+        self.RH0 = 0.99 * si.dimensionless
+        self.T0 = 280 * si.K
+        self.w = 0.25 * si.m / si.s
+
+        self.initial_air_density = 1.245 * si.kg / si.m**3
+
+        self.output_interval = 4
+        self.output_points = 250
+        self.n_sd = 1024
+
+        self.formulae = Formulae()
+
+        self.cloud_range = (1 * si.um, 25 * si.um)
+
+        self.kappa_sea_salt = 1.28 * si.dimensionless
+        self.kappa_sulphate = 0.61 * si.dimensionless
+
+        sea_salt_spectrum = Sum(
+            (
+                Lognormal(
+                    norm_factor=51.1 / si.cm**3,
+                    m_mode=0.10 * si.um,
+                    s_geom=1.90,
+                ),
+                Lognormal(
+                    norm_factor=2.21 / si.cm**3,
+                    m_mode=1.00 * si.um,
+                    s_geom=2.00,
+                ),
+                Lognormal(
+                    norm_factor=1e-5 / si.cm**3,
+                    m_mode=6.00 * si.um,
+                    s_geom=3.00,
+                ),
+            )
+        )
+
+        sulphate_spectrum = Lognormal(
+            norm_factor=100 / si.cm**3,
+            m_mode=0.08 * si.um,
+            s_geom=1.45,
+        )
+
+        self.total_aerosol_concentration = (
+            sea_salt_spectrum.norm_factor + sulphate_spectrum.norm_factor
+        )
+
+        self.aerosol_modes_by_kappa = {
+            self.kappa_sea_salt: sea_salt_spectrum,
+            self.kappa_sulphate: sulphate_spectrum,
+        }
+
+        self.aerosol_mode_names = (
+            "sea salt",
+            "sulphate",
+        )

pysdm_examples-3.0.0rc31/PySDM_examples/Arabas_and_Pawlowska_2011/simulation.py

@@ -0,0 +1,156 @@
+import numpy as np
+
+from PySDM_examples.utils.basic_simulation import BasicSimulation
+
+from PySDM import Builder, products
+from PySDM.backends import CPU
+from PySDM.dynamics import AmbientThermodynamics, Condensation
+from PySDM.environments import Parcel
+from PySDM.initialisation import discretise_multiplicities
+from PySDM.initialisation.hygroscopic_equilibrium import equilibrate_wet_radii
+from PySDM.initialisation.sampling import spectral_sampling
+
+
+class Simulation(BasicSimulation):
+    def __init__(
+        self,
+        settings,
+        product_list=None,
+    ):
+        self.settings = settings
+
+        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,
+        )
+
+        builder.add_dynamic(AmbientThermodynamics())
+        builder.add_dynamic(Condensation())
+
+        builder.request_attribute("radius")
+
+        self.builder = builder
+
+        attributes, self.mode_id = self._make_attributes()
+
+        if product_list is None:
+            product_list = (
+                products.AmbientRelativeHumidity(name="RH"),
+                products.Time(name="time"),
+                products.AmbientTemperature(name="T"),
+            )
+
+        particulator = builder.build(
+            attributes=attributes,
+            products=product_list,
+        )
+
+        super().__init__(
+            particulator=particulator,
+            output_attributes=["radius"],
+        )
+
+    def _make_attributes(self):
+        settings = self.settings
+        formulae = settings.formulae
+        environment = self.builder.particulator.environment
+
+        parcel_volume = environment.mass_of_dry_air / settings.initial_air_density
+
+        n_components = len(settings.aerosol_modes_by_kappa)
+
+        if settings.n_sd % n_components != 0:
+            raise ValueError(
+                f"settings.n_sd={settings.n_sd} must be divisible by "
+                f"n_components={n_components}"
+            )
+
+        n_sd_per_component = settings.n_sd // n_components
+
+        dry_volume_parts = []
+        kappa_vdry_parts = []
+        multiplicity_parts = []
+        mode_id_parts = []
+
+        for component_id, (kappa, spectrum) in enumerate(
+            settings.aerosol_modes_by_kappa.items()
+        ):
+            r_dry, concentration = spectral_sampling.Logarithmic(
+                spectrum=spectrum
+            ).sample_deterministic(n_sd_per_component)
+
+            v_dry = formulae.trivia.volume(radius=r_dry)
+
+            dry_volume_parts.append(v_dry)
+            kappa_vdry_parts.append(kappa * v_dry)
+
+            multiplicity_parts.append(
+                discretise_multiplicities(concentration * parcel_volume)
+            )
+
+            mode_id_parts.append(
+                np.full(n_sd_per_component, component_id, dtype=np.int64)
+            )
+
+        dry_volume = np.concatenate(dry_volume_parts)
+        kappa_times_dry_volume = np.concatenate(kappa_vdry_parts)
+        multiplicity = np.concatenate(multiplicity_parts)
+        mode_id = np.concatenate(mode_id_parts)
+
+        r_wet = equilibrate_wet_radii(
+            r_dry=formulae.trivia.radius(volume=dry_volume),
+            environment=environment,
+            kappa_times_dry_volume=kappa_times_dry_volume,
+        )
+
+        attributes = {
+            "multiplicity": multiplicity,
+            "dry volume": dry_volume,
+            "kappa times dry volume": kappa_times_dry_volume,
+            "volume": formulae.trivia.volume(radius=r_wet),
+        }
+
+        self._sanity_check_attributes(attributes, mode_id, parcel_volume)
+
+        return attributes, mode_id
+
+    def _sanity_check_attributes(self, attributes, mode_id, volume):
+        for attribute in attributes.values():
+            assert attribute.shape[0] == self.settings.n_sd
+
+        assert mode_id.shape[0] == self.settings.n_sd
+
+        assert np.all(attributes["multiplicity"] > 0)
+        assert np.all(attributes["dry volume"] > 0)
+        assert np.all(attributes["volume"] >= attributes["dry volume"])
+
+        kappa_eff = attributes["kappa times dry volume"] / attributes["dry volume"]
+
+        for component_id, kappa in enumerate(
+            self.settings.aerosol_modes_by_kappa.keys()
+        ):
+            mask = mode_id == component_id
+            assert np.any(mask)
+            assert np.allclose(kappa_eff[mask], kappa)
+
+        np.testing.assert_allclose(
+            np.sum(attributes["multiplicity"]) / volume,
+            self.settings.total_aerosol_concentration,
+            rtol=1e-2,
+        )
+
+    def run(self):
+        return self._run(
+            nt=self.settings.output_interval * self.settings.output_points,
+            steps_per_output_interval=self.settings.output_interval,
+        )

{pysdm_examples-3.0.0rc29 → pysdm_examples-3.0.0rc31}/PySDM_examples/Grabowski_and_Pawlowska_2023/settings.py

@@ -55,21 +55,26 @@ class Settings:
             },
         }[aerosol]
 
-        const = self.formulae.constants
         self.vertical_velocity = vertical_velocity
         self.initial_pressure = initial_pressure
         self.initial_temperature = initial_temperature
-        pv0 = (
-            initial_relative_humidity
-            * self.formulae.saturation_vapour_pressure.pvs_water(initial_temperature)
-        )
-        self.initial_vapour_mixing_ratio = const.eps * pv0 / (initial_pressure - pv0)
+        self.initial_relative_humidity = initial_relative_humidity
         self.t_max = displacement / vertical_velocity
         self.timestep = dt
         self.output_interval = self.timestep
         self.rtol_thd = rtol_thd
         self.rtol_x = rtol_x
 
+        self.initial_vapour_mixing_ratio = (
+            self.formulae.trivia.water_vapour_mixing_ratio(
+                self.initial_pressure,
+                self.initial_relative_humidity,
+                self.formulae.saturation_vapour_pressure.pvs_water(
+                    self.initial_temperature
+                ),
+            )
+        )
+
     @property
     def initial_air_density(self):
         const = self.formulae.constants

{pysdm_examples-3.0.0rc29 → pysdm_examples-3.0.0rc31}/PySDM_examples/Grabowski_and_Pawlowska_2023/simulation.py

@@ -26,7 +26,7 @@ class Simulation(BasicSimulation):
             environment=Parcel(
                 dt=settings.timestep,
                 p0=settings.initial_pressure,
-                initial_water_vapour_mixing_ratio=settings.initial_vapour_mixing_ratio,
+                initial_relative_humidity=settings.initial_relative_humidity,
                 T0=settings.initial_temperature,
                 w=settings.vertical_velocity,
                 mass_of_dry_air=44 * si.kg,

{pysdm_examples-3.0.0rc29 → pysdm_examples-3.0.0rc31}/PySDM_examples/Jensen_and_Nugent_2017/simulation.py

@@ -28,24 +28,20 @@ class Simulation(BasicSimulation):
         gccn: bool = False,
         gravitational_coalsecence: bool = False,
     ):
-        const = settings.formulae.constants
-        pvs_water = settings.formulae.saturation_vapour_pressure.pvs_water
-        initial_water_vapour_mixing_ratio = const.eps / (
-            settings.p0 / settings.RH0 / pvs_water(settings.T0) - 1
-        )
 
         n_gccn = np.count_nonzero(table_3.NA) if gccn else 0
 
         builder = Builder(
             n_sd=N_SD_NON_GCCN + n_gccn,
             backend=CPU(
-                formulae=settings.formulae, override_jit_flags={"parallel": False}
+                formulae=settings.formulae,
+                override_jit_flags={"parallel": False},
             ),
             environment=Parcel(
                 dt=settings.dt,
                 mass_of_dry_air=666 * si.kg,
                 p0=settings.p0,
-                initial_water_vapour_mixing_ratio=initial_water_vapour_mixing_ratio,
+                initial_relative_humidity=settings.RH0,
                 T0=settings.T0,
                 w=settings.vertical_velocity,
                 z0=settings.z0,
@@ -77,7 +73,12 @@ class Simulation(BasicSimulation):
             )  # TODO #1266: check which temp, pres, RH assumed in the paper for NA???
 
         pd0 = settings.formulae.trivia.p_d(
-            settings.p0, initial_water_vapour_mixing_ratio
+            settings.p0,
+            settings.formulae.trivia.water_vapour_mixing_ratio(
+                settings.p0,
+                settings.RH0,
+                settings.formulae.saturation_vapour_pressure.pvs_water(settings.T0),
+            ),
         )
         rhod0 = settings.formulae.state_variable_triplet.rhod_of_pd_T(pd0, settings.T0)
 

pysdm_examples-3.0.0rc31/PySDM_examples/Luettmer_homogeneous_freezing/__init__.py

@@ -0,0 +1,17 @@
+"""
+Homogeneous freezing example
+
+.. include:: ./fig_1_2_3.ipynb
+.. include:: ./fig_4_5_6_S3_S4.ipynb
+.. include:: ./fig_S1_S2.ipynb
+.. include:: ./simple_homogenous_freezing_example.ipynb
+"""
+
+from .settings import Settings
+from .simulation import Simulation
+from .plot import (
+    plot_thermodynamics_and_bulk,
+    plot_freezing_temperatures_histogram,
+    plot_freezing_temperatures_histogram_allinone,
+    plot_freezing_temperatures_2d_histogram_seaborn,
+)

pysdm_examples-3.0.0rc31/PySDM_examples/Luettmer_homogeneous_freezing/commons.py

@@ -0,0 +1,91 @@
+"""commons for homogeneous freezing notebooks"""
+
+from PySDM_examples.Luettmer_homogeneous_freezing.settings import Settings
+from PySDM_examples.Luettmer_homogeneous_freezing.simulation import Simulation
+from PySDM import Formulae
+from PySDM.physics.constants import si
+from PySDM.backends import CPU
+
+formulae = Formulae(
+    particle_shape_and_density="MixedPhaseSpheres",
+)
+
+
+def run_simulations(setting):
+
+    simulation = {
+        "settings": setting,
+        "ensemble_member_outputs": [],
+    }
+    for _ in range(setting["number_of_ensemble_runs"]):
+        model_setup = Settings(**simulation["settings"])
+        model_setup.formulae.seed += 1
+        model = Simulation(model_setup)
+        simulation["ensemble_member_outputs"].append(model.run())
+
+    return simulation
+
+
+def hom_pure_droplet_freezing_backend():
+    cmn = {"override_jit_flags": {"parallel": False}}
+    backends = {
+        "threshold": CPU(
+            formulae=Formulae(
+                particle_shape_and_density="MixedPhaseSpheres",
+                homogeneous_ice_nucleation_rate="Null",
+                saturation_vapour_pressure="MurphyKoop2005",
+            ),
+            **cmn,
+        ),
+        "KoopMurray2016": CPU(
+            formulae=Formulae(
+                particle_shape_and_density="MixedPhaseSpheres",
+                homogeneous_ice_nucleation_rate="KoopMurray2016",
+                saturation_vapour_pressure="MurphyKoop2005",
+            ),
+            **cmn,
+        ),
+        "Spichtinger2023": CPU(
+            formulae=Formulae(
+                particle_shape_and_density="MixedPhaseSpheres",
+                homogeneous_ice_nucleation_rate="Koop_Correction",
+                saturation_vapour_pressure="MurphyKoop2005",
+            ),
+            **cmn,
+        ),
+        "Koop2000": CPU(
+            formulae=Formulae(
+                particle_shape_and_density="MixedPhaseSpheres",
+                homogeneous_ice_nucleation_rate="Koop2000",
+                saturation_vapour_pressure="MurphyKoop2005",
+            ),
+            **cmn,
+        ),
+        "KoopMurray2016_DWA": CPU(
+            formulae=Formulae(
+                particle_shape_and_density="MixedPhaseSpheres",
+                homogeneous_ice_nucleation_rate="KoopMurray2016_DWA",
+                saturation_vapour_pressure="MurphyKoop2005",
+            ),
+            **cmn,
+        ),
+    }
+    return backends
+
+
+def hom_pure_droplet_freezing_standard_setup():
+    standard = {
+        "n_sd": int(1e3),
+        "w_updraft": 1.0 * si.meter / si.second,
+        "T0": 245 * si.kelvin,
+        "dz": 1.0 * si.meter,
+        "n_ccn": 750 / si.cm**3,
+        "r_ccn": 15 * si.nanometer,
+        "type_droplet_distribution": "monodisperse",
+        "RH_0": 0.995,
+        "p0": 500 * si.hectopascals,
+        "deposition_enable": True,
+        "number_of_ensemble_runs": 1,
+        "silent": True,
+    }
+    return standard