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
def test_Shift_ortho_Geier_d2q9(self):
from SymbolicCollisions.core.cm_symbols import Shift_ortho_Geier, K_ortho_Geier, ex_Geier, ey_Geier
matrix_generator = MatrixGenerator(
ex=ex_Geier,
ey=ey_Geier,
ez=None,
order_of_moments=moments_dict['D2Q9'])
Smat = matrix_generator.get_shift_matrix(K_ortho_Geier)
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(Shift_ortho_Geier, 's')
out = f.getvalue()
f2 = io.StringIO()
with redirect_stdout(f2):
print_as_vector(Smat[3:, 3:], 's')
out2 = f2.getvalue()
assert out == out2
def test_Shift_ortho_Straka_d2q5(self):
from SymbolicCollisions.core.cm_symbols import Shift_ortho_Straka_d2q5, K_ortho_Straka_d2q5, \
ex_Straka_d2_q5, ey_Straka_d2_q5
matrix_generator = MatrixGenerator(
ex=ex_Straka_d2_q5,
ey=ey_Straka_d2_q5,
ez=None,
order_of_moments=moments_dict['D2Q5'])
Smat = matrix_generator.get_shift_matrix(K_ortho_Straka_d2q5)
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(Shift_ortho_Straka_d2q5, 's')
out = f.getvalue()
f2 = io.StringIO()
with redirect_stdout(f2):
print_as_vector(Smat[1:, 1:], 's')
out2 = f2.getvalue()
assert out == out2
def test_get_raw_matrix_d2q9(self):
from SymbolicCollisions.core.cm_symbols import ex_D2Q9, ey_D2Q9, Mraw_D2Q9
matrix_generator = MatrixGenerator(
ex=ex_D2Q9,
ey=ey_D2Q9,
ez=None,
order_of_moments=moments_dict['D2Q9'])
M = matrix_generator.get_raw_moments_matrix()
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(Mraw_D2Q9, 's')
out = f.getvalue()
f2 = io.StringIO()
with redirect_stdout(f2):
print_as_vector(M, 's')
out2 = f2.getvalue()
assert out == out2
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}")
# ARRANGE STUFF
matrixGenerator = MatrixGenerator(ex_new, ey_new, ez_new, moments_order)
Mraw = matrixGenerator.get_raw_moments_matrix()
Nraw = matrixGenerator.get_shift_matrix()
# from sympy import pprint
# pprint(Mraw)
# pprint(Nraw)
pop_in_str = 'h' # symbol defining populations
pop_eq_str = 'heq' # symbol defining populations
temp_pop_str = 'temp' # symbol defining populations
# GENERATE CODE
print(f"CudaDeviceFunction void relax_and_collide_ADE_SRT_from_cm_eq(real_t rho, real_t {omega_ade}, vector_t u) \n{{")
print("\t//=== THIS IS AUTOMATICALLY GENERATED CODE ===")
print_sigma_cht()
# hardcoded_F_cm = dynamic_import(*which_F_cm)
return hardcoded_m_eq, hardcoded_F_m
hardcoded_m_eq, hardcoded_F_m = get_m_eq_and_F_m_switcher(model)
# hardcoded_cm_eq = dynamic_import("SymbolicCollisions.core.hardcoded_results", f"hardcoded_cm_eq_compressible_D{d}Q{q}")
# hardcoded_F_cm = dynamic_import("SymbolicCollisions.core.hardcoded_results", f"hardcoded_F_cm_pf_D{d}Q{q}")
# hardcoded_cm_eq = dynamic_import("SymbolicCollisions.core.hardcoded_results", f"hardcoded_cm_eq_incompressible_D{d}Q{q}")
# hardcoded_F_cm = dynamic_import("SymbolicCollisions.core.hardcoded_results", f"hardcoded_F_cm_He_hydro_LB_incompressible_D{d}Q{q}")
# ARRANGE STUFF
matrixGenerator = MatrixGenerator(ex, ey, ez, moments_dict[f'D{d}Q{q}'])
Mraw = matrixGenerator.get_raw_moments_matrix()
Nraw = matrixGenerator.get_shift_matrix()
# from sympy import pprint
# pprint(Mraw) # see what you have done
# pprint(Nraw)
pop_in_str = 'x_in' # symbol defining populations
temp_pop_str = 'temp' # symbol defining populations
m_eq_pop_str = 'm_eq' # symbol defining populations
# GENERATE CODE
def make_header(choice):
model_switcher = {
from sympy import Symbol from sympy.matrices import Matrix, eye, zeros, ones, diag from sympy import pretty_print from SymbolicCollisions.core.cm_symbols import * from SymbolicCollisions.core.MatrixGenerator import MatrixGenerator from SymbolicCollisions.core.printers import * matrixGenerator = MatrixGenerator(ex_D2Q9, ey_D2Q9, None, moments_dict[f'D2Q9']) Mraw = matrixGenerator.get_raw_moments_matrix() Nraw = matrixGenerator.get_shift_matrix() Traw = matrixGenerator.get_raw_x_shift_moments_matrix() Nraw_alternative = Traw * Mraw.inv() Nraw_alternative_simplified = Matrix([round_and_simplify(Nraw_alternative[i, :]) for i in range(len(ex_D2Q9))]) # print_as_vector(f1, 'f1') pretty_print(Mraw) pretty_print(Nraw) pretty_print(Nraw_alternative)
moments_order=rmoments_order)
# print_as_vector(m_eq, 'm_raw_eq', raw_output=False, output_order_of_moments=rmoments_order)
print_as_vector_latex(m_eq, 'k^{H,eq}', output_order_of_moments=rmoments_order)
cm_eq = get_mom_vector_from_continuous_def(
ccmt.get_Maxwellian_DF,
continuous_transformation=ccmt.get_cm,
moments_order=rmoments_order)
# print_as_vector(cm_eq, 'cm_eq', raw_output=False, output_order_of_moments=rmoments_order)
print_as_vector_latex(cm_eq,
'\\tilde{k}^{H,eq}',
output_order_of_moments=rmoments_order)
print("--------------------------------------------------")
matrixGenerator = MatrixGenerator(ex, ey, ez, rmoments_order)
Mraw = matrixGenerator.get_raw_moments_matrix()
Nraw = matrixGenerator.get_shift_matrix()
feq = Mraw.inv() * m_eq.transpose()
print_as_vector(feq,
outprint_symbol='f_eq_from_anal_mom',
output_order_of_moments=rmoments_order)
# print_as_vector_latex(feq, 'h^{eq}', output_order_of_moments=rmoments_order)
print("--------------------------------------------------")
dcmt = DiscreteCMTransforms(e_D2Q9, u3D, None, None)
# pop_eq = get_mom_vector_from_discrete_def(lambda i: Symbol('m00') * dcmt.get_gamma_TRT_antisymmetric(i),
# discrete_transform=dcmt.get_m,
# moments_order=rmoments_order)
from sympy import Symbol
from sympy.matrices import Matrix, eye, zeros, ones, diag
from sympy import pretty_print
from SymbolicCollisions.core.cm_symbols import *
from SymbolicCollisions.core.MatrixGenerator import MatrixGenerator
from SymbolicCollisions.core.printers import *
matrixGenerator = MatrixGenerator(ex_D2Q9, ey_D2Q9, None,
moments_dict[f'D2Q9'])
Mraw = matrixGenerator.get_raw_moments_matrix()
ShiftMat = matrixGenerator.get_shift_matrix(M_ortho_GS)
# cm = get_populations('cm')
cm = Matrix([0.123, 0.234, 0.345, 0.456, 0.567, 0.678, 0.789, 0.890, 0.901])
ShiftMat = ShiftMat.subs({'u.x': 0.0123, 'u.y': 0.0234})
# pretty_print(ShiftMat)
f1 = M_ortho_GS * ShiftMat.inv() * cm
print_as_vector(f1, 'f1')
print('another approach')
Nraw = NrawD2Q9.subs({'u.x': 0.0123, 'u.y': 0.0234})
f2 = Mraw_D2Q9.inv() * Nraw.inv() * cm
print_as_vector(f2, 'f2')
from numpy.testing import assert_almost_equal
for i in range(0):
assert_almost_equal(f1[i], f2[i])
import pandas as pd
m_seed = [0, 1, 2]
rmoments_order = get_m_order_as_in_r(m_seed, m_seed, m_seed)
q, d = rmoments_order.shape
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)}")
e_seed = [0, 1, -1]
ex_D3Q27new, ey_D3Q27new, ez_D3Q27new, e_D3Q27new = get_e_as_in_r(e_seed, e_seed, e_seed)
# print(f"lattice velocities - e: \n {np.array(e_D3Q27new)}")
matrixGenerator = MatrixGenerator(ex_D3Q27new, ey_D3Q27new, ez_D3Q27new, moments_order)
# Mraw = matrixGenerator.get_raw_moments_matrix()
# Nraw = matrixGenerator.get_shift_matrix()
# from sympy import pprint
# pprint(Mraw) # see what you have done
# pprint(Nraw)
pop_in_str = 'CS_' # symbol defining populations
temp_pop_str = 'C_' # symbol defining populations
populations = get_print_symbols_in_m_notation(moments_order, pop_in_str)
temp_populations = get_print_symbols_in_m_notation(moments_order, temp_pop_str)
# const real_t CS_000 = C_000 ;
print(f"\treal_t H = {sum(populations)};")