Loading...
Searching...
No Matches
EpsilonDivDiv_kernel_gen Namespace Reference

Functions

 create_col_assigns (E, col, col_vec)
 
 double_contract (A, B)
 

Variables

 local_subdomain_id
 
 x_cell
 
 y_cell
 
 r_cell
 
 integer
 
str scalar_type = 'double'
 
 rads
 
 rad_assignments
 
 src_symbol
 
 src_array_declaration
 
 src_assignments
 
 k_symbol
 
 k_array_declaration
 
 k_assignments
 
str kernel_code = "\n"
 
 qp_data = quad_points_1x1
 
 qw_data = quad_weights_1x1
 
int num_qps = 1
 
int dim = 3
 
str qp_array_name = "qp_array"
 
str qw_array_name = "qw_array"
 
 qp_array = IndexedBase(qp_array_name, shape=(num_qps, 3), real=True)
 
 qw_array = IndexedBase(qw_array_name, shape=(num_qps), real=True)
 
int num_wedges_per_hex_cell = 2
 
int num_nodes_per_wedge_surface = 3
 
int num_nodes_per_wedge = 6
 
 cmb_shift
 
 surface_shift
 
 at_surface_boundary
 
 at_cmb_boundary
 
 max_rad
 
 treat_boundary
 
 diagonal
 
 postloop
 
str dst_array_name = "dst_array"
 
 dst_symbol
 
list quadloop_body = []
 
list quadloop_exprs = []
 
 q_symbol = sp.symbols("q", integer=True)
 
list qp = [qp_array[q_symbol, d] for d in range(dim)]
 
 qw = qw_array[q_symbol]
 
 w_symbol
 
 dimi_symbol
 
 dimj_symbol
 
 dim_diagBC_symbol
 
 k_eval_symbol = sp.symbols("k_eval", real=True)
 
 k_eval
 
 k_eval_replacements
 
 k_eval_reduced_exprs
 
 exprs
 
 symbols
 
 g_symbol = symbols("node_idx", integer=True)
 
str scalar_grad_name = "scalar_grad"
 
 scalar_grad = IndexedBase(scalar_grad_name, shape=(num_nodes_per_wedge, dim), real=True)
 
bool jac_laterally_precomputed = False
 
list jac_exprs = []
 
 J
 
 J_cse_assignments
 
 J_cse_exprs
 
 J_cse = sp.Matrix(3, 3, J_cse_exprs)
 
 J_cse_replaced_assignments
 
 J_cse_replaced
 
 J_det = J_cse_replaced.det()
 
 J_det_replacements
 
 J_det_reduced_exprs
 
 J_det_symbol = sp.symbols(f"J_det", real=True)
 
 J_abs_det = abs(J_det_symbol)
 
 J_inv = J_cse_replaced.adjugate() / J_det_symbol
 
 J_invT = J_inv.transpose()
 
 J_invT_replacements
 
 J_invT_reduced_exprs
 
 J_invT_cse = sp.Matrix(3, 3, J_invT_reduced_exprs)
 
 J_invT_cse_assignments
 
 J_invT_cse_replaced
 
list grad_exprs = []
 
list scalar_grad_is = []
 
 scalar_grad_i_replacements
 
 scalar_grad_i_reduced_exprs
 
 r_inv
 
 g3
 
 grad_r
 
 grad_r_inv
 
 real
 
 g1 = IndexedBase("grad1", shape=(3))
 
 g2 = IndexedBase("grad2", shape=(3))
 
 d_symbol = symbols("d", integer=True)
 
 value
 
int r = 1 / r_inv
 
list dimloop_j_body = []
 
list dimloop_j_exprs = []
 
list dimloop_i_body = []
 
list dimloop_i_exprs = []
 
str E_trial_name = "E_grad_trial"
 
 E_trial = IndexedBase(E_trial_name, shape=(3, 3), real=True)
 
 div_u = symbols("div_u", real=True)
 
list u_grad_loop_exprs = []
 
 E_trial_matrix = Matrix(3, 3, [E_trial[i, j] for i in range(dim) for j in range(dim)])
 
