Intrepid
Static Public Member Functions
Intrepid::FunctionSpaceToolsInPlace Class Reference

Defines expert-level interfaces for the evaluation of functions and operators in physical space (supported for FE, FV, and FD methods) and FE reference space; in addition, provides several function transformation utilities. More...

#include <Intrepid_FunctionSpaceToolsInPlace.hpp>

List of all members.

Static Public Member Functions

template<class Scalar , class ArrayType >
static void HGRADtransformVALUE (ArrayType &inOutVals)
 Transformation of a (scalar) value field in the H-grad space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P), into the output container outVals, defined on cells in physical space and indexed by (C,F,P).
template<class Scalar , class ArrayType >
static void HGRADtransformVALUEDual (ArrayType &inOutVals)
 Since there is no matrix involved, this is the same transformation as HGRADtransformVALUE.
template<class Scalar , class ArrayType , class ArrayTypeJac >
static void HGRADtransformGRAD (ArrayType &inOutVals, const ArrayTypeJac &jacobianInverse, const char transpose= 'T')
 Transformation of a gradient field in the H-grad space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P,D), into the output container outVals, defined on cells in physical space and indexed by (C,F,P,D).
template<class Scalar , class ArrayType , class ArrayTypeJac >
static void HGRADtransformGRADDual (ArrayType &inOutVals, const ArrayTypeJac &jacobianInverse, const char transpose= 'T')
 Applies the transpose of the HGRADtransformGRAD to the data.
template<class Scalar , class ArrayType , class ArrayTypeJac >
static void HCURLtransformVALUE (ArrayType &inOutVals, const ArrayTypeJac &jacobianInverse, const char transpose= 'T')
 Transformation of a (vector) value field in the H-curl space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P,D), into the output container outVals, defined on cells in physical space and indexed by (C,F,P,D).
template<class Scalar , class ArrayType , class ArrayTypeJac >
static void HCURLtransformVALUEDual (ArrayType &outVals, const ArrayTypeJac &jacobianInverse, const char transpose= 'T')
 Applies the dual of the HCURLtransformVALUE transformation.
template<class Scalar , class ArrayType , class ArrayTypeJac , class ArrayTypeDet >
static void HCURLtransformCURL (ArrayType &inOutVals, const ArrayTypeJac &jacobian, const ArrayTypeDet &jacobianDet, const char transpose= 'N')
 Transformation of a curl field in the H-curl space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P,D), into the output container outVals, defined on cells in physical space and indexed by (C,F,P,D).
template<class Scalar , class ArrayType , class ArrayTypeJac , class ArrayTypeDet >
static void HCURLtransformCURLDual (ArrayType &outVals, const ArrayTypeJac &jacobian, const ArrayTypeDet &jacobianDet, const char transpose= 'N')
 Applies the dual of the HCURLtransformCURL transformation.
template<class Scalar , class ArrayType , class ArrayTypeJac , class ArrayTypeDet >
static void HDIVtransformVALUE (ArrayType &inOutVals, const ArrayTypeJac &jacobian, const ArrayTypeDet &jacobianDet, const char transpose= 'N')
 Transformation of a (vector) value field in the H-div space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P,D), into the output container outVals, defined on cells in physical space and indexed by (C,F,P,D).
template<class Scalar , class ArrayType , class ArrayTypeJac , class ArrayTypeDet >
static void HDIVtransformVALUEDual (ArrayType &outVals, const ArrayTypeJac &jacobian, const ArrayTypeDet &jacobianDet, const char transpose= 'N')
 Applies the dual of HDIVtransformVALUE.
template<class Scalar , class ArrayType , class ArrayTypeDet >
static void HDIVtransformDIV (ArrayType &inOutVals, const ArrayTypeDet &jacobianDet)
 Transformation of a divergence field in the H-div space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P), into the output container outVals, defined on cells in physical space and indexed by (C,F,P).
template<class Scalar , class ArrayType , class ArrayTypeDet >
static void HDIVtransformDIVDual (ArrayType &inOutVals, const ArrayTypeDet &jacobianDet)
 Applies the dual of HDIVtransformDIV, which is the same.
