Symbolic Operator Representation

Based on pymbolic.

Basic Objects

DOF description

class grudge.sym.DTAG_SCALAR

class grudge.sym.DTAG_VOLUME_ALL

class grudge.sym.DTAG_BOUNDARY(tag)

class grudge.sym.QTAG_NONE

class grudge.sym.DOFDesc(domain_tag, quadrature_tag=None)

Describes the meaning of degrees of freedom.

domain_tag

quadrature_tag

is_scalar()

is_discretized()

is_volume()

is_boundary_or_partition_interface()

is_trace()

uses_quadrature()

with_qtag(qtag)

with_dtag(dtag)

__eq__(other)

Return self==value.

__ne__(other)

Return self!=value.

__hash__()

Return hash(self).

grudge.sym.as_dofdesc(dd)

grudge.sym.DD_SCALAR

grudge.sym.DD_VOLUME

Symbols

class grudge.sym.Variable(name, dd=None)

A user-supplied input variable with a known DOFDesc.

class grudge.sym.ScalarVariable(name)

class grudge.sym.FunctionSymbol(name)

A symbol to be used as the function argument of Call.

grudge.sym.make_sym_array(name, shape, dd=None)

grudge.sym.make_sym_mv(name, dim, var_factory=None)

grudge.sym.fabs(arg)

grudge.sym.sqrt(arg)

grudge.sym.exp(arg)

grudge.sym.sin(arg)

grudge.sym.cos(arg)

grudge.sym.besesl_j(n, arg)

grudge.sym.besesl_y(n, arg)

Helpers

class grudge.sym.OperatorBinding(op, field)

class grudge.sym.PrioritizedSubexpression(child, priority=0)

When the optemplate-to-code transformation is performed, prioritized subexpressions work like common subexpression in that they are assigned their own separate identifier/register location. In addition to this behavior, prioritized subexpressions are evaluated with a settable priority, allowing the user to expedite or delay the evaluation of the subexpression.

class grudge.sym.Ones(*args, **kwargs)

Geometry data

class grudge.sym.NodeCoordinateComponent(axis, dd=None)

grudge.sym.nodes(ambient_dim, dd=None)

grudge.sym.mv_nodes(ambient_dim, dd=None)

grudge.sym.forward_metric_derivative(xyz_axis, rst_axis, dd=None)

Pointwise metric derivatives representing

\[\frac{\partial x_{\mathrm{xyz\_axis}} }{\partial r_{\mathrm{rst\_axis}}}\]

grudge.sym.inverse_metric_derivative(rst_axis, xyz_axis, ambient_dim, dim=None, dd=None)

grudge.sym.forward_metric_derivative_mat(ambient_dim, dim=None, dd=None)

grudge.sym.inverse_metric_derivative_mat(ambient_dim, dim=None, dd=None)

grudge.sym.first_fundamental_form(ambient_dim, dim=None, dd=None)

grudge.sym.inverse_first_fundamental_form(ambient_dim, dim=None, dd=None)

grudge.sym.inverse_surface_metric_derivative(rst_axis, xyz_axis, ambient_dim, dim=None, dd=None)

grudge.sym.second_fundamental_form(ambient_dim, dim=None, dd=None)

grudge.sym.shape_operator(ambient_dim, dim=None, dd=None)

grudge.sym.pseudoscalar(ambient_dim, dim=None, dd=None)

grudge.sym.area_element(ambient_dim, dim=None, dd=None)

grudge.sym.mv_normal(dd, ambient_dim, dim=None)

Exterior unit normal as a MultiVector.

grudge.sym.normal(dd, ambient_dim, dim=None)

grudge.sym.surface_normal(ambient_dim, dim=None, dd=None)

grudge.sym.summed_curvature(ambient_dim, dim=None, dd=None)

Sum of the principal curvatures

grudge.sym.mean_curvature(ambient_dim, dim=None, dd=None)

Averaged (by dimension) sum of the principal curvatures.

Operators

Building blocks and mappers for operator expression trees.

Basic Operators

class grudge.symbolic.operators.Operator(dd_in, dd_out)

dd_in

an instance of DOFDesc describing the input discretization.

dd_out

an instance of DOFDesc describing the output discretization.

class grudge.symbolic.operators.ElementwiseLinearOperator(dd_in, dd_out)

class grudge.symbolic.operators.ProjectionOperator(dd_in, dd_out)

grudge.symbolic.operators.project

Reductions

class grudge.symbolic.operators.ElementwiseSumOperator(dd)

Returns a vector of DOFs with all entries on each element set to the sum of DOFs on that element.

class grudge.symbolic.operators.ElementwiseMinOperator(dd)

Returns a vector of DOFs with all entries on each element set to the minimum of DOFs on that element.

class grudge.symbolic.operators.ElementwiseMaxOperator(dd)

Returns a vector of DOFs with all entries on each element set to the maximum of DOFs on that element.

class grudge.symbolic.operators.NodalReductionOperator(dd_in, dd_out=None)

class grudge.symbolic.operators.NodalSum(dd_in, dd_out=None)

class grudge.symbolic.operators.NodalMax(dd_in, dd_out=None)

class grudge.symbolic.operators.NodalMin(dd_in, dd_out=None)

Differentiation

class grudge.symbolic.operators.StrongFormDiffOperatorBase(xyz_axis, dd_in=None, dd_out=None)

class grudge.symbolic.operators.WeakFormDiffOperatorBase(xyz_axis, dd_in=None, dd_out=None)

class grudge.symbolic.operators.StiffnessOperator(xyz_axis, dd_in=None, dd_out=None)

class grudge.symbolic.operators.DiffOperator(xyz_axis, dd_in=None, dd_out=None)

class grudge.symbolic.operators.StiffnessTOperator(xyz_axis, dd_in=None, dd_out=None)

class grudge.symbolic.operators.MInvSTOperator(xyz_axis, dd_in=None, dd_out=None)

class grudge.symbolic.operators.RefDiffOperator(rst_axis, dd_in=None, dd_out=None)

class grudge.symbolic.operators.RefStiffnessTOperator(rst_axis, dd_in=None, dd_out=None)

grudge.symbolic.operators.nabla(dim)

grudge.symbolic.operators.minv_stiffness_t(dim)

grudge.symbolic.operators.stiffness(dim)

grudge.symbolic.operators.stiffness_t(dim, dd_in=None, dd_out=None)

Mass Operators

class grudge.symbolic.operators.MassOperatorBase(dd_in=None, dd_out=None)

Inherits from Operator.

dd_in and dd_out may be surface or volume discretizations.

class grudge.symbolic.operators.MassOperator(dd_in=None, dd_out=None)

class grudge.symbolic.operators.InverseMassOperator(dd_in=None, dd_out=None)

class grudge.symbolic.operators.FaceMassOperator(dd_in=None, dd_out=None)

class grudge.symbolic.operators.RefMassOperator(dd_in, dd_out)

class grudge.symbolic.operators.RefInverseMassOperator(dd_in, dd_out)

class grudge.symbolic.operators.RefFaceMassOperator(dd_in, dd_out)