str grad_u_name = "grad_u"
 
 grad_u = IndexedBase(grad_u_name, shape=(3, 3), real=True)
 
 grad_u_matrix = Matrix(3, 3, [grad_u[i, j] for i in range(dim) for j in range(dim)])
 
float symm_grad_j = 0.5 * (E_trial_matrix + (E_trial_matrix).transpose())
 
 symm_grad_j_replacements
 
 symm_grad_j_reduced_exprs
 
str E_test_name = "E_grad_test"
 
 E_test = IndexedBase(E_test_name, shape=(3, 3), real=True)
 
list pairing_loop_exprs = []
 
 E_test_matrix = Matrix(3, 3, [E_test[i, j] for i in range(dim) for j in range(dim)])
 
float symm_grad_i = 0.5 * (E_test_matrix + (E_test_matrix).transpose())
 
 symm_grad_i_replacements
 
 symm_grad_i_reduced_exprs
 
 pairing_replacements
 
 pairing_reduced_exprs
 
list boundary_loop_exprs = []
 
str grad_u_diag_name = "grad_u_diag"
 
 grad_u_diag = IndexedBase(grad_u_diag_name, shape=(3, 3), real=True)
 
 grad_u_diag_matrix
 
 symm_grad_i_reduced_matrix = Matrix(3, 3, symm_grad_i_reduced_exprs[0])
 
 diag_pairing_replacements
 
 diag_pairing_reduced_exprs
 
list dimloop_diagBC_body
 
 encoding
 

Function Documentation

◆ create_col_assigns()

EpsilonDivDiv_kernel_gen.create_col_assigns (   E,
  col,
  col_vec 
)

◆ double_contract()

EpsilonDivDiv_kernel_gen.double_contract (   A,
  B 
)

Variable Documentation

◆ at_cmb_boundary

EpsilonDivDiv_kernel_gen.at_cmb_boundary

◆ at_surface_boundary

EpsilonDivDiv_kernel_gen.at_surface_boundary

◆ boundary_loop_exprs

list EpsilonDivDiv_kernel_gen.boundary_loop_exprs = []

◆ cmb_shift

EpsilonDivDiv_kernel_gen.cmb_shift

◆ d_symbol

EpsilonDivDiv_kernel_gen.d_symbol = symbols("d", integer=True)

◆ diag_pairing_reduced_exprs

EpsilonDivDiv_kernel_gen.diag_pairing_reduced_exprs

◆ diag_pairing_replacements

EpsilonDivDiv_kernel_gen.diag_pairing_replacements

◆ diagonal

EpsilonDivDiv_kernel_gen.diagonal

◆ dim

int EpsilonDivDiv_kernel_gen.dim = 3

◆ dim_diagBC_symbol

EpsilonDivDiv_kernel_gen.dim_diagBC_symbol

◆ dimi_symbol

EpsilonDivDiv_kernel_gen.dimi_symbol

◆ dimj_symbol

EpsilonDivDiv_kernel_gen.dimj_symbol

◆ dimloop_diagBC_body

list EpsilonDivDiv_kernel_gen.dimloop_diagBC_body
Initial value:
1= [
2 Conditional(
3 (
4 diagonal
5 | (treat_boundary & (Ne(at_surface_boundary, 0) | Ne(at_cmb_boundary, 0)))
6 ),
7 [
8 Variable.deduced(g_symbol).as_Declaration(),
9 For(
10 g_symbol,
11 [0 + surface_shift, num_nodes_per_wedge - cmb_shift, 1],
12 make_ast_from_exprs(boundary_loop_exprs),
13 ),
14 ],
15 ),
16]

◆ dimloop_i_body

list EpsilonDivDiv_kernel_gen.dimloop_i_body = []

◆ dimloop_i_exprs

list EpsilonDivDiv_kernel_gen.dimloop_i_exprs = []

◆ dimloop_j_body

list EpsilonDivDiv_kernel_gen.dimloop_j_body = []

◆ dimloop_j_exprs

list EpsilonDivDiv_kernel_gen.dimloop_j_exprs = []

◆ div_u

EpsilonDivDiv_kernel_gen.div_u = symbols("div_u", real=True)

