Intrepid2_OrientationTools.hpp

Go to the documentation of this file.

// @HEADER
// ************************************************************************
//
//                           Intrepid2 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 Kyungjoo Kim  (kyukim@sandia.gov), or
//                    Mauro Perego  (mperego@sandia.gov)
//
// ************************************************************************
// @HEADER

#ifndef __INTREPID2_ORIENTATIONTOOLS_HPP__
#define __INTREPID2_ORIENTATIONTOOLS_HPP__

#include "Intrepid2_ConfigDefs.hpp"
#include "Intrepid2_Types.hpp"
#include "Intrepid2_Utils.hpp"

#include "Shards_CellTopology.hpp"
#include "Shards_BasicTopologies.hpp"

#include "Intrepid2_PointTools.hpp"

#include "Intrepid2_Basis.hpp"

// -- HGRAD family
#include "Intrepid2_HGRAD_LINE_Cn_FEM.hpp"
#include "Intrepid2_HGRAD_QUAD_Cn_FEM.hpp"
#include "Intrepid2_HGRAD_HEX_Cn_FEM.hpp"

#include "Intrepid2_HGRAD_TRI_Cn_FEM.hpp"
#include "Intrepid2_HGRAD_TET_Cn_FEM.hpp"

// -- HCURL family
#include "Intrepid2_HCURL_QUAD_In_FEM.hpp"
#include "Intrepid2_HCURL_HEX_In_FEM.hpp"

#include "Intrepid2_HCURL_TRI_In_FEM.hpp"
#include "Intrepid2_HCURL_TET_In_FEM.hpp"
#include "Intrepid2_HVOL_LINE_Cn_FEM.hpp"

// -- HDIV family
#include "Intrepid2_HDIV_QUAD_In_FEM.hpp"
#include "Intrepid2_HDIV_HEX_In_FEM.hpp"

#include "Intrepid2_HDIV_TRI_In_FEM.hpp"
#include "Intrepid2_HDIV_TET_In_FEM.hpp"
#include "Intrepid2_HVOL_TRI_Cn_FEM.hpp"

// -- Lower order family
#include "Intrepid2_HCURL_QUAD_I1_FEM.hpp"
#include "Intrepid2_HCURL_TRI_I1_FEM.hpp"

#include "Intrepid2_HDIV_QUAD_I1_FEM.hpp"
#include "Intrepid2_HDIV_TRI_I1_FEM.hpp"

#include "Intrepid2_HCURL_HEX_I1_FEM.hpp"
#include "Intrepid2_HCURL_TET_I1_FEM.hpp"
#include "Intrepid2_HCURL_WEDGE_I1_FEM.hpp"

#include "Intrepid2_HDIV_HEX_I1_FEM.hpp"
#include "Intrepid2_HDIV_TET_I1_FEM.hpp"
#include "Intrepid2_HDIV_WEDGE_I1_FEM.hpp"

#include "Intrepid2_HierarchicalBasisFamily.hpp"
#include "Intrepid2_NodalBasisFamily.hpp"

#include "Teuchos_LAPACK.hpp"


namespace Intrepid2 {

  namespace Impl {

    class OrientationTools {
    public:

      // -----------------------------------------------------------------------------
      // Point modification
      //
      //

      template<typename ValueType>
      KOKKOS_INLINE_FUNCTION
      static void 
      getModifiedLinePoint(ValueType &ot,
                           const ValueType pt,
                           const ordinal_type ort);
      
      template<typename ValueType>
      KOKKOS_INLINE_FUNCTION
      static void 
      getModifiedTrianglePoint(ValueType &ot0,
                               ValueType &ot1,
                               const ValueType pt0,
                               const ValueType pt1,
                               const ordinal_type ort);
      
      template<typename ValueType>
      KOKKOS_INLINE_FUNCTION
      static void 
      getModifiedQuadrilateralPoint(ValueType &ot0,
                                    ValueType &ot1,
                                    const ValueType pt0,
                                    const ValueType pt1,
                                    const ordinal_type ort);

      template<typename outPointViewType,
               typename refPointViewType>
      inline
      static void 
      mapToModifiedReference(outPointViewType outPoints,
                             const refPointViewType refPoints,
                             const shards::CellTopology cellTopo,
                             const ordinal_type cellOrt = 0);

      template<typename outPointViewType,
               typename refPointViewType>
      KOKKOS_INLINE_FUNCTION
      static void
      mapToModifiedReference(outPointViewType outPoints,
                             const refPointViewType refPoints,
                             const unsigned cellTopoKey,
                             const ordinal_type cellOrt = 0);