template<class Scalar , class ArrayType , class ArrayTypeDet >
static void HVOLtransformVALUE (ArrayType &inOutVals, const ArrayTypeDet &jacobianDet)
 Transformation of a (scalar) value field in the H-vol space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P), into the output container outVals, defined on cells in physical space and indexed by (C,F,P).
template<class Scalar , class ArrayType , class ArrayTypeDet >
static void HVOLtransformVALUEDual (ArrayType &inOutVals, const ArrayTypeDet &jacobianDet)
 Applies the dual of HVOLtransformVALUE.
template<class Scalar , class ArrayType , class ArrayTypeMeasure >
static void multiplyMeasure (ArrayType &inOutVals, const ArrayTypeMeasure &inMeasure)

Detailed Description

Defines expert-level interfaces for the evaluation of functions and operators in physical space (supported for FE, FV, and FD methods) and FE reference space; in addition, provides several function transformation utilities.

The functionality here largely mirrors that in Intrepid::FunctionSpaceTools, except that the input data is overwrriten with the result of the particular transformation. This can reduce intermediate storage when the input values are not required by later calculations.

A new feature compared to Intrepid::FunctionSpaceTools is that of "dual" transforms that are useful in alternate workflow patterns. At the innermost loop nest, we may have a computation of the form (T_1 D_1 u).(T_2 D_2 v), and we would like to rewrite this as (T_2^t T_1 D_1 u).(D_2 v). The transposes of each of these transformations are supplied in this routine.

Definition at line 78 of file Intrepid_FunctionSpaceToolsInPlace.hpp.


Member Function Documentation

template<class Scalar , class ArrayType , class ArrayTypeJac , class ArrayTypeDet >
void Intrepid::FunctionSpaceToolsInPlace::HCURLtransformCURL ( ArrayType &  inOutVals,
const ArrayTypeJac &  jacobian,
const ArrayTypeDet &  jacobianDet,
const char  transpose = 'N' 
) [static]

Transformation of a curl field in the H-curl space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P,D), into the output container outVals, defined on cells in physical space and indexed by (C,F,P,D).

Computes pullback of curls of HCURL functions $\Phi^*(\widehat{\bf u}_f) = \left(J^{-1}_{c} DF_{c}\cdot\nabla\times\widehat{\bf u}_f\right)\circ F^{-1}_{c}$ for points in one or more physical cells that are images of a given set of points in the reference cell:

\[ \{ x_{c,p} \}_{p=0}^P = \{ F_{c} (\widehat{x}_p) \}_{p=0}^{P}\qquad 0\le c < C \,. \]

In this case $ F^{-1}_{c}(x_{c,p}) = \widehat{x}_p $ and the user-provided container should contain the curls of the vector function set $\{\widehat{\bf u}_f\}_{f=0}^{F}$ at the reference points:

\[ inVals(f,p,*) = \nabla\times\widehat{\bf u}_f(\widehat{x}_p) \,. \]

The method returns

\[ outVals(c,f,p,*) = \left(J^{-1}_{c} DF_{c}\cdot\nabla\times\widehat{\bf u}_f\right)\circ F^{-1}_{c}(x_{c,p}) = J^{-1}_{c}(\widehat{x}_p) DF_{c}(\widehat{x}_p)\cdot\nabla\times\widehat{\bf u}_f(\widehat{x}_p) \qquad 0\le c < C \,. \]

See Section Pullbacks for more details about pullbacks.

    |------|----------------------|--------------------------------------------------|
    |      |         Index        |                   Dimension                      |
    |------|----------------------|--------------------------------------------------|
    |   C  |         cell         |  0 <= C < num. integration domains               |
    |   F  |         field        |  0 <= F < dim. of the basis                      |
    |   P  |         point        |  0 <= P < num. integration points                |
    |   D  |         space dim    |  0 <= D < spatial dimension                      |
    |------|----------------------|--------------------------------------------------|

Definition at line 186 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

template<class Scalar , class ArrayType , class ArrayTypeJac >
void Intrepid::FunctionSpaceToolsInPlace::HCURLtransformVALUE ( ArrayType &  inOutVals,
const ArrayTypeJac &  jacobianInverse,
const char  transpose = 'T' 
) [static]

