PySDM_examples.Abade_and_Albuquerque_2024.simulation

 1import numpy as np
 2
 3from PySDM_examples.utils import BasicSimulation
 4
 5from PySDM import Builder
 6from PySDM.backends import CPU
 7from PySDM.dynamics import (
 8    Condensation,
 9    AmbientThermodynamics,
10    VapourDepositionOnIce,
11    Freezing,
12)
13from PySDM.initialisation.sampling.spectral_sampling import ConstantMultiplicity
14from PySDM.products import (
15    AmbientTemperature,
16    AmbientWaterVapourMixingRatio,
17    ParcelDisplacement,
18    WaterMixingRatio,
19    SpecificIceWaterContent,
20)
21from PySDM.environments import Parcel
22
23
24class Simulation(BasicSimulation):
25    def __init__(self, settings):
26        builder = Builder(
27            backend=CPU(settings.formulae, override_jit_flags={"parallel": False}),
28            n_sd=settings.n_sd,
29            environment=Parcel(
30                dt=settings.timestep,
31                mass_of_dry_air=settings.mass_of_dry_air,
32                p0=settings.initial_total_pressure,
33                initial_water_vapour_mixing_ratio=settings.initial_water_vapour_mixing_ratio,
34                T0=settings.initial_temperature,
35                w=settings.updraft,
36                mixed_phase=True,
37            ),
38        )
39        builder.add_dynamic(AmbientThermodynamics())
40        builder.add_dynamic(Condensation())
41
42        if settings.enable_immersion_freezing:
43            builder.add_dynamic(Freezing())
44        if settings.enable_vapour_deposition_on_ice:
45            builder.add_dynamic(VapourDepositionOnIce())
46
47        r_dry, n_in_dv = ConstantMultiplicity(settings.soluble_aerosol).sample(
48            n_sd=settings.n_sd
49        )
50        attributes = builder.particulator.environment.init_attributes(
51            n_in_dv=n_in_dv, kappa=settings.kappa, r_dry=r_dry
52        )
53        attributes["signed water mass"] = (
54            builder.particulator.formulae.particle_shape_and_density.volume_to_mass(
55                attributes["volume"]
56            )
57        )
58        del attributes["volume"]
59
60        if settings.enable_immersion_freezing:
61            trivia = builder.particulator.formulae.trivia
62            n_inp = int(settings.n_sd * settings.freezing_inp_frac)
63
64            rng = np.random.default_rng(seed=builder.particulator.formulae.seed)
65
66            attributes["freezing temperature"] = rng.permutation(
67                np.pad(
68                    builder.particulator.formulae.freezing_temperature_spectrum.invcdf(
69                        cdf=rng.uniform(low=0, high=1, size=n_inp),
70                        A_insol=trivia.sphere_surface(
71                            diameter=2 * settings.freezing_inp_dry_radius
72                        ),
73                    ),
74                    (0, settings.n_sd - n_inp),
75                    mode="constant",
76                    constant_values=(trivia.C2K(-38)),
77                )
78            )
79
80        self.products = (
81            WaterMixingRatio(name="water", radius_range=(0, np.inf)),
82            SpecificIceWaterContent(name="ice"),
83            ParcelDisplacement(name="height"),
84            AmbientTemperature(name="T"),
85            AmbientWaterVapourMixingRatio(
86                name="vapour", var="water_vapour_mixing_ratio"
87            ),
88        )
89        super().__init__(
90            particulator=builder.build(attributes=attributes, products=self.products)
91        )
92
93    def run(self, *, nt, steps_per_output_interval):
94        return self._run(nt=nt, steps_per_output_interval=steps_per_output_interval)
25class Simulation(BasicSimulation):
26    def __init__(self, settings):
27        builder = Builder(
28            backend=CPU(settings.formulae, override_jit_flags={"parallel": False}),
29            n_sd=settings.n_sd,
30            environment=Parcel(
31                dt=settings.timestep,
32                mass_of_dry_air=settings.mass_of_dry_air,
33                p0=settings.initial_total_pressure,
34                initial_water_vapour_mixing_ratio=settings.initial_water_vapour_mixing_ratio,
35                T0=settings.initial_temperature,
36                w=settings.updraft,
37                mixed_phase=True,
38            ),
39        )
40        builder.add_dynamic(AmbientThermodynamics())
41        builder.add_dynamic(Condensation())
42
43        if settings.enable_immersion_freezing:
44            builder.add_dynamic(Freezing())
45        if settings.enable_vapour_deposition_on_ice:
46            builder.add_dynamic(VapourDepositionOnIce())
47
48        r_dry, n_in_dv = ConstantMultiplicity(settings.soluble_aerosol).sample(
49            n_sd=settings.n_sd
50        )
51        attributes = builder.particulator.environment.init_attributes(
52            n_in_dv=n_in_dv, kappa=settings.kappa, r_dry=r_dry
53        )
54        attributes["signed water mass"] = (
55            builder.particulator.formulae.particle_shape_and_density.volume_to_mass(
56                attributes["volume"]
57            )
58        )
59        del attributes["volume"]
60
61        if settings.enable_immersion_freezing:
62            trivia = builder.particulator.formulae.trivia
63            n_inp = int(settings.n_sd * settings.freezing_inp_frac)
64
65            rng = np.random.default_rng(seed=builder.particulator.formulae.seed)
66
67            attributes["freezing temperature"] = rng.permutation(
68                np.pad(
69                    builder.particulator.formulae.freezing_temperature_spectrum.invcdf(
70                        cdf=rng.uniform(low=0, high=1, size=n_inp),
71                        A_insol=trivia.sphere_surface(
72                            diameter=2 * settings.freezing_inp_dry_radius
73                        ),
74                    ),
75                    (0, settings.n_sd - n_inp),
76                    mode="constant",
77                    constant_values=(trivia.C2K(-38)),
78                )
79            )
80
81        self.products = (
82            WaterMixingRatio(name="water", radius_range=(0, np.inf)),
83            SpecificIceWaterContent(name="ice"),
84            ParcelDisplacement(name="height"),
85            AmbientTemperature(name="T"),
86            AmbientWaterVapourMixingRatio(
87                name="vapour", var="water_vapour_mixing_ratio"
88            ),
89        )
90        super().__init__(
91            particulator=builder.build(attributes=attributes, products=self.products)
92        )
93
94    def run(self, *, nt, steps_per_output_interval):
95        return self._run(nt=nt, steps_per_output_interval=steps_per_output_interval)
Simulation(settings)
26    def __init__(self, settings):
27        builder = Builder(
28            backend=CPU(settings.formulae, override_jit_flags={"parallel": False}),
29            n_sd=settings.n_sd,
30            environment=Parcel(
31                dt=settings.timestep,
32                mass_of_dry_air=settings.mass_of_dry_air,
33                p0=settings.initial_total_pressure,
34                initial_water_vapour_mixing_ratio=settings.initial_water_vapour_mixing_ratio,
35                T0=settings.initial_temperature,
36                w=settings.updraft,
37                mixed_phase=True,
38            ),
39        )
40        builder.add_dynamic(AmbientThermodynamics())
41        builder.add_dynamic(Condensation())
42
43        if settings.enable_immersion_freezing:
44            builder.add_dynamic(Freezing())
45        if settings.enable_vapour_deposition_on_ice:
46            builder.add_dynamic(VapourDepositionOnIce())
47
48        r_dry, n_in_dv = ConstantMultiplicity(settings.soluble_aerosol).sample(
49            n_sd=settings.n_sd
50        )
51        attributes = builder.particulator.environment.init_attributes(
52            n_in_dv=n_in_dv, kappa=settings.kappa, r_dry=r_dry
53        )
54        attributes["signed water mass"] = (
55            builder.particulator.formulae.particle_shape_and_density.volume_to_mass(
56                attributes["volume"]
57            )
58        )
59        del attributes["volume"]
60
61        if settings.enable_immersion_freezing:
62            trivia = builder.particulator.formulae.trivia
63            n_inp = int(settings.n_sd * settings.freezing_inp_frac)
64
65            rng = np.random.default_rng(seed=builder.particulator.formulae.seed)
66
67            attributes["freezing temperature"] = rng.permutation(
68                np.pad(
69                    builder.particulator.formulae.freezing_temperature_spectrum.invcdf(
70                        cdf=rng.uniform(low=0, high=1, size=n_inp),
71                        A_insol=trivia.sphere_surface(
72                            diameter=2 * settings.freezing_inp_dry_radius
73                        ),
74                    ),
75                    (0, settings.n_sd - n_inp),
76                    mode="constant",
77                    constant_values=(trivia.C2K(-38)),
78                )
79            )
80
81        self.products = (
82            WaterMixingRatio(name="water", radius_range=(0, np.inf)),
83            SpecificIceWaterContent(name="ice"),
84            ParcelDisplacement(name="height"),
85            AmbientTemperature(name="T"),
86            AmbientWaterVapourMixingRatio(
87                name="vapour", var="water_vapour_mixing_ratio"
88            ),
89        )
90        super().__init__(
91            particulator=builder.build(attributes=attributes, products=self.products)
92        )
products
def run(self, *, nt, steps_per_output_interval):
94    def run(self, *, nt, steps_per_output_interval):
95        return self._run(nt=nt, steps_per_output_interval=steps_per_output_interval)