def get_m_eq_and_F_m_switcher(choice):
cm_eq_switcher = {
'hydro_compressible': ("SymbolicCollisions.core.hardcoded_results", f"hardcoded_cm_eq_compressible_D{d}Q{q}"),
'hydro_incompressible': ("SymbolicCollisions.core.hardcoded_results", f"hardcoded_cm_eq_incompressible_D{d}Q{q}"),
'ade_with_f': ("SymbolicCollisions.core.hardcoded_results", f"hardcoded_cm_eq_compressible_D{d}Q{q}"),
'ade': ("SymbolicCollisions.core.hardcoded_results", f"hardcoded_m_eq_D{d}Q{q}"),
}
which_m_eq = cm_eq_switcher.get(choice, lambda: "Invalid argument")
hardcoded_m_eq = dynamic_import(*which_m_eq)
F_m_switcher = {
'hydro_compressible': ("SymbolicCollisions.core.hardcoded_results", f"hardcoded_F_cm_hydro_density_based_D{d}Q{q}"),
'hydro_incompressible': ("SymbolicCollisions.core.hardcoded_results", f"hardcoded_F_cm_hydro_velocity_based_D{d}Q{q}"),
'ade_with_f': ("SymbolicCollisions.core.hardcoded_results", f"hardcoded_F_cm_pf_D{d}Q{q}"),
'ade': None,
}
which_F_m = F_m_switcher.get(choice, lambda: "Invalid argument")
hardcoded_F_m = \
dynamic_import(*which_F_m) if which_F_m is not None \
else Matrix(np.full((q, 1), 1, dtype=int)) # make dummy F
# hardcoded_F_cm = dynamic_import(*which_F_cm)
return hardcoded_m_eq, hardcoded_F_m
def get_s_relax_switcher(choice):
s_relax_switcher = {
'hydro': ("SymbolicCollisions.core.cm_symbols", f"S_relax_hydro_D{d}Q{q}"),
'ade': ("SymbolicCollisions.core.cm_symbols", f"S_relax_ADE_D{d}Q{q}"),
}
which_model = s_relax_switcher.get(choice, lambda: "Invalid argument")
return dynamic_import(*which_model)
def get_s_relax_switcher(choice):
s_relax_switcher = {
'hydro': ("SymbolicCollisions.core.cm_symbols", f"S_relax_hydro_D{d}Q{q}"),
'ade': ("SymbolicCollisions.core.cm_symbols", f"S_relax_ADE_D{d}Q{q}"),
}
which_model = s_relax_switcher.get(choice, lambda: "Invalid argument")
return dynamic_import(*which_model)
def test_df_to_m(self):
# SETUP
d = 2
q = 9
# DYNAMIC IMPORTS
ex = dynamic_import("SymbolicCollisions.core.cm_symbols",
f"ex_D{d}Q{q}")
ey = dynamic_import("SymbolicCollisions.core.cm_symbols",
f"ey_D{d}Q{q}")
if d == 3:
ez = dynamic_import("SymbolicCollisions.core.cm_symbols",
f"ez_D{d}Q{q}")
else:
ez = None
pop_in_str = 'x_in' # symbol defining populations
temp_pop_str = 'temp' # symbol defining populations
temp_populations = get_print_symbols_in_indx_notation(q, temp_pop_str)
matrixGenerator = MatrixGenerator(ex, ey, ez,
moments_dict[f'D{d}Q{q}'])
Mraw = matrixGenerator.get_raw_moments_matrix()
m = Mraw * temp_populations
expected_results = "\tx_in[0] = temp[0] + temp[1] + temp[2] + temp[3] + temp[4] + temp[5] + temp[6] + temp[7] + temp[8];\n" \
"\tx_in[1] = temp[1] - temp[3] + temp[5] - temp[6] - temp[7] + temp[8];\n" \
"\tx_in[2] = temp[2] - temp[4] + temp[5] + temp[6] - temp[7] - temp[8];\n" \
"\tx_in[3] = temp[1] + temp[3] + temp[5] + temp[6] + temp[7] + temp[8];\n" \
"\tx_in[4] = temp[2] + temp[4] + temp[5] + temp[6] + temp[7] + temp[8];\n" \
"\tx_in[5] = temp[5] - temp[6] + temp[7] - temp[8];\n" \
"\tx_in[6] = temp[5] + temp[6] - temp[7] - temp[8];\n" \
"\tx_in[7] = temp[5] - temp[6] - temp[7] + temp[8];\n" \
"\tx_in[8] = temp[5] + temp[6] + temp[7] + temp[8];\n"
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(m, outprint_symbol=pop_in_str)
out = f.getvalue()
assert out == expected_results
# ex_new, ey_new, ez_new, e_new = get_e_as_in_r(e_seed, e_seed, e_seed)
# print(f"lattice velocities - e: \n {np.array(e_new)}")
rmoments_order = np.array(
[(0, 0, 0),
(1, 0, 0),
(2, 0, 0),
(0, 1, 0),
(0, 2, 0),
(0, 0, 1),
(0, 0, 2)]) # TCLB order
q, d = rmoments_order.shape
# DYNAMIC IMPORTS
ex_new = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ex_D{d}Q{q}")
ey_new = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ey_D{d}Q{q}")
if d == 3:
ez_new = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ez_D{d}Q{q}")
else:
ez_new = None
e_new = dynamic_import("SymbolicCollisions.core.cm_symbols", f"e_D{d}Q{q}")
moments_order = np.array(moments_dict[f'D{d}Q{q}'])
print(f"order of moments | rmoments: \n "
f"{pd.concat([pd.DataFrame.from_records(moments_order),pd.DataFrame.from_records(rmoments_order)], axis=1)}")
hardcoded_cm_eq = dynamic_import("SymbolicCollisions.core.hardcoded_results", f"hardcoded_cm_eq_cht_D{d}Q{q}")
from SymbolicCollisions.core.printers import print_u2, print_as_vector, get_print_symbols_in_indx_notation
from SymbolicCollisions.core.MatrixGenerator import MatrixGenerator
from sympy.matrices import Matrix
import numpy as np
# inspired by:
# "Consistent Forcing Scheme in the cascaded LBM" L. Fei et al. 2017
# eqs 8-12 : (eye(q)-S)*cm + S*cm_eq + (eye(q)-S/2.)*force_in_cm_space
# SETUP
d = 3
q = 27
model = 'ade' # choose from '['hydro_compressible', 'hydro_incompressible', 'ade', 'ade_with_f']
# DYNAMIC IMPORTS
ex = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ex_D{d}Q{q}")
ey = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ey_D{d}Q{q}")
if d == 3:
ez = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ez_D{d}Q{q}")
else:
ez = None
def get_s_relax_switcher(choice):
s_relax_switcher = {
'hydro_compressible': ("SymbolicCollisions.core.cm_symbols", f"S_relax_hydro_D{d}Q{q}"),
'hydro_incompressible': ("SymbolicCollisions.core.cm_symbols", f"S_relax_hydro_D{d}Q{q}"),
'ade_with_f': ("SymbolicCollisions.core.cm_symbols", f"S_relax_ADE_D{d}Q{q}"),
'ade': ("SymbolicCollisions.core.cm_symbols", f"S_relax_ADE_D{d}Q{q}"),
}
which_model = s_relax_switcher.get(choice, lambda: "Invalid argument")
from SymbolicCollisions.core.cm_symbols import dynamic_import
from SymbolicCollisions.core.DiscreteCMTransforms import get_DF, get_m00
from SymbolicCollisions.core.printers import print_u2, print_as_vector
from SymbolicCollisions.core.MatrixGenerator import get_raw_moments_matrix, get_shift_matrix
# inspired by:
# "Consistent Forcing Scheme in the cascaded LBM" L. Fei et al. 2017
# eqs 8-12 : (eye(q)-S)*cm + S*cm_eq + (eye(q)-S/2.)*force_in_cm_space
# SETUP
d = 2
q = 9
model = 'hydro' # choose from '['hydro', 'ade', 'ade_with_f']
# DYNAMIC IMPORTS
ex = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ex_D{d}Q{q}")
ey = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ey_D{d}Q{q}")
if d == 3:
ez = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ez_D{d}Q{q}")
else:
ez = None
def get_s_relax_switcher(choice):
s_relax_switcher = {
'hydro': ("SymbolicCollisions.core.cm_symbols", f"S_relax_hydro_D{d}Q{q}"),
'ade_with_f': ("SymbolicCollisions.core.cm_symbols", f"S_relax_ADE_D{d}Q{q}"),
'ade': ("SymbolicCollisions.core.cm_symbols", f"S_relax_ADE_D{d}Q{q}"),
}
which_model = s_relax_switcher.get(choice, lambda: "Invalid argument")
return dynamic_import(*which_model)
from SymbolicCollisions.core.cm_symbols import dynamic_import
from SymbolicCollisions.core.DiscreteCMTransforms import get_m00
from SymbolicCollisions.core.printers import print_u2, print_as_vector, get_print_symbols_in_indx_notation
from SymbolicCollisions.core.MatrixGenerator import MatrixGenerator
# inspired by:
# "Consistent Forcing Scheme in the cascaded LBM" L. Fei et al. 2017
# eqs 8-12 : (eye(q)-S)*cm + S*cm_eq + (eye(q)-S/2.)*force_in_cm_space
# SETUP
d = 2
q = 9
model = 'hydro' # choose from '['hydro', 'ade']
# DYNAMIC IMPORTS
ex = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ex_D{d}Q{q}")
ey = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ey_D{d}Q{q}")
if d == 3:
ez = dynamic_import("SymbolicCollisions.core.cm_symbols", f"ez_D{d}Q{q}")
else:
ez = None
def get_s_relax_switcher(choice):
s_relax_switcher = {
'hydro': ("SymbolicCollisions.core.cm_symbols", f"S_relax_hydro_D{d}Q{q}"),
'ade': ("SymbolicCollisions.core.cm_symbols", f"S_relax_ADE_D{d}Q{q}"),
}
which_model = s_relax_switcher.get(choice, lambda: "Invalid argument")
return dynamic_import(*which_model)
print("\t//=== THIS IS AUTOMATICALLY GENERATED CODE ===")
print_sigma_cht()
print_u2(d)
populations = get_print_symbols_in_m_notation(moments_dict[f'D{d}Q{q}'],
pop_in_str)
temp_populations = get_print_symbols_in_m_notation(moments_dict[f'D{d}Q{q}'],
temp_pop_str)
# if 'cht' in model:
# print(f"\treal_t {Enthalpy} = {sum(populations)};")
# else:
# print(f"\treal_t {m00} = {sum(populations)};")
print("\n\t//equilibrium in central moments space")
hardcoded_cm_eq = dynamic_import("SymbolicCollisions.core.hardcoded_results",
f"hardcoded_cm_eq_cht_D{d}Q{q}")
print_as_vector(hardcoded_cm_eq,
outprint_symbol=pop_in_str,
output_order_of_moments=moments_order)
print("\n\t//back to raw moments")
print_as_vector(Nraw.inv() * populations,
outprint_symbol=f"real_t {temp_pop_str}",
output_order_of_moments=moments_order)
print("\n\t//back to density-probability functions")
print_as_vector(Mraw.inv() * temp_populations,
outprint_symbol=pop_in_str,
output_order_of_moments=rmoments_order)
print("\n}\n")