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