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).
 
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

◆ HCURLtransformCURL()

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.

◆ HCURLtransformCURLDual()

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

Applies the dual of the HCURLtransformCURL transformation.

Definition at line 251 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

◆ HCURLtransformVALUE()

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.

◆ HCURLtransformVALUEDual()

template<class Scalar , class ArrayType , class ArrayTypeJac >
void Intrepid::FunctionSpaceToolsInPlace::HCURLtransformVALUEDual ( ArrayType &  outVals,
const ArrayTypeJac &  jacobianInverse,
const char  transpose = 'T' 
)
static

Applies the dual of the HCURLtransformVALUE transformation.

Definition at line 161 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

◆ HDIVtransformDIV()

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.

◆ HDIVtransformDIVDual()

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

Applies the dual of HDIVtransformDIV, which is the same.

Definition at line 328 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

◆ HDIVtransformVALUE()

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.

◆ HDIVtransformVALUEDual()

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

Applies the dual of HDIVtransformVALUE.

Definition at line 286 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

◆ HGRADtransformGRAD()

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.

◆ HGRADtransformGRADDual()

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

Applies the transpose of the HGRADtransformGRAD to the data.

Definition at line 128 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

◆ HGRADtransformVALUE()

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.

◆ HGRADtransformVALUEDual()

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

Since there is no matrix involved, this is the same transformation as HGRADtransformVALUE.

Definition at line 59 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

◆ HVOLtransformVALUE()

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.

◆ HVOLtransformVALUEDual()

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

Applies the dual of HVOLtransformVALUE.

Definition at line 343 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.

References HVOLtransformVALUEDual().

Referenced by HVOLtransformVALUEDual().

◆ multiplyMeasure()

template<class Scalar , class ArrayType , class ArrayTypeMeasure >
void Intrepid::FunctionSpaceToolsInPlace::multiplyMeasure ( ArrayType &  inOutVals,
const ArrayTypeMeasure &  inMeasure 
)
static

Definition at line 352 of file Intrepid_FunctionSpaceToolsInPlaceDef.hpp.


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