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_KokkosRank.hpp>

#ifdef INTREPID_OLD_KOKKOS_CODE

#include "Kokkos_Core.hpp"

#endif

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                    //

    //                                                                                            //

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


/*

 #ifdef INTREPID_OLD_KOKKOS_CODE


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

        struct setJacobianTempSpecKokkos;


        template<class Scalar1,class Scalar2,class Scalar3,class Layout,class MemorySpace>

        static void setJacobianTemp(Kokkos::View<Scalar1,Layout,MemorySpace> &               jacobian,

                            const Kokkos::View<Scalar2,Layout,MemorySpace> &           points,

                            const Kokkos::View<Scalar3,Layout,MemorySpace>  &           cellWorkset,

                            const shards::CellTopology & cellTopo,

                            const int &                  whichCell = -1);


 #endif */

    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

#ifdef INTREPID_OLD_KOKKOS_CODE

#include <Intrepid_CellTools_Kokkos.hpp>

#endif

#include "Intrepid_CellToolsDef.hpp"


#endif


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

 **                                                                                               **

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

 **                                                                                               **

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


#endif