◆ dst_array_name

str EpsilonDivDiv_kernel_gen.dst_array_name = "dst_array"

◆ dst_symbol

EpsilonDivDiv_kernel_gen.dst_symbol
Initial value:
1= IndexedBase(
2 dst_array_name, shape=(dim, num_wedges_per_hex_cell, num_nodes_per_wedge)
3)

◆ E_test

EpsilonDivDiv_kernel_gen.E_test = IndexedBase(E_test_name, shape=(3, 3), real=True)

◆ E_test_matrix

EpsilonDivDiv_kernel_gen.E_test_matrix = Matrix(3, 3, [E_test[i, j] for i in range(dim) for j in range(dim)])

◆ E_test_name

str EpsilonDivDiv_kernel_gen.E_test_name = "E_grad_test"

◆ E_trial

EpsilonDivDiv_kernel_gen.E_trial = IndexedBase(E_trial_name, shape=(3, 3), real=True)

◆ E_trial_matrix

EpsilonDivDiv_kernel_gen.E_trial_matrix = Matrix(3, 3, [E_trial[i, j] for i in range(dim) for j in range(dim)])

◆ E_trial_name

str EpsilonDivDiv_kernel_gen.E_trial_name = "E_grad_trial"

◆ encoding

EpsilonDivDiv_kernel_gen.encoding

◆ exprs

EpsilonDivDiv_kernel_gen.exprs

◆ g1

EpsilonDivDiv_kernel_gen.g1 = IndexedBase("grad1", shape=(3))

◆ g2

EpsilonDivDiv_kernel_gen.g2 = IndexedBase("grad2", shape=(3))

◆ g3

EpsilonDivDiv_kernel_gen.g3

◆ g_symbol

EpsilonDivDiv_kernel_gen.g_symbol = symbols("node_idx", integer=True)

◆ grad_exprs

list EpsilonDivDiv_kernel_gen.grad_exprs = []

◆ grad_r

EpsilonDivDiv_kernel_gen.grad_r

◆ grad_r_inv

EpsilonDivDiv_kernel_gen.grad_r_inv

◆ grad_u

EpsilonDivDiv_kernel_gen.grad_u = IndexedBase(grad_u_name, shape=(3, 3), real=True)

◆ grad_u_diag

EpsilonDivDiv_kernel_gen.grad_u_diag = IndexedBase(grad_u_diag_name, shape=(3, 3), real=True)

◆ grad_u_diag_matrix

EpsilonDivDiv_kernel_gen.grad_u_diag_matrix
Initial value:
1= Matrix(3, 3, symm_grad_i_reduced_exprs[0]).multiply_elementwise(
2 Matrix(
3 3,
4 3,
5 [
6 src_symbol[dim_diagBC_symbol, w_symbol, g_symbol]
7 for i in range(dim)
8 for j in range(dim)
9 ],
10 )
11)

◆ grad_u_diag_name

str EpsilonDivDiv_kernel_gen.grad_u_diag_name = "grad_u_diag"

◆ grad_u_matrix

EpsilonDivDiv_kernel_gen.grad_u_matrix = Matrix(3, 3, [grad_u[i, j] for i in range(dim) for j in range(dim)])

◆ grad_u_name

str EpsilonDivDiv_kernel_gen.grad_u_name = "grad_u"

◆ integer

EpsilonDivDiv_kernel_gen.integer

◆ J

EpsilonDivDiv_kernel_gen.J
Initial value:
1= jac_from_array(
2 [
3 [wedge_surf_phy_coords_symbol[w_symbol, j, d] for d in range(dim)]
4 for j in range(dim)
5 ],
6 rads[0],
7 rads[1],
8 qp,
9 )

◆ J_abs_det

int EpsilonDivDiv_kernel_gen.J_abs_det = abs(J_det_symbol)

◆ J_cse

EpsilonDivDiv_kernel_gen.J_cse = sp.Matrix(3, 3, J_cse_exprs)

◆ J_cse_assignments

EpsilonDivDiv_kernel_gen.J_cse_assignments

◆ J_cse_exprs

EpsilonDivDiv_kernel_gen.J_cse_exprs