Transformation of a (vector) value field in the H-curl space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P,D), into the output container outVals, defined on cells in physical space and indexed by (C,F,P,D).

Computes pullback of HCURL functions $\Phi^*(\widehat{\bf u}_f) = \left((DF_c)^{-{\sf T}}\cdot\widehat{\bf u}_f\right)\circ F^{-1}_{c}$ for points in one or more physical cells that are images of a given set of points in the reference cell:

\[ \{ x_{c,p} \}_{p=0}^P = \{ F_{c} (\widehat{x}_p) \}_{p=0}^{P}\qquad 0\le c < C \,. \]

In this case $ F^{-1}_{c}(x_{c,p}) = \widehat{x}_p $ and the user-provided container should contain the values of the vector function set $\{\widehat{\bf u}_f\}_{f=0}^{F}$ at the reference points:

\[ inVals(f,p,*) = \widehat{\bf u}_f(\widehat{x}_p) \,. \]

The method returns

\[ outVals(c,f,p,*) = \left((DF_c)^{-{\sf T}}\cdot\widehat{\bf u}_f\right)\circ F^{-1}_{c}(x_{c,p}) = (DF_c)^{-{\sf T}}(\widehat{x}_p)\cdot\widehat{\bf u}_f(\widehat{x}_p) \qquad 0\le c < C \,. \]

See Section Pullbacks for more details about pullbacks.

    |------|----------------------|--------------------------------------------------|
    |      |         Index        |                   Dimension                      |
    |------|----------------------|--------------------------------------------------|
    |   C  |         cell         |  0 <= C < num. integration domains               |
    |   F  |         field        |  0 <= F < dim. of native basis                   |
    |   P  |         point        |  0 <= P < num. integration points                |
    |   D  |         space dim    |  0 <= D < spatial dimension                      |
    |------|----------------------|--------------------------------------------------|

Definition at line 153 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

template<class Scalar , class ArrayType , class ArrayTypeDet >
void Intrepid::FunctionSpaceToolsInPlace::HDIVtransformDIV ( ArrayType &  inOutVals,
const ArrayTypeDet &  jacobianDet 
) [static]

Transformation of a divergence field in the H-div space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P), into the output container outVals, defined on cells in physical space and indexed by (C,F,P).

Computes pullback of the divergence of HDIV functions $\Phi^*(\widehat{\bf u}_f) = \left(J^{-1}_{c}\nabla\cdot\widehat{\bf u}_{f}\right) \circ F^{-1}_{c} $ for points in one or more physical cells that are images of a given set of points in the reference cell:

\[ \{ x_{c,p} \}_{p=0}^P = \{ F_{c} (\widehat{x}_p) \}_{p=0}^{P}\qquad 0\le c < C \,. \]

In this case $ F^{-1}_{c}(x_{c,p}) = \widehat{x}_p $ and the user-provided container should contain the divergencies of the vector function set $\{\widehat{\bf u}_f\}_{f=0}^{F}$ at the reference points:

\[ inVals(f,p) = \nabla\cdot\widehat{\bf u}_f(\widehat{x}_p) \,. \]

The method returns

\[ outVals(c,f,p,*) = \left(J^{-1}_{c}\nabla\cdot\widehat{\bf u}_{f}\right) \circ F^{-1}_{c} (x_{c,p}) = J^{-1}_{c}(\widehat{x}_p) \nabla\cdot\widehat{\bf u}_{f} (\widehat{x}_p) \qquad 0\le c < C \,. \]

See Section Pullbacks for more details about pullbacks.

    |------|----------------------|--------------------------------------------------|
    |      |         Index        |                   Dimension                      |
    |------|----------------------|--------------------------------------------------|
    |   C  |         cell         |  0 <= C < num. integration domains               |
    |   F  |         field        |  0 <= F < dim. of the basis                      |
    |   P  |         point        |  0 <= P < num. integration points                |
    |------|----------------------|--------------------------------------------------|

Definition at line 312 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

