def test_interpolation():
'''
'''
threshold = 8e-9
params.N_LGL = 8
gv = gvar.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, params.wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
N_LGL = 8
xi_LGL = lagrange.LGL_points(N_LGL)
xi_i = af.flat(af.transpose(af.tile(xi_LGL, 1, N_LGL)))
eta_j = af.tile(xi_LGL, N_LGL)
f_ij = np.e**(xi_i + eta_j)
interpolated_f = wave_equation_2d.lag_interpolation_2d(
f_ij, gv.Li_Lj_coeffs)
xi = utils.linspace(-1, 1, 8)
eta = utils.linspace(-1, 1, 8)
assert (af.mean(
af.transpose(utils.polyval_2d(interpolated_f, xi, eta)) -
np.e**(xi + eta)) < threshold)
def test_integrate():
'''
Testing the integrate() function by passing coefficients
of a polynomial and comparing it to the analytical result.
'''
threshold = 1e-14
params.N_LGL = 8
params.N_quad = 10
params.N_Elements = 10
wave = 'gaussian'
gv = global_variables.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
test_coeffs = af.np_to_af_array(np.array([7., 6, 4, 2, 1, 3, 9, 2]))
# The coefficients of a test polynomial
# `7x^7 + 6x^6 + 4x^5 + 2x^4 + x^3 + 3x^2 + 9x + 2`
# Using integrate() function.
calculated_integral = lagrange.integrate(af.transpose(test_coeffs), gv)
analytical_integral = 8.514285714285714
assert (calculated_integral - analytical_integral) <= threshold
def test_A_matrix():
'''
Compares the tensor product calculated using the ``A_matrix`` function
with an analytic value of the tensor product for :math:`N_{LGL} = 4`.
The analytic value of the tensor product is calculated in this
`document`_
.. _document: https://goo.gl/QNWxXp
'''
threshold = 1e-12
A_matrix_ref = af.np_to_af_array(
utils.csv_to_numpy(
'dg_maxwell/tests/wave_equation_2d/files/A_matrix_ref.csv'))
params.N_LGL = 4
advec_var = gvar.advection_variables(params.N_LGL, params.N_quad,
params.x_nodes, params.N_Elements,
params.c, params.total_time,
params.wave, params.c_x, params.c_y,
params.courant, params.mesh_file,
params.total_time_2d)
A_matrix_test = wave_equation_2d.A_matrix(params.N_LGL, advec_var)
assert af.max(af.abs(A_matrix_test - A_matrix_ref)) < threshold
def test_surface_term():
'''
A test function to test the surface_term function in the wave_equation
module using analytical Lax-Friedrichs flux.
'''
threshold = 1e-13
params.c = 1
params.N_LGL = 8
params.N_quad = 10
params.N_Elements = 10
wave = 'gaussian'
gv = global_variables.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
analytical_f_i = (gv.u_init[-1, :])
analytical_f_i_minus1 = (af.shift(gv.u_init[-1, :], 0, 1))
L_p_1 = af.constant(0, params.N_LGL, dtype=af.Dtype.f64)
L_p_1[params.N_LGL - 1] = 1
L_p_minus1 = af.constant(0, params.N_LGL, dtype=af.Dtype.f64)
L_p_minus1[0] = 1
analytical_surface_term = af.blas.matmul(L_p_1, analytical_f_i)\
- af.blas.matmul(L_p_minus1, analytical_f_i_minus1)
numerical_surface_term = (wave_equation.surface_term(gv.u_init[:, :], gv))
assert af.max(af.abs(analytical_surface_term - numerical_surface_term)) \
< threshold
return analytical_surface_term
def test_b_vector():
'''
A test function to check the b vector obtained analytically and compare it
with the one returned by b_vector function in wave_equation module.
'''
threshold = 1e-13
params.c = 1
params.N_LGL = 8
params.N_quad = 10
params.N_Elements = 10
wave = 'gaussian'
gv = global_variables.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
u_n_A_matrix = af.blas.matmul(wave_equation.A_matrix(gv),\
gv.u_init)
volume_integral_flux = test_volume_integral_flux()
surface_term = test_surface_term()
b_vector_analytical = u_n_A_matrix + (volume_integral_flux -\
(surface_term)) * gv.delta_t
b_vector_array = wave_equation.b_vector(gv.u_init, gv)
assert (b_vector_analytical - b_vector_array) < threshold
def test_dx_dxi():
'''
A Test function to check the dx_xi function in wave_equation module by
passing nodes of an element and using the LGL points. Analytically, the
differential would be a constant. The check has a tolerance 1e-7.
'''
threshold = 1e-8
params.N_LGL = 8
params.N_quad = 10
params.N_Elements = 10
wave = 'gaussian'
gv = global_variables.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
nodes = np.array([7, 10], dtype=np.float64)
test_nodes = af.interop.np_to_af_array(nodes)
analytical_dx_dxi = 1.5
check_dx_dxi = abs(
(af.mean(wave_equation.dx_dxi_numerical(test_nodes, gv.xi_LGL)) -
analytical_dx_dxi)) <= threshold
assert check_dx_dxi
def test_lax_friedrichs_flux():
'''
A test function to test the lax_friedrichs_flux function in wave_equation
module.
'''
threshold = 1e-14
params.N_LGL = 8
params.N_quad = 10
params.N_Elements = 10
wave = 'gaussian'
gv = global_variables.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
f_i = wave_equation.lax_friedrichs_flux(gv.u_init)
analytical_lax_friedrichs_flux = gv.u_init[-1, :]
assert af.max(af.abs(analytical_lax_friedrichs_flux - f_i)) < threshold
from dg_maxwell import wave_equation_2d
from dg_maxwell.tests import test_waveEqn
from dg_maxwell import isoparam
from dg_maxwell import lagrange
from dg_maxwell import params
from dg_maxwell import advection_2d
from dg_maxwell import utils
from dg_maxwell import global_variables
af.set_backend(params.backend)
#print(af.mean(af.abs(advection_2d.u_analytical(0) - params.u_e_ij)))
gv = global_variables.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, params.wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
print('start')
print(af.info())
#print(wave_equation_2d.dx_deta(gv.nodes[gv.elements[0]][:, 1], gv.xi_i, gv.eta_j))
#print(gv.nodes[gv.elements[1]][:, 1])
#print(af.np_to_af_array(gv.nodes[gv.elements[1]]))#[:, 0])
elements_nodes = (af.reorder(
af.transpose(af.np_to_af_array(gv.nodes[gv.elements[:]])), 0, 2,
1)) #[0, :, :])
#print(elements_nodes)
#dxi_dx_elements = (wave_equation_2d.trial_dxi_dx(elements_nodes[:, 0, :],\
# elements_nodes[:, 1, :], gv.xi_i, gv.eta_j))
def test_volume_integral_flux():
'''
A test function to check the volume_integral_flux function in wave_equation
module by analytically calculated Gauss-Lobatto quadrature.
Reference
---------
The link to the sage worksheet where the calculations were caried out is
given below.
`https://goo.gl/5Mub8M`
'''
threshold = 4e-9
params.c = 1
params.N_LGL = 8
params.N_quad = 10
params.N_Elements = 10
wave = 'gaussian'
gv = global_variables.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
reference_flux_integral = af.transpose(af.interop.np_to_af_array(np.array
([
[-0.002016634876668093, -0.000588597708116113, -0.0013016773719126333,\
-0.002368387579324652, -0.003620502047659841, -0.004320197094090966,
-0.003445512010153811, 0.0176615086879261],\
[-0.018969769374, -0.00431252844519,-0.00882630935977,-0.0144355176966,\
-0.019612124119, -0.0209837936827, -0.0154359890788, 0.102576031756], \
[-0.108222418798, -0.0179274222595, -0.0337807018822, -0.0492589052599,\
-0.0588472807471, -0.0557970236273, -0.0374764132459, 0.361310165819],\
[-0.374448714304, -0.0399576371245, -0.0683852285846, -0.0869229749357,\
-0.0884322503841, -0.0714664112839, -0.0422339853622, 0.771847201979], \
[-0.785754362849, -0.0396035640187, -0.0579313769517, -0.0569022801117,\
-0.0392041960688, -0.0172295769141, -0.00337464521455, 1.00000000213],\
[-1.00000000213, 0.00337464521455, 0.0172295769141, 0.0392041960688,\
0.0569022801117, 0.0579313769517, 0.0396035640187, 0.785754362849],\
[-0.771847201979, 0.0422339853622, 0.0714664112839, 0.0884322503841, \
0.0869229749357, 0.0683852285846, 0.0399576371245, 0.374448714304],\
[-0.361310165819, 0.0374764132459, 0.0557970236273, 0.0588472807471,\
0.0492589052599, 0.0337807018822, 0.0179274222595, 0.108222418798], \
[-0.102576031756, 0.0154359890788, 0.0209837936827, 0.019612124119, \
0.0144355176966, 0.00882630935977, 0.00431252844519, 0.018969769374],\
[-0.0176615086879, 0.00344551201015 ,0.00432019709409, 0.00362050204766,\
0.00236838757932, 0.00130167737191, 0.000588597708116, 0.00201663487667]\
])))
numerical_flux = wave_equation.volume_integral_flux(gv.u_init[:, :], gv)
assert (af.mean(af.abs(numerical_flux - reference_flux_integral)) <
threshold)
return numerical_flux
def test_A_matrix():
'''
Test function to check the A matrix obtained from wave_equation module with
one obtained by numerical integral solvers.
'''
threshold = 1e-8
params.N_LGL = 8
params.N_quad = 10
params.N_Elements = 10
wave = 'gaussian'
gv = global_variables.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
reference_A_matrix = 0.1 * af.interop.np_to_af_array(np.array([\
[0.03333333333332194, 0.005783175201965206, -0.007358427761753982, \
0.008091331778355441, -0.008091331778233877, 0.007358427761705623, \
-0.00578317520224949, 0.002380952380963754], \
[0.005783175201965206, 0.19665727866729804, 0.017873132323192046,\
-0.01965330750343234, 0.019653307503020866, -0.017873132322725152,\
0.014046948476303067, -0.005783175202249493], \
[-0.007358427761753982, 0.017873132323192046, 0.31838117965137114, \
0.025006581762566073, -0.025006581761945083, 0.022741512832051156,\
-0.017873132322725152, 0.007358427761705624], \
[0.008091331778355441, -0.01965330750343234, 0.025006581762566073, \
0.3849615416814164, 0.027497252976343693, -0.025006581761945083, \
0.019653307503020863, -0.008091331778233875],\
[-0.008091331778233877, 0.019653307503020866, -0.025006581761945083, \
0.027497252976343693, 0.3849615416814164, 0.025006581762566073, \
-0.019653307503432346, 0.008091331778355443], \
[0.007358427761705623, -0.017873132322725152, 0.022741512832051156, \
-0.025006581761945083, 0.025006581762566073, 0.31838117965137114, \
0.017873132323192046, -0.0073584277617539835], \
[-0.005783175202249493, 0.014046948476303067, -0.017873132322725152, \
0.019653307503020863, -0.019653307503432346, 0.017873132323192046, \
0.19665727866729804, 0.0057831752019652065], \
[0.002380952380963754, -0.005783175202249493, 0.007358427761705624, \
-0.008091331778233875, 0.008091331778355443, -0.0073584277617539835, \
0.0057831752019652065, 0.033333333333321946]
]))
test_A_matrix = wave_equation.A_matrix(gv)
print(test_A_matrix, reference_A_matrix)
error_array = af.abs(reference_A_matrix - test_A_matrix)
assert af.max(error_array) < threshold
def test_lagrange_coeffs():
'''
Function to test the lagrange_coeffs in global_variables module by
passing 8 LGL points and comparing the numerically obtained basis function
coefficients to analytically calculated ones.
Reference
---------
The link to the sage worksheet where the calculations were carried out.
`https://goo.gl/6EFX5S`
'''
threshold = 1e-10
params.N_LGL = 8
params.N_quad = 10
params.N_Elements = 10
wave = 'gaussian'
gv = global_variables.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
basis_array_analytical = np.zeros([8, 8])
basis_array_analytical[0] = np.array([-3.351562500008004,\
3.351562500008006, \
3.867187500010295,\
-3.867187500010297,\
- 1.054687500002225, \
1.054687500002225, \
0.03906249999993106,\
- 0.03906249999993102])
basis_array_analytical[1] = np.array([8.140722718246403,\
- 7.096594831382852,\
- 11.34747768400062,\
9.89205188146461, \
3.331608712119162, \
- 2.904297073479968,\
- 0.1248537463649464,\
0.1088400233982081])
basis_array_analytical[2] = np.array([-10.35813682892759,\
6.128911440984293,\
18.68335515838398,\
- 11.05494463699297,\
- 8.670037141196786,\
5.130062549476987,\
0.3448188117404021,\
- 0.2040293534683072])
basis_array_analytical[3] = np.array([11.38981374849497,\
- 2.383879109609436,\
- 24.03296250200938,\
5.030080255538657,\
15.67350804691132,\
- 3.28045297599924,\
- 3.030359293396907,\
0.6342518300700298])
basis_array_analytical[4] = np.array([-11.38981374849497,\
- 2.383879109609437,\
24.03296250200939,\
5.030080255538648,\
- 15.67350804691132,\
- 3.28045297599924,\
3.030359293396907,\
0.6342518300700299])
basis_array_analytical[5] = np.array([10.35813682892759,\
6.128911440984293,\
-18.68335515838398,\
- 11.05494463699297,\
8.670037141196786,\
5.130062549476987,\
- 0.3448188117404021,\
- 0.2040293534683072])
basis_array_analytical[6] = np.array([-8.140722718246403,\
- 7.096594831382852,\
11.34747768400062,\
9.89205188146461, \
-3.331608712119162, \
- 2.904297073479968,\
0.1248537463649464,\
0.1088400233982081])
basis_array_analytical[7] = np.array([3.351562500008004,\
3.351562500008005, \
- 3.867187500010295,\
- 3.867187500010298,\
1.054687500002225, \
1.054687500002224, \
- 0.039062499999931,\
- 0.03906249999993102])
basis_array_analytical = af.interop.np_to_af_array(basis_array_analytical)
assert af.max(af.abs(basis_array_analytical - gv.lagrange_coeffs)) \
< threshold
