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)