Intrepid2
Functions
Intrepid2_UtilsDef.hpp File Reference

Definition file for Intrepid2 utilities. More...

#include "Intrepid2_Utils.hpp"

Go to the source code of this file.

Functions

KOKKOS_INLINE_FUNCTION ordinal_type Intrepid2::getFieldRank (const EFunctionSpace spaceType)
 Returns the rank of fields in a function space of the specified type. More...
 
KOKKOS_INLINE_FUNCTION ordinal_type Intrepid2::getOperatorRank (const EFunctionSpace spaceType, const EOperator operatorType, const ordinal_type spaceDim)
 Returns rank of an operator. More...
 
KOKKOS_INLINE_FUNCTION ordinal_type Intrepid2::getOperatorOrder (const EOperator operatorType)
 Returns order of an operator. More...
 
template<ordinal_type spaceDim>
KOKKOS_INLINE_FUNCTION ordinal_type Intrepid2::getDkEnumeration (const ordinal_type xMult, const ordinal_type yMult=-1, const ordinal_type zMult=-1)
 Returns the ordinal of a partial derivative of order k based on the multiplicities of the partials dx, dy, and dz. More...
 
KOKKOS_INLINE_FUNCTION ordinal_type Intrepid2::getDkCardinality (const EOperator operatorType, const ordinal_type spaceDim)
 Returns multiplicities of dx, dy, and dz based on the enumeration of the partial derivative, its order and the space dimension. Inverse of the getDkEnumeration() method. More...
 

Detailed Description

Definition file for Intrepid2 utilities.

Author
Created by P. Bochev and D. Ridzal and Kyungjoo Kim.

Definition in file Intrepid2_UtilsDef.hpp.

Function Documentation

◆ getDkCardinality()

KOKKOS_INLINE_FUNCTION ordinal_type Intrepid2::getDkCardinality ( const EOperator  operatorType,
const ordinal_type  spaceDim 
)

Returns multiplicities of dx, dy, and dz based on the enumeration of the partial derivative, its order and the space dimension. Inverse of the getDkEnumeration() method.

Parameters
partialMult[out] - array with the multiplicities f dx, dy and dz
derivativeEnum[in] - enumeration of the partial derivative
operatorType[in] - k-th partial derivative Dk
spaceDim[in] - space dimensionReturns cardinality of Dk, i.e., the number of all derivatives of order k.

The set of all partial derivatives of order k is isomorphic to the set of all multisets of cardinality k with elements taken from the sets {x}, {x,y}, and {x,y,z} in 1D, 2D, and 3D respectively. For example, the partial derivative $\displaystyle D\{1,2,1\}f = \frac{d^4 f}{dx dy^2 dz}$ maps to the multiset $\{x, y, z\}$ with multiplicities $\{1,2,1\}$. The number of all such multisets is given by the binomial coefficient

\[ \begin{pmatrix} spaceDim + k - 1 \\ spaceDim - 1 \end{pmatrix} \]

Therefore:

  • in 1D: cardinality = 1
  • in 2D: cardinality = k + 1
  • in 3D: cardinality = (k + 1)*(k + 2)/2
Parameters
operatorType[in] - k-th derivative operator Dk
spaceDim[in] - space dimension
Returns
the number of all partial derivatives of order k

Definition at line 410 of file Intrepid2_BasisDef.hpp.

References Intrepid2::getDkCardinality().

Referenced by Intrepid2::getDkCardinality().

◆ getDkEnumeration()

template<ordinal_type spaceDim>
KOKKOS_INLINE_FUNCTION ordinal_type Intrepid2::getDkEnumeration ( const ordinal_type  xMult,
const ordinal_type  yMult = -1,
const ordinal_type  zMult = -1 
)

Returns the ordinal of a partial derivative of order k based on the multiplicities of the partials dx, dy, and dz.

By default, any implementation of Intrepid2::Basis method returns partials of order k (specified by OPERATOR_Dk) as a multiset ordered by the lexicographical order of the partial derivatives multiplicities. For example, the 10 derivatives of order 3 in 3D are enumerated as:

D3={(3,0,0),(2,1,0),(2,0,1),(1,2,0),(1,1,1),(1,0,2),(0,3,0),(0,2,1),(0,1,2),(0,0,3)}

The enumeration formula for this lexicographical order is

$i() = 0$ in 1D (only 1 derivative)
$i(yMult) =yMult$ in 2D
$i(yMult,zMult)=zMult+\sum_{r = 0}^{k-xMult} r$ in 3D

