def test_coalescence():
# TODO: np.random.RandomState in backend?
# 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 = Particles(n_sd=n_sd, dt=dt, backend=backend)
particles.set_mesh_0d(dv=dv)
particles.set_environment(Box, {})
v, n = constant_multiplicity(n_sd, spectrum, (v_min, v_max))
particles.create_state_0d(n=n, extensive={'volume': v}, intensive={})
particles.add_dynamic(SDM, {"kernel": kernel})
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')
class Simulation:
def __init__(self, setup):
self.particles = Particles(backend=setup.backend,
n_sd=setup.n_sd,
dt=setup.dt)
self.particles.set_mesh_0d()
self.particles.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, self.particles.environment,
np.zeros_like(setup.n), setup.kappa)
v_wet = phys.volume(radius=r_wet)
self.particles.create_state_0d(n=setup.n,
extensive={
'dry volume': v_dry,
'volume': v_wet
},
intensive={})
self.particles.add_dynamic(Condensation, {"kappa": setup.kappa})
self.n_steps = setup.n_steps
# TODO: make it common with Arabas_and_Shima_2017
def save(self, output):
cell_id = 0
volume = self.particles.state.get_backend_storage('volume')
volume = self.particles.backend.to_ndarray(volume)
output["r"].append(phys.radius(volume=volume))
output["S"].append(self.particles.environment["RH"][cell_id] - 1)
output["qv"].append(self.particles.environment["qv"][cell_id])
output["T"].append(self.particles.environment["T"][cell_id])
output["z"].append(self.particles.environment["z"][cell_id])
output["t"].append(self.particles.environment["t"][cell_id])
def run(self):
output = {"r": [], "S": [], "z": [], "t": [], "qv": [], "T": []}
self.save(output)
for step in range(self.n_steps):
self.particles.run(1)
self.save(output)
return output
class Simulation:
def __init__(self, setup):
t_half = setup.z_half / setup.w_avg
dt = (2 * t_half) / setup.n_steps
self.particles = Particles(backend=setup.backend, n_sd=1, dt=dt)
self.particles.set_mesh_0d()
self.particles.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, self.particles.environment, np.zeros_like(n),
setup.kappa)
v_wet = phys.volume(radius=r_wet)
self.particles.create_state_0d(n=n,
extensive={
'dry volume': x_dry,
'volume': v_wet
},
intensive={})
self.particles.add_dynamic(Condensation, {"kappa": setup.kappa})
self.n_steps = setup.n_steps
# TODO: common with Yang?
def save(self, output):
cell_id = 0
volume = self.particles.state.get_backend_storage('volume')
volume = self.particles.backend.to_ndarray(volume)
output["r"].append(phys.radius(volume=volume))
output["S"].append(self.particles.environment["RH"][cell_id] - 1)
output["z"].append(self.particles.environment["z"][cell_id])
output["t"].append(self.particles.environment["t"][cell_id])
def run(self):
output = {"r": [], "S": [], "z": [], "t": []}
self.save(output)
for step in range(self.n_steps):
self.particles.run(1)
self.save(output)
return output
def run(setup):
particles = Particles(n_sd=setup.n_sd, dt=setup.dt, backend=setup.backend)
particles.set_mesh_0d(setup.dv)
particles.set_environment(Box, {})
v, n = constant_multiplicity(setup.n_sd, setup.spectrum,
(setup.x_min, setup.x_max))
particles.create_state_0d(n=n, extensive={'volume': v}, intensive={})
particles.add_dynamic(SDM, {"kernel": setup.kernel})
states = {}
for step in setup.steps:
particles.run(step - particles.n_steps)
# setup.check(runner.state, runner.n_steps) TODO???
return states, particles.stats