Intrepid
Static Public Member Functions | List of all members
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>

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). More...
 
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). More...
 
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). More...
 
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). More...
 
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). More...
 
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). More...
 
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). More...
 
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 \e 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 \e 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 \e 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 \e 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 \e 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 \e HGRAD functions \form#242 
     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 \e 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:
Generated by   doxygen 1.8.5