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)
basis = basis.subs([(v, c)
for v, c in zip(eps_gll, gll_coordinates(order))])
basis = basis.subs([(v, c)
for v, c in zip(eta_gll, gll_coordinates(order))])
sym.pprint(basis)
# 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 diagonal mass matrix
mass_matrix = rho * basis * basis.T
mass_matrix_diagonal = sym.Matrix(
[mass_matrix[i, i] for i in range(total_integration_points)])
# 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('diagonal_mass_matrix_order{}_square'.format(order),
mass_matrix_diagonal,
argument_sequence=None))
autocode.write(routines, 'order{}_square'.format(order), to_files=True)
def E_d(x_shadow, x_nonshadow, pen_inter, y_dim, patch):
############################
# Compute A
############################
# Compute quadratic outer product via sympy
quadratic = Matrix(3, 1, [x * x, x, 1.0])
quadratic_outer = TensorProduct(quadratic, quadratic.T)
A_nonshadow = np.zeros((3, 3))
# Non-shadow pattern
for x_ in x_nonshadow:
A_nonshadow += np.array(quadratic_outer.subs(x, x_)).astype(np.float64)
# Shadow pattern
A_shadow = np.zeros((3, 3))
for x_ in x_shadow:
A_shadow += np.array(quadratic_outer.subs(x, x_)).astype(np.float64)
# Fill A along diagonal with the two patterns
# First half non_shadow, second half shadow pattern
A_dim = y_dim * 3 * 2
A = np.zeros((A_dim, A_dim))
for i in np.arange(0, A_dim / 2, 3, dtype=np.int16):
A[i:i + 3, i:i + 3] = A_nonshadow
for i in np.arange(A_dim / 2, A_dim, 3, dtype=np.int16):
A[i:i + 3, i:i + 3] = A_shadow
###########################
# Compute b
###########################
b = np.zeros(y_dim * 3 * 2)
for i in range(0, y_dim):
# Cut out nonshadow patch
patch_nonshadow = patch[i, int(np.ceil(pen_inter[1])):]
# Cut out shadow patch
patch_shadow = patch[i, 0:int(np.floor(pen_inter[0])) + 1]
# sum_j I_{i,j} * x_i^2
b[3 * i] = np.sum(np.multiply(patch_nonshadow, np.square(x_nonshadow)))
# sum_j I_{i,j} * x_i
b[3 * i + 1] = np.sum(np.multiply(patch_nonshadow, x_nonshadow))
# sum_j I_{i,j}
b[3 * i + 2] = np.sum(patch_nonshadow)
b[3 * i + y_dim * 3] = np.sum(
np.multiply(patch_shadow, np.square(x_shadow)))
b[3 * i + y_dim * 3 + 1] = np.sum(np.multiply(patch_shadow, x_shadow))
b[3 * i + y_dim * 3 + 2] = np.sum(patch_shadow)
return A, b
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)
basis = basis.subs([(v, c) for v, c in zip(eps_gll, gll_coordinates(order))])
basis = basis.subs([(v, c) for v, c in zip(eta_gll, gll_coordinates(order))])
sym.pprint(basis)
# 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 diagonal mass matrix
mass_matrix = rho * basis * basis.T
mass_matrix_diagonal = sym.Matrix([mass_matrix[i, i] for i in range(total_integration_points)])
# 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(
"diagonal_mass_matrix_order{}_square".format(order), mass_matrix_diagonal, argument_sequence=None
)
)
autocode.write(routines, "order{}_square".format(order), to_files=True)
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)