◆ J_cse_replaced

EpsilonDivDiv_kernel_gen.J_cse_replaced

◆ J_cse_replaced_assignments

EpsilonDivDiv_kernel_gen.J_cse_replaced_assignments

◆ J_det

EpsilonDivDiv_kernel_gen.J_det = J_cse_replaced.det()

◆ J_det_reduced_exprs

EpsilonDivDiv_kernel_gen.J_det_reduced_exprs

◆ J_det_replacements

EpsilonDivDiv_kernel_gen.J_det_replacements

◆ J_det_symbol

EpsilonDivDiv_kernel_gen.J_det_symbol = sp.symbols(f"J_det", real=True)

◆ J_inv

EpsilonDivDiv_kernel_gen.J_inv = J_cse_replaced.adjugate() / J_det_symbol

◆ J_invT

EpsilonDivDiv_kernel_gen.J_invT = J_inv.transpose()

◆ J_invT_cse

EpsilonDivDiv_kernel_gen.J_invT_cse = sp.Matrix(3, 3, J_invT_reduced_exprs)

◆ J_invT_cse_assignments

EpsilonDivDiv_kernel_gen.J_invT_cse_assignments

◆ J_invT_cse_replaced

EpsilonDivDiv_kernel_gen.J_invT_cse_replaced

◆ J_invT_reduced_exprs

EpsilonDivDiv_kernel_gen.J_invT_reduced_exprs

◆ J_invT_replacements

EpsilonDivDiv_kernel_gen.J_invT_replacements

◆ jac_exprs

list EpsilonDivDiv_kernel_gen.jac_exprs = []

◆ jac_laterally_precomputed

bool EpsilonDivDiv_kernel_gen.jac_laterally_precomputed = False

◆ k_array_declaration

EpsilonDivDiv_kernel_gen.k_array_declaration

◆ k_assignments

EpsilonDivDiv_kernel_gen.k_assignments

◆ k_eval

EpsilonDivDiv_kernel_gen.k_eval
Initial value:
1= sum(
2 [shape_vec(j, qp) * k_symbol[w_symbol, j] for j in range(num_nodes_per_wedge)]
3)

◆ k_eval_reduced_exprs

EpsilonDivDiv_kernel_gen.k_eval_reduced_exprs

◆ k_eval_replacements

EpsilonDivDiv_kernel_gen.k_eval_replacements

◆ k_eval_symbol

EpsilonDivDiv_kernel_gen.k_eval_symbol = sp.symbols("k_eval", real=True)

◆ k_symbol

EpsilonDivDiv_kernel_gen.k_symbol

◆ kernel_code

str EpsilonDivDiv_kernel_gen.kernel_code = "\n"

◆ local_subdomain_id

EpsilonDivDiv_kernel_gen.local_subdomain_id

◆ max_rad

EpsilonDivDiv_kernel_gen.max_rad

◆ num_nodes_per_wedge

int EpsilonDivDiv_kernel_gen.num_nodes_per_wedge = 6

◆ num_nodes_per_wedge_surface

int EpsilonDivDiv_kernel_gen.num_nodes_per_wedge_surface = 3

◆ num_qps

int EpsilonDivDiv_kernel_gen.num_qps = 1

◆ num_wedges_per_hex_cell

int EpsilonDivDiv_kernel_gen.num_wedges_per_hex_cell = 2

◆ pairing_loop_exprs

list EpsilonDivDiv_kernel_gen.pairing_loop_exprs = []

◆ pairing_reduced_exprs

EpsilonDivDiv_kernel_gen.pairing_reduced_exprs

◆ pairing_replacements

EpsilonDivDiv_kernel_gen.pairing_replacements

◆ postloop

EpsilonDivDiv_kernel_gen.postloop

◆ q_symbol

EpsilonDivDiv_kernel_gen.q_symbol = sp.symbols("q", integer=True)

◆ qp

list EpsilonDivDiv_kernel_gen.qp = [qp_array[q_symbol, d] for d in range(dim)]

◆ qp_array

EpsilonDivDiv_kernel_gen.qp_array = IndexedBase(qp_array_name, shape=(num_qps, 3), real=True)

