Intrepid
Macros | Functions
Intrepid_Utils.cpp File Reference

Implementation file for Intrepid_Utils.hpp. More...

#include "Intrepid_Utils.hpp"

Go to the source code of this file.

Functions

int Intrepid::getFieldRank (const EFunctionSpace spaceType)
 Returns the rank of fields in a function space of the specified type.
int Intrepid::getOperatorRank (const EFunctionSpace spaceType, const EOperator operatorType, const int spaceDim)
 Returns rank of an operator.
int Intrepid::getOperatorOrder (const EOperator operatorType)
 Returns order of an operator.
int Intrepid::getDkEnumeration (const int xMult, const int yMult=-1, const int zMult=-1)
 Returns the ordinal of a partial derivative of order k based on the multiplicities of the partials dx, dy, and dz.
void Intrepid::getDkMultiplicities (Teuchos::Array< int > &partialMult, const int derivativeEnum, const EOperator operatorType, const int 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.
int Intrepid::getDkCardinality (const EOperator operatorType, const int spaceDim)
 Returns cardinality of Dk, i.e., the number of all derivatives of order k.
void Intrepid::setOrdinalTagData (std::vector< std::vector< std::vector< int > > > &tagToOrdinal, std::vector< std::vector< int > > &ordinalToTag, const int *tags, const int basisCard, const int tagSize, const int posScDim, const int posScOrd, const int posDfOrd)
 Fills ordinalToTag_ and tagToOrdinal_ by basis-specific tag data.

Detailed Description

Implementation file for Intrepid_Utils.hpp.

Author
Created by P. Bochev and D. Ridzal.

Definition in file Intrepid_Utils.cpp.

Macro Definition Documentation

◆ INTREPID_UTILS_CPP

#define INTREPID_UTILS_CPP

Definition at line 50 of file Intrepid_Utils.cpp.

Function Documentation

◆ getDkCardinality()

int Intrepid::getDkCardinality ( const EOperator operatorType,
const int spaceDim )

Returns 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 400 of file Intrepid_Utils.cpp.

◆ getDkEnumeration()

int Intrepid::getDkEnumeration ( const int xMult,
const int yMult = -1,
const int 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 Intrepid::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(xMult) = 0$ in 1D (only 1 derivative)
$i(xMult,yMult) =yMult$ in 2D
$i(xMult,yMult,zMult)=zMult+\sum_{r = 0}^{k-xMult} r$in 3D

where the order k of Dk is implicitly defined by xMult + yMult + zMult. Space dimension is implicitly defined by the default values of the multiplicities of y and z derivatives.

Parameters
xMult[in] - multiplicity of dx
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 234 of file Intrepid_Utils.cpp.

References INTREPID_MAX_DERIVATIVE.

◆ getDkMultiplicities()

void Intrepid::getDkMultiplicities ( Teuchos::Array< int > & partialMult,
const int derivativeEnum,
const EOperator operatorType,
const int 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 dimension

Definition at line 284 of file Intrepid_Utils.cpp.

◆ getFieldRank()

int Intrepid::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 62 of file Intrepid_Utils.cpp.

◆ getOperatorOrder()

int Intrepid::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 196 of file Intrepid_Utils.cpp.

◆ getOperatorRank()

int Intrepid::getOperatorRank ( const EFunctionSpace spaceType,
const EOperator operatorType,
const int 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 91 of file Intrepid_Utils.cpp.

◆ setOrdinalTagData()

void Intrepid::setOrdinalTagData ( std::vector< std::vector< std::vector< int > > > & tagToOrdinal,
std::vector< std::vector< int > > & ordinalToTag,
const int * tags,
const int basisCard,
const int tagSize,
const int posScDim,
const int posScOrd,
const int posDfOrd )

Fills ordinalToTag_ and tagToOrdinal_ by basis-specific tag data.

Parameters
tagToOrdinal[out] - Lookup table for the DoF's ordinal by its tag
ordinalToTag[out] - Lookup table for the DoF's tag by its ordinal
tags[in] - a set of basis-dependent tags in flat (rank-1) array format.
basisCard[in] - cardinality of the basis
tagSize[in] - number of fields in a DoF tag
posScDim[in] - position in the tag, counting from 0, of the subcell dim
posScOrd[in] - position in the tag, counting from 0, of the subcell ordinal
posDfOrd[in] - position in the tag, counting from 0, of DoF ordinal relative to the subcell

Definition at line 455 of file Intrepid_Utils.cpp.

Generated by doxygen 1.15.0