PySDM_examples.Bieli_et_al_2022.simulation 

 1import PySDM.products.size_spectral.arbitrary_moment as am
 2from PySDM.backends import CPU
 3from PySDM.particulator import Particulator
 4from PySDM.dynamics import Collision
 5from PySDM.environments import Box
 6from PySDM.initialisation.sampling.spectral_sampling import ConstantMultiplicity
 7
 8
 9def make_core(settings, coal_eff):
10    backend = CPU
11    collision = Collision(
12        collision_kernel=settings.kernel,
13        coalescence_efficiency=coal_eff,
14        breakup_efficiency=settings.break_eff,
15        fragmentation_function=settings.fragmentation,
16        adaptive=settings.adaptive,
17    )
18    environment = Box(
19        dv=settings.dv,
20        dt=settings.dt,
21        backend=backend(settings.formulae),
22    )
23
24    environment["rhod"] = 1.0
25    attributes = {}
26    attributes["volume"], attributes["multiplicity"] = ConstantMultiplicity(
27        settings.spectrum
28    ).sample_deterministic(settings.n_sd)
29    common_args = {
30        "attr": "volume",
31        "attr_unit": "m^3",
32        "skip_division_by_m0": True,
33        "skip_division_by_dv": True,
34    }
35    products = tuple(
36        am.make_arbitrary_moment_product(rank=rank, **common_args)(name=f"M{rank}")
37        for rank in range(3)
38    )
39    return Particulator(
40        n_sd=settings.n_sd,
41        environment=environment,
42        dynamics=[collision],
43        attributes=attributes,
44        products=products,
45    )
def make_core(settings, coal_eff): 
10def make_core(settings, coal_eff):
11    backend = CPU
12    collision = Collision(
13        collision_kernel=settings.kernel,
14        coalescence_efficiency=coal_eff,
15        breakup_efficiency=settings.break_eff,
16        fragmentation_function=settings.fragmentation,
17        adaptive=settings.adaptive,
18    )
19    environment = Box(
20        dv=settings.dv,
21        dt=settings.dt,
22        backend=backend(settings.formulae),
23    )
24
25    environment["rhod"] = 1.0
26    attributes = {}
27    attributes["volume"], attributes["multiplicity"] = ConstantMultiplicity(
28        settings.spectrum
29    ).sample_deterministic(settings.n_sd)
30    common_args = {
31        "attr": "volume",
32        "attr_unit": "m^3",
33        "skip_division_by_m0": True,
34        "skip_division_by_dv": True,
35    }
36    products = tuple(
37        am.make_arbitrary_moment_product(rank=rank, **common_args)(name=f"M{rank}")
38        for rank in range(3)
39    )
40    return Particulator(
41        n_sd=settings.n_sd,
42        environment=environment,
43        dynamics=[collision],
44        attributes=attributes,
45        products=products,
46    )