PySDM_examples.Srivastava_1982.simulation

View Source

 1import numpy as np
 2from PySDM_examples.Srivastava_1982.settings import SimProducts
 3
 4from PySDM import Builder, 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(dt=self.settings.dt, dv=self.settings.dv)
26        builder = Builder(
27            backend=self.settings.backend_class(
28                formulae=Formulae(
29                    constants={"rho_w": self.settings.rho},
30                    fragmentation_function="ConstantMass",
31                    seed=seed,
32                ),
33                double_precision=self.double_precision,
34            ),
35            n_sd=n_sd,
36            environment=env,
37            dynamics=(self.collision_dynamic,),
38        )
39
40        particulator = builder.build(
41            products=products,
42            attributes={
43                "multiplicity": np.full(n_sd, self.settings.total_number_0 / n_sd),
44                "volume": np.full(
45                    n_sd,
46                    self.settings.total_volume / self.settings.total_number_0,
47                ),
48            },
49        )
50        return particulator
51
52    def run_convergence_analysis(self, x, seeds):
53        for n_sd in self.settings.n_sds:
54            for seed in seeds:
55                products = (
56                    SuperDropletCountPerGridbox(
57                        name=SimProducts.PySDM.super_particle_count.name
58                    ),
59                    VolumeFirstMoment(name=SimProducts.PySDM.total_volume.name),
60                    ZerothMoment(name=SimProducts.PySDM.total_numer.name),
61                )
62
63                particulator = self.build(n_sd, seed, products)
64
65                for prod in self.settings.prods:
66                    self.simulation_res[n_sd][prod][seed] = np.full(
67                        self.n_steps + 1, -np.inf
68                    )
69
70                for step in range(len(x)):
71                    if step != 0:
72                        particulator.run(steps=1)
73                    for prod in self.settings.prods:
74                        (self.simulation_res[n_sd][prod][seed][step],) = (
75                            particulator.products[prod].get()
76                        )
77
78                np.testing.assert_allclose(
79                    actual=self.simulation_res[n_sd][
80                        SimProducts.PySDM.total_volume.name
81                    ][seed],
82                    desired=self.settings.total_volume,
83                    rtol=1e-3,
84                )
85
86        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(dt=self.settings.dt, dv=self.settings.dv)
27        builder = Builder(
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            n_sd=n_sd,
37            environment=env,
38            dynamics=(self.collision_dynamic,),
39        )
40
41        particulator = builder.build(
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.run(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

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(dt=self.settings.dt, dv=self.settings.dv)
27        builder = Builder(
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            n_sd=n_sd,
37            environment=env,
38            dynamics=(self.collision_dynamic,),
39        )
40
41        particulator = builder.build(
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

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

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.run(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