trilinos/intrepid/Intrepid__CellTools_8hpp_source.html

 #ifndef INTREPID_CELTOOLS_HPP

 #define INTREPID_CELTOOLS_HPP


 // @HEADER

 // ************************************************************************

 //

 //                           Intrepid Package

 //                 Copyright (2007) Sandia Corporation

 //

 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive

 // license for use of this work by or on behalf of the U.S. Government.

 //

 // Redistribution and use in source and binary forms, with or without

 // modification, are permitted provided that the following conditions are

 // met:

 //

 // 1. Redistributions of source code must retain the above copyright

 // notice, this list of conditions and the following disclaimer.

 //

 // 2. Redistributions in binary form must reproduce the above copyright

 // notice, this list of conditions and the following disclaimer in the

 // documentation and/or other materials provided with the distribution.

 //

 // 3. Neither the name of the Corporation nor the names of the

 // contributors may be used to endorse or promote products derived from

 // this software without specific prior written permission.

 //

 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY

 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE

 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 //

 // Questions? Contact Pavel Bochev  (pbboche@sandia.gov)

 //                    Denis Ridzal  (dridzal@sandia.gov), or

 //                    Kara Peterson (kjpeter@sandia.gov)

 //

 // ************************************************************************

 // @HEADER


 #ifndef INTREPID_CELLTOOLS_HPP

 #define INTREPID_CELLTOOLS_HPP


 #include "Intrepid_FieldContainer.hpp"

 #include "Intrepid_RealSpaceTools.hpp"

 #include "Intrepid_ConfigDefs.hpp"

 #include "Intrepid_Types.hpp"

 #include "Intrepid_Utils.hpp"

 #include "Intrepid_Basis.hpp"

 #include "Intrepid_HGRAD_TRI_C1_FEM.hpp"

 #include "Intrepid_HGRAD_QUAD_C1_FEM.hpp"

 #include "Intrepid_HGRAD_TET_C1_FEM.hpp"

 #include "Intrepid_HGRAD_WEDGE_C1_FEM.hpp"

 #include "Intrepid_HGRAD_PYR_C1_FEM.hpp"

 #include "Intrepid_HGRAD_HEX_C1_FEM.hpp"


 #include "Intrepid_HGRAD_LINE_C1_FEM.hpp"


 #include "Intrepid_HGRAD_TRI_C2_FEM.hpp"

 #include "Intrepid_HGRAD_QUAD_C2_FEM.hpp"

 #include "Intrepid_HGRAD_TET_C2_FEM.hpp"

 #include "Intrepid_HGRAD_TET_COMP12_FEM.hpp"

 #include "Intrepid_HGRAD_WEDGE_C2_FEM.hpp"

 #include "Intrepid_HGRAD_WEDGE_I2_FEM.hpp"

 #include "Intrepid_HGRAD_HEX_C2_FEM.hpp"

 #include "Intrepid_HGRAD_HEX_I2_FEM.hpp"

 #include "Intrepid_HGRAD_PYR_I2_FEM.hpp"


 #include "Shards_CellTopology.hpp"

 #include "Shards_BasicTopologies.hpp"


 #include "Teuchos_Assert.hpp"

 #include "Teuchos_RCP.hpp"


 #include <Intrepid_Rank.hpp>


 namespace Intrepid {


 //nn

   //============================================================================================//

   //                                                                                            //

   //                                          CellTools                                         //

   //                                                                                            //

   //============================================================================================//


 template<class Scalar>

 class CellTools {

 private:


   //============================================================================================//

   //                                                                                            //

   //          Parametrization coefficients of edges and faces of reference cells                //

   //                                                                                            //

   //============================================================================================//


   static const FieldContainer<double>& getSubcellParametrization(const int                   subcellDim,

                                                                  const shards::CellTopology& parentCell);


   static void setSubcellParametrization(FieldContainer<double>&     subcellParametrization,

                                         const int                   subcellDim,

                                         const shards::CellTopology& parentCell);


   //============================================================================================//

   //                                                                                            //

   //                  Validation of input/output arguments for CellTools methods                //

   //                                                                                            //

   //============================================================================================//


   template<class ArrayJac, class ArrayPoint, class ArrayCell>

   static void validateArguments_setJacobian(const ArrayJac    &          jacobian,

                                             const ArrayPoint  &          points,

                                             const ArrayCell   &          cellWorkset,

                                             const int &                  whichCell,

                                             const shards::CellTopology & cellTopo);


   template<class ArrayJacInv, class ArrayJac>

   static void validateArguments_setJacobianInv(const ArrayJacInv &  jacobianInv,

                                                const ArrayJac    &  jacobian);


   template<class ArrayJacDet, class ArrayJac>

   static void validateArguments_setJacobianDetArgs(const ArrayJacDet &  jacobianDet,

                                                    const ArrayJac    &  jacobian);


   template<class ArrayPhysPoint, class ArrayRefPoint, class ArrayCell>

   static void validateArguments_mapToPhysicalFrame(const ArrayPhysPoint &        physPoints,

                                                    const ArrayRefPoint  &        refPoints,

                                                    const ArrayCell      &        cellWorkset,

                                                    const shards::CellTopology &  cellTopo,

                                                    const int&                    whichCell);


   template<class ArrayRefPoint, class ArrayPhysPoint, class ArrayCell>

   static void validateArguments_mapToReferenceFrame(const ArrayRefPoint  &        refPoints,

                                                     const ArrayPhysPoint &        physPoints,

                                                     const ArrayCell      &        cellWorkset,

                                                     const shards::CellTopology &  cellTopo,

                                                     const int&                    whichCell);


   template<class ArrayRefPoint, class ArrayInitGuess, class ArrayPhysPoint, class ArrayCell>

   static void validateArguments_mapToReferenceFrame(const ArrayRefPoint  &        refPoints,

                                                     const ArrayInitGuess &        initGuess,

                                                     const ArrayPhysPoint &        physPoints,

                                                     const ArrayCell      &        cellWorkset,

                                                     const shards::CellTopology &  cellTopo,

                                                     const int&                    whichCell);


   template<class ArrayIncl, class ArrayPoint, class ArrayCell>

   static void validateArguments_checkPointwiseInclusion(ArrayIncl        &            inCell,

                                                         const ArrayPoint &            physPoints,

                                                         const ArrayCell  &            cellWorkset,

                                                         const int &                   whichCell,

                                                         const shards::CellTopology &  cell);

 public:


     CellTools(){ };


     ~CellTools(){ };


     //============================================================================================//

     //                                                                                            //

     //                     Jacobian, inverse Jacobian and Jacobian determinant                    //

     //                                                                                            //

     //============================================================================================//


     template<class ArrayJac, class ArrayPoint, class ArrayCell, bool typecheck>

         struct setJacobianTempSpec;


         /*template<class ArrayJac, class ArrayPoint, class ArrayCell>

         static void setJacobianTemp(ArrayJac &               jacobian,

                             const ArrayPoint &           points,

                             const ArrayCell  &           cellWorkset,

                             const shards::CellTopology & cellTopo,

                             const int &                  whichCell = -1);*/

     template<class ArrayJac, class ArrayPoint, class ArrayCell>

     static void setJacobian(ArrayJac &                   jacobian,

                             const ArrayPoint &           points,

                             const ArrayCell  &           cellWorkset,

                             const shards::CellTopology & cellTopo,

                             const int &                  whichCell = -1);


     template<class ArrayJac, class ArrayPoint, class ArrayCell>

     static void setJacobian(ArrayJac &                   jacobian,

                             const ArrayPoint &           points,

                             const ArrayCell  &           cellWorkset,

                             const Teuchos::RCP< Basis< Scalar, FieldContainer<Scalar> > > HGRAD_Basis,

                             const int &                  whichCell = -1);


     template<class ArrayJacInv, class ArrayJac>

     static void setJacobianInv(ArrayJacInv &     jacobianInv,

                                const ArrayJac &  jacobian);


  /*   template<class ArrayJacInv, class ArrayJac>

     static void setJacobianInvTemp(ArrayJacInv &     jacobianInv,

                                const ArrayJac &  jacobian);

     */


     template<class ArrayJacDet, class ArrayJac>

     static void setJacobianDet(ArrayJacDet &     jacobianDet,

                                const ArrayJac &  jacobian);


   /*  template<class ArrayJacDet, class ArrayJac>

     static void setJacobianDetTemp(ArrayJacDet &     jacobianDet,

                                const ArrayJac &  jacobian);*/


     //============================================================================================//

     //                                                                                            //

     //                      Reference-to-physical frame mapping and its inverse                   //

     //                                                                                            //

     //============================================================================================//


     template<class ArrayPhysPoint, class ArrayRefPoint, class ArrayCell>

     static void mapToPhysicalFrame(ArrayPhysPoint      &         physPoints,

                                    const ArrayRefPoint &         refPoints,

                                    const ArrayCell     &         cellWorkset,

                                    const shards::CellTopology &  cellTopo,

                                    const int &                   whichCell = -1);


     template<class ArrayPhysPoint, class ArrayRefPoint, class ArrayCell>

     static void mapToPhysicalFrame(ArrayPhysPoint      &         physPoints,

                                    const ArrayRefPoint &         refPoints,

                                    const ArrayCell     &         cellWorkset,

                                    const Teuchos::RCP< Basis< Scalar, FieldContainer<Scalar> > > HGRAD_Basis,

                                    const int &                   whichCell = -1);


  /*       template<class ArrayPhysPoint, class ArrayRefPoint, class ArrayCell>

     static void mapToPhysicalFrameTemp(ArrayPhysPoint      &         physPoints,

                                    const ArrayRefPoint &         refPoints,

                                    const ArrayCell     &         cellWorkset,

                                    const shards::CellTopology &  cellTopo,

                                    const int &                   whichCell = -1);

                 */

             template<class ArrayPhysPoint, class ArrayRefPoint, class ArrayCell, int refRank,int phyptsrank>

         struct mapToPhysicalFrameTempSpec;


     template<class ArrayRefPoint, class ArrayPhysPoint, class ArrayCell>

     static void mapToReferenceFrame(ArrayRefPoint        &        refPoints,

                                     const ArrayPhysPoint &        physPoints,

                                     const ArrayCell      &        cellWorkset,

                                     const shards::CellTopology &  cellTopo,

                                     const int &                   whichCell = -1);


     template<class ArrayRefPoint, class ArrayPhysPoint, class ArrayCell>

     static void mapToReferenceFrame(ArrayRefPoint        &        refPoints,

                                     const ArrayPhysPoint &        physPoints,

                                     const ArrayCell      &        cellWorkset,

                                     const Teuchos::RCP< Basis< Scalar, FieldContainer<Scalar> > > HGRAD_Basis,

                                     const int &                   whichCell = -1);


     template<class ArrayRefPoint, class ArrayInitGuess, class ArrayPhysPoint, class ArrayCell>

     static void mapToReferenceFrameInitGuess(ArrayRefPoint        &        refPoints,

                                              const ArrayInitGuess &        initGuess,

                                              const ArrayPhysPoint &        physPoints,

                                              const ArrayCell      &        cellWorkset,

                                              const shards::CellTopology &  cellTopo,

                                              const int &                   whichCell = -1);


     template<class ArrayRefPoint, class ArrayInitGuess, class ArrayPhysPoint, class ArrayCell>

     static void mapToReferenceFrameInitGuess(ArrayRefPoint        &        refPoints,

                                              const ArrayInitGuess &        initGuess,

                                              const ArrayPhysPoint &        physPoints,

                                              const ArrayCell      &        cellWorkset,

                                              const Teuchos::RCP< Basis< Scalar, FieldContainer<Scalar> > > HGRAD_Basis,

                                              const int &                   whichCell = -1);


     template<class ArraySubcellPoint, class ArrayParamPoint>

     static void mapToReferenceSubcell(ArraySubcellPoint     &       refSubcellPoints,

                                       const ArrayParamPoint &       paramPoints,

                                       const int                     subcellDim,

                                       const int                     subcellOrd,

                                       const shards::CellTopology &  parentCell);


     template<class ArrayEdgeTangent>

     static void getReferenceEdgeTangent(ArrayEdgeTangent &            refEdgeTangent,

                                         const int &                   edgeOrd,

                                         const shards::CellTopology &  parentCell);


     template<class ArrayFaceTangentU, class ArrayFaceTangentV>

     static void getReferenceFaceTangents(ArrayFaceTangentU &           refFaceTanU,

                                          ArrayFaceTangentV &           refFaceTanV,

                                          const int &                   faceOrd,

                                          const shards::CellTopology &  parentCell);


     template<class ArraySideNormal>

     static void getReferenceSideNormal(ArraySideNormal &             refSideNormal,

                                        const int &                   sideOrd,

                                        const shards::CellTopology &  parentCell);


     template<class ArrayFaceNormal>

     static void getReferenceFaceNormal(ArrayFaceNormal &             refFaceNormal,

                                        const int &                   faceOrd,

                                        const shards::CellTopology &  parentCell);


     template<class ArrayEdgeTangent, class ArrayJac>

     static void getPhysicalEdgeTangents(ArrayEdgeTangent &            edgeTangents,

                                         const ArrayJac &              worksetJacobians,

                                         const int &                   worksetEdgeOrd,

                                         const shards::CellTopology &  parentCell);


   /*  template<class ArrayEdgeTangent, class ArrayJac>

     static void getPhysicalEdgeTangentsTemp(ArrayEdgeTangent &            edgeTangents,

                                         const ArrayJac &              worksetJacobians,

                                         const int &                   worksetEdgeOrd,

                                         const shards::CellTopology &  parentCell);    */


     template<class ArrayFaceTangentU, class ArrayFaceTangentV, class ArrayJac>

     static void getPhysicalFaceTangents(ArrayFaceTangentU &           faceTanU,

                                         ArrayFaceTangentV &           faceTanV,

                                         const ArrayJac &              worksetJacobians,

                                         const int &                   worksetFaceOrd,

                                         const shards::CellTopology &  parentCell);


  /*   template<class ArrayFaceTangentU, class ArrayFaceTangentV, class ArrayJac>

     static void getPhysicalFaceTangentsTemp(ArrayFaceTangentU &           faceTanU,

                                         ArrayFaceTangentV &           faceTanV,

                                         const ArrayJac &              worksetJacobians,

                                         const int &                   worksetFaceOrd,

                                         const shards::CellTopology &  parentCell);

     */

     template<class ArraySideNormal, class ArrayJac>

     static void getPhysicalSideNormals(ArraySideNormal &             sideNormals,

                                        const ArrayJac &              worksetJacobians,

                                        const int &                   worksetSideOrd,

                                        const shards::CellTopology &  parentCell);


     template<class ArrayFaceNormal, class ArrayJac>

     static void getPhysicalFaceNormals(ArrayFaceNormal &             faceNormals,

                                        const ArrayJac &              worksetJacobians,

                                        const int &                   worksetFaceOrd,

                                        const shards::CellTopology &  parentCell);


   /*  template<class ArrayFaceNormal, class ArrayJac>

     static void getPhysicalFaceNormalsTemp(ArrayFaceNormal &             faceNormals,

                                        const ArrayJac &              worksetJacobians,

                                        const int &                   worksetFaceOrd,

                                        const shards::CellTopology &  parentCell);

     */

     //============================================================================================//

     //                                                                                            //

     //                                        Inclusion tests                                     //

     //                                                                                            //

     //============================================================================================//


     static int checkPointInclusion(const Scalar*                 point,

                                    const int                     pointDim,

                                    const shards::CellTopology &  cellTopo,

                                    const double &                threshold = INTREPID_THRESHOLD);


     template<class ArrayPoint>

     static int checkPointsetInclusion(const ArrayPoint &            points,

                                       const shards::CellTopology &  cellTopo,

                                       const double &                threshold = INTREPID_THRESHOLD);


     template<class ArrayIncl, class ArrayPoint>

     static void checkPointwiseInclusion(ArrayIncl &                   inRefCell,

                                         const ArrayPoint &            points,

                                         const shards::CellTopology &  cellTopo,

                                         const double &                threshold = INTREPID_THRESHOLD);


     template<class ArrayIncl, class ArrayPoint, class ArrayCell>

     static void checkPointwiseInclusion(ArrayIncl &                   inCell,

                                         const ArrayPoint &            points,

                                         const ArrayCell &             cellWorkset,

                                         const shards::CellTopology &  cell,

                                         const int &                   whichCell = -1,

                                         const double &                threshold = INTREPID_THRESHOLD);


     static const double* getReferenceVertex(const shards::CellTopology& cell,

                                             const int                   vertexOrd);


     template<class ArraySubcellVert>

     static void getReferenceSubcellVertices(ArraySubcellVert &          subcellVertices,

                                             const int                   subcellDim,

                                             const int                   subcellOrd,

                                             const shards::CellTopology& parentCell);


     static const double* getReferenceNode(const shards::CellTopology& cell,

                                           const int                   nodeOrd);


     template<class ArraySubcellNode>

     static void getReferenceSubcellNodes(ArraySubcellNode&          subcellNodes,

                                         const int                   subcellDim,

                                         const int                   subcellOrd,

                                         const shards::CellTopology& parentCell);


     static int hasReferenceCell(const shards::CellTopology &  cellTopo);


     //============================================================================================//

     //                                                                                            //

     //                                           Debug                                            //

     //                                                                                            //

     //============================================================================================//


     static void printSubcellVertices(const int subcellDim,

                                      const int subcellOrd,

                                      const shards::CellTopology & parentCell);


     template<class ArrayCell>

     static void printWorksetSubcell(const ArrayCell &             cellWorkset,

                                     const shards::CellTopology &  parentCell,

                                     const int&                    pCellOrd,

                                     const int&                    subcellDim,

                                     const int&                    subcellOrd,

                                     const int&                    fieldWidth = 3);


     //============================================================================================//

     //                                                                                            //

     //                             Control Volume Coordinates                                     //

     //                                                                                            //

     //============================================================================================//


   template<class ArrayCVCoord, class ArrayCellCoord>

   static void getSubCVCoords(ArrayCVCoord & subCVcoords, const ArrayCellCoord & cellCoords,

                              const shards::CellTopology& primaryCell);


   template<class ArrayCent, class ArrayCellCoord>

   static void getBarycenter(ArrayCent & barycenter, const ArrayCellCoord & cellCoords);


   }; // class CellTools


 } // namespace Intrepid


 // include templated function definitions

 #include "Intrepid_CellToolsDef.hpp"


 #endif


 /***************************************************************************************************

  **                                                                                               **

  **                           D O C U M E N T A T I O N   P A G E S                               **

  **                                                                                               **

  **************************************************************************************************/


 #endif

