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)