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()