      template<typename JacobianViewType>
      KOKKOS_INLINE_FUNCTION
      static void
      getLineJacobian(JacobianViewType jacobian, const ordinal_type ort);

      template<typename JacobianViewType>
      KOKKOS_INLINE_FUNCTION
      static void
      getTriangleJacobian(JacobianViewType jacobian, const ordinal_type ort);

      template<typename JacobianViewType>
      KOKKOS_INLINE_FUNCTION
      static void
      getQuadrilateralJacobian(JacobianViewType jacobian, const ordinal_type ort);


      template<typename JacobianViewType>
      inline
      static void
      getJacobianOfOrientationMap(JacobianViewType jacobian,
                                  const shards::CellTopology cellTopo,
                                  const ordinal_type cellOrt);

      template<typename JacobianViewType>
      KOKKOS_INLINE_FUNCTION
      static void
      getJacobianOfOrientationMap(JacobianViewType jacobian,
                                  const unsigned cellTopoKey,
                                  const ordinal_type cellOrt);


      template<typename TanViewType, typename ParamViewType>
      KOKKOS_INLINE_FUNCTION
      static void getRefSubcellTangents(TanViewType tangents,
                                        const ParamViewType subCellParametrization,
                                        const unsigned subcellTopoKey,
                                        const ordinal_type subCellOrd,
                                        const ordinal_type ort);


      template<typename TanNormViewType, typename ParamViewType>
      KOKKOS_INLINE_FUNCTION
      static void getRefSideTangentsAndNormal(TanNormViewType tangentsAndNormal,
                                              const ParamViewType subCellParametrization,
                                              const unsigned subcellTopoKey,
                                              const ordinal_type subCellOrd,
                                              const ordinal_type ort);


      template<typename coordsViewType, typename subcellCoordsViewType, typename ParamViewType>
      KOKKOS_INLINE_FUNCTION
      static void mapSubcellCoordsToRefCell(coordsViewType cellCoords,
                                            const subcellCoordsViewType subCellCoords,
                                            const ParamViewType subcellParametrization,
                                            const unsigned subcellTopoKey,
                                            const ordinal_type subCellOrd,
                                            const ordinal_type ort);

      // -----------------------------------------------------------------------------
      // Coefficient Matrix
      //
      //
      
      template<typename OutputViewType,
               typename subcellBasisHostType,
               typename cellBasisHostType>
      inline
      static void
      getCoeffMatrix_HGRAD(OutputViewType &output,
                           const subcellBasisHostType& subcellBasis,
                           const cellBasisHostType& cellBasis,
                           const ordinal_type subcellId,
                           const ordinal_type subcellOrt,
                           const bool inverse = false);

      template<typename OutputViewType,
               typename subcellBasisHostType,
               typename cellBasisHostType>
      inline
      static void
      getCoeffMatrix_HCURL(OutputViewType &output,
                           const subcellBasisHostType& subcellBasis,
                           const cellBasisHostType& cellBasis,
                           const ordinal_type subcellId,
                           const ordinal_type subcellOrt,
                           const bool inverse = false);


      template<typename OutputViewType,
               typename subcellBasisHostType,
               typename cellBasisHostType>
      inline
      static void
      getCoeffMatrix_HDIV(OutputViewType &output,
                          const subcellBasisHostType& subcellBasis,
                          const cellBasisHostType& cellBasis,
                          const ordinal_type subcellId,
                          const ordinal_type subcellOrt,
                           const bool inverse = false);


      template<typename OutputViewType,
               typename cellBasisHostType>
      inline
      static void
      getCoeffMatrix_HVOL(OutputViewType &output,
                           const cellBasisHostType& cellBasis,
                           const ordinal_type cellOrt,
                           const bool inverse = false);

    };
  }

  template<typename DeviceType>
  class OrientationTools {
  public:

    typedef Kokkos::View<double****,DeviceType> CoeffMatrixDataViewType;

    // 
    static std::map<std::pair<std::string,ordinal_type>,CoeffMatrixDataViewType> ortCoeffData;
    static std::map<std::pair<std::string,ordinal_type>,CoeffMatrixDataViewType> ortInvCoeffData;
    
  private:

    template<typename BasisHostType>
    inline 
    static CoeffMatrixDataViewType createCoeffMatrixInternal(const BasisHostType* basis, const bool invTrans = false);
    