Intrepid_Basis.hpp
Header file for the abstract base class Intrepid::Basis.

Intrepid_CellToolsDef.hpp
Definition file for the Intrepid::CellTools class.

Intrepid_FieldContainer.hpp
Header file for utility class to provide multidimensional containers.

Intrepid_HGRAD_HEX_C2_FEM.hpp
Header file for the Intrepid::HGRAD_HEX_C2_FEM class.

Intrepid_HGRAD_HEX_I2_FEM.hpp
Header file for the Intrepid::HGRAD_HEX_I2_FEM class.

Intrepid_HGRAD_LINE_C1_FEM.hpp
Header file for the Intrepid::HGRAD_LINE_C1_FEM class.

Intrepid_HGRAD_PYR_I2_FEM.hpp
Header file for the Intrepid::HGRAD_PYR_I2_FEM class.

Intrepid_HGRAD_TET_C2_FEM.hpp
Header file for the Intrepid::HGRAD_TET_C2_FEM class.

Intrepid_HGRAD_TET_COMP12_FEM.hpp
Header file for the Intrepid::HGRAD_TET_COMP12_FEM class.

Intrepid_HGRAD_TRI_C1_FEM.hpp
Header file for the Intrepid::HGRAD_TRI_C1_FEM class.

Intrepid_HGRAD_TRI_C2_FEM.hpp
Header file for the Intrepid::HGRAD_TRI_C2_FEM class.

