Intrepid2_CubatureDirect.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                           Intrepid2 Package
//
// Copyright 2007 NTESS and the Intrepid2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef __INTREPID2_CUBATURE_DIRECT_HPP__
#define __INTREPID2_CUBATURE_DIRECT_HPP__
 
#include "Intrepid2_ConfigDefs.hpp"
#include "Intrepid2_Cubature.hpp"
 
namespace Intrepid2 {
 
  template<typename DeviceType = void,
           typename pointValueType = double,
           typename weightValueType = double>
  class CubatureDirect
    : public Cubature<DeviceType,pointValueType,weightValueType> {
  protected:
 
    struct CubatureDataStatic {
 
      ordinal_type numPoints_;
 
      pointValueType points_[Parameters::MaxIntegrationPoints][Parameters::MaxDimension];
 
      weightValueType weights_[Parameters::MaxIntegrationPoints];
    };
 
    struct CubatureData {
 
      ordinal_type numPoints_;
 
      Kokkos::DynRankView<pointValueType,DeviceType> points_;
 
      Kokkos::DynRankView<weightValueType,DeviceType> weights_;
 
    };
 
    ordinal_type degree_;
 
    ordinal_type dimension_;
 
    CubatureData cubatureData_;
 
    template<typename cubPointValueType,  class ...cubPointProperties,
             typename cubWeightValueType, class ...cubWeightProperties>
    void
    getCubatureFromData( Kokkos::DynRankView<cubPointValueType, cubPointProperties...>  cubPoints,
                         Kokkos::DynRankView<cubWeightValueType,cubWeightProperties...> cubWeights,
                         const CubatureData cubData) const {
#ifdef HAVE_INTREPID2_DEBUG
      // check size of cubPoints and cubWeights
      INTREPID2_TEST_FOR_EXCEPTION( rank(cubPoints) != 2, std::invalid_argument,
                                    ">>> ERROR (CubatureDirect): cubPoints must be rank 2." );
 
      INTREPID2_TEST_FOR_EXCEPTION( rank(cubWeights) != 1, std::invalid_argument,
                                    ">>> ERROR (CubatureDirect): cubPoints must be rank 1." );
 
      INTREPID2_TEST_FOR_EXCEPTION( static_cast<ordinal_type>(cubPoints.extent(0))  < this->getNumPoints() ||
                                    static_cast<ordinal_type>(cubPoints.extent(1))  < this->getDimension(), std::out_of_range,
                                    ">>> ERROR (CubatureDirect): Insufficient space allocated for cubature points.");
 
      INTREPID2_TEST_FOR_EXCEPTION( static_cast<ordinal_type>(cubWeights.extent(0)) < this->getNumPoints(), std::out_of_range,
                                    ">>> ERROR (CubatureDirect): Insufficient space allocated for cubature weights.");
#endif
      // need subview here
      typedef Kokkos::pair<ordinal_type,ordinal_type> range_type;
 
      range_type pointRange(0, this->getNumPoints());
      range_type dimRange  (0, this->getDimension());
      {
        const auto src = Kokkos::subdynrankview(cubData.points_, pointRange, dimRange);
              auto dst = Kokkos::subdynrankview(cubPoints,       pointRange, dimRange);
 
        Kokkos::deep_copy( dst, src );
      }
      {
        const auto src = Kokkos::subdynrankview(cubData.weights_, pointRange);
              auto dst = Kokkos::subdynrankview(cubWeights,       pointRange);
 
        Kokkos::deep_copy(dst ,src);
      }
    }
 
  public:
 
    //
    // Cubature public functions
    //
    typedef typename Cubature<DeviceType,pointValueType,weightValueType>::PointViewType  PointViewType;
    typedef typename Cubature<DeviceType,pointValueType,weightValueType>::weightViewType weightViewType;
 
    using Cubature<DeviceType,pointValueType,weightValueType>::getCubature;
 
    virtual
    void
    getCubature( PointViewType  cubPoints,
                 weightViewType cubWeights ) const override {
      this->getCubatureFromData(cubPoints, cubWeights, this->cubatureData_);
    }
 
    virtual
    ordinal_type
    getNumPoints() const override {
      return cubatureData_.numPoints_;
    }
 
    virtual
    ordinal_type
    getDimension() const override {
      return dimension_;
    }
 
    virtual
    const char*
    getName() const override {
      return "CubatureDirect";
    }
 
    virtual
    ordinal_type 
    getAccuracy() const override {
      return degree_;
    }
 
    CubatureDirect()
      : degree_(),
        dimension_(),
        cubatureData_() {}
 
    CubatureDirect(const CubatureDirect &b)
      : degree_(b.degree_),
        dimension_(b.dimension_),
        cubatureData_(b.cubatureData_) {}
 
    CubatureDirect& operator=(const CubatureDirect &b) {
        this->degree_       = b.degree_;
        this->dimension_    = b.dimension_;
        this->cubatureData_ = b.cubatureData_;
        return *this;
    } 
    
    CubatureDirect(const ordinal_type degree,
                   const ordinal_type dimension) 
    : degree_(degree),
      dimension_(dimension),
      cubatureData_() {}
 
  };
 
} // end namespace Intrepid2
 
 
#endif