where the order k of Dk is defined by xMult + yMult + zMult. However, xMult is not really needed needed. Enumeration goes from 0 to ( (k+spaceDim-1) choose (spaceDim-1) )-1.

Parameters
yMult[in] - multiplicity of dy (default = -1)
zMult[in] - multiplicity of dz (default = -1)
Returns
the ordinal of partial derivative of order k as function of dx, dy, dz multiplicities

Definition at line 240 of file Intrepid2_BasisDef.hpp.

References Intrepid2::getDkEnumeration().

Referenced by Intrepid2::getDkEnumeration().

◆ getFieldRank()

KOKKOS_INLINE_FUNCTION ordinal_type Intrepid2::getFieldRank ( const EFunctionSpace  spaceType)

Returns the rank of fields in a function space of the specified type.

Field rank is defined as the number of indices needed to specify function value and equals 0, 1,or 2 for scalars, vectors and tensors, respectively. The scalar field spaces in Intrepid are FUNCTION_SPACE_HGRAD and FUNCTION_SPACE_HVOL. The vector field spaces are FUNCTION_SPACE_HCURL, FUNCTION_SPACE_HDIV and FUNCTION_SPACE_VECTOR_HGRAD. FUNCTION_SPACE_TENSOR_HGRAD contains rank-2 tensors.

Parameters
spaceType[in] - function space type
Returns
rank of the fields in the specified function space

Definition at line 67 of file Intrepid2_BasisDef.hpp.

References Intrepid2::getFieldRank().

Referenced by Intrepid2::getFieldRank(), and Intrepid2::getOperatorRank().

◆ getOperatorOrder()

KOKKOS_INLINE_FUNCTION ordinal_type Intrepid2::getOperatorOrder ( const EOperator  operatorType)

Returns order of an operator.

Parameters
operatorType[in] - type of the operator whose order we want to know
Returns
result ranges from 0 (for OPERATOR_VALUE) to 10 (OPERATOR_D10)

Definition at line 194 of file Intrepid2_BasisDef.hpp.

References Intrepid2::getOperatorOrder().

Referenced by Intrepid2::getOperatorOrder().

◆ getOperatorRank()

KOKKOS_INLINE_FUNCTION ordinal_type Intrepid2::getOperatorRank ( const EFunctionSpace  spaceType,
const EOperator  operatorType,
const ordinal_type  spaceDim 
)

Returns rank of an operator.

When an operator acts on a field of a certain rank, the result can be a field with the same or a different rank. Operator rank is defined the difference between the ranks of the output field and the input field:

Rank(OPERATOR) = Rank(OPERATOR(FIELD)) - Rank(FIELD)

Therefore, operator rank allows us to figure out the rank of the result:

Rank(OPERATOR(FIELD)) = Rank(FIELD) + Rank(OPERATOR)

and provides means to size properly arrays for output results. The following table summarizes operator ranks (~ denotes undefined, below slash means 3D). By default, in 1D any operator other than VALUE has rank 1, i.e., GRAD, CURL and DIV reduce to d/dx and Dk are the higher-order derivatives d^k/dx^k. Only scalar functions are allowed in 1D.

|========|======|============================|=========|==========|==========|==========|
| field  | rank |  FUNCTION_SPACE_[type]     |  VALUE  | GRAD, Dk |   CURL   |    DIV   |
|--------|------|----------------------------|---------|----------|----------|----------|
| scalar |   0  |  HGRAD, HVOL               |    0    |     1    | 3-dim/~  |     ~    |
| vector |   1  |  HCURL, HDIV, VECTOR_HGRAD |    0    |     1    | dim - 3  |    -1    |
| tensor |   2  |  TENSOR_HGRAD              |    0    |     1    | dim - 3  |    -1    |
|--------|------|----------------------------|---------|----------|----------|----------|
|   1D   |   0  |  HGRAD, HVOL only          |    0    |     1    |     1    |     1    |
|=======================================================================================|
Parameters
spaceType[in] - function space type
operatorType[in] - the operator acting on the specified function space
spaceDim[in] - spatial dimension
Returns
rank of the operator as defined in the table

Definition at line 96 of file Intrepid2_BasisDef.hpp.

References Intrepid2::getFieldRank(), and Intrepid2::getOperatorRank().

Referenced by Intrepid2::getOperatorRank().