Intrepid_HGRAD_WEDGE_C2_FEM.hpp
Header file for the Intrepid::G_WEDGE_C2_FEM class.

Intrepid_HGRAD_WEDGE_I2_FEM.hpp
Header file for the Intrepid::HGRAD_WEDGE_I2_FEM class.

Intrepid_RealSpaceTools.hpp
Header file for classes providing basic linear algebra functionality in 1D, 2D and 3D.

Intrepid_Types.hpp
Contains definitions of custom data types in Intrepid.

Intrepid_Utils.hpp
Intrepid utilities.

Intrepid::Basis
An abstract base class that defines interface for concrete basis implementations for Finite Element (...
Definition: Intrepid_Basis.hpp:89

Intrepid::CellTools
A stateless class for operations on cell data. Provides methods for:
Definition: Intrepid_CellTools.hpp:109

Intrepid::CellTools::validateArguments_setJacobianInv
static void validateArguments_setJacobianInv(const ArrayJacInv &jacobianInv, const ArrayJac &jacobian)
Validates arguments to Intrepid::CellTools::setJacobianInv.
Definition: Intrepid_CellToolsDef.hpp:2829

Intrepid::CellTools::getPhysicalFaceNormals
static void getPhysicalFaceNormals(ArrayFaceNormal &faceNormals, const ArrayJac &worksetJacobians, const int &worksetFaceOrd, const shards::CellTopology &parentCell)
Computes non-normalized normal vectors to physical faces in a face workset ; (see Subcell worksets fo...
Definition: Intrepid_CellToolsDef.hpp:2388

Intrepid::CellTools::getReferenceVertex
static const double * getReferenceVertex(const shards::CellTopology &cell, const int vertexOrd)
Retrieves the Cartesian coordinates of a reference cell vertex.
Definition: Intrepid_CellToolsDef.hpp:471

Intrepid::CellTools::checkPointsetInclusion
static int checkPointsetInclusion(const ArrayPoint &points, const shards::CellTopology &cellTopo, const double &threshold=INTREPID_THRESHOLD)
Checks if a set of points belongs to a reference cell.
Definition: Intrepid_CellToolsDef.hpp:2523

Intrepid::CellTools::validateArguments_setJacobian
static void validateArguments_setJacobian(const ArrayJac &jacobian, const ArrayPoint &points, const ArrayCell &cellWorkset, const int &whichCell, const shards::CellTopology &cellTopo)
Validates arguments to Intrepid::CellTools::setJacobian.
Definition: Intrepid_CellToolsDef.hpp:2715

Intrepid::CellTools::getReferenceEdgeTangent
static void getReferenceEdgeTangent(ArrayEdgeTangent &refEdgeTangent, const int &edgeOrd, const shards::CellTopology &parentCell)
Computes constant tangent vectors to edges of 2D or 3D reference cells.
Definition: Intrepid_CellToolsDef.hpp:2094

Intrepid::CellTools::mapToReferenceSubcell
static void mapToReferenceSubcell(ArraySubcellPoint &refSubcellPoints, const ArrayParamPoint &paramPoints, const int subcellDim, const int subcellOrd, const shards::CellTopology &parentCell)
Computes parameterization maps of 1- and 2-subcells of reference cells.
Definition: Intrepid_CellToolsDef.hpp:2027

Intrepid::CellTools::getReferenceSideNormal
static void getReferenceSideNormal(ArraySideNormal &refSideNormal, const int &sideOrd, const shards::CellTopology &parentCell)
Computes constant normal vectors to sides of 2D or 3D reference cells.
Definition: Intrepid_CellToolsDef.hpp:2175

Intrepid::CellTools::setSubcellParametrization
static void setSubcellParametrization(FieldContainer< double > &subcellParametrization, const int subcellDim, const shards::CellTopology &parentCell)
Defines orientation-preserving parametrizations of reference edges and faces of cell topologies with ...
Definition: Intrepid_CellToolsDef.hpp:327

Intrepid::CellTools::validateArguments_mapToReferenceFrame
static void validateArguments_mapToReferenceFrame(const ArrayRefPoint &refPoints, const ArrayPhysPoint &physPoints, const ArrayCell &cellWorkset, const shards::CellTopology &cellTopo, const int &whichCell)
Validates arguments to Intrepid::CellTools::mapToReferenceFrame with default initial guess.
Definition: Intrepid_CellToolsDef.hpp:2991

Intrepid::CellTools::validateArguments_checkPointwiseInclusion
static void validateArguments_checkPointwiseInclusion(ArrayIncl &inCell, const ArrayPoint &physPoints, const ArrayCell &cellWorkset, const int &whichCell, const shards::CellTopology &cell)
Validates arguments to Intrepid::CellTools::checkPointwiseInclusion.
Definition: Intrepid_CellToolsDef.hpp:3055

Intrepid::CellTools::getReferenceSubcellNodes
static void getReferenceSubcellNodes(ArraySubcellNode &subcellNodes, const int subcellDim, const int subcellOrd, const shards::CellTopology &parentCell)
Retrieves the Cartesian coordinates of all nodes of a reference subcell.
Definition: Intrepid_CellToolsDef.hpp:788

Intrepid::CellTools::mapToPhysicalFrame
static void mapToPhysicalFrame(ArrayPhysPoint &physPoints, const ArrayRefPoint &refPoints, const ArrayCell &cellWorkset, const shards::CellTopology &cellTopo, const int &whichCell=-1)
Computes F, the reference-to-physical frame map.
Definition: Intrepid_CellToolsDef.hpp:1447

Intrepid::CellTools::getReferenceFaceTangents
static void getReferenceFaceTangents(ArrayFaceTangentU &refFaceTanU, ArrayFaceTangentV &refFaceTanV, const int &faceOrd, const shards::CellTopology &parentCell)
Computes pairs of constant tangent vectors to faces of a 3D reference cells.
Definition: Intrepid_CellToolsDef.hpp:2130

Intrepid::CellTools::getPhysicalSideNormals
static void getPhysicalSideNormals(ArraySideNormal &sideNormals, const ArrayJac &worksetJacobians, const int &worksetSideOrd, const shards::CellTopology &parentCell)
Computes non-normalized normal vectors to physical sides in a side workset .
Definition: Intrepid_CellToolsDef.hpp:2349

Intrepid::CellTools::getPhysicalFaceTangents
static void getPhysicalFaceTangents(ArrayFaceTangentU &faceTanU, ArrayFaceTangentV &faceTanV, const ArrayJac &worksetJacobians, const int &worksetFaceOrd, const shards::CellTopology &parentCell)
Computes non-normalized tangent vector pairs to physical faces in a face workset ; (see Subcell works...
Definition: Intrepid_CellToolsDef.hpp:2286

Intrepid::CellTools::setJacobianDet
static void setJacobianDet(ArrayJacDet &jacobianDet, const ArrayJac &jacobian)
Computes the determinant of the Jacobian matrix DF of the reference-to-physical frame map F.
Definition: Intrepid_CellToolsDef.hpp:1314

Intrepid::CellTools::getSubCVCoords
static void getSubCVCoords(ArrayCVCoord &subCVcoords, const ArrayCellCoord &cellCoords, const shards::CellTopology &primaryCell)
Computes coordinates of sub-control volumes in each primary cell.
Definition: Intrepid_CellToolsDef.hpp:3223

Intrepid::CellTools::getSubcellParametrization
static const FieldContainer< double > & getSubcellParametrization(const int subcellDim, const shards::CellTopology &parentCell)
Returns array with the coefficients of the parametrization maps for the edges or faces of a reference...
Definition: Intrepid_CellToolsDef.hpp:60

Intrepid::CellTools::getReferenceNode
static const double * getReferenceNode(const shards::CellTopology &cell, const int nodeOrd)
Retrieves the Cartesian coordinates of a reference cell node.
Definition: Intrepid_CellToolsDef.hpp:529

Intrepid::CellTools::CellTools
CellTools()
Default constructor.
Definition: Intrepid_CellTools.hpp:288

Intrepid::CellTools::validateArguments_setJacobianDetArgs
static void validateArguments_setJacobianDetArgs(const ArrayJacDet &jacobianDet, const ArrayJac &jacobian)
Validates arguments to Intrepid::CellTools::setJacobianDet.
Definition: Intrepid_CellToolsDef.hpp:2857

Intrepid::CellTools::printWorksetSubcell
static void printWorksetSubcell(const ArrayCell &cellWorkset, const shards::CellTopology &parentCell, const int &pCellOrd, const int &subcellDim, const int &subcellOrd, const int &fieldWidth=3)
Prints the nodes of a subcell from a cell workset.
Definition: Intrepid_CellToolsDef.hpp:3180

Intrepid::CellTools::mapToReferenceFrame
static void mapToReferenceFrame(ArrayRefPoint &refPoints, const ArrayPhysPoint &physPoints, const ArrayCell &cellWorkset, const shards::CellTopology &cellTopo, const int &whichCell=-1)
Computes , the inverse of the reference-to-physical frame map using a default initial guess.
Definition: Intrepid_CellToolsDef.hpp:1662

Intrepid::CellTools::checkPointwiseInclusion
static void checkPointwiseInclusion(ArrayIncl &inRefCell, const ArrayPoint &points, const shards::CellTopology &cellTopo, const double &threshold=INTREPID_THRESHOLD)
Checks every point in a set for inclusion in a reference cell.
Definition: Intrepid_CellToolsDef.hpp:2564

Intrepid::CellTools::~CellTools
~CellTools()
Destructor.
Definition: Intrepid_CellTools.hpp:293

Intrepid::CellTools::mapToReferenceFrameInitGuess
static void mapToReferenceFrameInitGuess(ArrayRefPoint &refPoints, const ArrayInitGuess &initGuess, const ArrayPhysPoint &physPoints, const ArrayCell &cellWorkset, const shards::CellTopology &cellTopo, const int &whichCell=-1)
Computation of , the inverse of the reference-to-physical frame map using user-supplied initial guess...
Definition: Intrepid_CellToolsDef.hpp:1899

Intrepid::CellTools::getReferenceFaceNormal
static void getReferenceFaceNormal(ArrayFaceNormal &refFaceNormal, const int &faceOrd, const shards::CellTopology &parentCell)
Computes constant normal vectors to faces of 3D reference cell.
Definition: Intrepid_CellToolsDef.hpp:2209

Intrepid::CellTools::hasReferenceCell
static int hasReferenceCell(const shards::CellTopology &cellTopo)
Checks if a cell topology has reference cell.
Definition: Intrepid_CellToolsDef.hpp:839

Intrepid::CellTools::setJacobianInv
static void setJacobianInv(ArrayJacInv &jacobianInv, const ArrayJac &jacobian)
Computes the inverse of the Jacobian matrix DF of the reference-to-physical frame map F.
Definition: Intrepid_CellToolsDef.hpp:1283

Intrepid::CellTools::validateArguments_mapToPhysicalFrame
static void validateArguments_mapToPhysicalFrame(const ArrayPhysPoint &physPoints, const ArrayRefPoint &refPoints, const ArrayCell &cellWorkset, const shards::CellTopology &cellTopo, const int &whichCell)
Validates arguments to Intrepid::CellTools::mapToPhysicalFrame.
Definition: Intrepid_CellToolsDef.hpp:2900

Intrepid::CellTools::getPhysicalEdgeTangents
static void getPhysicalEdgeTangents(ArrayEdgeTangent &edgeTangents, const ArrayJac &worksetJacobians, const int &worksetEdgeOrd, const shards::CellTopology &parentCell)
Computes non-normalized tangent vectors to physical edges in an edge workset ; (see Subcell worksets ...
Definition: Intrepid_CellToolsDef.hpp:2239

Intrepid::CellTools::checkPointInclusion
static int checkPointInclusion(const Scalar *point, const int pointDim, const shards::CellTopology &cellTopo, const double &threshold=INTREPID_THRESHOLD)
Checks if a point belongs to a reference cell.
Definition: Intrepid_CellToolsDef.hpp:2432

Intrepid::CellTools::printSubcellVertices
static void printSubcellVertices(const int subcellDim, const int subcellOrd, const shards::CellTopology &parentCell)
Prints the reference space coordinates of the vertices of the specified subcell.
Definition: Intrepid_CellToolsDef.hpp:3140

Intrepid::CellTools::getBarycenter
static void getBarycenter(ArrayCent &barycenter, const ArrayCellCoord &cellCoords)
Compute cell barycenters.
Definition: Intrepid_CellToolsDef.hpp:3443

Intrepid::CellTools::getReferenceSubcellVertices
static void getReferenceSubcellVertices(ArraySubcellVert &subcellVertices, const int subcellDim, const int subcellOrd, const shards::CellTopology &parentCell)
Retrieves the Cartesian coordinates of all vertices of a reference subcell.
Definition: Intrepid_CellToolsDef.hpp:490

Intrepid::FieldContainer< double >

Intrepid::CellTools::mapToPhysicalFrameTempSpec
Computes F, the reference-to-physical frame map.
Definition: Intrepid_CellTools.hpp:553

Intrepid::CellTools::setJacobianTempSpec
Computes the Jacobian matrix DF of the reference-to-physical frame map F.
Definition: Intrepid_CellTools.hpp:350