def test_get_force_He_discrete(self):
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
F_in_cm = get_mom_vector_from_discrete_def(dcmt.get_force_He,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True)
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(F_in_cm, 'F_in_cm')
out = f.getvalue()
expected_result = '\tF_in_cm[0] = 0;\n' \
'\tF_in_cm[1] = Fhydro.x*m00/rho;\n' \
'\tF_in_cm[2] = Fhydro.y*m00/rho;\n' \
'\tF_in_cm[3] = -3.*m00*ux2*(Fhydro.x*u.x + Fhydro.y*u.y)/rho;\n' \
'\tF_in_cm[4] = -3.*m00*uy2*(Fhydro.x*u.x + Fhydro.y*u.y)/rho;\n' \
'\tF_in_cm[5] = -3.*m00*uxuy*(Fhydro.x*u.x + Fhydro.y*u.y)/rho;\n' \
'\tF_in_cm[6] = m00*(9.*Fhydro.x*ux3*u.y + 9.*Fhydro.y*ux2*uy2 + 1/3.*Fhydro.y)/rho;\n' \
'\tF_in_cm[7] = m00*(9.*Fhydro.x*ux2*uy2 + 1/3.*Fhydro.x + 9.*Fhydro.y*u.x*uy3)/rho;\n' \
'\tF_in_cm[8] = -m00*(18.*Fhydro.x*ux3*uy2 + Fhydro.x*ux3 + 3.*Fhydro.x*u.x*uy2 + 18.*Fhydro.y*ux2*uy3 + 3.*Fhydro.y*ux2*u.y + Fhydro.y*uy3)/rho;\n' # noqa
assert 'F_in_cm[0] = 0;' in out
assert 'F_in_cm[1] = Fhydro.x*m00/rho;' in out
assert 'F_in_cm[2] = Fhydro.y*m00/rho;' in out
assert 'F_in_cm[3] = -3.*m00*ux2*(Fhydro.x*u.x + Fhydro.y*u.y)/rho;\n' in out
assert 'F_in_cm[4] = -3.*m00*uy2*(Fhydro.x*u.x + Fhydro.y*u.y)/rho;\n' in out
assert 'F_in_cm[5] = -3.*m00*uxuy*(Fhydro.x*u.x + Fhydro.y*u.y)/rho;\n' in out
assert 'F_in_cm[6] = m00*(9.*Fhydro.x*ux3*u.y + 9.*Fhydro.y*ux2*uy2 + 1/3.*Fhydro.y)/rho;\n' in out
assert 'F_in_cm[7] = m00*(9.*Fhydro.x*ux2*uy2 + 1/3.*Fhydro.x + 9.*Fhydro.y*u.x*uy3)/rho;\n' in out
assert 'F_in_cm[8] = -m00*(18.*Fhydro.x*ux3*uy2 + Fhydro.x*ux3 + 3.*Fhydro.x*u.x*uy2 + 18.*Fhydro.y*ux2*uy3 + 3.*Fhydro.y*ux2*u.y + Fhydro.y*uy3)/rho;\n' in out # noqa
assert expected_result == out
def test_get_force_He_discrete(self):
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
F_in_cm = get_mom_vector_from_discrete_def(
dcmt.get_force_He,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True)
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(F_in_cm, f'F_in_cm')
out = f.getvalue()
assert f'F_in_cm[0] = 0;' in out
assert f'F_in_cm[1] = {Force_str}.x*{m00}/rho;' in out
assert f'F_in_cm[2] = {Force_str}.y*{m00}/rho;' in out
assert f'F_in_cm[3] = -3.*{m00}*ux2*({Force_str}.x*u.x + {Force_str}.y*u.y)/rho;\n' in out
assert f'F_in_cm[4] = -3.*{m00}*uy2*({Force_str}.x*u.x + {Force_str}.y*u.y)/rho;\n' in out
assert f'F_in_cm[5] = -3.*{m00}*uxuy*({Force_str}.x*u.x + {Force_str}.y*u.y)/rho;\n' in out
assert f'F_in_cm[6] = {m00}*(9.*{Force_str}.x*ux3*u.y + 9.*{Force_str}.y*ux2*uy2 + 1/3.*{Force_str}.y)/rho;\n' in out
assert f'F_in_cm[7] = {m00}*(9.*{Force_str}.x*ux2*uy2 + 1/3.*{Force_str}.x + 9.*{Force_str}.y*u.x*uy3)/rho;\n' in out
assert f'F_in_cm[8] = -{m00}*(18.*{Force_str}.x*ux3*uy2 + {Force_str}.x*ux3 + 3.*{Force_str}.x*u.x*uy2 + 18.*{Force_str}.y*ux2*uy3 + 3.*{Force_str}.y*ux2*u.y + {Force_str}.y*uy3)/rho;\n' in out # noqa
expected_result = f'\tF_in_cm[0] = 0;\n' \
f'\tF_in_cm[1] = {Force_str}.x*{m00}/rho;\n' \
f'\tF_in_cm[2] = {Force_str}.y*{m00}/rho;\n' \
f'\tF_in_cm[3] = -3.*{m00}*ux2*({Force_str}.x*u.x + {Force_str}.y*u.y)/rho;\n' \
f'\tF_in_cm[4] = -3.*{m00}*uy2*({Force_str}.x*u.x + {Force_str}.y*u.y)/rho;\n' \
f'\tF_in_cm[5] = -3.*{m00}*uxuy*({Force_str}.x*u.x + {Force_str}.y*u.y)/rho;\n' \
f'\tF_in_cm[6] = {m00}*(9.*{Force_str}.x*ux3*u.y + 9.*{Force_str}.y*ux2*uy2 + 1/3.*{Force_str}.y)/rho;\n' \
f'\tF_in_cm[7] = {m00}*(9.*{Force_str}.x*ux2*uy2 + 1/3.*{Force_str}.x + 9.*{Force_str}.y*u.x*uy3)/rho;\n' \
f'\tF_in_cm[8] = -{m00}*(18.*{Force_str}.x*ux3*uy2 + {Force_str}.x*ux3 + 3.*{Force_str}.x*u.x*uy2 + 18.*{Force_str}.y*ux2*uy3 + 3.*{Force_str}.y*ux2*u.y + {Force_str}.y*uy3)/rho;\n' # noqa
assert expected_result == out
def test_get_cm_eq_hydro_discrete(self):
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
cm_eq = get_mom_vector_from_discrete_def(dcmt.get_EDF_hydro,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True)
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(cm_eq, 'cm_eq')
out = f.getvalue()
expected_result = '\tcm_eq[0] = m00;\n' \
'\tcm_eq[1] = u.x*(-m00 + 1);\n' \
'\tcm_eq[2] = u.y*(-m00 + 1);\n' \
'\tcm_eq[3] = m00*ux2 + 1/3.*m00 - ux2;\n' \
'\tcm_eq[4] = m00*uy2 + 1/3.*m00 - uy2;\n' \
'\tcm_eq[5] = uxuy*(m00 - 1.);\n' \
'\tcm_eq[6] = u.y*(-m00*ux2 - 1/3.*m00 + 1/3.);\n' \
'\tcm_eq[7] = u.x*(-m00*uy2 - 1/3.*m00 + 1/3.);\n' \
'\tcm_eq[8] = m00*ux2*uy2 + 1/3.*m00*ux2 + 1/3.*m00*uy2 + 1/9.*m00 + 2.*ux2*uy2 - 1/3.*ux2 - 1/3.*uy2;\n' # noqa
assert 'cm_eq[0] = m00;' in out
assert 'cm_eq[1] = u.x*(-m00 + 1)' in out
assert 'cm_eq[2] = u.y*(-m00 + 1);' in out
assert 'cm_eq[3] = m00*ux2 + 1/3.*m00 - ux2;\n' in out
assert 'cm_eq[4] = m00*uy2 + 1/3.*m00 - uy2;\n' in out
assert 'cm_eq[5] = uxuy*(m00 - 1.);\n' in out
assert 'cm_eq[6] = u.y*(-m00*ux2 - 1/3.*m00 + 1/3.);\n' in out
assert 'cm_eq[7] = u.x*(-m00*uy2 - 1/3.*m00 + 1/3.);\n' in out
assert 'cm_eq[8] = m00*ux2*uy2 + 1/3.*m00*ux2 + 1/3.*m00*uy2 + 1/9.*m00 + 2.*ux2*uy2 - 1/3.*ux2 - 1/3.*uy2;\n' in out # noqa
assert expected_result == out
def test_shift_vs_def_cm(self):
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
functions = [
lambda i: w_D2Q9[i], dcmt.get_force_He, dcmt.get_force_Guo
]
from SymbolicCollisions.core.cm_symbols import Mraw_D2Q9, NrawD2Q9
for fun in functions:
F_in_cm = get_mom_vector_from_discrete_def(
fun,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True) # calculate from definition of cm
NMF_cm = get_mom_vector_from_shift_mat(
fun,
mat=NrawD2Q9 * Mraw_D2Q9) # calculate using shift matrices
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(F_in_cm, 'F_in_cm')
out = f.getvalue()
f2 = io.StringIO()
with redirect_stdout(f2):
print_as_vector(NMF_cm, 'F_in_cm')
out2 = f2.getvalue()
assert out == out2
def test_get_F_cm_Guo_continuous_and_discrete(self):
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
F_cm_Guo_disc = get_mom_vector_from_discrete_def(dcmt.get_force_Guo,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True)
from SymbolicCollisions.core.ContinousCMTransforms import \
ContinousCMTransforms, get_mom_vector_from_continuous_def
from SymbolicCollisions.core.cm_symbols import \
F3D, dzeta3D, u3D
ccmt = ContinousCMTransforms(dzeta3D, u3D, F3D, rho)
F_cm_Guo_cont = get_mom_vector_from_continuous_def(ccmt.get_force_Guo,
continuous_transformation=ccmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True)
# print_as_vector(F_cm_Guo_cont, 'F_cm')
results = [F_cm_Guo_disc, F_cm_Guo_cont]
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(hardcoded_F_cm_Guo_hydro_LB_velocity_based_D2Q9, 'F_cm')
expected_result = f.getvalue()
for result in results:
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(result, 'F_cm')
out = f.getvalue()
assert out == expected_result
def test_cm_eq_compressible_discrete(self):
"""
test eq 10 from
'Modeling incompressible thermal flows using a central-moment-based lattice Boltzmann method'
Linlin Fei, Kai Hong Luo, Chuandong Lin, Qing Li
2017
"""
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
cm_eq = get_mom_vector_from_discrete_def(
lambda i: m00 * dcmt.get_gamma(i),
discrete_transform=dcmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True)
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(cm_eq, 'cm_eq')
out = f.getvalue()
assert f'cm_eq[0] = {m00};' in out
assert f'cm_eq[2] = 0;' in out
assert f'cm_eq[2] = 0;' in out
assert f'cm_eq[3] = 1/3.*{m00};\n' in out
assert f'cm_eq[4] = 1/3.*{m00};\n' in out
assert f'cm_eq[5] = 0;\n' in out
assert f'cm_eq[6] = -{m00}*ux2*u.y;\n' in out
assert f'cm_eq[7] = -{m00}*u.x*uy2;\n' in out
assert f'cm_eq[8] = {m00}*(3.*ux2*uy2 + 1/9.);\n' in out
expected_result = f'\tcm_eq[0] = {m00};\n' \
f'\tcm_eq[1] = 0;\n' \
f'\tcm_eq[2] = 0;\n' \
f'\tcm_eq[3] = 1/3.*{m00};\n' \
f'\tcm_eq[4] = 1/3.*{m00};\n' \
f'\tcm_eq[5] = 0;\n' \
f'\tcm_eq[6] = -{m00}*ux2*u.y;\n' \
f'\tcm_eq[7] = -{m00}*u.x*uy2;\n' \
f'\tcm_eq[8] = {m00}*(3.*ux2*uy2 + 1/9.);\n'
assert expected_result == out
def test_cm_eq_compressible_discrete(self):
"""
test eq 10 from
'Modeling incompressible thermal flows using a central-moment-based lattice Boltzmann method'
Linlin Fei, Kai Hong Luo, Chuandong Lin, Qing Li
2017
"""
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
cm_eq = get_mom_vector_from_discrete_def(lambda i: Symbol('m00') * dcmt.get_gamma(i),
discrete_transform=dcmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True)
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(cm_eq, 'cm_eq')
out = f.getvalue()
expected_result = '\tcm_eq[0] = m00;\n' \
'\tcm_eq[1] = 0;\n' \
'\tcm_eq[2] = 0;\n' \
'\tcm_eq[3] = 1/3.*m00;\n' \
'\tcm_eq[4] = 1/3.*m00;\n' \
'\tcm_eq[5] = 0;\n' \
'\tcm_eq[6] = -m00*ux2*u.y;\n' \
'\tcm_eq[7] = -m00*u.x*uy2;\n' \
'\tcm_eq[8] = m00*(3.*ux2*uy2 + 1/9.);\n'
assert 'cm_eq[0] = m00;' in out
assert 'cm_eq[2] = 0;' in out
assert 'cm_eq[2] = 0;' in out
assert 'cm_eq[3] = 1/3.*m00;\n' in out
assert 'cm_eq[4] = 1/3.*m00;\n' in out
assert 'cm_eq[5] = 0;\n' in out
assert 'cm_eq[6] = -m00*ux2*u.y;\n' in out
assert 'cm_eq[7] = -m00*u.x*uy2;\n' in out
assert 'cm_eq[8] = m00*(3.*ux2*uy2 + 1/9.);\n' in out
assert expected_result == out
def test_get_F_cm_Guo_continuous_and_discrete(self):
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
F_cm_Guo_disc = get_mom_vector_from_discrete_def(
dcmt.get_force_Guo,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True)
from SymbolicCollisions.core.ContinuousCMTransforms import \
ContinuousCMTransforms, get_mom_vector_from_continuous_def
from SymbolicCollisions.core.cm_symbols import \
F3D, dzeta3D, u3D
ccmt = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho)
F_cm_Guo_cont = get_mom_vector_from_continuous_def(
ccmt.get_force_Guo,
continuous_transformation=ccmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True)
# print_as_vector(F_cm_Guo_cont, 'F_cm')
results = [F_cm_Guo_disc, F_cm_Guo_cont]
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(hardcoded_F_cm_Guo_hydro_incompressible_D2Q9,
'F_cm')
expected_result = f.getvalue()
for result in results:
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(result, 'F_cm')
out = f.getvalue()
assert out == expected_result
def test_shift_vs_def_cm(self):
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
functions = [lambda i: w_D2Q9[i], dcmt.get_force_He, dcmt.get_force_Guo]
from SymbolicCollisions.core.cm_symbols import Mraw_D2Q9, NrawD2Q9
for fun in functions:
F_in_cm = get_mom_vector_from_discrete_def(fun,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True) # calculate from definition of cm
NMF_cm = get_mom_vector_from_shift_mat(fun, mat=NrawD2Q9 * Mraw_D2Q9) # calculate using shift matrices
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(F_in_cm, 'F_in_cm')
out = f.getvalue()
f2 = io.StringIO()
with redirect_stdout(f2):
print_as_vector(NMF_cm, 'F_in_cm')
out2 = f2.getvalue()
assert out == out2
def test_get_cm_eq_hydro_discrete(self):
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
cm_eq = get_mom_vector_from_discrete_def(
dcmt.get_EDF_incompressible,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict['D2Q9'],
serial_run=True)
f = io.StringIO()
with redirect_stdout(f):
print_as_vector(cm_eq, 'cm_eq')
out = f.getvalue()
# TODO: be aware that sympy may switch hardcoded terms like 'u.x*(-m00 + 1)' to '-u.x*(m00 - 1')
# thank you sympy...
assert f'cm_eq[0] = {m00};' in out
assert f'cm_eq[1] = u.x*(1 - {m00});' in out or f'cm_eq[1] = u.x*(-{m00} + 1);' in out
assert f'cm_eq[2] = u.y*(1 - {m00});' in out or f'cm_eq[2] = u.y*(-{m00} + 1);' in out
assert f'cm_eq[3] = {m00}*ux2 + 1/3.*{m00} - ux2;\n' in out
assert f'cm_eq[4] = {m00}*uy2 + 1/3.*{m00} - uy2;\n' in out
assert f'cm_eq[5] = uxuy*({m00} - 1.);\n' in out
assert f'cm_eq[6] = u.y*(-{m00}*ux2 - 1/3.*{m00} + 1/3.);\n' in out
assert f'cm_eq[7] = u.x*(-{m00}*uy2 - 1/3.*{m00} + 1/3.);\n' in out
assert f'cm_eq[8] = {m00}*ux2*uy2 + 1/3.*{m00}*ux2 + 1/3.*{m00}*uy2 + 1/9.*{m00} + 2.*ux2*uy2 - 1/3.*ux2 - 1/3.*uy2;\n' in out # noqa
ccmt = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho)
import time
start = time.process_time()
lattice = 'D2Q9'
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
print("\n--- FORCES ---")
print('// === welcome to central moments space! === \n ')
print('// === discrete central moments ===\n ')
print('\n//F_cm_He_discrete')
F_cm_He = get_mom_vector_from_discrete_def(dcmt.get_force_He,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(F_cm_He, 'F_cm')
print('\n//N*M*F_He')
NMF_cm_He = get_mom_vector_from_shift_mat(dcmt.get_force_He,
mat=NrawD2Q9 * Mraw_D2Q9)
print_as_vector(NMF_cm_He, 'F_cm')
print('\n//F_cm_Guo')
F_cm_Guo = get_mom_vector_from_discrete_def(
dcmt.get_force_Guo,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(F_cm_Guo, 'F_cm')
lattice = 'D3Q27'
ccmt = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho)
# ccmt = ContinuousCMTransforms(dzeta2D, u2D, F2D, rho)
start = time.process_time()
print('\n\n// === discrete m === \n ')
from SymbolicCollisions.core.cm_symbols import e_D3Q7
print("moments: first order (linear) velocity expansion.")
dcmt = DiscreteCMTransforms(e_D3Q7, u3D, F3D, rho)
pop_eq = get_mom_vector_from_discrete_def(
lambda i: dcmt.get_gamma_first_order_cht(i),
discrete_transform=dcmt.get_m,
moments_order=moments_dict['D3Q7'],
serial_run=True)
print_as_vector(pop_eq, 'pop_eq_first_order', raw_output=True)
print('\n\n// === continous cm === \n ')
# to calculate particular moment
row = moments_dict['D2Q9'][0]
moment = ccmt.get_cm(row, ccmt.get_cht_DF)
print_as_vector(Matrix([moment]), 'particular_moment')
print('\n//population_eq -> cm_eq - from continous definition: \n'
'k_mn = integrate(fun, (x, -oo, oo), (y, -oo, oo)) \n'
'where fun = fM(rho,u,x,y) *(x-ux)^m *(y-uy)^n *(z-uz)^o ')
from SymbolicCollisions.core.cm_symbols import \
print(
'\n\n\n// let us relax both parts together - as we used to do in the article (eq C5 in appendix)'
)
print(
'\n// both parts - central moments - as we used to do in the article (eq C5 in appendix)'
)
cm_eq_both_parts = get_mom_vector_from_continuous_def(
ccmt.get_incompressible_DF,
continuous_transformation=ccmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(cm_eq_both_parts,
'cm_eq_both_parts',
output_order_of_moments=moments_dict[lattice])
print('\n// cm_eq_both_parts - central moments after relaxation')
print_as_vector(S_relax_hydro_D2Q9 * cm_eq_both_parts.transpose(),
'cm_eq_both_parts_relaxation',
output_order_of_moments=moments_dict[lattice])
print(f'\n\n Done in {time.process_time() - start} [s].')
print('\n\n\n// --------------- more EXPERIMENTS ------------------------')
print('\n// cm_eq_p_new')
cm_eq_p_new = get_mom_vector_from_discrete_def(
lambda i: dcmt.get_EDF_p_with_u(i),
discrete_transform=dcmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(cm_eq_p_new,
'cm_eq_p_new',
output_order_of_moments=moments_dict[lattice])
# mom_bc = get_mom_vector_from_discrete_def(lambda i: Symbol('m00') * dcmt.get_pressure_bc(i),
# discrete_transform=dcmt.get_m,
# moments_order=moments_dict[lattice])
#
# print_as_vector(mom_bc, 'drm_pressure_bc')
#
# print("\n\n discrete raw moments: pressure bc")
# mom_bc = get_mom_vector_from_discrete_def(lambda i: Symbol('m00') * dcmt.get_pressure_bc(i),
# discrete_transform=dcmt.get_cm,
# moments_order=moments_dict[lattice])
#
# print_as_vector(mom_bc, 'dcm_pressure_bc')
#
print("\n\n discrete raw moments: heat flux cht bc - He forcing scheme")
mom_bc = get_mom_vector_from_discrete_def(dcmt.get_force_He,
discrete_transform=dcmt.get_m,
moments_order=moments_dict[lattice])
print_as_vector(mom_bc, 'He forcing scheme - dm ')
mom_bc = get_mom_vector_from_discrete_def(dcmt.get_force_He,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(mom_bc, 'He forcing scheme - dcm ')
mom_bc = get_mom_vector_from_discrete_def(
lambda i: Symbol('H') * dcmt.get_heat_flux_bc(i),
discrete_transform=dcmt.get_m,
moments_order=moments_dict[lattice])
print_as_vector(mom_bc, 'dm_heat_flux_cht_bc', raw_output=False)
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)
# print_as_vector(pop_eq, 'dcm_eq_antisymmetric', output_order_of_moments=rmoments_order)
#
print("TRT cm antisymmetric - moments: full velocity expansion.")
# notice that the moments of non-eq DF is splited into sym and antisymmetric moments in the same way.
feq = get_print_symbols_in_m_notation(rmoments_order, "h")
feq_symm = lambda i: (feq[i] + feq[rev_i[i]]) / 2
feq_antisymm = lambda i: (feq[i] - feq[rev_i[i]]) / 2
pop_eq_full = get_mom_vector_from_discrete_def(feq_symm,
discrete_transform=dcmt.get_m,
moments_order=rmoments_order)
# print_as_vector(pop_eq_full, 'm_eq_full_symmetric', output_order_of_moments=rmoments_order)
print_as_vector_latex(pop_eq_full,
'k^{H,seq}',
output_order_of_moments=rmoments_order)
# print_as_vector_latex(pop_eq_full, 'm_s', output_order_of_moments=rmoments_order)
pop_eq_full = get_mom_vector_from_discrete_def(feq_antisymm,
discrete_transform=dcmt.get_m,
moments_order=rmoments_order)
# print_as_vector(pop_eq_full, 'm_eq_full_antisymmetric', output_order_of_moments=rmoments_order)
print_as_vector_latex(pop_eq_full,
'k^{H,aeq}',
output_order_of_moments=rmoments_order)
# print_as_vector_latex(pop_eq_full, 'm_a', output_order_of_moments=rmoments_order)
ccmt = ContinousCMTransforms(dzeta3D, u3D, F3D, rho)
import time
start = time.process_time()
lattice = 'D2Q9'
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
print("\n--- FORCES ---")
print('// === welcome to central moments space! === \n ')
print('// === discrete central moments ===\n ')
print('\n//F_cm_He_discrete')
F_cm_He = get_mom_vector_from_discrete_def(dcmt.get_force_He,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(F_cm_He, 'F_cm')
print('\n//N*M*F_He')
NMF_cm_He = get_mom_vector_from_shift_mat(dcmt.get_force_He, mat=NrawD2Q9 * Mraw_D2Q9)
print_as_vector(NMF_cm_He, 'F_cm')
print('\n//F_cm_Guo')
F_cm_Guo = get_mom_vector_from_discrete_def(dcmt.get_force_Guo,
discrete_transform=dcmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(F_cm_Guo, 'F_cm')
print('\n//N*M*F_cm_Guo_second_order ')
NMF_cm_Guo = get_mom_vector_from_shift_mat(dcmt.get_force_Guo, mat=NrawD2Q9 * Mraw_D2Q9)
from sympy import Symbol
from SymbolicCollisions.core.cm_symbols import e_D2Q9, u2D, F2D, rho, moments_dict, NrawD2Q9, Mraw_D2Q9, M_ortho_GS
from SymbolicCollisions.core.printers import print_as_vector
import time
start = time.process_time()
lattice = 'D2Q9'
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
ccmt = ContinousCMTransforms(dzeta3D, u3D, F3D, rho)
print('\n\n// === discrete moments === \n ')
print("moments: first order (linear) velocity expansion.")
pop_eq = get_mom_vector_from_discrete_def(lambda i: Symbol('m00') * dcmt.get_gamma_first_order(i),
discrete_transform=dcmt.get_m,
moments_order=moments_dict[lattice])
print_as_vector(pop_eq, 'pop_eq_first_order')
print("moments: second order (quadratic) velocity expansion.")
print('\n//population_eq -> m_eq - by definition: k_mn = sum( (e_ix)^m (e_iy)^n * population_eq_i)')
pop_eq = get_mom_vector_from_discrete_def(lambda i: Symbol('m00') * dcmt.get_gamma(i),
discrete_transform=dcmt.get_m,
moments_order=moments_dict[lattice])
print_as_vector(pop_eq, 'pop_eq')
print('\n\n// === continuous moments === \n ')
print('\n//population_eq -> m_eq - from continuous definition: \n'
'k_mn = integrate(fun, (x, -oo, oo), (y, -oo, oo)) \n'
'where fun = fMB(rho,u,x,y) *(x)^m (y)^n ')
start = time.process_time()
lattice = 'D2Q9'
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
ccmt = ContinuousCMTransforms(dzeta2D, u2D, F2D, rho)
# u2D * u2D
# e_D2Q9[2,:]
# Conservative phase-field lattice Boltzmann model for interface tracking equation
# PHYSICAL REVIEW E 91, 063309 (2015)
# Martin Geier, Abbas Fakhari and Taehun Lee
print('\n\n// === discrete moments === \n ')
print('\n//moments from definition: k_mn = sum( (e_ix)^m (e_iy)^n * fun_i)')
print('\n\n// === BOUNDARY CONDITIONS === \n ')
print("discrete raw moments: separation flux")
# mom_bc = get_mom_vector_from_discrete_def(lambda i: Symbol('H') * dcmt.get_heat_flux_bc(i),
# discrete_transform=dcmt.get_cm,
# moments_order=moments_dict[lattice])
# print_as_vector(mom_bc, 'dcm_heat_flux_cht_bc', raw_output=False)
mom_flux = get_mom_vector_from_discrete_def(dcmt.get_separation_flux,
discrete_transform=dcmt.get_m,
moments_order=moments_dict[lattice])
print_as_vector(mom_flux, 'mom_sep_flux', output_order_of_moments=moments_dict[lattice])
from SymbolicCollisions.core.cm_symbols import e_D2Q9, u2D, F2D, rho, moments_dict, NrawD2Q9, Mraw_D2Q9, M_ortho_GS
from SymbolicCollisions.core.printers import print_as_vector
import time
start = time.process_time()
# lattice = 'D3Q27'
lattice = 'D2Q9'
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
ccmt = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho)
print('\n\n// === discrete moments === \n ')
print("moments: first order (linear) velocity expansion.")
pop_eq = get_mom_vector_from_discrete_def(
lambda i: Symbol('m00') * dcmt.get_gamma_first_order(i),
discrete_transform=dcmt.get_m,
moments_order=moments_dict[lattice],
serial_run=True)
print_as_vector(pop_eq, 'pop_eq_first_order')
print("moments: second order (quadratic) velocity expansion.")
print(
'\n//population_eq -> m_eq - by definition: k_mn = sum( (e_ix)^m (e_iy)^n * population_eq_i)'
)
pop_eq = get_mom_vector_from_discrete_def(
lambda i: Symbol('m00') * dcmt.get_gamma(i),
discrete_transform=dcmt.get_m,
moments_order=moments_dict[lattice])
print_as_vector(pop_eq, 'm_raw_eq')
print(
from SymbolicCollisions.core.DiscreteCMTransforms import \
DiscreteCMTransforms, get_mom_vector_from_discrete_def
from SymbolicCollisions.core.MatrixGenerator import get_m_order_as_in_r, get_e_as_in_r, MatrixGenerator, get_reverse_direction_idx, get_reverse_indices
lattice = 'D2Q9'
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
start = time.process_time()
print('// === discrete (central) moments ===\n ')
print('// === welcome to TRT! === \n ')
print("moments: second order (quadratic) velocity expansion.")
pop_eq = get_mom_vector_from_discrete_def(lambda i: Symbol('m00') * dcmt.get_gamma(i),
discrete_transform=dcmt.get_m,
moments_order=moments_dict[lattice])
print_as_vector(pop_eq, 'm_eq', output_order_of_moments=moments_dict[lattice])
print("TRT m antisymmetric - moments: second order (quadratic) velocity expansion.")
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=moments_dict[lattice])
print_as_vector(pop_eq, 'm_eq_antisymmetric', output_order_of_moments=moments_dict[lattice])
print("TRT m symmetric - moments: second order (quadratic) velocity expansion.")
pop_eq = get_mom_vector_from_discrete_def(lambda i: Symbol('m00') * dcmt.get_gamma_TRT_symmetric(i),
discrete_transform=dcmt.get_m,
moments_order=moments_dict[lattice])
print_as_vector(pop_eq, 'm_eq_symmetric', output_order_of_moments=moments_dict[lattice])
lattice = 'D2Q9'
ccmt = ContinousCMTransforms(dzeta3D, u3D, F3D, rho)
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
start = time.process_time()
print('// === welcome to cm! === \n ')
print('// === discrete cm ===\n ')
print('\n//population_eq -> cm_eq - by definition: k_mn = sum( (e_ix-ux)^m (e_iy-uy)^n * population_eq_i)')
print("moments: first order (linear) velocity expansion.")
pop_eq = get_mom_vector_from_discrete_def(lambda i: Symbol('m00') * dcmt.get_gamma_first_order(i),
discrete_transform=dcmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(pop_eq, 'pop_eq_first_order')
print("moments: second order (quadratic) velocity expansion.")
pop_eq = get_mom_vector_from_discrete_def(lambda i: Symbol('m00') * dcmt.get_gamma(i),
discrete_transform=dcmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(pop_eq, 'pop_eq')
print('\n//population -> cm - by definition: k_mn = sum( (e_ix-ux)^m (e_iy-uy)^n * population_i)')
pop_eq = get_mom_vector_from_discrete_def(lambda i: Symbol('%s[%d]' % ('pop', i)),
discrete_transform=dcmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(pop_eq, 'pop_cm')
lattice = 'D2Q9'
ccmt = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho)
dcmt = DiscreteCMTransforms(e_D2Q9, u2D, F2D, rho)
start = time.process_time()
print('// === welcome to cm! === \n ')
print('// === discrete cm ===\n ')
print(
'\n//population_eq -> cm_eq - by definition: k_mn = sum( (e_ix-ux)^m (e_iy-uy)^n * population_eq_i)'
)
print("central moments: first order (linear) velocity expansion.")
pop_eq = get_mom_vector_from_discrete_def(
lambda i: Symbol('m00') * dcmt.get_gamma_first_order(i),
discrete_transform=dcmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(pop_eq, 'pop_eq_first_order')
print("central moments: second order (quadratic) velocity expansion.")
pop_eq = get_mom_vector_from_discrete_def(
lambda i: Symbol('m00') * dcmt.get_gamma(i),
discrete_transform=dcmt.get_cm,
moments_order=moments_dict[lattice])
print_as_vector(pop_eq, 'cm_eq')
print(
'\n//population -> cm - by definition: k_mn = sum( (e_ix-ux)^m (e_iy-uy)^n * population_i)'
)
pop_eq = get_mom_vector_from_discrete_def(lambda i: Symbol('%s[%d]' %
('pop', i)),
discrete_transform=dcmt.get_cm,