    template<typename BasisHostType>
    inline
    static void init_HGRAD(CoeffMatrixDataViewType matData,
                           BasisHostType const *cellBasis,
                           const bool inverse = false);

    template<typename BasisHostType>
    inline
    static void init_HCURL(CoeffMatrixDataViewType matData,
                           BasisHostType const *cellBasis,
                           const bool inverse = false);

    template<typename BasisHostType>
    inline
    static void init_HDIV(CoeffMatrixDataViewType matData,
                          BasisHostType const *cellBasis,
                           const bool inverse = false);
    
    template<typename BasisHostType>
    inline
    static void init_HVOL(CoeffMatrixDataViewType matData,
                           BasisHostType const *cellBasis,
                           const bool inverse = false);

  public:

    template<typename BasisType>
    inline 
    static CoeffMatrixDataViewType createCoeffMatrix(const BasisType* basis);

    template<typename BasisType>
    inline 
    static CoeffMatrixDataViewType createInvCoeffMatrix(const BasisType* basis);

    inline 
    static void clearCoeffMatrix();

    template<typename elemOrtValueType, class ...elemOrtProperties,
             typename elemNodeValueType, class ...elemNodeProperties>
    inline 
    static void
    getOrientation(Kokkos::DynRankView<elemOrtValueType,elemOrtProperties...> elemOrts,
                   const Kokkos::DynRankView<elemNodeValueType,elemNodeProperties...> elemNodes,
                   const shards::CellTopology cellTopo,
                   bool isSide = false);


    template<typename outputValueType, class ...outputProperties,
             typename inputValueType,  class ...inputProperties,
             typename OrientationViewType,
             typename BasisType>
    inline
    static void
    modifyBasisByOrientation(Kokkos::DynRankView<outputValueType,outputProperties...> output,
                             const Kokkos::DynRankView<inputValueType, inputProperties...>  input,
                             const OrientationViewType orts,
                             const BasisType * basis,
                             const bool transpose = false);
    
    template<typename outputValueType, class ...outputProperties,
             typename inputValueType,  class ...inputProperties,
             typename OrientationViewType,
             typename BasisType>
    inline
    static void
    modifyBasisByOrientationTranspose(Kokkos::DynRankView<outputValueType,outputProperties...> output,
                                      const Kokkos::DynRankView<inputValueType, inputProperties...>  input,
                                      const OrientationViewType orts,
                                      const BasisType * basis);


    template<typename outputValueType, class ...outputProperties,
             typename inputValueType,  class ...inputProperties,
             typename OrientationViewType,
             typename BasisType>
    inline
    static void
    modifyBasisByOrientationInverse(Kokkos::DynRankView<outputValueType,outputProperties...> output,
                                      const Kokkos::DynRankView<inputValueType, inputProperties...>  input,
                                      const OrientationViewType orts,
                                      const BasisType * basis,
                                      const bool transpose = false);
    
    
    template<typename outputValueType, class ...outputProperties,
             typename inputValueType,  class ...inputProperties,
             typename OrientationViewType,
             typename BasisTypeLeft,
             typename BasisTypeRight>
    inline
    static void
    modifyMatrixByOrientation(Kokkos::DynRankView<outputValueType,outputProperties...> output,
                              const Kokkos::DynRankView<inputValueType, inputProperties...>  input,
                              const OrientationViewType orts,
                              const BasisTypeLeft* basisLeft,
                              const BasisTypeRight* basisRight);
  };
  
  template<typename T> 
  std::map<std::pair<std::string,ordinal_type>, typename OrientationTools<T>::CoeffMatrixDataViewType>
  OrientationTools<T>::ortCoeffData;

  template<typename T> 
  std::map<std::pair<std::string,ordinal_type>, typename OrientationTools<T>::CoeffMatrixDataViewType>
  OrientationTools<T>::ortInvCoeffData;
}

// include templated function definitions
#include "Intrepid2_OrientationToolsDefModifyPoints.hpp"
#include "Intrepid2_OrientationToolsDefCoeffMatrix_HGRAD.hpp"
#include "Intrepid2_OrientationToolsDefCoeffMatrix_HCURL.hpp"
#include "Intrepid2_OrientationToolsDefCoeffMatrix_HDIV.hpp"
#include "Intrepid2_OrientationToolsDefCoeffMatrix_HVOL.hpp"
#include "Intrepid2_OrientationToolsDefMatrixData.hpp"
#include "Intrepid2_OrientationToolsDefModifyBasis.hpp"

#endif