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        dynamics=(
15            Coalescence(collision_kernel=settings.kernel, adaptive=settings.adaptive),
16        ),
17    )
18    attributes = {}
19    sampling = ConstantMultiplicity(settings.spectrum)
20    attributes["volume"], attributes["multiplicity"] = sampling.sample_deterministic(
21        settings.n_sd
22    )
23    products = (
24        ParticleVolumeVersusRadiusLogarithmSpectrum(
25            settings.radius_bins_edges, name="dv/dlnr"
26        ),
27        WallTime(),
28    )
29    particulator = builder.build(attributes, products)
30    if hasattr(settings, "u_term") and "terminal velocity" in particulator.attributes:
31        particulator.attributes["terminal velocity"].approximation = settings.u_term(
32            particulator
33        )
34
35    for observer in observers:
36        particulator.observers.append(observer)
37
38    vals = {}
39    particulator.products["wall time"].reset()
40    for step in settings.output_steps:
41        particulator.run(step - particulator.n_steps)
42        vals[step] = particulator.products["dv/dlnr"].get()[0]
43        vals[step][:] *= settings.rho
44
45    exec_time = particulator.products["wall time"].get()
46    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        dynamics=(
16            Coalescence(collision_kernel=settings.kernel, adaptive=settings.adaptive),
17        ),
18    )
19    attributes = {}
20    sampling = ConstantMultiplicity(settings.spectrum)
21    attributes["volume"], attributes["multiplicity"] = sampling.sample_deterministic(
22        settings.n_sd
23    )
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