Intrepid_PointTools.hpp

Go to the documentation of this file.

// @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_POINTTOOLS_HPP
#define INTREPID_POINTTOOLS_HPP

#include "Shards_CellTopology.hpp"
#include "Teuchos_Assert.hpp"
#include "Intrepid_Polylib.hpp"
#include "Intrepid_FieldContainer.hpp"
#include "Intrepid_CellTools.hpp"
#include <stdexcept>

namespace Intrepid {
  
  class PointTools {
  public:
   static inline int getLatticeSize( const shards::CellTopology& cellType ,
                                     const int order ,
                                     const int offset = 0 )
    {
      switch( cellType.getKey() ) {
      case shards::Tetrahedron<4>::key:
      case shards::Tetrahedron<8>::key:
      case shards::Tetrahedron<10>::key:
        {
          const int effectiveOrder = order - 4 * offset;
          if (effectiveOrder < 0) return 0;
          else return (effectiveOrder+1)*(effectiveOrder+2)*(effectiveOrder+3)/6;
        }
        break;
      case shards::Triangle<3>::key:
      case shards::Triangle<4>::key:
      case shards::Triangle<6>::key: 
        {
          const int effectiveOrder = order - 3 * offset;
          if (effectiveOrder < 0) return 0;
          else return (effectiveOrder+1)*(effectiveOrder+2)/2;
        }
        break;
      case shards::Line<2>::key:
      case shards::Line<3>::key:
        {
          const int effectiveOrder = order - 2 * offset;
          if (effectiveOrder < 0) return 0;
          else return (effectiveOrder+1);
        }
        break;
      default:
        TEUCHOS_TEST_FOR_EXCEPTION( true , std::invalid_argument ,
                            ">>> ERROR (Intrepid::PointTools::getLatticeSize): Illegal cell type" );
      }
    }


    template<class Scalar, class ArrayType>
    static void getLattice( ArrayType &pts ,
                            const shards::CellTopology& cellType ,
                            const int order ,
                            const int offset = 0 ,
                            const EPointType pointType = POINTTYPE_EQUISPACED );

    template<class Scalar, class ArrayType>
    static void getGaussPoints( ArrayType &pts ,
                                const int order );


  private:
    template<class Scalar, class ArrayTypeOut, class ArrayTypeIn1, class ArrayTypeIn2>
    static void cartToBaryTriangle( ArrayTypeOut & baryValues ,
                                    const ArrayTypeIn1 & cartValues ,
                                    const ArrayTypeIn2 & vertices );


    template<class Scalar, class ArrayTypeOut, class ArrayTypeIn1, class ArrayTypeIn2>
    static void baryToCartTriangle( ArrayTypeOut & cartValues ,
                                    const ArrayTypeIn1 & baryValues ,
                                    const ArrayTypeIn2 & vertices );


    template<class Scalar, class ArrayTypeOut, class ArrayTypeIn1, class ArrayTypeIn2>
    static void cartToBaryTetrahedron( ArrayTypeOut & baryValues ,
                                      const ArrayTypeIn1 & cartValues ,
                                      const ArrayTypeIn2 & vertices );

    template<class Scalar, class ArrayTypeOut, class ArrayTypeIn1, class ArrayTypeIn2>
    static void baryToCartTetrahedron( ArrayTypeOut & cartValues ,
                                      const ArrayTypeIn1 & baryValues ,
                                      const ArrayTypeIn2 & vertices );


  template<class Scalar, class ArrayType>
  static void getEquispacedLattice( const shards::CellTopology& cellType ,
                                    ArrayType &points ,
                                    const int order ,
                                    const int offset = 0 );


    template<class Scalar, class ArrayType>
    static void getWarpBlendLattice( const shards::CellTopology& cellType ,
                                    ArrayType &points ,
                                    const int order ,
                                    const int offset = 0);
    

    template<class Scalar, class ArrayType>
    static void getEquispacedLatticeLine( ArrayType &points ,
                                          const int order ,
                                          const int offset = 0 );

    template<class Scalar, class ArrayType>
    static void getEquispacedLatticeTriangle( ArrayType &points ,
                                              const int order ,
                                              const int offset = 0 );

    template<class Scalar, class ArrayType>
    static void getEquispacedLatticeTetrahedron( ArrayType &points ,
                                                const int order ,
                                                const int offset = 0 );

    template<class Scalar, class ArrayType>
    static void getWarpBlendLatticeLine( ArrayType &points ,
                                        const int order ,
                                        const int offset = 0 );

    template<class Scalar, class ArrayType>
    static void warpFactor( const int order ,
                            const ArrayType &xnodes ,
                            const ArrayType &xout ,
                            ArrayType &warp );

    template<class Scalar, class ArrayType>
    static void getWarpBlendLatticeTriangle(ArrayType &points ,
                                            const int order ,
                                            const int offset = 0 );

    template<class Scalar, class ArrayType>
    static void getWarpBlendLatticeTetrahedron( ArrayType &points ,
                                                const int order ,
                                                const int offset = 0 );


  template<class Scalar, class ArrayType>
  static void warpShiftFace3D( const int order ,
                        const Scalar pval ,
                        const ArrayType &L1,
                        const ArrayType &L2,
                        const ArrayType &L3,
                        const ArrayType &L4,
                        ArrayType &dxy);

  template<class Scalar, class ArrayType>
  static void evalshift( const int order ,
                  const Scalar pval ,
                  const ArrayType &L1 ,
                  const ArrayType &L2 ,
                  const ArrayType &L3 ,
                  ArrayType &dxy );

  template<class Scalar, class ArrayType>
  static void evalwarp( ArrayType &warp ,
                const int order ,
                const ArrayType &xnodes ,
                const ArrayType &xout );


  }; // end class PointTools

} // end namespace Intrepid

// include templated definitions
#include <Intrepid_PointToolsDef.hpp>

#endif