PySDM_examples.featured.Srivastava_1982.simulation

View Source

 1import numpy as np
 2from PySDM_examples.featured.Srivastava_1982.settings import SimProducts
 3
 4from PySDM import Particulator, Formulae
 5from PySDM.environments import Box
 6from PySDM.products import SuperDropletCountPerGridbox, VolumeFirstMoment, ZerothMoment
 7
 8
 9class Simulation:
10    def __init__(
11        self, n_steps, settings, collision_dynamic=None, double_precision=True
12    ):
13        self.collision_dynamic = collision_dynamic
14        self.settings = settings
15        self.n_steps = n_steps
16
17        self.double_precision = double_precision
18
19        self.simulation_res = {
20            n_sd: {prod: {} for prod in self.settings.prods}
21            for n_sd in self.settings.n_sds
22        }
23
24    def build(self, n_sd, seed, products):
25        env = Box(
26            dt=self.settings.dt,
27            dv=self.settings.dv,
28            backend=self.settings.backend_class(
29                formulae=Formulae(
30                    constants={"rho_w": self.settings.rho},
31                    fragmentation_function="ConstantMass",
32                    seed=seed,
33                ),
34                double_precision=self.double_precision,
35            ),
36        )
37
38        particulator = Particulator(
39            n_sd=n_sd,
40            environment=env,
41            dynamics=(self.collision_dynamic,),
42            products=products,
43            attributes={
44                "multiplicity": np.full(n_sd, self.settings.total_number_0 / n_sd),
45                "volume": np.full(
46                    n_sd,
47                    self.settings.total_volume / self.settings.total_number_0,
48                ),
49            },
50        )
51        return particulator
52
53    def run_convergence_analysis(self, x, seeds):
54        for n_sd in self.settings.n_sds:
55            for seed in seeds:
56                products = (
57                    SuperDropletCountPerGridbox(
58                        name=SimProducts.PySDM.super_particle_count.name
59                    ),
60                    VolumeFirstMoment(name=SimProducts.PySDM.total_volume.name),
61                    ZerothMoment(name=SimProducts.PySDM.total_numer.name),
62                )
63
64                particulator = self.build(n_sd, seed, products)
65
66                for prod in self.settings.prods:
67                    self.simulation_res[n_sd][prod][seed] = np.full(
68                        self.n_steps + 1, -np.inf
69                    )
70
71                for step in range(len(x)):
72                    if step != 0:
73                        particulator.advance(n_steps=1)
74                    for prod in self.settings.prods:
75                        (self.simulation_res[n_sd][prod][seed][step],) = (
76                            particulator.products[prod].get()
77                        )
78
79                np.testing.assert_allclose(
80                    actual=self.simulation_res[n_sd][
81                        SimProducts.PySDM.total_volume.name
82                    ][seed],
83                    desired=self.settings.total_volume,
84                    rtol=1e-3,
85                )
86
87        return self.simulation_res

class Simulation: View Source

