def prg():
return make_loopy_program(
"""{[iel,idof,j]:
0<=iel<nelements and
0<=idof,j<nunit_dofs}""",
"result[iel,idof] = sum(j, diff_mat[idof, j] * vec[iel, j])",
name="diff")
def prg():
return make_loopy_program(
"{[iel, idof, jdof]: 0<=iel<nelements and 0<=idof, jdof<ndofs}",
"""
result[iel, idof] = %s(jdof, operand[iel, jdof])
""" % op_name,
name="grudge_elementwise_%s" % op_name)
def knl(sym_then, sym_else):
return make_loopy_program(
"{[iel, idof]: 0<=iel<nelements and 0<=idof<nunit_dofs}", [
lp.Assignment(
var("out")[iel, idof],
p.If(var("crit")[iel, idof], sym_then, sym_else))
])
def kproj():
return make_loopy_program(
[
"{[iel]: 0 <= iel < nelements}",
"{[idof_quad]: 0 <= idof_quad < n_from_nodes}"
],
"""
for iel
<> element_dot = sum(idof_quad,
ary[from_element_indices[iel], idof_quad]
* basis[idof_quad] * weights[idof_quad])
result[to_element_indices[iel], ibasis] = \
result[to_element_indices[iel], ibasis] + element_dot
end
""", [
lp.GlobalArg("ary",
None,
shape=("n_from_elements", "n_from_nodes")),
lp.GlobalArg(
"result", None, shape=("n_to_elements", "n_to_nodes")),
lp.GlobalArg("basis", None, shape="n_from_nodes"),
lp.GlobalArg("weights", None, shape="n_from_nodes"),
lp.ValueArg("n_from_elements", np.int32),
lp.ValueArg("n_to_elements", np.int32),
lp.ValueArg("n_to_nodes", np.int32),
lp.ValueArg("ibasis", np.int32), "..."
],
name="conn_projection_knl")
def knl():
return make_loopy_program(
"""{[iel,idof,j]:
0<=iel<nelements and
0<=idof<ndiscr_nodes_out and
0<=j<ndiscr_nodes_in}""",
"result[iel,idof] = sum(j, mat[idof, j] * vec[iel, j])",
name="diff")
def knl():
return make_loopy_program(
"""{[iel,idof,f,j]:
0<=iel<nelements and
0<=f<nfaces and
0<=idof<nvol_nodes and
0<=j<nface_nodes}""", "result[iel,idof] = "
"sum(f, sum(j, mat[idof, f, j] * vec[f, iel, j]))",
name="face_mass")
def mat_knl():
if self.is_surjective:
domains = [
"""
{[iel, idof, j]:
0<=iel<nelements and
0<=idof<n_to_nodes and
0<=j<n_from_nodes}
""",
]
instructions = """
result[to_element_indices[iel], idof] \
= sum(j, resample_mat[idof, j] \
* ary[from_element_indices[iel], j])
"""
else:
domains = [
"""
{[iel_init, idof_init]:
0<=iel_init<nelements_result and
0<=idof_init<n_to_nodes}
""",
"""
{[iel, idof, j]:
0<=iel<nelements and
0<=idof<n_to_nodes and
0<=j<n_from_nodes}
""",
]
instructions = """
result[iel_init, idof_init] = 0 {id=init}
... gbarrier {id=barrier, dep=init}
result[to_element_indices[iel], idof] \
= sum(j, resample_mat[idof, j] \
* ary[from_element_indices[iel], j]) {dep=barrier}
"""
knl = make_loopy_program(
domains,
instructions, [
lp.GlobalArg("result",
None,
shape="nelements_result, n_to_nodes",
offset=lp.auto),
lp.GlobalArg("ary",
None,
shape="nelements_vec, n_from_nodes",
offset=lp.auto),
lp.ValueArg("nelements_result", np.int32),
lp.ValueArg("nelements_vec", np.int32),
lp.ValueArg("n_from_nodes", np.int32),
"...",
],
name="resample_by_mat")
return knl
def node_knl():
from meshmode.array_context import make_loopy_program
return make_loopy_program("""{[iel, idof, jdof]:
0<=iel<nelements and
0<=idof, jdof<ndofs}""",
"""
result[iel, idof] = %s(jdof, operand[iel, jdof])
""" % reduction_name,
name="nodewise_reduce")
def prg():
return make_loopy_program("""{[iel,idof,j]:
0<=iel<nelements and
0<=idof<ndiscr_nodes and
0<=j<nmesh_nodes}""",
"""
result[iel, idof] = \
sum(j, resampling_mat[idof, j] * nodes[iel, j])
""",
name="nodes")
def prg():
result = make_loopy_program(
"""{[iel, idof, j]:
0<=iel<nelements and
0<=idof<ndiscr_nodes_out and
0<=j<ndiscr_nodes_in}""",
"result[iel, idof] = sum(j, mat[idof, j] * vec[iel, j])",
name="diff")
result = lp.tag_array_axes(result, "mat", "stride:auto,stride:auto")
return result
def prg():
from meshmode.array_context import make_loopy_program
return make_loopy_program(
"""{[iel, idof]: 0<=iel<nelements and 0<=idof<nunit_dofs}""",
"""
dst[iel, 2*idof] = src1[iel, idof]
dst[iel, 2*idof + 1] = src2[iel, idof]
""", [
lp.GlobalArg("src1", shape="(nelements, nunit_dofs)"),
lp.GlobalArg("src2", shape="(nelements, nunit_dofs)"),
lp.GlobalArg("dst", shape="(nelements, 2*nunit_dofs)"),
"...",
],
name="interleave")
def keval():
return make_loopy_program(
[
"{[iel]: 0 <= iel < nelements}",
"{[idof]: 0 <= idof < n_to_nodes}",
"{[ibasis]: 0 <= ibasis < n_to_nodes}"
],
"""
result[iel, idof] = result[iel, idof] + \
sum(ibasis, vdm[idof, ibasis] * coefficients[iel, ibasis])
""", [
lp.GlobalArg("coefficients",
None,
shape=("nelements", "n_to_nodes")), "..."
],
name="conn_evaluate_knl")
def keval():
return make_loopy_program(
[
"{[iel]: 0 <= iel < nelements}",
"{[idof]: 0 <= idof < n_to_nodes}"
],
"""
result[iel, idof] = result[iel, idof] + \
coefficients[iel, ibasis] * basis[idof]
""", [
lp.GlobalArg("coefficients",
None,
shape=("nelements", "n_to_nodes")),
lp.ValueArg("ibasis", np.int32), "..."
],
name="conn_evaluate_knl")
def prg(nmatrices):
result = make_loopy_program(
"""{[imatrix, iel, idof, j]:
0<=imatrix<nmatrices and
0<=iel<nelements and
0<=idof<nunit_nodes_out and
0<=j<nunit_nodes_in}""",
"""
result[imatrix, iel, idof] = sum(
j, diff_mat[imatrix, idof, j] * vec[iel, j])
""",
name="diff")
result = lp.fix_parameters(result, nmatrices=nmatrices)
result = lp.tag_inames(result, "imatrix: unr")
result = lp.tag_array_axes(result, "result", "sep,c,c")
return result
def knl():
return make_loopy_program(
"""{[iel, idof, j]:
0<=iel<nelements and
0<=idof<n_to_nodes and
0<=j<n_from_nodes}""",
"result[itgt_base + to_element_indices[iel]*n_to_nodes + idof, \
isrc_base + from_element_indices[iel]*n_from_nodes + j] \
= resample_mat[idof, j]", [
lp.GlobalArg("result",
None,
shape="nnodes_tgt, nnodes_src",
offset=lp.auto),
lp.ValueArg("itgt_base,isrc_base", np.int32),
lp.ValueArg("nnodes_tgt,nnodes_src", np.int32),
"...",
],
name="oversample_mat")
def pick_knl():
knl = make_loopy_program(
"""{[iel, idof]:
0<=iel<nelements and
0<=idof<n_to_nodes}""",
"result[to_element_indices[iel], idof] \
= ary[from_element_indices[iel], pick_list[idof]]",
[
lp.GlobalArg("result", None,
shape="nelements_result, n_to_nodes",
offset=lp.auto),
lp.GlobalArg("ary", None,
shape="nelements_vec, n_from_nodes",
offset=lp.auto),
lp.ValueArg("nelements_result", np.int32),
lp.ValueArg("nelements_vec", np.int32),
lp.ValueArg("n_from_nodes", np.int32),
"...",
],
name="resample_by_picking")
return knl
def mat_knl():
knl = make_loopy_program(
"""{[iel, idof, j]:
0<=iel<nelements and
0<=idof<n_to_nodes and
0<=j<n_from_nodes}""",
"result[to_element_indices[iel], idof] \
= sum(j, resample_mat[idof, j] \
* ary[from_element_indices[iel], j])",
[
lp.GlobalArg("result", None,
shape="nelements_result, n_to_nodes",
offset=lp.auto),
lp.GlobalArg("ary", None,
shape="nelements_vec, n_from_nodes",
offset=lp.auto),
lp.ValueArg("nelements_result", np.int32),
lp.ValueArg("nelements_vec", np.int32),
"...",
],
name="resample_by_mat")
return knl
def prg():
return make_loopy_program(
"{[iel,idof]: 0<=iel<nelements and 0<=idof<ndofs_per_element}",
"result[iel, idof] = ary[grp_start + iel*ndofs_per_element + idof]",
name="unflatten")
def prg():
return make_loopy_program(
"{[iel,idof]: 0<=iel<nelements and 0<=idof<nunit_dofs}",
"result[iel,idof] = weights[idof]",
name="quad_weights")