◆ qp_array_name

str EpsilonDivDiv_kernel_gen.qp_array_name = "qp_array"

◆ qp_data

EpsilonDivDiv_kernel_gen.qp_data = quad_points_1x1

◆ quadloop_body

list EpsilonDivDiv_kernel_gen.quadloop_body = []

◆ quadloop_exprs

list EpsilonDivDiv_kernel_gen.quadloop_exprs = []

◆ qw

EpsilonDivDiv_kernel_gen.qw = qw_array[q_symbol]

◆ qw_array

EpsilonDivDiv_kernel_gen.qw_array = IndexedBase(qw_array_name, shape=(num_qps), real=True)

◆ qw_array_name

str EpsilonDivDiv_kernel_gen.qw_array_name = "qw_array"

◆ qw_data

EpsilonDivDiv_kernel_gen.qw_data = quad_weights_1x1

◆ r

int EpsilonDivDiv_kernel_gen.r = 1 / r_inv

◆ r_cell

EpsilonDivDiv_kernel_gen.r_cell

◆ r_inv

EpsilonDivDiv_kernel_gen.r_inv

◆ rad_assignments

EpsilonDivDiv_kernel_gen.rad_assignments

◆ rads

EpsilonDivDiv_kernel_gen.rads

◆ real

EpsilonDivDiv_kernel_gen.real

◆ scalar_grad

EpsilonDivDiv_kernel_gen.scalar_grad = IndexedBase(scalar_grad_name, shape=(num_nodes_per_wedge, dim), real=True)

◆ scalar_grad_i_reduced_exprs

EpsilonDivDiv_kernel_gen.scalar_grad_i_reduced_exprs

◆ scalar_grad_i_replacements

EpsilonDivDiv_kernel_gen.scalar_grad_i_replacements

◆ scalar_grad_is

list EpsilonDivDiv_kernel_gen.scalar_grad_is = []

◆ scalar_grad_name

str EpsilonDivDiv_kernel_gen.scalar_grad_name = "scalar_grad"

◆ scalar_type

str EpsilonDivDiv_kernel_gen.scalar_type = 'double'

◆ src_array_declaration

EpsilonDivDiv_kernel_gen.src_array_declaration

◆ src_assignments

EpsilonDivDiv_kernel_gen.src_assignments

◆ src_symbol

EpsilonDivDiv_kernel_gen.src_symbol

◆ surface_shift

EpsilonDivDiv_kernel_gen.surface_shift

◆ symbols

EpsilonDivDiv_kernel_gen.symbols

◆ symm_grad_i

float EpsilonDivDiv_kernel_gen.symm_grad_i = 0.5 * (E_test_matrix + (E_test_matrix).transpose())

◆ symm_grad_i_reduced_exprs

EpsilonDivDiv_kernel_gen.symm_grad_i_reduced_exprs

◆ symm_grad_i_reduced_matrix

EpsilonDivDiv_kernel_gen.symm_grad_i_reduced_matrix = Matrix(3, 3, symm_grad_i_reduced_exprs[0])

◆ symm_grad_i_replacements

EpsilonDivDiv_kernel_gen.symm_grad_i_replacements

◆ symm_grad_j

float EpsilonDivDiv_kernel_gen.symm_grad_j = 0.5 * (E_trial_matrix + (E_trial_matrix).transpose())

◆ symm_grad_j_reduced_exprs

EpsilonDivDiv_kernel_gen.symm_grad_j_reduced_exprs

◆ symm_grad_j_replacements

EpsilonDivDiv_kernel_gen.symm_grad_j_replacements

◆ treat_boundary

EpsilonDivDiv_kernel_gen.treat_boundary

◆ u_grad_loop_exprs

list EpsilonDivDiv_kernel_gen.u_grad_loop_exprs = []

◆ value

EpsilonDivDiv_kernel_gen.value

◆ w_symbol

EpsilonDivDiv_kernel_gen.w_symbol

◆ x_cell

EpsilonDivDiv_kernel_gen.x_cell

◆ y_cell

EpsilonDivDiv_kernel_gen.y_cell