def test_get_F_cm_using_He_scheme_and_continuous_Maxwellian_DF(self): cm_i = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho) F_cm = get_mom_vector_from_continuous_def( cm_i.get_force_He_hydro_DF, continuous_transformation=cm_i.get_cm, moments_order=moments_dict['D2Q9'], serial_run=True) f = io.StringIO() with redirect_stdout(f): print_as_vector(F_cm, 'F_cm') out = f.getvalue() # TODO: can't use hardcoded_cm_eq_incompressible_D2Q9, # because sympy switches hardcoded terms like 'u.x*(-m00 + 1)' to '-u.x*(m00 - 1') and test fails. # thank you sympy... assert f'\tF_cm[0] = 0;\n' in out assert f'\tF_cm[1] = {Force_str}.x*{m00}/rho;\n' in out assert f'\tF_cm[2] = {Force_str}.y*{m00}/rho;\n' in out assert f'\tF_cm[3] = -2.*{Force_str}.x*u.x*({m00} - 1.)/rho;\n' in out assert f'\tF_cm[4] = -2.*{Force_str}.y*u.y*({m00} - 1.)/rho;\n' in out assert f'\tF_cm[5] = (-{Force_str}.x*{m00}*u.y + {Force_str}.x*u.y - {Force_str}.y*{m00}*u.x + {Force_str}.y*u.x)/rho;\n' in out assert f'\tF_cm[6] = (2.*{Force_str}.x*{m00}*uxuy - 2.*{Force_str}.x*uxuy + {Force_str}.y*{m00}*ux2 + 1/3.*{Force_str}.y*{m00} - {Force_str}.y*ux2)/rho;\n' in out assert f'\tF_cm[7] = ({Force_str}.x*{m00}*uy2 + 1/3.*{Force_str}.x*{m00} - {Force_str}.x*uy2 + 2.*{Force_str}.y*{m00}*uxuy - 2.*{Force_str}.y*uxuy)/rho;\n' in out assert f'\tF_cm[8] = (-2.*{Force_str}.x*{m00}*u.x*uy2 - 2/3.*{Force_str}.x*{m00}*u.x + 2.*{Force_str}.x*u.x*uy2 + 2/3.*{Force_str}.x*u.x - 2.*{Force_str}.y*{m00}*ux2*u.y - 2/3.*{Force_str}.y*{m00}*u.y + 2.*{Force_str}.y*ux2*u.y + 2/3.*{Force_str}.y*u.y)/rho;\n' in out
def test_get_cm_eq_incompressible_continuous(self): # population_eq -> cm_eq - from continous definition: ' # k_mn = integrate(fun, (x, -oo, oo), (y, -oo, oo)) ' # where fun = fM(rho,u,x,y) *(x-ux)^m *(y-uy)^n * (z-uz)^o ') cm_i = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho) cm_eq = get_mom_vector_from_continuous_def( cm_i.get_incompressible_DF, continuous_transformation=cm_i.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: can't use hardcoded_cm_eq_incompressible_D2Q9, # because sympy switches hardcoded 'u.x*(-m00 + 1)' to '-u.x*(m00 - 1') and test fails. # 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} + ux2 + 1/3.);\n' in out assert f'cm_eq[7] = u.x*(-{m00}*uy2 - 1/3.*{m00} + uy2 + 1/3.);\n' in out assert f'cm_eq[8] = {m00}*ux2*uy2 + 1/3.*{m00}*ux2 + 1/3.*{m00}*uy2 + 1/9.*{m00} - ux2*uy2 - 1/3.*ux2 - 1/3.*uy2;\n' in out # noqa
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_thermal_cm_eq_vector_from_continuous_def(self): ccmt = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho, cs2=cs2_thermal) import warnings with warnings.catch_warnings(): warnings.simplefilter("ignore") cm_eq = get_mom_vector_from_continuous_def( ccmt.get_Maxwellian_DF, continuous_transformation=ccmt.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() f2 = io.StringIO() with redirect_stdout(f2): expected_result = hardcoded_cm_eq_compressible_D2Q9_thermal print_as_vector(expected_result, 'cm_eq') ccode_expected_result = f2.getvalue() assert ccode_expected_result == out
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) print_as_vector(NMF_cm_Guo, 'F_cm') print('\n\n// === continuous central moments === \n ') print('\n//Force -> Force_cm - from continuous definition: \n' 'k_mn = integrate(fun, (x, -oo, oo), (y, -oo, oo)) \n' 'where fun = forceM(rho,u,x,y) *(x-ux)^m (y-uy)^n ') F_cm = get_mom_vector_from_continuous_def( ccmt.get_force_Guo, continuous_transformation=ccmt.get_cm, moments_order=moments_dict[lattice]) print_as_vector(F_cm, 'F_cm') print('\n//Force -> Force_cm - from continous definition: \n' 'k_mn = integrate(fun, (x, -oo, oo), (y, -oo, oo)) \n' 'where fun = forceM(rho,u,x,y) *(x-ux)^m *(y-uy)^n *(z-uz)^o ') F_cm = get_mom_vector_from_continuous_def( ccmt.get_force_He_MB, continuous_transformation=ccmt.get_cm, moments_order=moments_dict[lattice]) print_as_vector(F_cm, 'F_cm') print('\n//Force -> Force_cm - from continous definition: \n' 'k_mn = integrate(fun, (x, -oo, oo), (y, -oo, oo)) \n' 'where fun = forceM(rho,u,x,y) *(x-ux)^m *(y-uy)^n *(z-uz)^o ')
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('\n//population_eq -> (central) m_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 ') print('The raw moments for the pressure part') m_eq_p = get_mom_vector_from_continuous_def( ccmt.get_incompressible_DF_part_p, continuous_transformation=ccmt.get_m, moments_order=moments_dict[lattice]) print_as_vector(m_eq_p, 'm_eq_p', output_order_of_moments=moments_dict[lattice]) print('The central moments for the velocity part') cm_eq_gamma = get_mom_vector_from_continuous_def( ccmt.get_incompressible_DF_part_gamma, continuous_transformation=ccmt.get_cm, moments_order=moments_dict[lattice]) print_as_vector(cm_eq_gamma, 'cm_eq_gamma', output_order_of_moments=moments_dict[lattice])
def test_cm_vector_from_continuous_def(self): # this test runs long without output and CI may consider it as a timeout :/ ccmt = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho) from SymbolicCollisions.core.cm_symbols import Sigma2asSymbol ccmt_cht = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho, cs2=Sigma2asSymbol) ccmts = [ ccmt, ccmt, ccmt, ccmt, ccmt, ccmt_cht, ] lattices = ['D2Q9', 'D3Q19', 'D2Q9', 'D2Q9', 'D3Q19', 'D2Q9'] functions = [ ccmt.get_Maxwellian_DF, ccmt.get_Maxwellian_DF, ccmt.get_force_Guo, ccmt.get_force_He_MB, ccmt.get_force_He_MB, ccmt_cht.get_cht_DF, ] expected_results = [ hardcoded_cm_eq_compressible_D2Q9, hardcoded_cm_eq_compressible_D3Q19, hardcoded_F_cm_Guo_hydro_incompressible_D2Q9, hardcoded_F_cm_hydro_compressible_D2Q9, hardcoded_F_cm_hydro_compressible_D3Q19, hardcoded_cm_eq_cht_D2Q9, ] for fun, lattice, _ccmt, expected_result in zip( functions, lattices, ccmts, expected_results): cm_eq = get_mom_vector_from_continuous_def( fun, continuous_transformation=_ccmt.get_cm, moments_order=moments_dict[lattice], serial_run=True) # print("------------\n\n") # print_as_vector(cm_eq, 'CM') # print_as_vector(expected_result, 'CM_expected') # print("------------\n\n") f = io.StringIO() with redirect_stdout(f): print_as_vector(cm_eq, 'cm_eq') out = f.getvalue() f2 = io.StringIO() with redirect_stdout(f2): print_as_vector(expected_result, 'cm_eq') ccode_expected_result = f2.getvalue() assert ccode_expected_result == out
# 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 \ F3D, dzeta3D, u3D, \ rho, cs2_thermal ccmt = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho, cs2=cs2_thermal) cm_eq = get_mom_vector_from_continuous_def( ccmt.get_Maxwellian_DF, continuous_transformation=ccmt.get_cm, moments_order=moments_dict['D2Q9'], serial_run=False) print_as_vector(cm_eq, 'cm_eq') print('---- CHT ----') cm_cht_eq = get_mom_vector_from_continuous_def( ccmt.get_cht_DF, continuous_transformation=ccmt.get_cm, moments_order=moments_dict[lattice], serial_run=False) print_as_vector(cm_cht_eq, 'cm_cht_eq', raw_output=False) cm_cht_eq = get_mom_vector_from_continuous_def( ccmt.get_cht_DF, continuous_transformation=ccmt.get_m,
rev_i = get_reverse_indices(e_D2Q9) print(f"reverse direction indices: {rev_i}") print(f"order of rmoments: \n {pd.DataFrame.from_records(rmoments_order)}") print(f"lattice velocities - e: \n {np.array(e_D2Q9)}") ###################### ccmt = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho) 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 ') m_eq = get_mom_vector_from_continuous_def(ccmt.get_Maxwellian_DF, continuous_transformation=ccmt.get_m, 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("--------------------------------------------------")
# continuous_transformation=ccmt.get_cm, # moments_order=moments_dict[lattice]) # # print_as_vector(mom_bc, 'He forcing scheme') kx = Symbol('k.x') ky = Symbol('k.y') k2D = Matrix([kx, ky]) ccmt = ContinuousCMTransforms(dzeta2D, u2D, k2D, rho) # kz = Symbol('k.z') # k3D = Matrix([kx, ky, kz]) # lattice = 'D2Q9' # ccmt = ContinuousCMTransforms(dzeta3D, u3D, k3D, rho) mom_bc = get_mom_vector_from_continuous_def( ccmt.get_bc_bb_heat_flux_cht, continuous_transformation=ccmt.get_m, moments_order=moments_dict[lattice]) print_as_vector(mom_bc, 'm_heat_flux_cht_bc', raw_output=False) mom_bc = get_mom_vector_from_continuous_def( ccmt.get_bc_bb_heat_flux_cht, continuous_transformation=ccmt.get_cm, moments_order=moments_dict[lattice]) print_as_vector(mom_bc, 'cm_heat_flux_cht_bc', raw_output=False) print("------- raw output----------") print_as_vector(mom_bc, 'cm_heat_flux_cht_bc', raw_output=True)
ccmt = ContinuousCMTransforms(dzeta3D, u3D, F3D, rho) start = time.process_time() print('\n\n// === continous cm === \n ') # to calculate particular moment row = moments_dict['D2Q9'][0] moment = ccmt.get_cm(row, ccmt.get_Maxwellian_DF) print_as_vector(Matrix([moment]), 'particular_moment') print('\n//Force -> Force_cm - from continous definition: \n' 'k_mn = integrate(fun, (x, -oo, oo), (y, -oo, oo)) \n' 'where fun = forceM(rho,u,x,y) *(x-ux)^m *(y-uy)^n *(z-uz)^o ') F_cm = get_mom_vector_from_continuous_def( ccmt.get_force_He_MB, continuous_transformation=ccmt.get_cm, moments_order=moments_dict[lattice]) print_as_vector(F_cm, 'F_cm') 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 ') cm_eq = get_mom_vector_from_continuous_def( ccmt.get_Maxwellian_DF, continuous_transformation=ccmt.get_cm, moments_order=moments_dict[lattice]) print_as_vector(cm_eq, 'cm_eq') print(f'\n\n Done in {time.process_time() - start} [s].')
print_as_vector(pop_eq, 'cm_eq_pf') print('\n\n// === continous cm === \n ') print("\n--- EQUILIBRIA ---") # to calculate particular moment row = moments_dict['D2Q9'][0] moment = ccmt.get_cm(row, ccmt.get_Maxwellian_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 ') cm_eq = get_mom_vector_from_continuous_def( ccmt.get_Maxwellian_DF, continuous_transformation=ccmt.get_cm, moments_order=moments_dict[lattice]) print_as_vector(cm_eq, 'cm_eq') print_as_vector(cm_eq, 'cm_eq', output_order_of_moments=moments_dict[lattice]) 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 ') cm_eq = 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, 'cm_eq')