PySDM_examples.Shima_et_al_2009.tutorial_example

View Source

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

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

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