def test_set_mesh(self):
# Arrange
sut = ParticlesBuilder(0, 0, Default)
grid = (1, 1)
size = (1, 1)
# Act & Assert
sut.set_mesh(grid, size)
try:
sut.set_mesh(grid, size)
except AssertionError:
return
assert False
def run(setup):
particles_builder = ParticlesBuilder(n_sd=setup.n_sd,
dt=setup.dt,
backend=setup.backend)
particles_builder.set_mesh_0d(setup.dv)
particles_builder.set_environment(Box, {})
v, n = constant_multiplicity(setup.n_sd, setup.spectrum,
(setup.x_min, setup.x_max))
particles_builder.create_state_0d(n=n,
extensive={'volume': v},
intensive={})
particles_builder.register_dynamic(SDM, {"kernel": setup.kernel})
particles = particles_builder.get_particles()
states = {}
for step in setup.steps:
particles.run(step - particles.n_steps)
setup.check(particles.state, particles.n_steps)
states[particles.n_steps] = copy.deepcopy(particles.state)
return states, particles.stats
def __init__(self, setup):
dt_output = setup.total_time / setup.n_steps
self.n_substeps = 1 # TODO:
while (dt_output / self.n_substeps >= setup.dt_max):
self.n_substeps += 1
particles_builder = ParticlesBuilder(backend=setup.backend,
n_sd=setup.n_sd,
dt=dt_output / self.n_substeps)
particles_builder.set_mesh_0d()
particles_builder.set_environment(
MoistLagrangianParcelAdiabatic, {
"mass_of_dry_air": setup.mass_of_dry_air,
"p0": setup.p0,
"q0": setup.q0,
"T0": setup.T0,
"w": setup.w,
"z0": setup.z0
})
v_dry = phys.volume(radius=setup.r_dry)
r_wet = r_wet_init(setup.r_dry,
particles_builder.particles.environment,
np.zeros_like(setup.n), setup.kappa)
v_wet = phys.volume(radius=r_wet)
particles_builder.create_state_0d(n=setup.n,
extensive={
'dry volume': v_dry,
'volume': v_wet
},
intensive={})
particles_builder.register_dynamic(
Condensation, {
"kappa": setup.kappa,
"rtol_x": setup.rtol_x,
"rtol_thd": setup.rtol_thd,
})
self.particles = particles_builder.get_particles()
self.n_steps = setup.n_steps
def test_coalescence(croupier):
np.random.seed(0) # TODO: working only for backend based on numpy
# Arrange
v_min = 4.186e-15
v_max = 4.186e-12
n_sd = 2**13
steps = [0, 30, 60]
X0 = 4 / 3 * 3.14 * 30.531e-6**3
n_part = 2**23 # [m-3]
dv = 1e6 # [m3]
dt = 1 # [s]
norm_factor = n_part * dv
kernel = Golovin(b=1.5e3) # [s-1]
spectrum = Exponential(norm_factor=norm_factor, scale=X0)
particles_builder = ParticlesBuilder(n_sd=n_sd, dt=dt, backend=backend)
particles_builder.set_mesh_0d(dv=dv)
particles_builder.set_environment(Box, {})
v, n = constant_multiplicity(n_sd, spectrum, (v_min, v_max))
particles_builder.create_state_0d(n=n,
extensive={'volume': v},
intensive={})
particles_builder.register_dynamic(SDM, {"kernel": kernel})
particles = particles_builder.get_particles()
particles.croupier = croupier
states = {}
# Act
for step in steps:
particles.run(step - particles.n_steps)
states[particles.n_steps] = copy.deepcopy(particles.state)
# Assert
x_max = 0
for state in states.values():
assert x_max < state.max('volume')
x_max = state.max('volume')
def reinit(self):
particles_builder = ParticlesBuilder(n_sd=self.setup.n_sd,
dt=self.setup.dt,
backend=self.setup.backend)
particles_builder.set_terminal_velocity(TerminalVelocity)
particles_builder.set_mesh(grid=self.setup.grid, size=self.setup.size)
particles_builder.set_environment(
MoistEulerian2DKinematic, {
"stream_function": self.setup.stream_function,
"field_values": self.setup.field_values,
"rhod_of": self.setup.rhod,
"mpdata_iga": self.setup.mpdata_iga,
"mpdata_tot": self.setup.mpdata_tot,
"mpdata_fct": self.setup.mpdata_fct,
"mpdata_iters": self.setup.mpdata_iters
})
particles_builder.create_state_2d(
extensive={},
intensive={},
spatial_discretisation=spatial_sampling.pseudorandom,
spectral_discretisation=spectral_sampling.
constant_multiplicity, # TODO: random
spectrum_per_mass_of_dry_air=self.setup.
spectrum_per_mass_of_dry_air,
r_range=(self.setup.r_min, self.setup.r_max),
kappa=self.setup.kappa,
radius_threshold=self.setup.aerosol_radius_threshold,
enable_temperatures=self.setup.enable_particle_temperatures)
# <TODO> ?
particles_builder.set_condensation_coord(self.setup.condensation_coord)
particles_builder.register_dynamic(
Condensation, {
"kappa": self.setup.kappa,
"rtol_x": self.setup.condensation_rtol_x,
"rtol_thd": self.setup.condensation_rtol_thd,
"do_advection": self.setup.processes["fluid advection"],
"do_condensation": self.setup.processes["condensation"]
})
particles_builder.register_dynamic(EulerianAdvection, {})
# </TODO>
if self.setup.processes["particle advection"]:
particles_builder.register_dynamic(
Displacement, {
"scheme": 'FTBS',
"sedimentation": self.setup.processes["sedimentation"]
})
if self.setup.processes["coalescence"]:
particles_builder.register_dynamic(SDM,
{"kernel": self.setup.kernel})
if self.setup.processes["relaxation"]:
raise NotImplementedError()
self.particles = particles_builder.get_particles()
# TODO
if self.storage is not None:
self.storage.init(self.setup)
def __init__(self, setup):
t_half = setup.z_half / setup.w_avg
dt_output = (2 * t_half) / setup.n_steps
self.n_substeps = 1
while dt_output / self.n_substeps >= setup.dt_max: # TODO dt_max
self.n_substeps += 1
particles_builder = ParticlesBuilder(backend=setup.backend,
n_sd=1,
dt=dt_output / self.n_substeps)
particles_builder.set_mesh_0d()
particles_builder.set_environment(
MoistLagrangianParcelAdiabatic, {
"mass_of_dry_air": setup.mass_of_dry_air,
"p0": setup.p0,
"q0": setup.q0,
"T0": setup.T0,
"w": setup.w
})
r_dry = np.array([setup.r_dry])
x_dry = phys.volume(radius=r_dry)
n = np.array([setup.n_in_dv], dtype=np.int64)
r_wet = r_wet_init(r_dry, particles_builder.particles.environment,
np.zeros_like(n), setup.kappa)
v_wet = phys.volume(radius=r_wet)
particles_builder.create_state_0d(n=n,
extensive={
'dry volume': x_dry,
'volume': v_wet
},
intensive={})
particles_builder.register_dynamic(
Condensation, {
"kappa": setup.kappa,
"rtol_x": setup.rtol_x,
"rtol_thd": setup.rtol_thd,
})
self.particles = particles_builder.get_particles()
self.n_steps = setup.n_steps