def test_entropic_methods():
sc_kbc = create_lid_driven_cavity(
(20, 20),
method=Method.TRT_KBC_N4,
relaxation_rates=[1.9999, sp.Symbol("omega_free")],
entropic_newton_iterations=3,
entropic=True,
compressible=True,
force=(-1e-10, 0),
force_model=ForceModel.LUO)
sc_srt = create_lid_driven_cavity((40, 40),
relaxation_rate=1.9999,
lid_velocity=0.05,
compressible=True,
force=(-1e-10, 0),
force_model=ForceModel.LUO)
sc_entropic = create_lid_driven_cavity((40, 40),
method=Method.ENTROPIC_SRT,
relaxation_rate=1.9999,
lid_velocity=0.05,
compressible=True,
force=(-1e-10, 0),
force_model=ForceModel.LUO)
sc_srt.run(1000)
sc_kbc.run(1000)
sc_entropic.run(1000)
assert np.isnan(np.max(sc_srt.velocity[:, :]))
assert np.isfinite(np.max(sc_kbc.velocity[:, :]))
assert np.isfinite(np.max(sc_entropic.velocity[:, :]))
def test_equivalence_short(setup):
relaxation_rates = [1.8, 1.7, 1.0, 1.0, 1.0, 1.0]
stencil = LBStencil(setup[0])
compressible = setup[1]
method = setup[2]
force = (setup[3], 0) if stencil.D == 2 else (setup[3], 0, 0)
domain_size = (20, 30) if stencil.D == 2 else (10, 13, 7)
lbm_config = LBMConfig(stencil=stencil,
method=method,
compressible=compressible,
relaxation_rates=relaxation_rates,
force_model=ForceModel.GUO,
force=force)
lbm_opt_split = LBMOptimisation(split=True)
lbm_opt = LBMOptimisation(split=False)
with_split = create_lid_driven_cavity(domain_size=domain_size,
lbm_config=lbm_config,
lbm_optimisation=lbm_opt_split)
without_split = create_lid_driven_cavity(domain_size=domain_size,
lbm_config=lbm_config,
lbm_optimisation=lbm_opt)
with_split.run(100)
without_split.run(100)
np.testing.assert_almost_equal(with_split.velocity_slice(),
without_split.velocity_slice())
def test_lbm_vectorization(instruction_set, aligned_and_padding, nontemporal,
double_precision, fixed_loop_sizes):
vectorization_options = {
'instruction_set': instruction_set,
'assume_aligned': aligned_and_padding[0],
'nontemporal': nontemporal,
'assume_inner_stride_one': True,
'assume_sufficient_line_padding': aligned_and_padding[1]
}
time_steps = 100
size1 = (64, 32)
size2 = (666, 34)
relaxation_rate = 1.8
print("Computing reference solutions")
ldc1_ref = create_lid_driven_cavity(size1, relaxation_rate=relaxation_rate)
ldc1_ref.run(time_steps)
ldc2_ref = create_lid_driven_cavity(size2, relaxation_rate=relaxation_rate)
ldc2_ref.run(time_steps)
lbm_config = LBMConfig(relaxation_rate=relaxation_rate)
config = ps.CreateKernelConfig(
data_type="double" if double_precision else "float32",
cpu_vectorize_info=vectorization_options)
lbm_opt_split = LBMOptimisation(cse_global=True, split=True)
lbm_opt = LBMOptimisation(cse_global=True, split=False)
print(
f"Vectorization test, double precision {double_precision}, vectorization {vectorization_options}, "
f"fixed loop sizes {fixed_loop_sizes}")
ldc1 = create_lid_driven_cavity(size1,
fixed_loop_sizes=fixed_loop_sizes,
lbm_config=lbm_config,
lbm_optimisation=lbm_opt,
config=config)
ldc1.run(time_steps)
np.testing.assert_almost_equal(ldc1_ref.velocity[:, :],
ldc1.velocity[:, :])
ldc2 = create_lid_driven_cavity(size2,
fixed_loop_sizes=fixed_loop_sizes,
lbm_config=lbm_config,
lbm_optimisation=lbm_opt_split,
config=config)
ldc2.run(time_steps)
np.testing.assert_almost_equal(ldc2_ref.velocity[:, :],
ldc2.velocity[:, :])
def test_cumulant_ldc():
sc_cumulant = create_lid_driven_cavity((20, 20),
method=Method.CUMULANT,
relaxation_rate=1.999999,
compressible=True,
force=(-1e-10, 0))
sc_cumulant.run(100)
assert np.isfinite(np.max(sc_cumulant.velocity[:, :]))
def test_central_moment_ldc():
sc_central_moment = create_lid_driven_cavity((20, 20),
method=Method.CENTRAL_MOMENT,
relaxation_rate=1.8,
equilibrium_order=4,
compressible=True,
force=(-1e-10, 0))
sc_central_moment_3d = create_lid_driven_cavity(
(20, 20, 3),
method=Method.CENTRAL_MOMENT,
relaxation_rate=1.8,
equilibrium_order=4,
compressible=True,
force=(-1e-10, 0, 0))
sc_central_moment.run(1000)
sc_central_moment_3d.run(1000)
assert np.isfinite(np.max(sc_central_moment.velocity[:, :]))
assert np.isfinite(np.max(sc_central_moment_3d.velocity[:, :, :]))
def test_lbm_vectorization_short():
print("Computing reference solutions")
size1 = (64, 32)
relaxation_rate = 1.8
ldc1_ref = create_lid_driven_cavity(size1, relaxation_rate=relaxation_rate)
ldc1_ref.run(10)
lbm_config = LBMConfig(relaxation_rate=relaxation_rate)
config = ps.CreateKernelConfig(
cpu_vectorize_info={
'instruction_set': get_supported_instruction_sets()[-1],
'assume_aligned': True,
'nontemporal': True,
'assume_inner_stride_one': True,
'assume_sufficient_line_padding': False,
})
ldc1 = create_lid_driven_cavity(size1,
lbm_config=lbm_config,
config=config,
fixed_loop_sizes=False)
ldc1.run(10)
def test_entropic_methods(method):
sc_kbc = create_lid_driven_cavity(
(20, 20),
method=method,
relaxation_rates=[1.9999, sp.Symbol("omega_free")],
entropic_newton_iterations=3,
entropic=True,
compressible=True,
force=(-1e-10, 0),
force_model=ForceModel.LUO)
sc_kbc.run(1000)
assert np.isfinite(np.max(sc_kbc.velocity[:, :]))
def test_scenario(method_enum, double_precision):
lbm_config = LBMConfig(method=method_enum, relaxation_rate=1.5)
config = ps.CreateKernelConfig(
data_type="double" if double_precision else "float32")
sc = create_lid_driven_cavity((16, 16, 8),
lbm_config=lbm_config,
config=config)
sc.run(1)
code = ps.get_code_str(sc.ast)
if double_precision:
assert 'float' not in code
assert 'double' in code
else:
assert 'double' not in code
assert 'float' in code
def test_animation():
ldc = create_lid_driven_cavity((10, 10), relaxation_rate=1.8)
def run_vec():
ldc.run(100)
return ldc.velocity[:, :, :]
def run_scalar():
ldc.run(100)
return ldc.density[:, :]
plt.clf()
plt.cla()
with TemporaryDirectory() as tmp_dir:
ani = plt.vector_field_magnitude_animation(run_vec,
interval=1,
frames=2)
ani.save(os.path.join(tmp_dir, "animation1.avi"))
ani = plt.vector_field_animation(run_vec,
interval=1,
frames=2,
rescale=True)
ani.save(os.path.join(tmp_dir, "animation2.avi"))
ani = plt.vector_field_animation(run_vec,
interval=1,
frames=2,
rescale=False)
ani.save(os.path.join(tmp_dir, "animation3.avi"))
ani = plt.scalar_field_animation(run_scalar,
interval=1,
frames=2,
rescale=True)
ani.save(os.path.join(tmp_dir, "animation4.avi"))
ani = plt.scalar_field_animation(run_scalar,
interval=1,
frames=2,
rescale=False)
ani.save(os.path.join(tmp_dir, "animation5.avi"))
ani = plt.surface_plot_animation(run_scalar, frames=2)
ani.save(os.path.join(tmp_dir, "animation6.avi"))
def run(domain_size, **kwargs):
color = {'yellow': '\033[93m',
'blue': '\033[94m',
'green': '\033[92m',
'bold': '\033[1m',
'cend': '\033[0m',
}
study_name = kwargs.get('study_name', 'study')
del kwargs['study_name']
if 'relaxation_rates' in kwargs:
kwargs['relaxation_rates'] = [sp.sympify(e) for e in kwargs['relaxation_rates']]
if 'compiler_flags' in kwargs:
add_or_change_compiler_flags(kwargs['compiler_flags'].split())
del kwargs['compiler_flags']
else:
add_or_change_compiler_flags("-march=native")
opt_str = str(kwargs['optimization']).replace("'", "").replace("False", "0").replace("True", "1")
opt_str = opt_str.replace("assume_aligend", 'align').replace("instruction_set", "is").replace("nontemporal", "nt")
param_str = "{bold}{domain_size}{cend} {blue}method: {method: <5}, stencil: {stencil}, {cend} " \
"comp: {compressible:d}, const_loop: {fixed_loop_sizes:d}, const_rr: {fixed_relaxation_rates:d}, " \
"{green}opt: {opt_str}{cend}"
param_str = param_str.format(opt_str=opt_str, domain_size=domain_size, **kwargs, **color)
sc = create_lid_driven_cavity(domain_size, **kwargs)
mlups = [sc.benchmark(time_for_benchmark=2) for _ in range(5)]
if not np.isfinite(sc.data_handling.max(sc.velocity_data_name)):
print("-> ", param_str, " got unstable", flush=True)
return {'mlups_max': None,
'mlups_median': None,
'all_measurements': [],
'stable': False,
'study_name': study_name}
result_str = " {yellow}{bold}{mlups:.0f}±{diff:.2f} MLUPS {cend}".format(mlups=median(mlups),
diff=max(mlups) - min(mlups),
**color)
print("-> ", param_str, result_str, flush=True)
return {'mlups_max': max(mlups),
'mlups_median': median(mlups),
'all_measurements': mlups,
'stable': True}
def test_smagorinsky_setup():
step = create_lid_driven_cavity((30, 30),
smagorinsky=0.16,
relaxation_rate=1.99)
step.run(10)
def ldc_setup(**kwargs):
ldc = create_lid_driven_cavity(relaxation_rate=1.7, **kwargs)
ldc.run(50)
return ldc.density_slice()