def tensorized_basis_3D(order):
total_integration_points = (order + 1) * (order + 1)
r,s,t = sym.symbols('r,s,t')
r_gll = sym.symbols('r_0:%d' % (order + 1))
s_gll = sym.symbols('s_0:%d' % (order + 1))
t_gll = sym.symbols('t_0:%d' % (order + 1))
# Get N + 1 lagrange polynomials in each direction.
generator_r = generating_polynomial_lagrange(order, 'r', r_gll)
generator_s = generating_polynomial_lagrange(order, 's', s_gll)
generator_t = generating_polynomial_lagrange(order, 't', t_gll)
# Get tensorized basis.
basis = TensorProduct(generator_t, generator_s, generator_r)
gll_coordinates, gll_weights = gauss_lobatto_legendre_quadruature_points_weights(order + 1)
basis = basis.subs([(v, c) for v, c in zip(r_gll, gll_coordinates)])
basis = basis.subs([(v, c) for v, c in zip(s_gll, gll_coordinates)])
basis = basis.subs([(v, c) for v, c in zip(t_gll, gll_coordinates)])
# Get gradient of basis functions.
basis_gradient_r = sym.Matrix([sym.diff(i, r) for i in basis])
basis_gradient_s = sym.Matrix([sym.diff(i, s) for i in basis])
basis_gradient_t = sym.Matrix([sym.diff(i, t) for i in basis])
routines = [('interpolate_order{}_hex'.format(order),basis),
('interpolate_r_derivative_order{}_hex'.format(order), basis_gradient_r),
('interpolate_s_derivative_order{}_hex'.format(order), basis_gradient_s),
('interpolate_t_derivative_order{}_hex'.format(order), basis_gradient_t)]
codegen(routines, "C", "order{}_hex".format(order), to_files=True, project="SALVUS")
# fix headers (#include "order4_hex.h" -> #include <Element/HyperCube/Autogen/order3_hex.h>)
fixHeader(order,"hex",".")
def tensorized_basis_2D(order):
total_integration_points = (order + 1) * (order + 1)
eps, eta, rho = sym.symbols('epsilon eta rho')
eps_gll = sym.symbols('epsilon_0:%d' % (order + 1))
eta_gll = sym.symbols('eta_0:%d' % (order + 1))
# Get N + 1 lagrange polynomials in each direction.
generator_eps = generating_polynomial_lagrange(order, 'epsilon', eps_gll)
generator_eta = generating_polynomial_lagrange(order, 'eta', eta_gll)
# Get tensorized basis.
basis = TensorProduct(generator_eta, generator_eps)
gll_coordinates, gll_weights = gauss_lobatto_legendre_quadruature_points_weights(order + 1)
basis = basis.subs([(v, c) for v, c in zip(eps_gll, gll_coordinates)])
basis = basis.subs([(v, c) for v, c in zip(eta_gll, gll_coordinates)])
# Get gradient of basis functions.
basis_gradient_eps = sym.Matrix([sym.diff(i, eps) for i in basis])
basis_gradient_eta = sym.Matrix([sym.diff(i, eta) for i in basis])
# Get closure mapping.
closure = sym.Matrix(generate_closure_mapping(order), dtype=int)
# Write code
routines = []
autocode = CCodeGen()
routines.append(autocode.routine(
'interpolate_order{}_square'.format(order), basis,
argument_sequence=None))
routines.append(autocode.routine(
'interpolate_eps_derivative_order{}_square'.format(order), basis_gradient_eps,
argument_sequence=None))
routines.append(autocode.routine(
'interpolate_eta_derivative_order{}_square'.format(order), basis_gradient_eta,
argument_sequence=None))
routines.append(autocode.routine(
'closure_mapping_order{}_square'.format(order), closure,
argument_sequence=None))
routines.append(autocode.routine(
'gll_weights_order{}_square'.format(order), sym.Matrix(gll_weights),
argument_sequence=None))
routines.append(autocode.routine(
'gll_coordinates_order{}_square'.format(order), sym.Matrix(gll_coordinates),
argument_sequence=None))
autocode.write(routines, 'order{}_square'.format(order), to_files=True)
# reformat some code.
for code, lend in zip(['order{}_square.c', 'order{}_square.h'], [' {', ';']):
with io.open(code.format(order), 'rt') as fh:
text = fh.readlines()
text = [line.replace('double', 'int') if 'closure' in line else line for line in text]
with io.open(code.format(order), 'wt') as fh:
fh.writelines(text)
def tensorized_basis_3D(order):
total_integration_points = (order + 1) * (order + 1)
r, s, t = sym.symbols('r,s,t')
r_gll = sym.symbols('r_0:%d' % (order + 1))
s_gll = sym.symbols('s_0:%d' % (order + 1))
t_gll = sym.symbols('t_0:%d' % (order + 1))
# Get N + 1 lagrange polynomials in each direction.
generator_r = generating_polynomial_lagrange(order, 'r', r_gll)
generator_s = generating_polynomial_lagrange(order, 's', s_gll)
generator_t = generating_polynomial_lagrange(order, 't', t_gll)
# Get tensorized basis.
basis = TensorProduct(generator_t, generator_s, generator_r)
gll_coordinates, gll_weights = gauss_lobatto_legendre_quadruature_points_weights(
order + 1)
basis = basis.subs([(v, c) for v, c in zip(r_gll, gll_coordinates)])
basis = basis.subs([(v, c) for v, c in zip(s_gll, gll_coordinates)])
basis = basis.subs([(v, c) for v, c in zip(t_gll, gll_coordinates)])
# Get gradient of basis functions.
basis_gradient_r = sym.Matrix([sym.diff(i, r) for i in basis])
basis_gradient_s = sym.Matrix([sym.diff(i, s) for i in basis])
basis_gradient_t = sym.Matrix([sym.diff(i, t) for i in basis])
routines = [('interpolate_order{}_hex'.format(order), basis),
('interpolate_r_derivative_order{}_hex'.format(order),
basis_gradient_r),
('interpolate_s_derivative_order{}_hex'.format(order),
basis_gradient_s),
('interpolate_t_derivative_order{}_hex'.format(order),
basis_gradient_t)]
codegen(routines,
"C",
"order{}_hex".format(order),
to_files=True,
project="SALVUS")
# fix headers (#include "order4_hex.h" -> #include <Element/HyperCube/Autogen/order3_hex.h>)
fixHeader(order, "hex", ".")
def tensorized_basis_2D(order):
total_integration_points = (order + 1) * (order + 1)
eps, eta, rho = sym.symbols('epsilon eta rho')
eps_gll = sym.symbols('epsilon_0:%d' % (order + 1))
eta_gll = sym.symbols('eta_0:%d' % (order + 1))
# Get N + 1 lagrange polynomials in each direction.
generator_eps = generating_polynomial_lagrange(order, 'epsilon', eps_gll)
generator_eta = generating_polynomial_lagrange(order, 'eta', eta_gll)
# Get tensorized basis.
basis = TensorProduct(generator_eta, generator_eps)
gll_coordinates, gll_weights = gauss_lobatto_legendre_quadruature_points_weights(
order + 1)
basis = basis.subs([(v, c) for v, c in zip(eps_gll, gll_coordinates)])
basis = basis.subs([(v, c) for v, c in zip(eta_gll, gll_coordinates)])
# Get gradient of basis functions.
basis_gradient_eps = sym.Matrix([sym.diff(i, eps) for i in basis])
basis_gradient_eta = sym.Matrix([sym.diff(i, eta) for i in basis])
# Get closure mapping.
closure = sym.Matrix(generate_closure_mapping(order), dtype=int)
# Write code
routines = []
autocode = CCodeGen()
routines.append(
autocode.routine('interpolate_order{}_square'.format(order),
basis,
argument_sequence=None))
routines.append(
autocode.routine(
'interpolate_eps_derivative_order{}_square'.format(order),
basis_gradient_eps,
argument_sequence=None))
routines.append(
autocode.routine(
'interpolate_eta_derivative_order{}_square'.format(order),
basis_gradient_eta,
argument_sequence=None))
routines.append(
autocode.routine('closure_mapping_order{}_square'.format(order),
closure,
argument_sequence=None))
routines.append(
autocode.routine('gll_weights_order{}_square'.format(order),
sym.Matrix(gll_weights),
argument_sequence=None))
routines.append(
autocode.routine('gll_coordinates_order{}_square'.format(order),
sym.Matrix(gll_coordinates),
argument_sequence=None))
autocode.write(routines, 'order{}_square'.format(order), to_files=True)
# reformat some code.
for code, lend in zip(['order{}_square.c', 'order{}_square.h'],
[' {', ';']):
with io.open(code.format(order), 'rt') as fh:
text = fh.readlines()
text = [
line.replace('double', 'int') if 'closure' in line else line
for line in text
]
with io.open(code.format(order), 'wt') as fh:
fh.writelines(text)