10class Simulation:
11    def __init__(
12        self, n_steps, settings, collision_dynamic=None, double_precision=True
13    ):
14        self.collision_dynamic = collision_dynamic
15        self.settings = settings
16        self.n_steps = n_steps
17
18        self.double_precision = double_precision
19
20        self.simulation_res = {
21            n_sd: {prod: {} for prod in self.settings.prods}
22            for n_sd in self.settings.n_sds
23        }
24
25    def build(self, n_sd, seed, products):
26        env = Box(
27            dt=self.settings.dt,
28            dv=self.settings.dv,
29            backend=self.settings.backend_class(
30                formulae=Formulae(
31                    constants={"rho_w": self.settings.rho},
32                    fragmentation_function="ConstantMass",
33                    seed=seed,
34                ),
35                double_precision=self.double_precision,
36            ),
37        )
38
39        particulator = Particulator(
40            n_sd=n_sd,
41            environment=env,
42            dynamics=(self.collision_dynamic,),
43            products=products,
44            attributes={
45                "multiplicity": np.full(n_sd, self.settings.total_number_0 / n_sd),
46                "volume": np.full(
47                    n_sd,
48                    self.settings.total_volume / self.settings.total_number_0,
49                ),
50            },
51        )
52        return particulator
53
54    def run_convergence_analysis(self, x, seeds):
55        for n_sd in self.settings.n_sds:
56            for seed in seeds:
57                products = (
58                    SuperDropletCountPerGridbox(
59                        name=SimProducts.PySDM.super_particle_count.name
60                    ),
61                    VolumeFirstMoment(name=SimProducts.PySDM.total_volume.name),
62                    ZerothMoment(name=SimProducts.PySDM.total_numer.name),
63                )
64
65                particulator = self.build(n_sd, seed, products)
66
67                for prod in self.settings.prods:
68                    self.simulation_res[n_sd][prod][seed] = np.full(
69                        self.n_steps + 1, -np.inf
70                    )
71
72                for step in range(len(x)):
73                    if step != 0:
74                        particulator.advance(n_steps=1)
75                    for prod in self.settings.prods:
76                        (self.simulation_res[n_sd][prod][seed][step],) = (
77                            particulator.products[prod].get()
78                        )
79
80                np.testing.assert_allclose(
81                    actual=self.simulation_res[n_sd][
82                        SimProducts.PySDM.total_volume.name
83                    ][seed],
84                    desired=self.settings.total_volume,
85                    rtol=1e-3,
86                )
87
88        return self.simulation_res

Simulation(n_steps, settings, collision_dynamic=None, double_precision=True) View Source

11    def __init__(
12        self, n_steps, settings, collision_dynamic=None, double_precision=True
13    ):
14        self.collision_dynamic = collision_dynamic
15        self.settings = settings
16        self.n_steps = n_steps
17
18        self.double_precision = double_precision
19
20        self.simulation_res = {
21            n_sd: {prod: {} for prod in self.settings.prods}
22            for n_sd in self.settings.n_sds
23        }

collision_dynamic

settings

n_steps

double_precision

simulation_res

def build(self, n_sd, seed, products): View Source

25    def build(self, n_sd, seed, products):
26        env = Box(
27            dt=self.settings.dt,
28            dv=self.settings.dv,
29            backend=self.settings.backend_class(
30                formulae=Formulae(
31                    constants={"rho_w": self.settings.rho},
32                    fragmentation_function="ConstantMass",
33                    seed=seed,
34                ),
35                double_precision=self.double_precision,
36            ),
37        )
38
39        particulator = Particulator(
40            n_sd=n_sd,
41            environment=env,
42            dynamics=(self.collision_dynamic,),
43            products=products,
44            attributes={
45                "multiplicity": np.full(n_sd, self.settings.total_number_0 / n_sd),
46                "volume": np.full(
47                    n_sd,
48                    self.settings.total_volume / self.settings.total_number_0,
49                ),
50            },
51        )
52        return particulator

def run_convergence_analysis(self, x, seeds): View Source

54    def run_convergence_analysis(self, x, seeds):
55        for n_sd in self.settings.n_sds:
56            for seed in seeds:
57                products = (
58                    SuperDropletCountPerGridbox(
59                        name=SimProducts.PySDM.super_particle_count.name
60                    ),
61                    VolumeFirstMoment(name=SimProducts.PySDM.total_volume.name),
62                    ZerothMoment(name=SimProducts.PySDM.total_numer.name),
63                )
64
65                particulator = self.build(n_sd, seed, products)
66
67                for prod in self.settings.prods:
68                    self.simulation_res[n_sd][prod][seed] = np.full(
69                        self.n_steps + 1, -np.inf
70                    )
71
72                for step in range(len(x)):
73                    if step != 0:
74                        particulator.advance(n_steps=1)
75                    for prod in self.settings.prods:
76                        (self.simulation_res[n_sd][prod][seed][step],) = (
77                            particulator.products[prod].get()
78                        )
79
80                np.testing.assert_allclose(
81                    actual=self.simulation_res[n_sd][
82                        SimProducts.PySDM.total_volume.name
83                    ][seed],
84                    desired=self.settings.total_volume,
85                    rtol=1e-3,
86                )
87
88        return self.simulation_res