def run(settings, backend=CPU, observers=()):
builder = Builder(n_sd=settings.n_sd, backend=backend)
builder.set_environment(Box(dv=settings.dv, dt=settings.dt))
attributes = {}
attributes['volume'], attributes['n'] = ConstantMultiplicity(
settings.spectrum).sample(settings.n_sd)
coalescence = Coalescence(settings.kernel)
coalescence.adaptive = settings.adaptive
builder.add_dynamic(coalescence)
products = [ParticlesVolumeSpectrum(), WallTime()]
core = builder.build(attributes, products)
if hasattr(settings,
'u_term') and 'terminal velocity' in core.particles.attributes:
core.particles.attributes[
'terminal velocity'].approximation = settings.u_term(core)
for observer in observers:
core.observers.append(observer)
vals = {}
core.products['wall_time'].reset()
for step in settings.steps:
core.run(step - core.n_steps)
vals[step] = core.products['dv/dlnr'].get(settings.radius_bins_edges)
vals[step][:] *= settings.rho
exec_time = core.products['wall_time'].get()
return vals, exec_time
def test_coalescence_2_sd(backend):
# 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, 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))
core = builder.build(attributes)
volumes = {}
# Act
for step in steps:
core.run(step - core.n_steps)
volumes[core.n_steps] = core.particles['volume'].to_ndarray()
# Assert
x_max = 0
for volume in volumes.values():
assert x_max < np.amax(volume)
x_max = np.amax(volume)
print(core.particles['n'].to_ndarray())
assert core.particles.SD_num == 1
def test_coalescence(backend, kernel, croupier, adaptive):
if backend == ThrustRTC and croupier == 'local': # TODO #358
return
if backend == 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, 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))
core = builder.build(attributes)
volumes = {}
# Act
for step in steps:
core.run(step - core.n_steps)
volumes[core.n_steps] = core.particles['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(settings):
builder = Builder(n_sd=settings.n_sd, backend=settings.backend)
builder.set_environment(Box(dv=settings.dv, dt=settings.dt))
attributes = {}
attributes['volume'], attributes['n'] = ConstantMultiplicity(
settings.spectrum).sample(settings.n_sd)
builder.add_dynamic(Coalescence(settings.kernel))
particles = builder.build(attributes, products=[WallTime()])
states = {}
for step in settings.steps:
particles.run(step - particles.n_steps)
last_wall_time = particles.products['wall_time'].get()
return states, last_wall_time
def test_coalescence(croupier):
# Arrange
n_sd = 2 ** 13
steps = [0, 30, 60]
X0 = 4 / 3 * np.pi * 30.531e-6 ** 3
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)
builder.set_environment(Box(dt=dt, dv=dv))
attributes = {}
attributes['volume'], attributes['n'] = ConstantMultiplicity(spectrum).sample(n_sd)
builder.add_dynamic(Coalescence(kernel, seed=256))
core = builder.build(attributes)
core.croupier = croupier
class Seed:
seed = 0
def __call__(self):
Seed.seed += 1
return Seed.seed
core.dynamics['Coalescence'].seed = Seed()
states = {}
# Act
for step in steps:
core.run(step - core.n_steps)
check(n_part, dv, n_sd, rho, core.particles, step)
states[core.n_steps] = copy.deepcopy(core.particles)
# Assert
x_max = 0
for state in states.values():
assert x_max < np.amax(state['volume'].to_ndarray())
x_max = np.amax(state['volume'].to_ndarray())
def test_coalescence(backend, croupier, adaptive):
if backend == ThrustRTC and croupier == 'local': # TODO #358
return
if backend == 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(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)