def run(settings, backend=CPU, observers=()):
builder = Builder(n_sd=settings.n_sd,
backend=backend(formulae=settings.formulae))
builder.set_environment(Box(dv=settings.dv, dt=settings.dt))
attributes = {}
sampling = ConstantMultiplicity(settings.spectrum)
attributes["volume"], attributes["n"] = sampling.sample(settings.n_sd)
coalescence = Coalescence(collision_kernel=settings.kernel,
adaptive=settings.adaptive)
builder.add_dynamic(coalescence)
products = (
ParticleVolumeVersusRadiusLogarithmSpectrum(settings.radius_bins_edges,
name="dv/dlnr"),
WallTime(),
)
particulator = builder.build(attributes, products)
if hasattr(settings,
"u_term") and "terminal velocity" in particulator.attributes:
particulator.attributes[
"terminal velocity"].approximation = settings.u_term(particulator)
for observer in observers:
particulator.observers.append(observer)
vals = {}
particulator.products["wall time"].reset()
for step in settings.output_steps:
particulator.run(step - particulator.n_steps)
vals[step] = particulator.products["dv/dlnr"].get()[0]
vals[step][:] *= settings.rho
exec_time = particulator.products["wall time"].get()
return vals, exec_time
def __init__(
self, settings, products=None, scipy_solver=False, rtol_thd=1e-10, rtol_x=1e-10
):
env = Parcel(
dt=settings.timestep,
p0=settings.initial_pressure,
q0=settings.initial_vapour_mixing_ratio,
T0=settings.initial_temperature,
w=settings.vertical_velocity,
mass_of_dry_air=44 * si.kg,
)
n_sd = sum(settings.n_sd_per_mode)
builder = Builder(n_sd=n_sd, backend=CPU(formulae=settings.formulae))
builder.set_environment(env)
builder.add_dynamic(AmbientThermodynamics())
builder.add_dynamic(Condensation(rtol_thd=rtol_thd, rtol_x=rtol_x))
volume = env.mass_of_dry_air / settings.initial_air_density
attributes = {
k: np.empty(0) for k in ("dry volume", "kappa times dry volume", "n")
}
for i, (kappa, spectrum) in enumerate(settings.aerosol_modes_by_kappa.items()):
sampling = ConstantMultiplicity(spectrum)
r_dry, n_per_volume = sampling.sample(settings.n_sd_per_mode[i])
v_dry = settings.formulae.trivia.volume(radius=r_dry)
attributes["n"] = np.append(attributes["n"], n_per_volume * volume)
attributes["dry volume"] = np.append(attributes["dry volume"], v_dry)
attributes["kappa times dry volume"] = np.append(
attributes["kappa times dry volume"], v_dry * kappa
)
r_wet = equilibrate_wet_radii(
r_dry=settings.formulae.trivia.radius(volume=attributes["dry volume"]),
environment=env,
kappa_times_dry_volume=attributes["kappa times dry volume"],
)
attributes["volume"] = settings.formulae.trivia.volume(radius=r_wet)
super().__init__(
particulator=builder.build(attributes=attributes, products=products)
)
if scipy_solver:
bdf.patch_particulator(self.particulator)
self.output_attributes = {
"volume": tuple([] for _ in range(self.particulator.n_sd))
}
self.settings = settings
self.__sanity_checks(attributes, volume)
def run(settings, backend):
builder = Builder(n_sd=settings.n_sd, backend=backend)
builder.set_environment(Box(dv=settings.dv, dt=settings.dt))
attributes = {}
sampling = ConstantMultiplicity(settings.spectrum)
attributes["volume"], attributes["n"] = sampling.sample(settings.n_sd)
builder.add_dynamic(Coalescence(collision_kernel=settings.kernel))
particles = builder.build(attributes, products=(WallTime(), ))
states = {}
last_wall_time = None
for step in settings.output_steps:
particles.run(step - particles.n_steps)
last_wall_time = particles.products["wall time"].get()
return states, last_wall_time
def make_core(settings, coal_eff):
backend = CPU
builder = Builder(n_sd=settings.n_sd, backend=backend(settings.formulae))
env = Box(dv=settings.dv, dt=settings.dt)
builder.set_environment(env)
env["rhod"] = 1.0
attributes = {}
attributes["volume"], attributes["n"] = ConstantMultiplicity(
settings.spectrum).sample(settings.n_sd)
collision = Collision(
collision_kernel=settings.kernel,
coalescence_efficiency=coal_eff,
breakup_efficiency=settings.break_eff,
fragmentation_function=settings.fragmentation,
adaptive=settings.adaptive,
)
builder.add_dynamic(collision)
M0 = am.make_arbitrary_moment_product(rank=0,
attr="volume",
attr_unit="m^3")
M1 = am.make_arbitrary_moment_product(rank=1,
attr="volume",
attr_unit="m^3")
M2 = am.make_arbitrary_moment_product(rank=2,
attr="volume",
attr_unit="m^3")
products = (M0(name="M0"), M1(name="M1"), M2(name="M2"))
return builder.build(attributes, products)
def test_coalescence_2_sd(backend_class):
# Arrange
s = Settings()
s.kernel = Golovin(b=1.5e12)
s.formulae.seed = 0
steps = [0, 200]
s.n_sd = 2
builder = Builder(n_sd=s.n_sd, backend=backend_class(formulae=s.formulae))
builder.set_environment(Box(dt=s.dt, dv=s.dv))
attributes = {}
attributes['volume'], attributes['n'] = ConstantMultiplicity(
s.spectrum).sample(s.n_sd)
builder.add_dynamic(Coalescence(s.kernel, adaptive=False))
particulator = builder.build(attributes)
volumes = {}
# Act
for step in steps:
particulator.run(step - particulator.n_steps)
volumes[particulator.
n_steps] = particulator.attributes['volume'].to_ndarray()
# Assert
x_max = 0
for volume in volumes.values():
assert x_max < np.amax(volume)
x_max = np.amax(volume)
assert particulator.attributes.super_droplet_count == 1
def test_coalescence(backend_class, kernel, croupier, adaptive):
if backend_class == ThrustRTC and croupier == 'local': # TODO #358
return
if backend_class == ThrustRTC and adaptive and croupier == 'global': # TODO #329
return
# Arrange
s = Settings()
s.formulae.seed = 0
steps = [0, 800]
builder = Builder(n_sd=s.n_sd, backend=backend_class(formulae=s.formulae))
builder.set_environment(Box(dt=s.dt, dv=s.dv))
attributes = {}
attributes['volume'], attributes['n'] = ConstantMultiplicity(
s.spectrum).sample(s.n_sd)
builder.add_dynamic(
Coalescence(kernel, croupier=croupier, adaptive=adaptive))
particulator = builder.build(attributes)
volumes = {}
# Act
for step in steps:
particulator.run(step - particulator.n_steps)
volumes[particulator.
n_steps] = particulator.attributes['volume'].to_ndarray()
# Assert
x_max = 0
for volume in volumes.values():
assert x_max < np.amax(volume)
x_max = np.amax(volume)
def make_core(settings):
backend = CPU
builder = Builder(n_sd=settings.n_sd, backend=backend(settings.formulae))
env = Box(dv=settings.dv, dt=settings.dt)
builder.set_environment(env)
env["rhod"] = 1.0
attributes = {}
attributes["volume"], attributes["n"] = ConstantMultiplicity(
settings.spectrum).sample(settings.n_sd)
collision = Collision(
collision_kernel=settings.kernel,
coalescence_efficiency=settings.coal_eff,
breakup_efficiency=settings.break_eff,
fragmentation_function=settings.fragmentation,
adaptive=settings.adaptive,
)
builder.add_dynamic(collision)
products = (
ParticleSizeSpectrumPerVolume(
radius_bins_edges=settings.radius_bins_edges, name="dv/dlnr"),
CollisionRatePerGridbox(name="cr"),
CollisionRateDeficitPerGridbox(name="crd"),
)
return builder.build(attributes, products)
def run_box_NObreakup(settings, step):
backend = CPU
builder = Builder(n_sd=settings.n_sd, backend=backend(settings.formulae))
env = Box(dv=settings.dv, dt=settings.dt)
builder.set_environment(env)
env["rhod"] = 1.0
attributes = {}
attributes["volume"], attributes["n"] = ConstantMultiplicity(
settings.spectrum).sample(settings.n_sd)
coal = Coalescence(
collision_kernel=settings.kernel,
coalescence_efficiency=settings.coal_eff,
adaptive=settings.adaptive,
)
builder.add_dynamic(coal)
products = (
ParticleVolumeVersusRadiusLogarithmSpectrum(
radius_bins_edges=settings.radius_bins_edges, name="dv/dlnr"),
CollisionRatePerGridbox(name="cr"),
CollisionRateDeficitPerGridbox(name="crd"),
)
core = builder.build(attributes, products)
# run
core.run(step - core.n_steps)
x = (settings.radius_bins_edges[:-1] / si.micrometres, )
y = core.products["dv/dlnr"].get()
return (x, y)
def make_particulator(
*,
constants,
n_sd,
dt,
initial_temperature,
singular,
seed,
shima_T_fz,
ABIFM_spec,
droplet_volume,
total_particle_number,
volume
):
attributes = {"volume": np.ones(n_sd) * droplet_volume}
formulae_ctor_args = {"seed": seed, "constants": constants}
if singular:
formulae_ctor_args["freezing_temperature_spectrum"] = shima_T_fz
else:
formulae_ctor_args["heterogeneous_ice_nucleation_rate"] = "ABIFM"
formulae = Formulae(**formulae_ctor_args)
if singular:
sampling = SpectroGlacialSampling(
freezing_temperature_spectrum=formulae.freezing_temperature_spectrum,
insoluble_surface_spectrum=ABIFM_spec,
seed=formulae.seed,
)
attributes["freezing temperature"], _, attributes["n"] = sampling.sample(n_sd)
else:
sampling = ConstantMultiplicity(
spectrum=ABIFM_spec,
# seed=formulae.seed
)
attributes["immersed surface area"], attributes["n"] = sampling.sample(n_sd)
attributes["n"] *= total_particle_number
builder = Builder(n_sd, CPU(formulae))
env = Box(dt, volume)
builder.set_environment(env)
env["T"] = initial_temperature
env["RH"] = A_VALUE_LARGER_THAN_ONE
builder.add_dynamic(Freezing(singular=singular))
return builder.build(
attributes=attributes,
products=(
PySDM_products.Time(name="t"),
PySDM_products.AmbientTemperature(name="T"),
PySDM_products.SpecificIceWaterContent(name="qi"),
),
)
def test_coalescence(backend_class, croupier, adaptive):
if backend_class == ThrustRTC and croupier == 'local': # TODO #358
return
if backend_class == ThrustRTC and adaptive and croupier == 'global': # TODO #329
return
# Arrange
formulae = Formulae(seed=256)
n_sd = 2 ** 14
steps = [0, 100, 200]
X0 = formulae.trivia.volume(radius=30.531e-6)
n_part = 2 ** 23 / si.metre ** 3
dv = 1e6 * si.metres ** 3
dt = 1 * si.seconds
norm_factor = n_part * dv
rho = 1000 * si.kilogram / si.metre ** 3
kernel = Golovin(b=1.5e3) # [s-1]
spectrum = Exponential(norm_factor=norm_factor, scale=X0)
builder = Builder(n_sd=n_sd, backend=backend_class(formulae=formulae))
builder.set_environment(Box(dt=dt, dv=dv))
attributes = {}
attributes['volume'], attributes['n'] = ConstantMultiplicity(spectrum).sample(n_sd)
builder.add_dynamic(Coalescence(kernel, croupier=croupier, adaptive=adaptive))
particulator = builder.build(attributes)
volumes = {}
# Act
for step in steps:
particulator.run(step - particulator.n_steps)
check(n_part, dv, n_sd, rho, particulator.attributes, step)
volumes[particulator.n_steps] = particulator.attributes['volume'].to_ndarray()
# Assert
x_max = 0
for volume in volumes.values():
assert x_max < np.amax(volume)
x_max = np.amax(volume)
def run_parcel(
w,
sol2,
N2,
rad2,
n_sd_per_mode,
RH0=1.0,
T0=294 * si.K,
p0=1e5 * si.Pa,
n_steps=50,
mass_of_dry_air=1e3 * si.kg,
dt=2 * si.s,
):
products = (
PySDM_products.WaterMixingRatio(unit="g/kg", name="ql"),
PySDM_products.PeakSupersaturation(name="S max"),
PySDM_products.AmbientRelativeHumidity(name="RH"),
PySDM_products.ParcelDisplacement(name="z"),
)
formulae = Formulae()
const = formulae.constants
pv0 = RH0 * formulae.saturation_vapour_pressure.pvs_Celsius(T0 - const.T0)
q0 = const.eps * pv0 / (p0 - pv0)
env = Parcel(dt=dt,
mass_of_dry_air=mass_of_dry_air,
p0=p0,
q0=q0,
w=w,
T0=T0)
aerosol = AerosolARG(M2_sol=sol2, M2_N=N2, M2_rad=rad2)
n_sd = n_sd_per_mode * len(aerosol.modes)
builder = Builder(backend=CPU(), n_sd=n_sd)
builder.set_environment(env)
builder.add_dynamic(AmbientThermodynamics())
builder.add_dynamic(Condensation())
builder.add_dynamic(Magick())
attributes = {
k: np.empty(0)
for k in ("dry volume", "kappa times dry volume", "n")
}
for i, mode in enumerate(aerosol.modes):
kappa, spectrum = mode["kappa"]["CompressedFilmOvadnevaite"], mode[
"spectrum"]
r_dry, concentration = ConstantMultiplicity(spectrum).sample(
n_sd_per_mode)
v_dry = builder.formulae.trivia.volume(radius=r_dry)
specific_concentration = concentration / builder.formulae.constants.rho_STP
attributes["n"] = np.append(
attributes["n"], specific_concentration * env.mass_of_dry_air)
attributes["dry volume"] = np.append(attributes["dry volume"], v_dry)
attributes["kappa times dry volume"] = np.append(
attributes["kappa times dry volume"], v_dry * kappa)
r_wet = equilibrate_wet_radii(
r_dry=builder.formulae.trivia.radius(volume=attributes["dry volume"]),
environment=env,
kappa_times_dry_volume=attributes["kappa times dry volume"],
)
attributes["volume"] = builder.formulae.trivia.volume(radius=r_wet)
particulator = builder.build(attributes, products=products)
bdf.patch_particulator(particulator)
output = {product.name: [] for product in particulator.products.values()}
output_attributes = {
"n": tuple([] for _ in range(particulator.n_sd)),
"volume": tuple([] for _ in range(particulator.n_sd)),
"critical volume": tuple([] for _ in range(particulator.n_sd)),
"critical supersaturation":
tuple([] for _ in range(particulator.n_sd)),
}
for _ in range(n_steps):
particulator.run(steps=1)
for product in particulator.products.values():
value = product.get()
output[product.name].append(value[0])
for key, attr in output_attributes.items():
attr_data = particulator.attributes[key].to_ndarray()
for drop_id in range(particulator.n_sd):
attr[drop_id].append(attr_data[drop_id])
error = np.zeros(len(aerosol.modes))
activated_fraction_S = np.zeros(len(aerosol.modes))
activated_fraction_V = np.zeros(len(aerosol.modes))
for j, mode in enumerate(aerosol.modes):
activated_drops_j_S = 0
activated_drops_j_V = 0
RHmax = np.nanmax(np.asarray(output["RH"]))
for i, volume in enumerate(output_attributes["volume"]):
if j * n_sd_per_mode <= i < (j + 1) * n_sd_per_mode:
if output_attributes["critical supersaturation"][i][-1] < RHmax:
activated_drops_j_S += output_attributes["n"][i][-1]
if output_attributes["critical volume"][i][-1] < volume[-1]:
activated_drops_j_V += output_attributes["n"][i][-1]
Nj = np.asarray(output_attributes["n"])[j * n_sd_per_mode:(j + 1) *
n_sd_per_mode, -1]
max_multiplicity_j = np.max(Nj)
sum_multiplicity_j = np.sum(Nj)
error[j] = max_multiplicity_j / sum_multiplicity_j
activated_fraction_S[j] = activated_drops_j_S / sum_multiplicity_j
activated_fraction_V[j] = activated_drops_j_V / sum_multiplicity_j
Output = namedtuple(
"Output",
[
"profile",
"attributes",
"aerosol",
"activated_fraction_S",
"activated_fraction_V",
"error",
],
)
return Output(
profile=output,
attributes=output_attributes,
aerosol=aerosol,
activated_fraction_S=activated_fraction_S,
activated_fraction_V=activated_fraction_V,
error=error,
)