template<class Scalar , class ArrayType , class ArrayTypeJac , class ArrayTypeDet >
void Intrepid::FunctionSpaceToolsInPlace::HDIVtransformVALUE ( ArrayType &  inOutVals,
const ArrayTypeJac &  jacobian,
const ArrayTypeDet &  jacobianDet,
const char  transpose = 'N' 
) [static]

Transformation of a (vector) value field in the H-div space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P,D), into the output container outVals, defined on cells in physical space and indexed by (C,F,P,D).

Computes pullback of HDIV functions $\Phi^*(\widehat{\bf u}_f) = \left(J^{-1}_{c} DF_{c}\cdot\widehat{\bf u}_f\right)\circ F^{-1}_{c} $ for points in one or more physical cells that are images of a given set of points in the reference cell:

\[ \{ x_{c,p} \}_{p=0}^P = \{ F_{c} (\widehat{x}_p) \}_{p=0}^{P}\qquad 0\le c < C \,. \]

In this case $ F^{-1}_{c}(x_{c,p}) = \widehat{x}_p $ and the user-provided container should contain the values of the vector function set $\{\widehat{\bf u}_f\}_{f=0}^{F}$ at the reference points:

\[ inVals(f,p,*) = \widehat{\bf u}_f(\widehat{x}_p) \,. \]

The method returns

\[ outVals(c,f,p,*) = \left(J^{-1}_{c} DF_{c}\cdot \widehat{\bf u}_f\right)\circ F^{-1}_{c}(x_{c,p}) = J^{-1}_{c}(\widehat{x}_p) DF_{c}(\widehat{x}_p)\cdot\widehat{\bf u}_f(\widehat{x}_p) \qquad 0\le c < C \,. \]

See Section Pullbacks for more details about pullbacks.

    |------|----------------------|--------------------------------------------------|
    |      |         Index        |                   Dimension                      |
    |------|----------------------|--------------------------------------------------|
    |   C  |         cell         |  0 <= C < num. integration domains               |
    |   F  |         field        |  0 <= F < dim. of the basis                      |
    |   P  |         point        |  0 <= P < num. integration points                |
    |   D  |         space dim    |  0 <= D < spatial dimension                      |
    |------|----------------------|--------------------------------------------------|

Definition at line 277 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

template<class Scalar , class ArrayType , class ArrayTypeJac >
void Intrepid::FunctionSpaceToolsInPlace::HGRADtransformGRAD ( ArrayType &  inOutVals,
const ArrayTypeJac &  jacobianInverse,
const char  transpose = 'T' 
) [static]

Transformation of a gradient field in the H-grad space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P,D), into the output container outVals, defined on cells in physical space and indexed by (C,F,P,D).

Computes pullback of gradients of HGRAD functions $\Phi^*(\nabla\widehat{u}_f) = \left((DF_c)^{-{\sf T}}\cdot\nabla\widehat{u}_f\right)\circ F^{-1}_{c}$ for points in one or more physical cells that are images of a given set of points in the reference cell:

\[ \{ x_{c,p} \}_{p=0}^P = \{ F_{c} (\widehat{x}_p) \}_{p=0}^{P}\qquad 0\le c < C \,. \]

In this case $ F^{-1}_{c}(x_{c,p}) = \widehat{x}_p $ and the user-provided container should contain the gradients of the function set $\{\widehat{u}_f\}_{f=0}^{F}$ at the reference points:

\[ inVals(f,p,*) = \nabla\widehat{u}_f(\widehat{x}_p) \,. \]

The method returns

\[ outVals(c,f,p,*) = \left((DF_c)^{-{\sf T}}\cdot\nabla\widehat{u}_f\right)\circ F^{-1}_{c}(x_{c,p}) = (DF_c)^{-{\sf T}}(\widehat{x}_p)\cdot\nabla\widehat{u}_f(\widehat{x}_p) \qquad 0\le c < C \,. \]

See Section Pullbacks for more details about pullbacks.

    |------|----------------------|--------------------------------------------------|
    |      |         Index        |                   Dimension                      |
    |------|----------------------|--------------------------------------------------|
    |   C  |         cell         |  0 <= C < num. integration domains               |
    |   F  |         field        |  0 <= F < number of fields per cell              |
    |   P  |         point        |  0 <= P < num. integration points                |
    |   D  |         space dim    |  0 <= D < spatial dimension                      |
    |------|----------------------|--------------------------------------------------|

