PySDM_examples.Shima_et_al_2009.tutorial_example

View Source

 1from PySDM.backends import CPU
 2from PySDM.builder import Builder
 3from PySDM.dynamics import Coalescence
 4from PySDM.environments import Box
 5from PySDM.initialisation.sampling.spectral_sampling import ConstantMultiplicity
 6from PySDM.products import ParticleVolumeVersusRadiusLogarithmSpectrum, WallTime
 7
 8
 9def run(settings, observers=()):
10    builder = Builder(
11        n_sd=settings.n_sd,
12        backend=CPU(formulae=settings.formulae),
13        environment=Box(dv=settings.dv, dt=settings.dt),
14    )
15    attributes = {}
16    sampling = ConstantMultiplicity(settings.spectrum)
17    attributes["volume"], attributes["multiplicity"] = sampling.sample_deterministic(
18        settings.n_sd
19    )
20    coalescence = Coalescence(
21        collision_kernel=settings.kernel, adaptive=settings.adaptive
22    )
23    builder.add_dynamic(coalescence)
24    products = (
25        ParticleVolumeVersusRadiusLogarithmSpectrum(
26            settings.radius_bins_edges, name="dv/dlnr"
27        ),
28        WallTime(),
29    )
30    particulator = builder.build(attributes, products)
31    if hasattr(settings, "u_term") and "terminal velocity" in particulator.attributes:
32        particulator.attributes["terminal velocity"].approximation = settings.u_term(
33            particulator
34        )
35
36    for observer in observers:
37        particulator.observers.append(observer)
38
39    vals = {}
40    particulator.products["wall time"].reset()
41    for step in settings.output_steps:
42        particulator.run(step - particulator.n_steps)
43        vals[step] = particulator.products["dv/dlnr"].get()[0]
44        vals[step][:] *= settings.rho
45
46    exec_time = particulator.products["wall time"].get()
47    return vals, exec_time

def run(settings, observers=()): View Source

10def run(settings, observers=()):
11    builder = Builder(
12        n_sd=settings.n_sd,
13        backend=CPU(formulae=settings.formulae),
14        environment=Box(dv=settings.dv, dt=settings.dt),
15    )
16    attributes = {}
17    sampling = ConstantMultiplicity(settings.spectrum)
18    attributes["volume"], attributes["multiplicity"] = sampling.sample_deterministic(
19        settings.n_sd
20    )
21    coalescence = Coalescence(
22        collision_kernel=settings.kernel, adaptive=settings.adaptive
23    )
24    builder.add_dynamic(coalescence)
25    products = (
26        ParticleVolumeVersusRadiusLogarithmSpectrum(
27            settings.radius_bins_edges, name="dv/dlnr"
28        ),
29        WallTime(),
30    )
31    particulator = builder.build(attributes, products)
32    if hasattr(settings, "u_term") and "terminal velocity" in particulator.attributes:
33        particulator.attributes["terminal velocity"].approximation = settings.u_term(
34            particulator
35        )
36
37    for observer in observers:
38        particulator.observers.append(observer)
39
40    vals = {}
41    particulator.products["wall time"].reset()
42    for step in settings.output_steps:
43        particulator.run(step - particulator.n_steps)
44        vals[step] = particulator.products["dv/dlnr"].get()[0]
45        vals[step][:] *= settings.rho
46
47    exec_time = particulator.products["wall time"].get()
48    return vals, exec_time