Definition at line 65 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

template<class Scalar , class ArrayType >
void Intrepid::FunctionSpaceToolsInPlace::HGRADtransformVALUE ( ArrayType &  inOutVals) [static]

Transformation of a (scalar) value field in the H-grad space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P), into the output container outVals, defined on cells in physical space and indexed by (C,F,P).

Computes pullback of HGRAD functions $\Phi^*(\widehat{u}_f) = \widehat{u}_f\circ F^{-1}_{c} $ for points in one or more physical cells that are images of a given set of points in the reference cell:

\[ \{ x_{c,p} \}_{p=0}^P = \{ F_{c} (\widehat{x}_p) \}_{p=0}^{P}\qquad 0\le c < C \,. \]

In this case $ F^{-1}_{c}(x_{c,p}) = \widehat{x}_p $ and the user-provided container should contain the values of the function set $\{\widehat{u}_f\}_{f=0}^{F}$ at the reference points:

\[ inVals(f,p) = \widehat{u}_f(\widehat{x}_p) \,. \]

The method returns

\[ outVals(c,f,p) = \widehat{u}_f\circ F^{-1}_{c}(x_{c,p}) = \widehat{u}_f(\widehat{x}_p) = inVals(f,p) \qquad 0\le c < C \,, \]

i.e., it simply replicates the values in the user-provided container to every cell. See Section Pullbacks for more details about pullbacks.

    |------|----------------------|--------------------------------------------------|
    |      |         Index        |                   Dimension                      |
    |------|----------------------|--------------------------------------------------|
    |   C  |         cell         |  0 <= C < num. integration domains               |
    |   F  |         field        |  0 <= F < number of fields per cell to transform |
    |   P  |         point        |  0 <= P < num. integration points                |
    |------|----------------------|--------------------------------------------------|

Definition at line 53 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

template<class Scalar , class ArrayType , class ArrayTypeDet >
void Intrepid::FunctionSpaceToolsInPlace::HVOLtransformVALUE ( ArrayType &  inOutVals,
const ArrayTypeDet &  jacobianDet 
) [static]

Transformation of a (scalar) value field in the H-vol space, defined at points on a reference cell, stored in the user-provided container inVals and indexed by (F,P), into the output container outVals, defined on cells in physical space and indexed by (C,F,P).

Computes pullback of HVOL functions $\Phi^*(\widehat{u}_f) = \left(J^{-1}_{c}\widehat{u}_{f}\right) \circ F^{-1}_{c} $ for points in one or more physical cells that are images of a given set of points in the reference cell:

\[ \{ x_{c,p} \}_{p=0}^P = \{ F_{c} (\widehat{x}_p) \}_{p=0}^{P}\qquad 0\le c < C \,. \]

In this case $ F^{-1}_{c}(x_{c,p}) = \widehat{x}_p $ and the user-provided container should contain the values of the functions in the set $\{\widehat{\bf u}_f\}_{f=0}^{F}$ at the reference points:

\[ inVals(f,p) = \widehat{u}_f(\widehat{x}_p) \,. \]

The method returns

\[ outVals(c,f,p,*) = \left(J^{-1}_{c}\widehat{u}_{f}\right) \circ F^{-1}_{c} (x_{c,p}) = J^{-1}_{c}(\widehat{x}_p) \widehat{u}_{f} (\widehat{x}_p) \qquad 0\le c < C \,. \]

See Section Pullbacks for more details about pullbacks.

    |------|----------------------|--------------------------------------------------|
    |      |         Index        |                   Dimension                      |
    |------|----------------------|--------------------------------------------------|
    |   C  |         cell         |  0 <= C < num. integration domains               |
    |   F  |         field        |  0 <= F < dim. of the basis                      |
    |   P  |         point        |  0 <= P < num. integration points                |
    |------|----------------------|--------------------------------------------------|

Definition at line 336 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.


The documentation for this class was generated from the following files: